type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
functions | void
dump_function_to_file (tree fndecl, FILE *file, int flags)
{
tree arg, var, old_current_fndecl = current_function_decl;
struct function *dsf;
bool ignore_topmost_bind = false, any_var = false;
basic_block bb;
tree chain;
bool tmclone = (TREE_CODE (fndecl) == FUNCTION_DECL
&& decl_is_tm_clone (fndec... |
functions | void
debug_function (tree fn, int flags)
{
dump_function_to_file (fn, stderr, flags);
} |
functions | void
print_pred_bbs (FILE *file, basic_block bb)
{
edge e;
edge_iterator ei;
FOR_EACH_EDGE (e, ei, bb->preds)
fprintf (file, "bb_%d ", e->src->index);
} |
functions | void
print_succ_bbs (FILE *file, basic_block bb)
{
edge e;
edge_iterator ei;
FOR_EACH_EDGE (e, ei, bb->succs)
fprintf (file, "bb_%d ", e->dest->index);
} |
functions | void
print_loops_bb (FILE *file, basic_block bb, int indent, int verbosity)
{
char *s_indent = (char *) alloca ((size_t) indent + 1);
memset ((void *) s_indent, ' ', (size_t) indent);
s_indent[indent] = '\0';
/* Print basic_block's header. */
if (verbosity >= 2)
{
fprintf (file, "%s bb_%d (preds ... |
functions | void
print_loop (FILE *file, struct loop *loop, int indent, int verbosity)
{
char *s_indent;
basic_block bb;
if (loop == NULL)
return;
s_indent = (char *) alloca ((size_t) indent + 1);
memset ((void *) s_indent, ' ', (size_t) indent);
s_indent[indent] = '\0';
/* Print loop's header. */
fprintf (... |
functions | void
print_loop_and_siblings (FILE *file, struct loop *loop, int indent,
int verbosity)
{
if (loop == NULL)
return;
print_loop (file, loop, indent, verbosity);
print_loop_and_siblings (file, loop->next, indent, verbosity);
} |
functions | void
print_loops (FILE *file, int verbosity)
{
basic_block bb;
bb = ENTRY_BLOCK_PTR_FOR_FN (cfun);
if (bb && bb->loop_father)
print_loop_and_siblings (file, bb->loop_father, 0, verbosity);
} |
functions | void
debug (struct loop &ref)
{
print_loop (stderr, &ref, 0, /*verbosity*/0);
} |
functions | void
debug (struct loop *ptr)
{
if (ptr)
debug (*ptr);
else
fprintf (stderr, "<nil>\n");
} |
functions | void
debug_verbose (struct loop &ref)
{
print_loop (stderr, &ref, 0, /*verbosity*/3);
} |
functions | void
debug_verbose (struct loop *ptr)
{
if (ptr)
debug (*ptr);
else
fprintf (stderr, "<nil>\n");
} |
functions | void
debug_loops (int verbosity)
{
print_loops (stderr, verbosity);
} |
functions | void
debug_loop (struct loop *loop, int verbosity)
{
print_loop (stderr, loop, 0, verbosity);
} |
functions | void
debug_loop_num (unsigned num, int verbosity)
{
debug_loop (get_loop (cfun, num), verbosity);
} |
functions | bool
gimple_block_ends_with_call_p (basic_block bb)
{
gimple_stmt_iterator gsi = gsi_last_nondebug_bb (bb);
return !gsi_end_p (gsi) && is_gimple_call (gsi_stmt (gsi));
} |
functions | bool
gimple_block_ends_with_condjump_p (const_basic_block bb)
{
gimple stmt = last_stmt (CONST_CAST_BB (bb));
return (stmt && gimple_code (stmt) == GIMPLE_COND);
} |
functions | bool
need_fake_edge_p (gimple t)
{
tree fndecl = NULL_TREE;
int call_flags = 0;
/* NORETURN and LONGJMP calls already have an edge to exit.
CONST and PURE calls do not need one.
We don't currently check for CONST and PURE here, although
it would be a good idea, because those attributes are
fi... |
functions | int
gimple_flow_call_edges_add (sbitmap blocks)
{
int i;
int blocks_split = 0;
int last_bb = last_basic_block_for_fn (cfun);
bool check_last_block = false;
if (n_basic_blocks_for_fn (cfun) == NUM_FIXED_BLOCKS)
return 0;
if (! blocks)
check_last_block = true;
else
check_last_block = bitmap_bi... |
functions | ENABLE_CHECKING
if (stmt == last_stmt)
{
e = find_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun));
gcc_assert (e == NULL);
} |
functions | void
remove_edge_and_dominated_blocks (edge e)
{
vec<basic_block> bbs_to_remove = vNULL;
vec<basic_block> bbs_to_fix_dom = vNULL;
bitmap df, df_idom;
edge f;
edge_iterator ei;
bool none_removed = false;
unsigned i;
basic_block bb, dbb;
bitmap_iterator bi;
/* If we are removing a path inside a non-r... |
functions | bool
gimple_purge_dead_eh_edges (basic_block bb)
{
bool changed = false;
edge e;
edge_iterator ei;
gimple stmt = last_stmt (bb);
if (stmt && stmt_can_throw_internal (stmt))
return false;
for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
{
if (e->flags & EDGE_EH)
{
remove_edge_an... |
functions | bool
gimple_purge_all_dead_eh_edges (const_bitmap blocks)
{
bool changed = false;
unsigned i;
bitmap_iterator bi;
EXECUTE_IF_SET_IN_BITMAP (blocks, 0, i, bi)
{
basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i);
/* Earlier gimple_purge_dead_eh_edges could have removed
this basic block already. *... |
functions | bool
gimple_purge_dead_abnormal_call_edges (basic_block bb)
{
bool changed = false;
edge e;
edge_iterator ei;
gimple stmt = last_stmt (bb);
if (!cfun->has_nonlocal_label
&& !cfun->calls_setjmp)
return false;
if (stmt && stmt_can_make_abnormal_goto (stmt))
return false;
for (ei = ei_start ... |
functions | bool
gimple_purge_all_dead_abnormal_call_edges (const_bitmap blocks)
{
bool changed = false;
unsigned i;
bitmap_iterator bi;
EXECUTE_IF_SET_IN_BITMAP (blocks, 0, i, bi)
{
basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i);
/* Earlier gimple_purge_dead_abnormal_call_edges could have removed
this b... |
functions | void
gimple_execute_on_growing_pred (edge e)
{
basic_block bb = e->dest;
if (!gimple_seq_empty_p (phi_nodes (bb)))
reserve_phi_args_for_new_edge (bb);
} |
functions | void
gimple_execute_on_shrinking_pred (edge e)
{
if (!gimple_seq_empty_p (phi_nodes (e->dest)))
remove_phi_args (e);
} |
functions | void
gimple_lv_adjust_loop_header_phi (basic_block first, basic_block second,
basic_block new_head, edge e)
{
gphi *phi1, *phi2;
gphi_iterator psi1, psi2;
tree def;
edge e2 = find_edge (new_head, second);
/* Because NEW_HEAD has been created by splitting SECOND's incoming
edge, we should always ha... |
functions | void
gimple_lv_add_condition_to_bb (basic_block first_head ATTRIBUTE_UNUSED,
basic_block second_head ATTRIBUTE_UNUSED,
basic_block cond_bb, void *cond_e)
{
gimple_stmt_iterator gsi;
gimple new_cond_expr;
tree cond_expr = (tree) cond_e;
edge e0;
/* Build new conditional expr */
new_cond_... |
functions | void
gimple_account_profile_record (basic_block bb, int after_pass,
struct profile_record *record)
{
gimple_stmt_iterator i;
for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
{
record->size[after_pass]
+= estimate_num_insns (gsi_stmt (i), &eni_size_weights);
if (profile_status_fo... |
functions | int
split_critical_edges (void)
{
basic_block bb;
edge e;
edge_iterator ei;
/* split_edge can redirect edges out of SWITCH_EXPRs, which can get
expensive. So we want to enable recording of edge to CASE_LABEL_EXPR
mappings around the calls to split_edge. */
start_recording_case_labels ();
FOR_AL... |
functions | int execute (function *) { return split_critical_edges (); } |
functions | basic_block
insert_cond_bb (basic_block bb, gimple stmt, gimple cond)
{
edge fall = split_block (bb, stmt);
gimple_stmt_iterator iter = gsi_last_bb (bb);
basic_block new_bb;
/* Insert cond statement. */
gcc_assert (gimple_code (cond) == GIMPLE_COND);
if (gsi_end_p (iter))
gsi_insert_before (&iter, con... |
functions | tree
gimplify_build3 (gimple_stmt_iterator *gsi, enum tree_code code,
tree type, tree a, tree b, tree c)
{
tree ret;
location_t loc = gimple_location (gsi_stmt (*gsi));
ret = fold_build3_loc (loc, code, type, a, b, c);
STRIP_NOPS (ret);
return force_gimple_operand_gsi (gsi, ret, true, NULL, true,
... |
functions | tree
gimplify_build2 (gimple_stmt_iterator *gsi, enum tree_code code,
tree type, tree a, tree b)
{
tree ret;
ret = fold_build2_loc (gimple_location (gsi_stmt (*gsi)), code, type, a, b);
STRIP_NOPS (ret);
return force_gimple_operand_gsi (gsi, ret, true, NULL, true,
GSI_SAM... |
functions | tree
gimplify_build1 (gimple_stmt_iterator *gsi, enum tree_code code, tree type,
tree a)
{
tree ret;
ret = fold_build1_loc (gimple_location (gsi_stmt (*gsi)), code, type, a);
STRIP_NOPS (ret);
return force_gimple_operand_gsi (gsi, ret, true, NULL, true,
GSI_SAME_STMT);
} |
functions | void
extract_true_false_edges_from_block (basic_block b,
edge *true_edge,
edge *false_edge)
{
edge e = EDGE_SUCC (b, 0);
if (e->flags & EDGE_TRUE_VALUE)
{
*true_edge = e;
*false_edge = EDGE_SUCC (b, 1);
} |
functions | void
do_warn_unused_result (gimple_seq seq)
{
tree fdecl, ftype;
gimple_stmt_iterator i;
for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
{
gimple g = gsi_stmt (i);
switch (gimple_code (g))
{
case GIMPLE_BIND:
do_warn_unused_result (gimple_bind_body (as_a <gbind *>(g)));
break;
... |
functions | bool gate (function *) { return flag_warn_unused_result; } |
functions | int execute (function *)
{
do_warn_unused_result (gimple_body (current_function_decl));
return 0;
} |
functions | int
execute_fixup_cfg (void)
{
basic_block bb;
gimple_stmt_iterator gsi;
int todo = 0;
gcov_type count_scale;
edge e;
edge_iterator ei;
count_scale
= GCOV_COMPUTE_SCALE (cgraph_node::get (current_function_decl)->count,
ENTRY_BLOCK_PTR_FOR_FN (cfun)->count);
ENTRY_BLOCK_PTR_FOR_FN (cfun)->... |
functions | int execute (function *) { return execute_fixup_cfg (); } |
functions | void
gt_ggc_mx (rtx_insn *& x)
{
if (x)
gt_ggc_mx_rtx_def ((void *) x);
} |
functions | void
gt_ggc_mx (edge_def *e)
{
tree block = LOCATION_BLOCK (e->goto_locus);
gt_ggc_mx (e->src);
gt_ggc_mx (e->dest);
if (current_ir_type () == IR_GIMPLE)
gt_ggc_mx (e->insns.g);
else
gt_ggc_mx (e->insns.r);
gt_ggc_mx (block);
} |
functions | void
gt_pch_nx (rtx_insn *& x)
{
if (x)
gt_pch_nx_rtx_def ((void *) x);
} |
functions | void
gt_pch_nx (edge_def *e)
{
tree block = LOCATION_BLOCK (e->goto_locus);
gt_pch_nx (e->src);
gt_pch_nx (e->dest);
if (current_ir_type () == IR_GIMPLE)
gt_pch_nx (e->insns.g);
else
gt_pch_nx (e->insns.r);
gt_pch_nx (block);
} |
functions | void
gt_pch_nx (edge_def *e, gt_pointer_operator op, void *cookie)
{
tree block = LOCATION_BLOCK (e->goto_locus);
op (&(e->src), cookie);
op (&(e->dest), cookie);
if (current_ir_type () == IR_GIMPLE)
op (&(e->insns.g), cookie);
else
op (&(e->insns.r), cookie);
op (&(block), cookie);
} |
includes |
#include <linux/kernel.h> |
includes | #include <linux/module.h> |
includes | #include <linux/debugfs.h> |
includes | #include <linux/uaccess.h> |
includes | #include <linux/pci.h> |
includes | #include <linux/interrupt.h> |
includes | #include <linux/irq.h> |
includes | #include <linux/irqdomain.h> |
includes | #include <linux/clk.h> |
includes | #include <linux/delay.h> |
includes | #include <linux/export.h> |
includes | #include <linux/clk/tegra.h> |
includes | #include <linux/msi.h> |
includes | #include <linux/slab.h> |
includes | #include <linux/platform_device.h> |
includes | #include <linux/regulator/consumer.h> |
includes | #include <linux/workqueue.h> |
includes | #include <linux/gpio.h> |
includes | #include <linux/clk.h> |
includes | #include <linux/clk/tegra.h> |
includes | #include <linux/async.h> |
includes | #include <linux/vmalloc.h> |
includes | #include <linux/pm_runtime.h> |
includes | #include <linux/tegra-powergate.h> |
includes | #include <linux/tegra-soc.h> |
includes | #include <linux/pci-tegra.h> |
includes | #include <linux/of_device.h> |
includes | #include <linux/of_address.h> |
includes | #include <linux/of_gpio.h> |
includes | #include <linux/of_pci.h> |
includes | #include <linux/tegra_pm_domains.h> |
includes | #include <linux/pinctrl/pinctrl.h> |
includes | #include <linux/pinctrl/consumer.h> |
includes | #include <linux/pinctrl/pinconf-tegra.h> |
includes |
#include <asm/sizes.h> |
includes | #include <asm/mach/pci.h> |
includes | #include <asm/io.h> |
includes |
#include <mach/tegra_usb_pad_ctrl.h> |
includes | #include <mach/io_dpd.h> |
defines |
#define PCI_CFG_SPACE_SIZE 256 |
defines | #define PCI_EXT_CFG_SPACE_SIZE 4096 |
defines |
#define AFI_AXI_BAR0_SZ 0x00 |
defines | #define AFI_AXI_BAR1_SZ 0x04 |
defines | #define AFI_AXI_BAR2_SZ 0x08 |
defines | #define AFI_AXI_BAR3_SZ 0x0c |
defines | #define AFI_AXI_BAR4_SZ 0x10 |
defines | #define AFI_AXI_BAR5_SZ 0x14 |
defines |
#define AFI_AXI_BAR0_START 0x18 |
defines | #define AFI_AXI_BAR1_START 0x1c |
defines | #define AFI_AXI_BAR2_START 0x20 |
defines | #define AFI_AXI_BAR3_START 0x24 |
defines | #define AFI_AXI_BAR4_START 0x28 |
defines | #define AFI_AXI_BAR5_START 0x2c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.