call_info::print (pretty_printer *pp) const
{
label_text desc (get_desc (pp_show_color (pp)));
- pp_string (pp, desc.m_buffer);
+ pp_string (pp, desc.get ());
}
/* Implementation of custom_edge_info::add_events_to_path vfunc for
{
label_text event_desc (get_desc (false));
pp_printf (pp, "\"%s\" (depth %i",
- event_desc.m_buffer, m_effective_depth);
+ event_desc.get (), m_effective_depth);
if (m_effective_depth != m_original_depth)
pp_printf (pp, " corrected from %i",
label_text custom_desc
= m_pending_diagnostic->describe_region_creation_event
(evdesc::region_creation (can_colorize, m_reg));
- if (custom_desc.m_buffer)
+ if (custom_desc.get ())
return custom_desc;
}
= m_pending_diagnostic->describe_state_change
(evdesc::state_change (can_colorize, var, origin,
m_from, m_to, m_emission_id, *this));
- if (custom_desc.m_buffer)
+ if (custom_desc.get ())
{
if (flag_analyzer_verbose_state_changes)
{
return make_label_text
(can_colorize,
"%s (state of %qE: %qs -> %qs, origin: %qE, meaning: %s)",
- custom_desc.m_buffer,
+ custom_desc.get (),
var,
m_from->get_name (),
m_to->get_name (),
return make_label_text
(can_colorize,
"%s (state of %qE: %qs -> %qs, NULL origin, meaning: %s)",
- custom_desc.m_buffer,
+ custom_desc.get (),
var,
m_from->get_name (),
m_to->get_name (),
return make_label_text
(can_colorize,
"state of %qs: %qs -> %qs (origin: %qs)",
- sval_desc.m_buffer,
+ sval_desc.get (),
m_from->get_name (),
m_to->get_name (),
- origin_desc.m_buffer);
+ origin_desc.get ());
}
else
return make_label_text
(can_colorize,
"state of %qs: %qs -> %qs (NULL origin)",
- sval_desc.m_buffer,
+ sval_desc.get (),
m_from->get_name (),
m_to->get_name ());
}
/* Filter events with empty descriptions. This ought to filter
FALLTHRU, but retain true/false/switch edges. */
label_text desc = get_desc (false);
- gcc_assert (desc.m_buffer);
- if (desc.m_buffer[0] == '\0')
+ gcc_assert (desc.get ());
+ if (desc.get ()[0] == '\0')
return true;
}
}
label_text edge_desc (m_sedge->get_description (user_facing));
if (user_facing)
{
- if (edge_desc.m_buffer && strlen (edge_desc.m_buffer) > 0)
+ if (edge_desc.get () && strlen (edge_desc.get ()) > 0)
{
label_text cond_desc = maybe_describe_condition (can_colorize);
label_text result;
- if (cond_desc.m_buffer)
+ if (cond_desc.get ())
return make_label_text (can_colorize,
"following %qs branch (%s)...",
- edge_desc.m_buffer, cond_desc.m_buffer);
+ edge_desc.get (), cond_desc.get ());
else
return make_label_text (can_colorize,
"following %qs branch...",
- edge_desc.m_buffer);
+ edge_desc.get ());
}
else
return label_text::borrow ("");
}
else
{
- if (strlen (edge_desc.m_buffer) > 0)
+ if (strlen (edge_desc.get ()) > 0)
return make_label_text (can_colorize,
"taking %qs edge SN:%i -> SN:%i",
- edge_desc.m_buffer,
+ edge_desc.get (),
m_sedge->m_src->m_index,
m_sedge->m_dest->m_index);
else
m_dest_snode->m_fun->decl,
var,
m_critical_state));
- if (custom_desc.m_buffer)
+ if (custom_desc.get ())
return custom_desc;
}
m_dest_snode->m_fun->decl,
m_src_snode->m_fun->decl,
m_critical_state));
- if (custom_desc.m_buffer)
+ if (custom_desc.get ())
return custom_desc;
}
return make_label_text (can_colorize,
label_text ev_desc
= m_pending_diagnostic->describe_final_event
(evdesc::final_event (can_colorize, var, m_state));
- if (ev_desc.m_buffer)
+ if (ev_desc.get ())
{
if (m_sm && flag_analyzer_verbose_state_changes)
{
if (var)
return make_label_text (can_colorize,
"%s (%qE is in state %qs)",
- ev_desc.m_buffer,
+ ev_desc.get (),
var, m_state->get_name ());
else
return make_label_text (can_colorize,
"%s (in global state %qs)",
- ev_desc.m_buffer,
+ ev_desc.get (),
m_state->get_name ());
}
else
if (i > 0)
pp_string (pp, ", ");
label_text event_desc (e->get_desc (false));
- pp_printf (pp, "\"%s\"", event_desc.m_buffer);
+ pp_printf (pp, "\"%s\"", event_desc.get ());
}
pp_character (pp, ']');
}
"[%i]: %s \"%s\"\n",
i,
event_kind_to_string (m_events[i]->m_kind),
- event_desc.m_buffer);
+ event_desc.get ());
}
}
label_text sval_desc = sval->get_desc ();
log ("considering event %i (%s), with sval: %qs, state: %qs",
idx, event_kind_to_string (base_event->m_kind),
- sval_desc.m_buffer, state->get_name ());
+ sval_desc.get (), state->get_name ());
}
else
log ("considering event %i (%s), with global state: %qs",
= state_change->m_origin->get_desc ();
log ("event %i:"
" switching var of interest from %qs to %qs",
- idx, sval_desc.m_buffer,
- origin_sval_desc.m_buffer);
+ idx, sval_desc.get (),
+ origin_sval_desc.get ());
}
sval = state_change->m_origin;
}
label_text sval_desc = sval->get_desc ();
log ("filtering event %i:"
" state change to %qs unrelated to %qs",
- idx, change_sval_desc.m_buffer,
- sval_desc.m_buffer);
+ idx, change_sval_desc.get (),
+ sval_desc.get ());
}
else
log ("filtering event %i: state change to %qs",
- idx, change_sval_desc.m_buffer);
+ idx, change_sval_desc.get ());
}
else
log ("filtering event %i: global state change", idx);
log ("event %i:"
" recording critical state for %qs at call"
" from %qE in callee to %qE in caller",
- idx, sval_desc.m_buffer, callee_var, caller_var);
+ idx, sval_desc.get (), callee_var, caller_var);
}
if (expr.param_p ())
event->record_critical_state (caller_var, state);
log ("event %i:"
" recording critical state for %qs at return"
" from %qE in caller to %qE in callee",
- idx, sval_desc.m_buffer, callee_var, callee_var);
+ idx, sval_desc.get (), callee_var, callee_var);
}
if (expr.return_value_p ())
event->record_critical_state (callee_var, state);
(path->get_checker_event (idx)->get_desc (false));
log ("filtering events %i-%i:"
" irrelevant call/entry/return: %s",
- idx, idx + 2, desc.m_buffer);
+ idx, idx + 2, desc.get ());
}
path->delete_event (idx + 2);
path->delete_event (idx + 1);
(path->get_checker_event (idx)->get_desc (false));
log ("filtering events %i-%i:"
" irrelevant call/return: %s",
- idx, idx + 1, desc.m_buffer);
+ idx, idx + 1, desc.get ());
}
path->delete_event (idx + 1);
path->delete_event (idx);
logger->log (" sedge: SN:%i -> SN:%i %s",
sedge->m_src->m_index,
sedge->m_dest->m_index,
- desc.m_buffer);
+ desc.get ());
}
const gimple *last_stmt = src_point.get_supernode ()->get_last_stmt ();
entry_t e = (*iter).second;
label_text sval_desc = sval->get_desc ();
- map_obj->set (sval_desc.m_buffer, e.m_state->to_json ());
+ map_obj->set (sval_desc.get (), e.m_state->to_json ());
/* This doesn't yet JSONify e.m_origin. */
}
const svalue *sval = get_rvalue (t_val, ctxt);
bool simple = zerop (t_verbosity);
label_text desc = sval->get_desc (simple);
- warning_at (call->location, 0, "svalue: %qs", desc.m_buffer);
+ warning_at (call->location, 0, "svalue: %qs", desc.get ());
}
/* Handle a call to "__analyzer_dump_capacity".
const region *base_reg = reg->get_base_region ();
const svalue *capacity = get_capacity (base_reg);
label_text desc = capacity->get_desc (true);
- warning_at (call->location, 0, "capacity: %qs", desc.m_buffer);
+ warning_at (call->location, 0, "capacity: %qs", desc.get ());
}
/* Compare D1 and D2 using their names, and then IDs to order them. */
region::to_json () const
{
label_text desc = get_desc (true);
- json::value *reg_js = new json::string (desc.m_buffer);
+ json::value *reg_js = new json::string (desc.get ());
return reg_js;
}
label_text arg_desc = describe_argument_index (fndecl, arg_idx);
inform (DECL_SOURCE_LOCATION (fndecl),
"argument %s of %qD must be non-null",
- arg_desc.m_buffer, fndecl);
+ arg_desc.get (), fndecl);
/* Ideally we would use the location of the parm and underline the
attribute also - but we don't have the location_t values at this point
in the middle-end.
if (m_origin_of_unchecked_event.known_p ())
result = ev.formatted_print ("argument %s (%qE) from %@ could be NULL"
" where non-null expected",
- arg_desc.m_buffer, ev.m_expr,
+ arg_desc.get (), ev.m_expr,
&m_origin_of_unchecked_event);
else
result = ev.formatted_print ("argument %s (%qE) could be NULL"
" where non-null expected",
- arg_desc.m_buffer, ev.m_expr);
+ arg_desc.get (), ev.m_expr);
return result;
}
label_text result;
if (zerop (ev.m_expr))
result = ev.formatted_print ("argument %s NULL where non-null expected",
- arg_desc.m_buffer);
+ arg_desc.get ());
else
result = ev.formatted_print ("argument %s (%qE) NULL"
" where non-null expected",
- arg_desc.m_buffer, ev.m_expr);
+ arg_desc.get (), ev.m_expr);
return result;
}
{
const svalue *value = *const_cast <map_t &> (m_map).get (key);
label_text key_desc = key->get_desc ();
- map_obj->set (key_desc.m_buffer, value->to_json ());
+ map_obj->set (key_desc.get (), value->to_json ());
}
return map_obj;
binding_cluster *cluster
= *const_cast<cluster_map_t &> (m_cluster_map).get (base_reg);
label_text base_reg_desc = base_reg->get_desc ();
- clusters_in_parent_reg_obj->set (base_reg_desc.m_buffer,
+ clusters_in_parent_reg_obj->set (base_reg_desc.get (),
cluster->to_json ());
}
label_text parent_reg_desc = parent_reg->get_desc ();
- store_obj->set (parent_reg_desc.m_buffer, clusters_in_parent_reg_obj);
+ store_obj->set (parent_reg_desc.get (), clusters_in_parent_reg_obj);
}
store_obj->set ("called_unknown_fn", new json::literal (m_called_unknown_fn));
{
pp_printf (pp, "edge: SN: %i -> SN: %i", m_src->m_index, m_dest->m_index);
label_text desc (get_description (false));
- if (strlen (desc.m_buffer) > 0)
+ if (strlen (desc.get ()) > 0)
{
pp_space (pp);
- pp_string (pp, desc.m_buffer);
+ pp_string (pp, desc.get ());
}
}
svalue::to_json () const
{
label_text desc = get_desc (true);
- json::value *sval_js = new json::string (desc.m_buffer);
+ json::value *sval_js = new json::string (desc.get ());
return sval_js;
}
label_text get_text (unsigned range_idx) const final override
{
label_text text = range_label_for_type_mismatch::get_text (range_idx);
- if (text.m_buffer == NULL)
+ if (text.get () == NULL)
return text;
indirection_suffix suffix (m_pointer_count);
char *p = (char *) alloca (suffix.get_buffer_size ());
suffix.fill_buffer (p);
- char *result = concat (text.m_buffer, p, NULL);
+ char *result = concat (text.get (), p, NULL);
return label_text::take (result);
}
if (loc_range->m_label)
{
label_text text (loc_range->m_label->get_text (range_idx));
- if (text.m_buffer)
- result->set ("label", new json::string (text.m_buffer));
+ if (text.get ())
+ result->set ("label", new json::string (text.get ()));
}
return result;
/* "message" property (SARIF v2.1.0 section 3.28.5). */
label_text ev_desc = event.get_desc (false);
- json::object *message_obj = make_message_object (ev_desc.m_buffer);
+ json::object *message_obj = make_message_object (ev_desc.get ());
location_obj->set ("message", message_obj);
return location_obj;
{}
pod_label_text (label_text &&other)
- : m_buffer (other.m_buffer), m_caller_owned (other.m_owned)
+ : m_buffer (const_cast<char*> (other.get ())),
+ m_caller_owned (other.is_owner ())
{
- other.moved_from ();
+ other.release ();
}
void maybe_free ()
/* Allow for labels that return NULL from their get_text
implementation (so e.g. such labels can control their own
visibility). */
- if (text.m_buffer == NULL)
+ if (text.get () == NULL)
continue;
labels.safe_push (line_label (m_policy, i, disp_col, std::move (text)));
is special-cased for diagnostic paths. */
bool colorize = pp_show_color (global_dc->printer);
label_text event_text (event.get_desc (colorize));
- gcc_assert (event_text.m_buffer);
+ gcc_assert (event_text.get ());
pretty_printer pp;
pp_show_color (&pp) = pp_show_color (global_dc->printer);
diagnostic_event_id_t event_id (event_idx);
- pp_printf (&pp, "%@ %s", &event_id, event_text.m_buffer);
+ pp_printf (&pp, "%@ %s", &event_id, event_text.get ());
label_text result = label_text::take (xstrdup (pp_formatted_text (&pp)));
return result;
}
diagnostic_event_id_t event_id (i);
label_text event_text (iter_event.get_desc (true));
pretty_printer *pp = dc->printer;
- pp_printf (pp, " %@: %s", &event_id, event_text.m_buffer);
+ pp_printf (pp, " %@: %s", &event_id, event_text.get ());
pp_newline (pp);
}
return;
{
const diagnostic_event &event = path->get_event (i);
label_text event_text (event.get_desc (false));
- gcc_assert (event_text.m_buffer);
+ gcc_assert (event_text.get ());
diagnostic_event_id_t event_id (i);
if (context->show_path_depths)
{
if (fndecl)
inform (event.get_location (),
"%@ %s (fndecl %qD, depth %i)",
- &event_id, event_text.m_buffer,
+ &event_id, event_text.get (),
fndecl, stack_depth);
else
inform (event.get_location (),
"%@ %s (depth %i)",
- &event_id, event_text.m_buffer,
+ &event_id, event_text.get (),
stack_depth);
}
else
inform (event.get_location (),
- "%@ %s", &event_id, event_text.m_buffer);
+ "%@ %s", &event_id, event_text.get ());
}
}
break;
json_from_expanded_location (context,
event.get_location ()));
label_text event_text (event.get_desc (false));
- event_obj->set ("description", new json::string (event_text.m_buffer));
+ event_obj->set ("description", new json::string (event_text.get ()));
if (tree fndecl = event.get_fndecl ())
{
const char *function
label_text (label_text &&other)
: m_buffer (other.m_buffer), m_owned (other.m_owned)
{
- other.moved_from ();
+ other.release ();
}
/* Move assignment. */
free (m_buffer);
m_buffer = other.m_buffer;
m_owned = other.m_owned;
- other.moved_from ();
+ other.release ();
return *this;
}
return label_text (buffer, true);
}
- /* Take ownership of the buffer, copying if necessary. */
- char *take_or_copy ()
+ void release ()
{
- if (m_owned)
- return m_buffer;
- else
- return xstrdup (m_buffer);
+ m_buffer = NULL;
+ m_owned = false;
}
- void moved_from ()
+ const char *get () const
{
- m_buffer = NULL;
- m_owned = false;
+ return m_buffer;
}
+ bool is_owner () const
+ {
+ return m_owned;
+ }
+
+private:
char *m_buffer;
bool m_owned;
-private:
label_text (char *buffer, bool owned)
: m_buffer (buffer), m_owned (owned)
{}
projects / thirdparty / gcc.git / commitdiff
