class pending_diagnostic;
class pending_note;
+struct event_loc_info;
class state_change_event;
class checker_path;
class extrinsic_state;
void add_region_creation_events (const region *,
tree capacity,
- location_t loc,
- tree fndecl, int depth,
+ const event_loc_info &loc_info,
checker_path &emission_path) override
{
/* The memory space is described in the diagnostic message itself,
so we don't need an event for that. */
if (capacity)
emission_path.add_event
- (make_unique<region_creation_event_capacity> (capacity,
- loc, fndecl, depth));
+ (make_unique<region_creation_event_capacity> (capacity, loc_info));
}
protected:
void add_region_creation_events (const region *,
tree,
- location_t loc,
- tree fndecl, int depth,
+ const event_loc_info &loc_info,
checker_path &emission_path) final override
{
if (m_byte_bound && TREE_CODE (m_byte_bound) == INTEGER_CST)
emission_path.add_event
- (make_unique<region_creation_event_capacity> (m_byte_bound,
- loc, fndecl, depth));
+ (make_unique<region_creation_event_capacity> (m_byte_bound, loc_info));
}
protected:
class call_event : public custom_event
{
public:
- call_event (location_t loc, tree fndecl, int depth,
+ call_event (const event_loc_info &loc_info,
const call_info *call_info)
- : custom_event (loc, fndecl, depth),
- m_call_info (call_info)
+ : custom_event (loc_info),
+ m_call_info (call_info)
{}
label_text get_desc (bool can_colorize) const final override
tree caller_fndecl = src_point.get_fndecl ();
const int stack_depth = src_point.get_stack_depth ();
- emission_path->add_event (make_unique<call_event> (get_call_stmt ()->location,
- caller_fndecl,
- stack_depth,
- this));
+ emission_path->add_event
+ (make_unique<call_event> (event_loc_info (get_call_stmt ()->location,
+ caller_fndecl,
+ stack_depth),
+ this));
}
/* Recreate a call_details instance from this call_info. */
/* checker_event's ctor. */
checker_event::checker_event (enum event_kind kind,
- location_t loc, tree fndecl, int depth)
-: m_kind (kind), m_loc (loc),
- m_original_fndecl (fndecl), m_effective_fndecl (fndecl),
- m_original_depth (depth), m_effective_depth (depth),
+ const event_loc_info &loc_info)
+: m_kind (kind), m_loc (loc_info.m_loc),
+ m_original_fndecl (loc_info.m_fndecl),
+ m_effective_fndecl (loc_info.m_fndecl),
+ m_original_depth (loc_info.m_depth),
+ m_effective_depth (loc_info.m_depth),
m_pending_diagnostic (NULL), m_emission_id (),
- m_logical_loc (fndecl)
+ m_logical_loc (loc_info.m_fndecl)
{
/* Update effective fndecl and depth if inlining has been recorded. */
if (flag_analyzer_undo_inlining)
{
- inlining_info info (loc);
+ inlining_info info (m_loc);
if (info.get_inner_fndecl ())
{
m_effective_fndecl = info.get_inner_fndecl ();
statement_event::statement_event (const gimple *stmt, tree fndecl, int depth,
const program_state &dst_state)
-: checker_event (EK_STMT, gimple_location (stmt), fndecl, depth),
+: checker_event (EK_STMT,
+ event_loc_info (gimple_location (stmt), fndecl, depth)),
m_stmt (stmt),
m_dst_state (dst_state)
{
/* class region_creation_event : public checker_event. */
-region_creation_event::region_creation_event (location_t loc,
- tree fndecl,
- int depth)
-: checker_event (EK_REGION_CREATION, loc, fndecl, depth)
+region_creation_event::region_creation_event (const event_loc_info &loc_info)
+: checker_event (EK_REGION_CREATION, loc_info)
{
}
function_entry_event::function_entry_event (const program_point &dst_point)
: checker_event (EK_FUNCTION_ENTRY,
- dst_point.get_supernode ()->get_start_location (),
- dst_point.get_fndecl (),
- dst_point.get_stack_depth ())
+ event_loc_info (dst_point.get_supernode
+ ()->get_start_location (),
+ dst_point.get_fndecl (),
+ dst_point.get_stack_depth ()))
{
}
const svalue *origin,
const program_state &dst_state)
: checker_event (EK_STATE_CHANGE,
- stmt->location, node->m_fun->decl,
- stack_depth),
+ event_loc_info (stmt->location,
+ node->m_fun->decl,
+ stack_depth)),
m_node (node), m_stmt (stmt), m_sm (sm),
m_sval (sval), m_from (from), m_to (to),
m_origin (origin),
superedge_event::superedge_event (enum event_kind kind,
const exploded_edge &eedge,
- location_t loc, tree fndecl, int depth)
-: checker_event (kind, loc, fndecl, depth),
+ const event_loc_info &loc_info)
+: checker_event (kind, loc_info),
m_eedge (eedge), m_sedge (eedge.m_sedge),
m_var (NULL_TREE), m_critical_state (0)
{
cfg_edge_event::cfg_edge_event (enum event_kind kind,
const exploded_edge &eedge,
- location_t loc, tree fndecl, int depth)
-: superedge_event (kind, eedge, loc, fndecl, depth)
+ const event_loc_info &loc_info)
+: superedge_event (kind, eedge, loc_info)
{
gcc_assert (eedge.m_sedge->m_kind == SUPEREDGE_CFG_EDGE);
}
/* call_event's ctor. */
call_event::call_event (const exploded_edge &eedge,
- location_t loc, tree fndecl, int depth)
-: superedge_event (EK_CALL_EDGE, eedge, loc, fndecl, depth)
+ const event_loc_info &loc_info)
+: superedge_event (EK_CALL_EDGE, eedge, loc_info)
{
if (eedge.m_sedge)
gcc_assert (eedge.m_sedge->m_kind == SUPEREDGE_CALL);
/* return_event's ctor. */
return_event::return_event (const exploded_edge &eedge,
- location_t loc, tree fndecl, int depth)
-: superedge_event (EK_RETURN_EDGE, eedge, loc, fndecl, depth)
+ const event_loc_info &loc_info)
+: superedge_event (EK_RETURN_EDGE, eedge, loc_info)
{
if (eedge.m_sedge)
gcc_assert (eedge.m_sedge->m_kind == SUPEREDGE_RETURN);
rewind_event::rewind_event (const exploded_edge *eedge,
enum event_kind kind,
- location_t loc, tree fndecl, int depth,
+ const event_loc_info &loc_info,
const rewind_info_t *rewind_info)
-: checker_event (kind, loc, fndecl, depth),
+: checker_event (kind, loc_info),
m_rewind_info (rewind_info),
m_eedge (eedge)
{
namespace ana {
+/* A bundle of location information for a checker_event. */
+
+struct event_loc_info
+{
+ event_loc_info (location_t loc, tree fndecl, int depth)
+ : m_loc (loc), m_fndecl (fndecl), m_depth (depth)
+ {}
+
+ location_t m_loc;
+ tree m_fndecl;
+ int m_depth;
+};
+
/* An enum for discriminating between the concrete subclasses of
checker_event. */
protected:
checker_event (enum event_kind kind,
- location_t loc, tree fndecl, int depth);
+ const event_loc_info &loc_info);
public:
const enum event_kind m_kind;
class debug_event : public checker_event
{
public:
- debug_event (location_t loc, tree fndecl, int depth,
- const char *desc)
- : checker_event (EK_DEBUG, loc, fndecl, depth),
+
+ debug_event (const event_loc_info &loc_info,
+ const char *desc)
+ : checker_event (EK_DEBUG, loc_info),
m_desc (xstrdup (desc))
{
}
class custom_event : public checker_event
{
protected:
- custom_event (location_t loc, tree fndecl, int depth)
- : checker_event (EK_CUSTOM, loc, fndecl, depth)
+ custom_event (const event_loc_info &loc_info)
+ : checker_event (EK_CUSTOM, loc_info)
{
}
};
class precanned_custom_event : public custom_event
{
public:
- precanned_custom_event (location_t loc, tree fndecl, int depth,
+ precanned_custom_event (const event_loc_info &loc_info,
const char *desc)
- : custom_event (loc, fndecl, depth),
+ : custom_event (loc_info),
m_desc (xstrdup (desc))
{
}
class region_creation_event : public checker_event
{
protected:
- region_creation_event (location_t loc, tree fndecl, int depth);
+ region_creation_event (const event_loc_info &loc_info);
};
/* Concrete subclass of region_creation_event.
{
public:
region_creation_event_memory_space (enum memory_space mem_space,
- location_t loc, tree fndecl, int depth)
- : region_creation_event (loc, fndecl, depth),
+ const event_loc_info &loc_info)
+ : region_creation_event (loc_info),
m_mem_space (mem_space)
{
}
{
public:
region_creation_event_capacity (tree capacity,
- location_t loc, tree fndecl, int depth)
- : region_creation_event (loc, fndecl, depth),
+ const event_loc_info &loc_info)
+ : region_creation_event (loc_info),
m_capacity (capacity)
{
gcc_assert (m_capacity);
{
public:
region_creation_event_allocation_size (tree capacity,
- location_t loc, tree fndecl, int depth)
- : region_creation_event (loc, fndecl, depth),
+ const event_loc_info &loc_info)
+ : region_creation_event (loc_info),
m_capacity (capacity)
{}
{
public:
region_creation_event_debug (const region *reg, tree capacity,
- location_t loc, tree fndecl, int depth)
- : region_creation_event (loc, fndecl, depth),
+ const event_loc_info &loc_info)
+ : region_creation_event (loc_info),
m_reg (reg), m_capacity (capacity)
{
}
class function_entry_event : public checker_event
{
public:
- function_entry_event (location_t loc, tree fndecl, int depth)
- : checker_event (EK_FUNCTION_ENTRY, loc, fndecl, depth)
+ function_entry_event (const event_loc_info &loc_info)
+ : checker_event (EK_FUNCTION_ENTRY, loc_info)
{
}
protected:
superedge_event (enum event_kind kind, const exploded_edge &eedge,
- location_t loc, tree fndecl, int depth);
+ const event_loc_info &loc_info);
public:
const exploded_edge &m_eedge;
protected:
cfg_edge_event (enum event_kind kind, const exploded_edge &eedge,
- location_t loc, tree fndecl, int depth);
+ const event_loc_info &loc_info);
};
/* A concrete event subclass for the start of a CFG edge
{
public:
start_cfg_edge_event (const exploded_edge &eedge,
- location_t loc, tree fndecl, int depth)
- : cfg_edge_event (EK_START_CFG_EDGE, eedge, loc, fndecl, depth)
+ const event_loc_info &loc_info)
+ : cfg_edge_event (EK_START_CFG_EDGE, eedge, loc_info)
{
}
{
public:
end_cfg_edge_event (const exploded_edge &eedge,
- location_t loc, tree fndecl, int depth)
- : cfg_edge_event (EK_END_CFG_EDGE, eedge, loc, fndecl, depth)
+ const event_loc_info &loc_info)
+ : cfg_edge_event (EK_END_CFG_EDGE, eedge, loc_info)
{
}
{
public:
call_event (const exploded_edge &eedge,
- location_t loc, tree fndecl, int depth);
+ const event_loc_info &loc_info);
label_text get_desc (bool can_colorize) const override;
meaning get_meaning () const override;
{
public:
return_event (const exploded_edge &eedge,
- location_t loc, tree fndecl, int depth);
+ const event_loc_info &loc_info);
label_text get_desc (bool can_colorize) const final override;
meaning get_meaning () const override;
class start_consolidated_cfg_edges_event : public checker_event
{
public:
- start_consolidated_cfg_edges_event (location_t loc, tree fndecl, int depth,
+ start_consolidated_cfg_edges_event (const event_loc_info &loc_info,
bool edge_sense)
- : checker_event (EK_START_CONSOLIDATED_CFG_EDGES, loc, fndecl, depth),
+ : checker_event (EK_START_CONSOLIDATED_CFG_EDGES, loc_info),
m_edge_sense (edge_sense)
{
}
class end_consolidated_cfg_edges_event : public checker_event
{
public:
- end_consolidated_cfg_edges_event (location_t loc, tree fndecl, int depth)
- : checker_event (EK_END_CONSOLIDATED_CFG_EDGES, loc, fndecl, depth)
+ end_consolidated_cfg_edges_event (const event_loc_info &loc_info)
+ : checker_event (EK_END_CONSOLIDATED_CFG_EDGES, loc_info)
{
}
tree apparent_caller_fndecl,
int actual_depth,
int stack_depth_adjustment)
- : checker_event (EK_INLINED_CALL, loc,
- apparent_caller_fndecl,
- actual_depth + stack_depth_adjustment),
+ : checker_event (EK_INLINED_CALL,
+ event_loc_info (loc,
+ apparent_caller_fndecl,
+ actual_depth + stack_depth_adjustment)),
m_apparent_callee_fndecl (apparent_callee_fndecl),
m_apparent_caller_fndecl (apparent_caller_fndecl)
{
class setjmp_event : public checker_event
{
public:
- setjmp_event (location_t loc, const exploded_node *enode,
- tree fndecl, int depth, const gcall *setjmp_call)
- : checker_event (EK_SETJMP, loc, fndecl, depth),
+ setjmp_event (const event_loc_info &loc_info,
+ const exploded_node *enode,
+ const gcall *setjmp_call)
+ : checker_event (EK_SETJMP, loc_info),
m_enode (enode), m_setjmp_call (setjmp_call)
{
}
protected:
rewind_event (const exploded_edge *eedge,
enum event_kind kind,
- location_t loc, tree fndecl, int depth,
+ const event_loc_info &loc_info,
const rewind_info_t *rewind_info);
const rewind_info_t *m_rewind_info;
{
public:
rewind_from_longjmp_event (const exploded_edge *eedge,
- location_t loc, tree fndecl, int depth,
+ const event_loc_info &loc_info,
const rewind_info_t *rewind_info)
- : rewind_event (eedge, EK_REWIND_FROM_LONGJMP, loc, fndecl, depth,
+ : rewind_event (eedge, EK_REWIND_FROM_LONGJMP, loc_info,
rewind_info)
{
}
{
public:
rewind_to_setjmp_event (const exploded_edge *eedge,
- location_t loc, tree fndecl, int depth,
+ const event_loc_info &loc_info,
const rewind_info_t *rewind_info)
- : rewind_event (eedge, EK_REWIND_TO_SETJMP, loc, fndecl, depth,
+ : rewind_event (eedge, EK_REWIND_TO_SETJMP, loc_info,
rewind_info)
{
}
class warning_event : public checker_event
{
public:
- warning_event (location_t loc, tree fndecl, int depth,
+ warning_event (const event_loc_info &loc_info,
const state_machine *sm,
tree var, state_machine::state_t state)
- : checker_event (EK_WARNING, loc, fndecl, depth),
+ : checker_event (EK_WARNING, loc_info),
m_sm (sm), m_var (var), m_state (state)
{
}
checker_path::add_region_creation_events (pending_diagnostic *pd,
const region *reg,
const region_model *model,
- location_t loc,
- tree fndecl, int depth,
+ const event_loc_info &loc_info,
bool debug)
{
tree capacity = NULL_TREE;
if (const svalue *capacity_sval = model->get_capacity (reg))
capacity = model->get_representative_tree (capacity_sval);
- pd->add_region_creation_events (reg, capacity, loc, fndecl, depth, *this);
+ pd->add_region_creation_events (reg, capacity, loc_info, *this);
if (debug)
add_event (make_unique<region_creation_event_debug> (reg, capacity,
- loc, fndecl, depth));
+ loc_info));
}
void
void add_region_creation_events (pending_diagnostic *pd,
const region *reg,
const region_model *model,
- location_t loc,
- tree fndecl, int depth,
+ const event_loc_info &loc_info,
bool debug);
/* After all event-pruning, a hook for notifying each event what
emission_path->add_region_creation_events
(pb.get_pending_diagnostic (),
reg, NULL,
- DECL_SOURCE_LOCATION (decl),
- NULL_TREE,
- 0,
+ event_loc_info (DECL_SOURCE_LOCATION (decl),
+ NULL_TREE,
+ 0),
m_verbosity > 3);
}
}
(pb.get_pending_diagnostic (),
reg,
dst_model,
- src_point.get_location (),
- src_point.get_fndecl (),
- src_stack_depth,
+ event_loc_info (src_point.get_location (),
+ src_point.get_fndecl (),
+ src_stack_depth),
false);
emitted = true;
break;
emission_path->add_region_creation_events
(pb.get_pending_diagnostic (),
reg, dst_state.m_region_model,
- DECL_SOURCE_LOCATION (decl),
- dst_point.get_fndecl (),
- dst_stack_depth,
+ event_loc_info (DECL_SOURCE_LOCATION (decl),
+ dst_point.get_fndecl (),
+ dst_stack_depth),
m_verbosity > 3);
}
}
const gcall *call = dyn_cast <const gcall *> (stmt);
if (call && is_setjmp_call_p (call))
emission_path->add_event
- (make_unique<setjmp_event> (stmt->location,
+ (make_unique<setjmp_event> (event_loc_info (stmt->location,
+ dst_point.get_fndecl (),
+ dst_stack_depth),
dst_node,
- dst_point.get_fndecl (),
- dst_stack_depth,
call));
else
emission_path->add_event
emission_path->add_region_creation_events
(pb.get_pending_diagnostic (),
reg, dst_model,
- src_point.get_location (),
- src_point.get_fndecl (),
- src_stack_depth,
+ event_loc_info (src_point.get_location (),
+ src_point.get_fndecl (),
+ src_stack_depth),
m_verbosity > 3);
break;
}
pb.get_feasibility_problem ()->dump_to_pp (&pp);
emission_path->add_event
(make_unique<precanned_custom_event>
- (dst_point.get_location (),
- dst_point.get_fndecl (),
- dst_stack_depth,
+ (event_loc_info (dst_point.get_location (),
+ dst_point.get_fndecl (),
+ dst_stack_depth),
pp_formatted_text (&pp)));
}
}
case SUPEREDGE_CFG_EDGE:
{
emission_path->add_event
- (make_unique<start_cfg_edge_event> (eedge,
- (last_stmt
- ? last_stmt->location
- : UNKNOWN_LOCATION),
- src_point.get_fndecl (),
- src_stack_depth));
+ (make_unique<start_cfg_edge_event>
+ (eedge,
+ event_loc_info (last_stmt ? last_stmt->location : UNKNOWN_LOCATION,
+ src_point.get_fndecl (),
+ src_stack_depth)));
emission_path->add_event
(make_unique<end_cfg_edge_event>
(eedge,
- dst_point.get_supernode ()->get_start_location (),
- dst_point.get_fndecl (),
- dst_stack_depth));
+ event_loc_info (dst_point.get_supernode ()->get_start_location (),
+ dst_point.get_fndecl (),
+ dst_stack_depth)));
}
break;
/* TODO: add a subclass for this, or generate events for the
summary. */
emission_path->add_event
- (make_unique<debug_event> ((last_stmt
- ? last_stmt->location
- : UNKNOWN_LOCATION),
- src_point.get_fndecl (),
- src_stack_depth,
+ (make_unique<debug_event> (event_loc_info (last_stmt
+ ? last_stmt->location
+ : UNKNOWN_LOCATION,
+ src_point.get_fndecl (),
+ src_stack_depth),
"call summary"));
}
break;
const gcall *call_stmt = return_edge->get_call_stmt ();
emission_path->add_event
(make_unique<return_event> (eedge,
- (call_stmt
- ? call_stmt->location
- : UNKNOWN_LOCATION),
- dst_point.get_fndecl (),
- dst_stack_depth));
+ event_loc_info (call_stmt
+ ? call_stmt->location
+ : UNKNOWN_LOCATION,
+ dst_point.get_fndecl (),
+ dst_stack_depth)));
}
break;
}
start_idx, next_idx - 1, start_idx, start_idx +1);
start_consolidated_cfg_edges_event *new_start_ev
= new start_consolidated_cfg_edges_event
- (old_start_ev->get_location (),
- old_start_ev->get_fndecl (),
- old_start_ev->get_stack_depth (),
+ (event_loc_info (old_start_ev->get_location (),
+ old_start_ev->get_fndecl (),
+ old_start_ev->get_stack_depth ()),
edge_sense);
checker_event *new_end_ev
= new end_consolidated_cfg_edges_event
- (old_end_ev->get_location (),
- old_end_ev->get_fndecl (),
- old_end_ev->get_stack_depth ());
+ (event_loc_info (old_end_ev->get_location (),
+ old_end_ev->get_fndecl (),
+ old_end_ev->get_stack_depth ()));
path->replace_event (start_idx, new_start_ev);
path->replace_event (start_idx + 1, new_end_ev);
path->delete_events (start_idx + 2, next_idx - (start_idx + 2));
/* Compare with diagnostic_manager::add_events_for_superedge. */
const int src_stack_depth = src_point.get_stack_depth ();
m_stack_pop_event = new precanned_custom_event
- (src_point.get_location (),
- src_point.get_fndecl (),
- src_stack_depth,
+ (event_loc_info (src_point.get_location (),
+ src_point.get_fndecl (),
+ src_stack_depth),
"stack frame is popped here, invalidating saved environment");
emission_path->add_event
(std::unique_ptr<custom_event> (m_stack_pop_event));
if (m_is_returning_call)
emission_path->add_event
(make_unique<return_event> (eedge,
- (m_dynamic_call
- ? m_dynamic_call->location
- : UNKNOWN_LOCATION),
- dest_point.get_fndecl (),
- dest_stack_depth));
+ event_loc_info (m_dynamic_call
+ ? m_dynamic_call->location
+ : UNKNOWN_LOCATION,
+ dest_point.get_fndecl (),
+ dest_stack_depth)));
else
emission_path->add_event
(make_unique<call_event> (eedge,
- (m_dynamic_call
- ? m_dynamic_call->location
- : UNKNOWN_LOCATION),
- src_point.get_fndecl (),
- src_stack_depth));
+ event_loc_info (m_dynamic_call
+ ? m_dynamic_call->location
+ : UNKNOWN_LOCATION,
+ src_point.get_fndecl (),
+ src_stack_depth)));
}
/* class rewind_info_t : public custom_edge_info. */
emission_path->add_event
(make_unique<rewind_from_longjmp_event>
- (&eedge, get_longjmp_call ()->location,
- src_point.get_fndecl (),
- src_stack_depth, this));
+ (&eedge,
+ event_loc_info (get_longjmp_call ()->location,
+ src_point.get_fndecl (),
+ src_stack_depth),
+ this));
emission_path->add_event
(make_unique<rewind_to_setjmp_event>
- (&eedge, get_setjmp_call ()->location,
- dst_point.get_fndecl (),
- dst_stack_depth, this));
+ (&eedge,
+ event_loc_info (get_setjmp_call ()->location,
+ dst_point.get_fndecl (),
+ dst_stack_depth),
+ this));
}
/* class exploded_edge : public dedge<eg_traits>. */
class tainted_args_function_custom_event : public custom_event
{
public:
- tainted_args_function_custom_event (location_t loc, tree fndecl, int depth)
- : custom_event (loc, fndecl, depth),
- m_fndecl (fndecl)
+ tainted_args_function_custom_event (const event_loc_info &loc_info)
+ : custom_event (loc_info),
+ m_fndecl (loc_info.m_fndecl)
{
}
{
emission_path->add_event
(make_unique<tainted_args_function_custom_event>
- (DECL_SOURCE_LOCATION (m_fndecl), m_fndecl, 0));
+ (event_loc_info (DECL_SOURCE_LOCATION (m_fndecl), m_fndecl, 0)));
}
private:
{
public:
tainted_args_field_custom_event (tree field)
- : custom_event (DECL_SOURCE_LOCATION (field), NULL_TREE, 0),
+ : custom_event (event_loc_info (DECL_SOURCE_LOCATION (field), NULL_TREE, 0)),
m_field (field)
{
}
class tainted_args_callback_custom_event : public custom_event
{
public:
- tainted_args_callback_custom_event (location_t loc, tree fndecl, int depth,
- tree field)
- : custom_event (loc, fndecl, depth),
+ tainted_args_callback_custom_event (const event_loc_info &loc_info,
+ tree field)
+ : custom_event (loc_info),
m_field (field)
{
}
"(2) function 'gadget_dev_desc_UDC_store' used as initializer
for field 'store' marked with '__attribute__((tainted_args))'". */
emission_path->add_event
- (make_unique<tainted_args_callback_custom_event> (m_loc, m_fndecl,
- 0, m_field));
+ (make_unique<tainted_args_callback_custom_event>
+ (event_loc_info (m_loc, m_fndecl, 0),
+ m_field));
}
private:
gcc_assert (m_new_entry_enode);
emission_path->add_event
(make_unique<warning_event>
- (m_new_entry_enode->get_supernode ()->get_start_location (),
- m_callee_fndecl,
- m_new_entry_enode->get_stack_depth (),
+ (event_loc_info (m_new_entry_enode->get_supernode
+ ()->get_start_location (),
+ m_callee_fndecl,
+ m_new_entry_enode->get_stack_depth ()),
NULL, NULL, NULL));
}
const gimple *last_stmt = src_point.get_supernode ()->get_last_stmt ();
emission_path->add_event
(make_unique<call_event> (eedge,
- (last_stmt
- ? last_stmt->location
- : UNKNOWN_LOCATION),
- src_point.get_fndecl (),
- src_stack_depth));
+ event_loc_info (last_stmt
+ ? last_stmt->location
+ : UNKNOWN_LOCATION,
+ src_point.get_fndecl (),
+ src_stack_depth)));
}
/* Base implementation of pending_diagnostic::add_region_creation_events.
void
pending_diagnostic::add_region_creation_events (const region *reg,
tree capacity,
- location_t loc,
- tree fndecl, int depth,
+ const event_loc_info &loc_info,
checker_path &emission_path)
{
emission_path.add_event
(make_unique<region_creation_event_memory_space> (reg->get_memory_space (),
- loc, fndecl, depth));
+ loc_info));
if (capacity)
emission_path.add_event
- (make_unique<region_creation_event_capacity> (capacity,
- loc, fndecl, depth));
+ (make_unique<region_creation_event_capacity> (capacity, loc_info));
}
/* Base implementation of pending_diagnostic::add_final_event.
checker_path *emission_path)
{
emission_path->add_event
- (make_unique<warning_event> (get_stmt_location (stmt,
- enode->get_function ()),
- enode->get_function ()->decl,
- enode->get_stack_depth (),
- sm, var, state));
+ (make_unique<warning_event>
+ (event_loc_info (get_stmt_location (stmt, enode->get_function ()),
+ enode->get_function ()->decl,
+ enode->get_stack_depth ()),
+ sm, var, state));
}
} // namespace ana
See the comment for class region_creation_event. */
virtual void add_region_creation_events (const region *reg,
tree capacity,
- location_t loc,
- tree fndecl, int depth,
+ const event_loc_info &loc_info,
checker_path &emission_path);
/* Vfunc for adding the final warning_event to a checker_path, so that e.g.
void
add_region_creation_events (const region *,
tree capacity,
- location_t loc,
- tree fndecl, int depth,
+ const event_loc_info &loc_info,
checker_path &emission_path) final override
{
emission_path.add_event
- (make_unique<region_creation_event_allocation_size> (capacity,
- loc, fndecl, depth));
+ (make_unique<region_creation_event_allocation_size> (capacity, loc_info));
m_has_allocation_event = true;
}
{
emission_path->add_event
(make_unique<precanned_custom_event>
- (UNKNOWN_LOCATION, NULL_TREE, 0,
+ (event_loc_info (UNKNOWN_LOCATION, NULL_TREE, 0),
"later on,"
" when the signal is delivered to the process"));
}
{
public:
va_arg_call_event (const exploded_edge &eedge,
- location_t loc, tree fndecl, int depth,
+ const event_loc_info &loc_info,
int num_variadic_arguments)
- : call_event (eedge, loc, fndecl, depth),
+ : call_event (eedge, loc_info),
m_num_variadic_arguments (num_variadic_arguments)
{
}
= get_num_variadic_arguments (dst_node->get_function ()->decl,
call_stmt);
emission_path->add_event
- (make_unique<va_arg_call_event> (eedge,
- (last_stmt
- ? last_stmt->location
- : UNKNOWN_LOCATION),
- src_point.get_fndecl (),
- src_stack_depth,
- num_variadic_arguments));
+ (make_unique<va_arg_call_event>
+ (eedge,
+ event_loc_info (last_stmt ? last_stmt->location : UNKNOWN_LOCATION,
+ src_point.get_fndecl (),
+ src_stack_depth),
+ num_variadic_arguments));
}
else
pending_diagnostic::add_call_event (eedge, emission_path);
projects / platform / upstream / gcc.git / commitdiff