type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
functions | attribute_hidden do_dump(SEXP call, SEXP op, SEXP args, SEXP rho)
{
SEXP file, names, o, objs, tval, source, outnames;
int i, j, nobjs, nout, res;
Rboolean wasopen, havewarned = FALSE, evaluate;
Rconnection con;
int opts;
const char *obj_name;
RCNTXT cntxt;
checkArity(op, args);
na... |
functions | void linebreak(Rboolean *lbreak, LocalParseData *d)
{
if (d->len > d->cutoff) {
if (!*lbreak) {
*lbreak = TRUE;
d->indent++;
} |
functions | void deparse2(SEXP what, SEXP svec, LocalParseData *d)
{
d->strvec = svec;
d->linenumber = 0;
d->indent = 0;
deparse2buff(what, d);
writeline(d);
} |
functions | Rboolean
curlyahead(SEXP s)
{
if (isList(s) || isLanguage(s))
if (TYPEOF(CAR(s)) == SYMSXP && CAR(s) == R_BraceSymbol)
return TRUE;
return FALSE;
} |
functions | Rboolean needsparens(PPinfo mainop, SEXP arg, unsigned int left)
{
PPinfo arginfo;
if (TYPEOF(arg) == LANGSXP) {
if (TYPEOF(CAR(arg)) == SYMSXP) {
if ((TYPEOF(SYMVALUE(CAR(arg))) == BUILTINSXP) ||
(TYPEOF(SYMVALUE(CAR(arg))) == SPECIALSXP)) {
arginfo = PPINFO(SYMVALUE(CAR(arg)));
switch(arginfo.kind... |
functions | Rboolean hasAttributes(SEXP s)
{
SEXP a = ATTRIB(s);
if (length(a) > 2) return(TRUE);
while(!isNull(a)) {
if(TAG(a) != R_SrcrefSymbol)
return(TRUE);
a = CDR(a);
} |
functions | void attr1(SEXP s, LocalParseData *d)
{
if(hasAttributes(s))
print2buff("structure(", d);
} |
functions | void attr2(SEXP s, LocalParseData *d)
{
int localOpts = d->opts;
if(hasAttributes(s)) {
SEXP a = ATTRIB(s);
while(!isNull(a)) {
if(TAG(a) != R_SrcrefSymbol) {
print2buff(", ", d);
if(TAG(a) == R_DimSymbol) {
print2buff(".Dim", d);
} |
functions | void printcomment(SEXP s, LocalParseData *d)
{
SEXP cmt;
int i, ncmt;
const void *vmax = vmaxget();
/* look for old-style comments first */
if(isList(TAG(s)) && !isNull(TAG(s))) {
for (s = TAG(s); s != R_NilValue; s = CDR(s)) {
print2buff(translateChar(STRING_ELT(CAR(s), 0)), d);
writel... |
functions | Rboolean parenthesizeCaller(SEXP s)
{
SEXP op, sym;
if (TYPEOF(s) == LANGSXP) { /* unevaluated */
op = CAR(s);
if (TYPEOF(op) == SYMSXP) {
if (isUserBinop(op)) return TRUE; /* %foo% */
sym = SYMVALUE(op);
if (TYPEOF(sym) == BUILTINSXP
|| TYPEOF(sym) == SPECIALSXP) {
if (PPINFO(sym).preced... |
functions | void deparse2buff(SEXP s, LocalParseData *d)
{
PPinfo fop;
Rboolean lookahead = FALSE, lbreak = FALSE, parens;
SEXP op, t;
int localOpts = d->opts, i, n;
if (!d->active) return;
if (IS_S4_OBJECT(s)) d->isS4 = TRUE;
switch (TYPEOF(s)) {
case NILSXP:
print2buff("NULL", d);
break;
... |
functions | else if (fop.kind == PP_BINARY2) {
if (length(s) != 2)
fop.kind = PP_FUNCALL;
else if (userbinop)
fop.kind = PP_BINARY;
} |
functions | void writeline(LocalParseData *d)
{
if (d->strvec != R_NilValue && d->linenumber < d->maxlines)
SET_STRING_ELT(d->strvec, d->linenumber, mkChar(d->buffer.data));
d->linenumber++;
if (d->linenumber >= d->maxlines) d->active = FALSE;
/* reset */
d->len = 0;
d->buffer.data[0] = '\0';
d->startl... |
functions | void print2buff(const char *strng, LocalParseData *d)
{
size_t tlen, bufflen;
if (d->startline) {
d->startline = FALSE;
printtab2buff(d->indent, d); /*if at the start of a line tab over */
} |
functions | void vector2buff(SEXP vector, LocalParseData *d)
{
int tlen, i, quote;
const char *strp;
char *buff = 0, hex[64]; // 64 is more than enough
Rboolean surround = FALSE, allNA, addL = TRUE;
tlen = length(vector);
if( isString(vector) )
quote = '"';
else
quote = 0;
if (tlen == 0) {
switc... |
functions | void src2buff1(SEXP srcref, LocalParseData *d)
{
int i,n;
const void *vmax = vmaxget();
PROTECT(srcref);
PROTECT(srcref = lang2(install("as.character"), srcref));
PROTECT(srcref = eval(srcref, R_BaseEnv));
n = length(srcref);
for(i = 0 ; i < n ; i++) {
print2buff(translateChar(STRING_ELT(s... |
functions | Rboolean src2buff(SEXP sv, int k, LocalParseData *d)
{
SEXP t;
if (TYPEOF(sv) == VECSXP && length(sv) > k && !isNull(t = VECTOR_ELT(sv, k))) {
src2buff1(t, d);
return TRUE;
} |
functions | void vec2buff(SEXP v, LocalParseData *d)
{
SEXP nv, sv;
int i, n /*, localOpts = d->opts */;
Rboolean lbreak = FALSE;
const void *vmax = vmaxget();
n = length(v);
nv = getAttrib(v, R_NamesSymbol);
if (length(nv) == 0) nv = R_NilValue;
if (d->opts & USESOURCE) {
sv = getAttrib(v, R_Src... |
functions | else if(d->backtick) {
print2buff("`", d);
deparse2buff(STRING_ELT(nv, i), d);
print2buff("`", d);
} |
functions | void args2buff(SEXP arglist, int lineb, int formals, LocalParseData *d)
{
Rboolean lbreak = FALSE;
while (arglist != R_NilValue) {
if (TYPEOF(arglist) != LISTSXP && TYPEOF(arglist) != LANGSXP)
error(_("badly formed function expression"));
if (TAG(arglist) != R_NilValue) {
SEXP s = TAG(arglist);
... |
functions | void printtab2buff(int ntab, LocalParseData *d)
{
int i;
for (i = 1; i <= ntab; i++)
if (i <= 4)
print2buff(" ", d);
else
print2buff(" ", d);
} |
includes |
#include <stdio.h> |
includes | #include <openssl/buffer.h> |
includes | #include <openssl/objects.h> |
includes | #include <openssl/evp.h> |
includes | #include <openssl/rand.h> |
includes | #include <openssl/x509.h> |
includes | #include <openssl/pkcs12.h> |
includes | #include <openssl/pem.h> |
includes | #include <string.h> |
functions | void
cshift0_c16 (gfc_array_c16 *ret, const gfc_array_c16 *array, ptrdiff_t shift,
int which)
{
/* r.* indicates the return array. */
index_type rstride[GFC_MAX_DIMENSIONS];
index_type rstride0;
index_type roffset;
GFC_COMPLEX_16 *rptr;
/* s.* indicates the source array. */
index_type sstride[GF... |
includes |
#include <stdio.h> |
includes | #include <stdlib.h> |
includes | #include <string.h> |
includes |
#include <X11/Xlib.h> |
includes | #include <X11/Xutil.h> |
includes |
#include <wraster.h> |
functions | int wGetColorForColormap(Colormap colormap, const char *color_name, XColor *color)
{
if (!XParseColor(dpy, colormap, color_name, color)) {
wwarning(_("could not parse color \"%s\""), color_name);
return False;
} |
functions | int wGetColor(WScreen *scr, const char *color_name, XColor *color)
{
return wGetColorForColormap(scr->w_colormap, color_name, color);
} |
functions | void wFreeColor(WScreen * scr, unsigned long pixel)
{
if (pixel != scr->white_pixel && pixel != scr->black_pixel) {
unsigned long colors[1];
colors[0] = pixel;
XFreeColors(dpy, scr->w_colormap, colors, 1, 0);
} |
functions | uint32_t vpb_pci_config_addr(target_phys_addr_t addr)
{
return addr & 0xffffff;
} |
functions | void pci_vpb_config_writeb (void *opaque, target_phys_addr_t addr,
uint32_t val)
{
pci_data_write(opaque, vpb_pci_config_addr (addr), val, 1);
} |
functions | void pci_vpb_config_writew (void *opaque, target_phys_addr_t addr,
uint32_t val)
{
#ifdef TARGET_WORDS_BIGENDIAN
val = bswap16(val);
#endif
pci_data_write(opaque, vpb_pci_config_addr (addr), val, 2);
} |
functions | void pci_vpb_config_writel (void *opaque, target_phys_addr_t addr,
uint32_t val)
{
#ifdef TARGET_WORDS_BIGENDIAN
val = bswap32(val);
#endif
pci_data_write(opaque, vpb_pci_config_addr (addr), val, 4);
} |
functions | uint32_t pci_vpb_config_readb (void *opaque, target_phys_addr_t addr)
{
uint32_t val;
val = pci_data_read(opaque, vpb_pci_config_addr (addr), 1);
return val;
} |
functions | uint32_t pci_vpb_config_readw (void *opaque, target_phys_addr_t addr)
{
uint32_t val;
val = pci_data_read(opaque, vpb_pci_config_addr (addr), 2);
#ifdef TARGET_WORDS_BIGENDIAN
val = bswap16(val);
#endif
return val;
} |
functions | uint32_t pci_vpb_config_readl (void *opaque, target_phys_addr_t addr)
{
uint32_t val;
val = pci_data_read(opaque, vpb_pci_config_addr (addr), 4);
#ifdef TARGET_WORDS_BIGENDIAN
val = bswap32(val);
#endif
return val;
} |
functions | int pci_vpb_map_irq(PCIDevice *d, int irq_num)
{
return irq_num;
} |
functions | void pci_vpb_set_irq(qemu_irq *pic, int irq_num, int level)
{
qemu_set_irq(pic[irq_num], level);
} |
functions | void pci_vpb_map(SysBusDevice *dev, target_phys_addr_t base)
{
PCIVPBState *s = (PCIVPBState *)dev;
/* Selfconfig area. */
cpu_register_physical_memory(base + 0x01000000, 0x1000000, s->mem_config);
/* Normal config area. */
cpu_register_physical_memory(base + 0x02000000, 0x1000000, s->mem_config);... |
functions | void pci_vpb_init(SysBusDevice *dev)
{
PCIVPBState *s = FROM_SYSBUS(PCIVPBState, dev);
PCIBus *bus;
int i;
for (i = 0; i < 4; i++) {
sysbus_init_irq(dev, &s->irq[i]);
} |
functions | void pci_realview_init(SysBusDevice *dev)
{
PCIVPBState *s = FROM_SYSBUS(PCIVPBState, dev);
s->realview = 1;
pci_vpb_init(dev);
} |
functions | void versatile_pci_host_init(PCIDevice *d)
{
pci_config_set_vendor_id(d->config, PCI_VENDOR_ID_XILINX);
/* Both boards have the same device ID. Oh well. */
pci_config_set_device_id(d->config, PCI_DEVICE_ID_XILINX_XC2VP30);
d->config[0x04] = 0x00;
d->config[0x05] = 0x00;
d->config[0x06] = 0x20;... |
functions | void versatile_pci_register_devices(void)
{
sysbus_register_dev("versatile_pci", sizeof(PCIVPBState), pci_vpb_init);
sysbus_register_dev("realview_pci", sizeof(PCIVPBState),
pci_realview_init);
pci_qdev_register(&versatile_pci_host_info);
} |
defines | #define CHECK_OP(N, MSG) \ |
structs | struct cfg_stats_d
{
long num_merged_labels;
}; |
structs | struct replace_decls_d
{
hash_map<tree, tree> *vars_map;
tree to_context;
}; |
structs | struct locus_discrim_map
{
location_t locus;
int discriminator;
}; |
structs | struct move_stmt_d
{
tree orig_block;
tree new_block;
tree from_context;
tree to_context;
hash_map<tree, tree> *vars_map;
htab_t new_label_map;
hash_map<void *, void *> *eh_map;
bool remap_decls_p;
}; |
functions | void
init_empty_tree_cfg_for_function (struct function *fn)
{
/* Initialize the basic block array. */
init_flow (fn);
profile_status_for_fn (fn) = PROFILE_ABSENT;
n_basic_blocks_for_fn (fn) = NUM_FIXED_BLOCKS;
last_basic_block_for_fn (fn) = NUM_FIXED_BLOCKS;
vec_alloc (basic_block_info_for_fn (fn), initial... |
functions | void
init_empty_tree_cfg (void)
{
init_empty_tree_cfg_for_function (cfun);
} |
functions | void
build_gimple_cfg (gimple_seq seq)
{
/* Register specific gimple functions. */
gimple_register_cfg_hooks ();
memset ((void *) &cfg_stats, 0, sizeof (cfg_stats));
init_empty_tree_cfg ();
make_blocks (seq);
/* Make sure there is always at least one block, even if it's empty. */
if (n_basic_blocks_... |
functions | void
replace_loop_annotate_in_block (basic_block bb, struct loop *loop)
{
gimple_stmt_iterator gsi = gsi_last_bb (bb);
gimple stmt = gsi_stmt (gsi);
if (!(stmt && gimple_code (stmt) == GIMPLE_COND))
return;
for (gsi_prev_nondebug (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi))
{
stmt = gsi_stmt (gsi)... |
functions | void
replace_loop_annotate (void)
{
struct loop *loop;
basic_block bb;
gimple_stmt_iterator gsi;
gimple stmt;
FOR_EACH_LOOP (loop, 0)
{
/* First look into the header. */
replace_loop_annotate_in_block (loop->header, loop);
/* Then look into the latch, if any. */
if (loop->latch... |
functions | int
execute_build_cfg (void)
{
gimple_seq body = gimple_body (current_function_decl);
build_gimple_cfg (body);
gimple_set_body (current_function_decl, NULL);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Scope blocks:\n");
dump_scope_blocks (dump_file, dump_flags);
} |
functions | int execute (function *) { return execute_build_cfg (); } |
functions | bool
computed_goto_p (gimple t)
{
return (gimple_code (t) == GIMPLE_GOTO
&& TREE_CODE (gimple_goto_dest (t)) != LABEL_DECL);
} |
functions | bool
assert_unreachable_fallthru_edge_p (edge e)
{
basic_block pred_bb = e->src;
gimple last = last_stmt (pred_bb);
if (last && gimple_code (last) == GIMPLE_COND)
{
basic_block other_bb = EDGE_SUCC (pred_bb, 0)->dest;
if (other_bb == e->dest)
other_bb = EDGE_SUCC (pred_bb, 1)->dest;
if (EDG... |
functions | void
gimple_call_initialize_ctrl_altering (gimple stmt)
{
int flags = gimple_call_flags (stmt);
/* A call alters control flow if it can make an abnormal goto. */
if (call_can_make_abnormal_goto (stmt)
/* A call also alters control flow if it does not return. */
|| flags & ECF_NORETURN
/* TM e... |
functions | basic_block
make_blocks_1 (gimple_seq seq, basic_block bb)
{
gimple_stmt_iterator i = gsi_start (seq);
gimple stmt = NULL;
bool start_new_block = true;
bool first_stmt_of_seq = true;
while (!gsi_end_p (i))
{
gimple prev_stmt;
prev_stmt = stmt;
stmt = gsi_stmt (i);
if (stmt && is... |
functions | void
make_blocks (gimple_seq seq)
{
make_blocks_1 (seq, ENTRY_BLOCK_PTR_FOR_FN (cfun));
} |
functions | basic_block
create_bb (void *h, void *e, basic_block after)
{
basic_block bb;
gcc_assert (!e);
/* Create and initialize a new basic block. Since alloc_block uses
GC allocation that clears memory to allocate a basic block, we do
not have to clear the newly allocated basic block here. */
bb = alloc_... |
functions | basic_block
get_abnormal_succ_dispatcher (basic_block bb)
{
edge e;
edge_iterator ei;
FOR_EACH_EDGE (e, ei, bb->succs)
if ((e->flags & (EDGE_ABNORMAL | EDGE_EH)) == EDGE_ABNORMAL)
{
gimple_stmt_iterator gsi
= gsi_start_nondebug_after_labels_bb (e->dest);
gimple g = gsi_stmt (gsi);
if (g
&& i... |
functions | void
handle_abnormal_edges (basic_block *dispatcher_bbs,
basic_block for_bb, int *bb_to_omp_idx,
auto_vec<basic_block> *bbs, bool computed_goto)
{
basic_block *dispatcher = dispatcher_bbs + (computed_goto ? 1 : 0);
unsigned int idx = 0;
basic_block bb;
bool inner = false;
if (bb_to_omp_idx)... |
functions | int
make_edges_bb (basic_block bb, struct omp_region **pcur_region, int *pomp_index)
{
gimple last = last_stmt (bb);
bool fallthru = false;
int ret = 0;
if (!last)
return ret;
switch (gimple_code (last))
{
case GIMPLE_GOTO:
if (make_goto_expr_edges (bb))
ret = 1;
fallthru = false;
... |
functions | void
make_edges (void)
{
basic_block bb;
struct omp_region *cur_region = NULL;
auto_vec<basic_block> ab_edge_goto;
auto_vec<basic_block> ab_edge_call;
int *bb_to_omp_idx = NULL;
int cur_omp_region_idx = 0;
/* Create an edge from entry to the first block with executable
statements in it. */
make_e... |
functions | bool
gimple_find_sub_bbs (gimple_seq seq, gimple_stmt_iterator *gsi)
{
gimple stmt = gsi_stmt (*gsi);
basic_block bb = gimple_bb (stmt);
basic_block lastbb, afterbb;
int old_num_bbs = n_basic_blocks_for_fn (cfun);
edge e;
lastbb = make_blocks_1 (seq, bb);
if (old_num_bbs == n_basic_blocks_for_fn (cfun))
... |
functions | int
next_discriminator_for_locus (location_t locus)
{
struct locus_discrim_map item;
struct locus_discrim_map **slot;
item.locus = locus;
item.discriminator = 0;
slot = discriminator_per_locus->find_slot_with_hash (
&item, LOCATION_LINE (locus), INSERT);
gcc_assert (slot);
if (*slot == HTAB_EMPTY_E... |
functions | bool
same_line_p (location_t locus1, location_t locus2)
{
expanded_location from, to;
if (locus1 == locus2)
return true;
from = expand_location (locus1);
to = expand_location (locus2);
if (from.line != to.line)
return false;
if (from.file == to.file)
return true;
return (from.file != NULL
... |
functions | void
assign_discriminators (void)
{
basic_block bb;
FOR_EACH_BB_FN (bb, cfun)
{
edge e;
edge_iterator ei;
gimple last = last_stmt (bb);
location_t locus = last ? gimple_location (last) : UNKNOWN_LOCATION;
if (locus == UNKNOWN_LOCATION)
continue;
FOR_EACH_EDGE (e, ei, bb->... |
functions | void
make_cond_expr_edges (basic_block bb)
{
gcond *entry = as_a <gcond *> (last_stmt (bb));
gimple then_stmt, else_stmt;
basic_block then_bb, else_bb;
tree then_label, else_label;
edge e;
gcc_assert (entry);
gcc_assert (gimple_code (entry) == GIMPLE_COND);
/* Entry basic blocks for each component. *... |
functions | bool
edge_to_cases_cleanup (edge const &, tree const &value, void *)
{
tree t, next;
for (t = value; t; t = next)
{
next = CASE_CHAIN (t);
CASE_CHAIN (t) = NULL;
} |
functions | void
start_recording_case_labels (void)
{
gcc_assert (edge_to_cases == NULL);
edge_to_cases = new hash_map<edge, tree>;
touched_switch_bbs = BITMAP_ALLOC (NULL);
} |
functions | bool
recording_case_labels_p (void)
{
return (edge_to_cases != NULL);
} |
functions | void
end_recording_case_labels (void)
{
bitmap_iterator bi;
unsigned i;
edge_to_cases->traverse<void *, edge_to_cases_cleanup> (NULL);
delete edge_to_cases;
edge_to_cases = NULL;
EXECUTE_IF_SET_IN_BITMAP (touched_switch_bbs, 0, i, bi)
{
basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i);
if (bb)
... |
functions | tree
get_cases_for_edge (edge e, gswitch *t)
{
tree *slot;
size_t i, n;
/* If we are not recording cases, then we do not have CASE_LABEL_EXPR
chains available. Return NULL so the caller can detect this case. */
if (!recording_case_labels_p ())
return NULL;
slot = edge_to_cases->get (e);
if (slo... |
functions | void
make_gimple_switch_edges (gswitch *entry, basic_block bb)
{
size_t i, n;
n = gimple_switch_num_labels (entry);
for (i = 0; i < n; ++i)
{
tree lab = CASE_LABEL (gimple_switch_label (entry, i));
basic_block label_bb = label_to_block (lab);
make_edge (bb, label_bb, 0);
} |
functions | basic_block
label_to_block_fn (struct function *ifun, tree dest)
{
int uid = LABEL_DECL_UID (dest);
/* We would die hard when faced by an undefined label. Emit a label to
the very first basic block. This will hopefully make even the dataflow
and undefined variable warnings quite right. */
if (seen_e... |
functions | bool
make_goto_expr_edges (basic_block bb)
{
gimple_stmt_iterator last = gsi_last_bb (bb);
gimple goto_t = gsi_stmt (last);
/* A simple GOTO creates normal edges. */
if (simple_goto_p (goto_t))
{
tree dest = gimple_goto_dest (goto_t);
basic_block label_bb = label_to_block (dest);
edge e ... |
functions | void
make_gimple_asm_edges (basic_block bb)
{
gasm *stmt = as_a <gasm *> (last_stmt (bb));
int i, n = gimple_asm_nlabels (stmt);
for (i = 0; i < n; ++i)
{
tree label = TREE_VALUE (gimple_asm_label_op (stmt, i));
basic_block label_bb = label_to_block (label);
make_edge (bb, label_bb, 0);
... |
functions | tree
main_block_label (tree label)
{
basic_block bb = label_to_block (label);
tree main_label = label_for_bb[bb->index].label;
/* label_to_block possibly inserted undefined label into the chain. */
if (!main_label)
{
label_for_bb[bb->index].label = label;
main_label = label;
} |
functions | void
cleanup_dead_labels_eh (void)
{
eh_landing_pad lp;
eh_region r;
tree lab;
int i;
if (cfun->eh == NULL)
return;
for (i = 1; vec_safe_iterate (cfun->eh->lp_array, i, &lp); ++i)
if (lp && lp->post_landing_pad)
{
lab = main_block_label (lp->post_landing_pad);
if (lab != lp->post_landing_p... |
functions | void
cleanup_dead_labels (void)
{
basic_block bb;
label_for_bb = XCNEWVEC (struct label_record, last_basic_block_for_fn (cfun));
/* Find a suitable label for each block. We use the first user-defined
label if there is one, or otherwise just the first label we see. */
FOR_EACH_BB_FN (bb, cfun)
{
... |
functions | void
group_case_labels_stmt (gswitch *stmt)
{
int old_size = gimple_switch_num_labels (stmt);
int i, j, new_size = old_size;
basic_block default_bb = NULL;
default_bb = label_to_block (CASE_LABEL (gimple_switch_default_label (stmt)));
/* Look for possible opportunities to merge cases. */
i = 1;
while (... |
functions | void
group_case_labels (void)
{
basic_block bb;
FOR_EACH_BB_FN (bb, cfun)
{
gimple stmt = last_stmt (bb);
if (stmt && gimple_code (stmt) == GIMPLE_SWITCH)
group_case_labels_stmt (as_a <gswitch *> (stmt));
} |
functions | bool
gimple_can_merge_blocks_p (basic_block a, basic_block b)
{
gimple stmt;
if (!single_succ_p (a))
return false;
if (single_succ_edge (a)->flags & EDGE_COMPLEX)
return false;
if (single_succ (a) != b)
return false;
if (!single_pred_p (b))
return false;
if (a == ENTRY_BLOCK_PTR_FOR_FN ... |
functions | void
replace_uses_by (tree name, tree val)
{
imm_use_iterator imm_iter;
use_operand_p use;
gimple stmt;
edge e;
FOR_EACH_IMM_USE_STMT (stmt, imm_iter, name)
{
/* Mark the block if we change the last stmt in it. */
if (cfgcleanup_altered_bbs
&& stmt_ends_bb_p (stmt))
bitmap_set_bit (cfgcl... |
functions | void
gimple_merge_blocks (basic_block a, basic_block b)
{
gimple_stmt_iterator last, gsi;
gphi_iterator psi;
if (dump_file)
fprintf (dump_file, "Merging blocks %d and %d\n", a->index, b->index);
/* Remove all single-valued PHI nodes from block B of the form
V_i = PHI <V_j> by propagating V_j to all t... |
functions | basic_block
single_noncomplex_succ (basic_block bb)
{
edge e0, e1;
if (EDGE_COUNT (bb->succs) != 2)
return bb;
e0 = EDGE_SUCC (bb, 0);
e1 = EDGE_SUCC (bb, 1);
if (e0->flags & EDGE_COMPLEX)
return e1->dest;
if (e1->flags & EDGE_COMPLEX)
return e0->dest;
return bb;
} |
functions | void
notice_special_calls (gcall *call)
{
int flags = gimple_call_flags (call);
if (flags & ECF_MAY_BE_ALLOCA)
cfun->calls_alloca = true;
if (flags & ECF_RETURNS_TWICE)
cfun->calls_setjmp = true;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.