static tree
init_module_descriptor (tree type, long vers)
{
tree expr, ltyp;
location_t loc;
vec<constructor_elt, va_gc> *v = NULL;
/* No really useful place to point to. */
loc = UNKNOWN_LOCATION;
/* version = { 1, ... } */
expr = build_int_cst (long_integer_type_node, vers);
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
/* size = { ..., sizeof (struct _objc_module), ... } */
expr = convert (long_integer_type_node,
size_in_bytes (objc_module_template));
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
/* Don't provide any file name for security reasons. */
/* name = { ..., "", ... } */
expr = add_objc_string (get_identifier (""), class_names);
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
/* symtab = { ..., _OBJC_SYMBOLS, ... } */
ltyp = build_pointer_type (xref_tag (RECORD_TYPE,
get_identifier (UTAG_SYMTAB)));
if (UOBJC_SYMBOLS_decl)
expr = convert (ltyp, build_unary_op (loc,
ADDR_EXPR, UOBJC_SYMBOLS_decl, 0));
else
expr = convert (ltyp, null_pointer_node);
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
return objc_build_constructor (type, v);
}
tree
build_ivar_list_initializer (tree type, tree field_decl)
{
vec<constructor_elt, va_gc> *inits = NULL;
do
{
vec<constructor_elt, va_gc> *ivar = NULL;
tree id;
/* Set name. */
if (DECL_NAME (field_decl))
CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE,
add_objc_string (DECL_NAME (field_decl),
meth_var_names));
else
/* Unnamed bit-field ivar (yuck). */
CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, build_int_cst (NULL_TREE, 0));
/* Set type. */
id = add_objc_string (encode_field_decl (field_decl),
meth_var_types);
CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, id);
/* Set offset. */
CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, byte_position (field_decl));
CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE,
objc_build_constructor (type, ivar));
do
field_decl = DECL_CHAIN (field_decl);
while (field_decl && TREE_CODE (field_decl) != FIELD_DECL);
}
while (field_decl);
return objc_build_constructor (build_array_type (type, 0), inits);
}
tree
build_dispatch_table_initializer (tree type, tree entries)
{
vec<constructor_elt, va_gc> *inits = NULL;
do
{
vec<constructor_elt, va_gc> *elems = NULL;
tree expr;
CONSTRUCTOR_APPEND_ELT (elems, NULL_TREE,
build_selector (METHOD_SEL_NAME (entries)));
/* Generate the method encoding if we don't have one already. */
if (! METHOD_ENCODING (entries))
METHOD_ENCODING (entries) =
encode_method_prototype (entries);
CONSTRUCTOR_APPEND_ELT (elems, NULL_TREE,
add_objc_string (METHOD_ENCODING (entries),
meth_var_types));
expr = convert (ptr_type_node,
build_unary_op (input_location, ADDR_EXPR,
METHOD_DEFINITION (entries), 1));
CONSTRUCTOR_APPEND_ELT (elems, NULL_TREE, expr);
CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE,
objc_build_constructor (type, elems));
entries = DECL_CHAIN (entries);
}
while (entries);
return objc_build_constructor (build_array_type (type, 0), inits);
}
tree
build_descriptor_table_initializer (tree type, tree entries)
{
vec<constructor_elt, va_gc> *inits = NULL;
do
{
vec<constructor_elt, va_gc> *elts = NULL;
CONSTRUCTOR_APPEND_ELT (elts, NULL_TREE,
build_selector (METHOD_SEL_NAME (entries)));
CONSTRUCTOR_APPEND_ELT (elts, NULL_TREE,
add_objc_string (METHOD_ENCODING (entries),
meth_var_types));
CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE,
objc_build_constructor (type, elts));
entries = DECL_CHAIN (entries);
}
while (entries);
return objc_build_constructor (build_array_type (type, 0), inits);
}
static void
lto_input_ts_constructor_tree_pointers (struct lto_input_block *ib,
struct data_in *data_in, tree expr)
{
unsigned i, len;
len = streamer_read_uhwi (ib);
for (i = 0; i < len; i++)
{
tree index, value;
index = stream_read_tree (ib, data_in);
value = stream_read_tree (ib, data_in);
CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (expr), index, value);
}
}
static void
create_common (gfc_common_head *com, segment_info *head, bool saw_equiv)
{
segment_info *s, *next_s;
tree union_type;
tree *field_link;
tree field;
tree field_init = NULL_TREE;
record_layout_info rli;
tree decl;
bool is_init = false;
bool is_saved = false;
/* Declare the variables inside the common block.
If the current common block contains any equivalence object, then
make a UNION_TYPE node, otherwise RECORD_TYPE. This will let the
alias analyzer work well when there is no address overlapping for
common variables in the current common block. */
if (saw_equiv)
union_type = make_node (UNION_TYPE);
else
union_type = make_node (RECORD_TYPE);
rli = start_record_layout (union_type);
field_link = &TYPE_FIELDS (union_type);
/* Check for overlapping initializers and replace them with a single,
artificial field that contains all the data. */
if (saw_equiv)
field = get_init_field (head, union_type, &field_init, rli);
else
field = NULL_TREE;
if (field != NULL_TREE)
{
is_init = true;
*field_link = field;
field_link = &DECL_CHAIN (field);
}
for (s = head; s; s = s->next)
{
build_field (s, union_type, rli);
/* Link the field into the type. */
*field_link = s->field;
field_link = &DECL_CHAIN (s->field);
/* Has initial value. */
if (s->sym->value)
is_init = true;
/* Has SAVE attribute. */
if (s->sym->attr.save)
is_saved = true;
}
finish_record_layout (rli, true);
if (com)
decl = build_common_decl (com, union_type, is_init);
else
decl = build_equiv_decl (union_type, is_init, is_saved);
if (is_init)
{
tree ctor, tmp;
VEC(constructor_elt,gc) *v = NULL;
if (field != NULL_TREE && field_init != NULL_TREE)
CONSTRUCTOR_APPEND_ELT (v, field, field_init);
else
for (s = head; s; s = s->next)
{
if (s->sym->value)
{
/* Add the initializer for this field. */
tmp = gfc_conv_initializer (s->sym->value, &s->sym->ts,
TREE_TYPE (s->field),
s->sym->attr.dimension,
s->sym->attr.pointer
|| s->sym->attr.allocatable, false);
CONSTRUCTOR_APPEND_ELT (v, s->field, tmp);
}
}
gcc_assert (!VEC_empty (constructor_elt, v));
ctor = build_constructor (union_type, v);
TREE_CONSTANT (ctor) = 1;
TREE_STATIC (ctor) = 1;
DECL_INITIAL (decl) = ctor;
#ifdef ENABLE_CHECKING
{
tree field, value;
unsigned HOST_WIDE_INT idx;
FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), idx, field, value)
gcc_assert (TREE_CODE (field) == FIELD_DECL);
}
#endif
}
/* Build component reference for each variable. */
for (s = head; s; s = next_s)
{
tree var_decl;
var_decl = build_decl (s->sym->declared_at.lb->location,
VAR_DECL, DECL_NAME (s->field),
TREE_TYPE (s->field));
TREE_STATIC (var_decl) = TREE_STATIC (decl);
/* Mark the variable as used in order to avoid warnings about
unused variables. */
TREE_USED (var_decl) = 1;
if (s->sym->attr.use_assoc)
DECL_IGNORED_P (var_decl) = 1;
if (s->sym->attr.target)
TREE_ADDRESSABLE (var_decl) = 1;
/* Fake variables are not visible from other translation units. */
TREE_PUBLIC (var_decl) = 0;
/* To preserve identifier names in COMMON, chain to procedure
scope unless at top level in a module definition. */
if (com
&& s->sym->ns->proc_name
&& s->sym->ns->proc_name->attr.flavor == FL_MODULE)
var_decl = pushdecl_top_level (var_decl);
else
gfc_add_decl_to_function (var_decl);
SET_DECL_VALUE_EXPR (var_decl,
fold_build3_loc (input_location, COMPONENT_REF,
TREE_TYPE (s->field),
decl, s->field, NULL_TREE));
DECL_HAS_VALUE_EXPR_P (var_decl) = 1;
GFC_DECL_COMMON_OR_EQUIV (var_decl) = 1;
if (s->sym->attr.assign)
{
gfc_allocate_lang_decl (var_decl);
GFC_DECL_ASSIGN (var_decl) = 1;
GFC_DECL_STRING_LEN (var_decl) = GFC_DECL_STRING_LEN (s->field);
GFC_DECL_ASSIGN_ADDR (var_decl) = GFC_DECL_ASSIGN_ADDR (s->field);
}
s->sym->backend_decl = var_decl;
next_s = s->next;
free (s);
}
}
static tree
get_init_field (segment_info *head, tree union_type, tree *field_init,
record_layout_info rli)
{
segment_info *s;
HOST_WIDE_INT length = 0;
HOST_WIDE_INT offset = 0;
unsigned HOST_WIDE_INT known_align, desired_align;
bool overlap = false;
tree tmp, field;
tree init;
unsigned char *data, *chk;
VEC(constructor_elt,gc) *v = NULL;
tree type = unsigned_char_type_node;
int i;
/* Obtain the size of the union and check if there are any overlapping
initializers. */
for (s = head; s; s = s->next)
{
HOST_WIDE_INT slen = s->offset + s->length;
if (s->sym->value)
{
if (s->offset < offset)
overlap = true;
offset = slen;
}
length = length < slen ? slen : length;
}
if (!overlap)
return NULL_TREE;
/* Now absorb all the initializer data into a single vector,
whilst checking for overlapping, unequal values. */
data = XCNEWVEC (unsigned char, (size_t)length);
chk = XCNEWVEC (unsigned char, (size_t)length);
/* TODO - change this when default initialization is implemented. */
memset (data, '\0', (size_t)length);
memset (chk, '\0', (size_t)length);
for (s = head; s; s = s->next)
if (s->sym->value)
gfc_merge_initializers (s->sym->ts, s->sym->value,
&data[s->offset],
&chk[s->offset],
(size_t)s->length);
for (i = 0; i < length; i++)
CONSTRUCTOR_APPEND_ELT (v, NULL, build_int_cst (type, data[i]));
free (data);
free (chk);
/* Build a char[length] array to hold the initializers. Much of what
follows is borrowed from build_field, above. */
tmp = build_int_cst (gfc_array_index_type, length - 1);
tmp = build_range_type (gfc_array_index_type,
gfc_index_zero_node, tmp);
tmp = build_array_type (type, tmp);
field = build_decl (gfc_current_locus.lb->location,
FIELD_DECL, NULL_TREE, tmp);
known_align = BIGGEST_ALIGNMENT;
desired_align = update_alignment_for_field (rli, field, known_align);
if (desired_align > known_align)
DECL_PACKED (field) = 1;
DECL_FIELD_CONTEXT (field) = union_type;
DECL_FIELD_OFFSET (field) = size_int (0);
DECL_FIELD_BIT_OFFSET (field) = bitsize_zero_node;
SET_DECL_OFFSET_ALIGN (field, known_align);
rli->offset = size_binop (MAX_EXPR, rli->offset,
size_binop (PLUS_EXPR,
DECL_FIELD_OFFSET (field),
DECL_SIZE_UNIT (field)));
init = build_constructor (TREE_TYPE (field), v);
TREE_CONSTANT (init) = 1;
*field_init = init;
for (s = head; s; s = s->next)
{
if (s->sym->value == NULL)
continue;
gfc_free_expr (s->sym->value);
s->sym->value = NULL;
}
return field;
}
tree
build_lambda_object (tree lambda_expr)
{
/* Build aggregate constructor call.
- cp_parser_braced_list
- cp_parser_functional_cast */
vec<constructor_elt, va_gc> *elts = NULL;
tree node, expr, type;
location_t saved_loc;
if (processing_template_decl)
return lambda_expr;
/* Make sure any error messages refer to the lambda-introducer. */
saved_loc = input_location;
input_location = LAMBDA_EXPR_LOCATION (lambda_expr);
for (node = LAMBDA_EXPR_CAPTURE_LIST (lambda_expr);
node;
node = TREE_CHAIN (node))
{
tree field = TREE_PURPOSE (node);
tree val = TREE_VALUE (node);
if (field == error_mark_node)
{
expr = error_mark_node;
goto out;
}
if (DECL_P (val))
mark_used (val);
/* Mere mortals can't copy arrays with aggregate initialization, so
do some magic to make it work here. */
if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE)
val = build_array_copy (val);
else if (DECL_NORMAL_CAPTURE_P (field)
&& !DECL_VLA_CAPTURE_P (field)
&& TREE_CODE (TREE_TYPE (field)) != REFERENCE_TYPE)
{
/* "the entities that are captured by copy are used to
direct-initialize each corresponding non-static data
member of the resulting closure object."
There's normally no way to express direct-initialization
from an element of a CONSTRUCTOR, so we build up a special
TARGET_EXPR to bypass the usual copy-initialization. */
val = force_rvalue (val, tf_warning_or_error);
if (TREE_CODE (val) == TARGET_EXPR)
TARGET_EXPR_DIRECT_INIT_P (val) = true;
}
CONSTRUCTOR_APPEND_ELT (elts, DECL_NAME (field), val);
}
expr = build_constructor (init_list_type_node, elts);
CONSTRUCTOR_IS_DIRECT_INIT (expr) = 1;
/* N2927: "[The closure] class type is not an aggregate."
But we briefly treat it as an aggregate to make this simpler. */
type = LAMBDA_EXPR_CLOSURE (lambda_expr);
CLASSTYPE_NON_AGGREGATE (type) = 0;
expr = finish_compound_literal (type, expr, tf_warning_or_error);
CLASSTYPE_NON_AGGREGATE (type) = 1;
out:
input_location = saved_loc;
return expr;
}
tree
prepare_eh_table_type (tree type)
{
tree exp;
tree *slot;
const char *name;
char *buf;
tree decl;
tree utf8_ref;
/* The "type" (match_info) in a (Java) exception table is a pointer to:
* a) NULL - meaning match any type in a try-finally.
* b) a pointer to a pointer to a class.
* c) a pointer to a pointer to a utf8_ref. The pointer is
* rewritten to point to the appropriate class. */
if (type == NULL_TREE)
return NULL_TREE;
if (TYPE_TO_RUNTIME_MAP (output_class) == NULL)
TYPE_TO_RUNTIME_MAP (output_class) = java_treetreehash_create (10);
slot = java_treetreehash_new (TYPE_TO_RUNTIME_MAP (output_class), type);
if (*slot != NULL)
return TREE_VALUE (*slot);
if (is_compiled_class (type) && !flag_indirect_dispatch)
{
name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
buf = (char *) alloca (strlen (name) + 5);
sprintf (buf, "%s_ref", name);
decl = build_decl (input_location,
VAR_DECL, get_identifier (buf), ptr_type_node);
TREE_STATIC (decl) = 1;
DECL_ARTIFICIAL (decl) = 1;
DECL_IGNORED_P (decl) = 1;
TREE_READONLY (decl) = 1;
TREE_THIS_VOLATILE (decl) = 0;
DECL_INITIAL (decl) = build_class_ref (type);
layout_decl (decl, 0);
pushdecl (decl);
exp = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (decl)), decl);
}
else
{
utf8_ref = build_utf8_ref (DECL_NAME (TYPE_NAME (type)));
name = IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (utf8_ref, 0)));
buf = (char *) alloca (strlen (name) + 5);
sprintf (buf, "%s_ref", name);
decl = build_decl (input_location,
VAR_DECL, get_identifier (buf), utf8const_ptr_type);
TREE_STATIC (decl) = 1;
DECL_ARTIFICIAL (decl) = 1;
DECL_IGNORED_P (decl) = 1;
TREE_READONLY (decl) = 1;
TREE_THIS_VOLATILE (decl) = 0;
layout_decl (decl, 0);
pushdecl (decl);
exp = build1 (ADDR_EXPR, build_pointer_type (utf8const_ptr_type), decl);
CONSTRUCTOR_APPEND_ELT (TYPE_CATCH_CLASSES (output_class),
NULL_TREE,
make_catch_class_record (exp, utf8_ref));
}
exp = convert (ptr_type_node, exp);
*slot = tree_cons (type, exp, NULL_TREE);
return exp;
}
tree
ubsan_create_data (const char *name, const location_t *ploc,
const struct ubsan_mismatch_data *mismatch, ...)
{
va_list args;
tree ret, t;
tree fields[5];
vec<tree, va_gc> *saved_args = NULL;
size_t i = 0;
location_t loc = UNKNOWN_LOCATION;
/* Firstly, create a pointer to type descriptor type. */
tree td_type = ubsan_type_descriptor_type ();
TYPE_READONLY (td_type) = 1;
td_type = build_pointer_type (td_type);
/* Create the structure type. */
ret = make_node (RECORD_TYPE);
if (ploc != NULL)
{
loc = LOCATION_LOCUS (*ploc);
fields[i] = build_decl (UNKNOWN_LOCATION, FIELD_DECL, NULL_TREE,
ubsan_source_location_type ());
DECL_CONTEXT (fields[i]) = ret;
i++;
}
va_start (args, mismatch);
for (t = va_arg (args, tree); t != NULL_TREE;
i++, t = va_arg (args, tree))
{
gcc_checking_assert (i < 3);
/* Save the tree arguments for later use. */
vec_safe_push (saved_args, t);
fields[i] = build_decl (UNKNOWN_LOCATION, FIELD_DECL, NULL_TREE,
td_type);
DECL_CONTEXT (fields[i]) = ret;
if (i)
DECL_CHAIN (fields[i - 1]) = fields[i];
}
va_end (args);
if (mismatch != NULL)
{
/* We have to add two more decls. */
fields[i] = build_decl (UNKNOWN_LOCATION, FIELD_DECL, NULL_TREE,
pointer_sized_int_node);
DECL_CONTEXT (fields[i]) = ret;
DECL_CHAIN (fields[i - 1]) = fields[i];
i++;
fields[i] = build_decl (UNKNOWN_LOCATION, FIELD_DECL, NULL_TREE,
unsigned_char_type_node);
DECL_CONTEXT (fields[i]) = ret;
DECL_CHAIN (fields[i - 1]) = fields[i];
i++;
}
TYPE_FIELDS (ret) = fields[0];
TYPE_NAME (ret) = get_identifier (name);
layout_type (ret);
/* Now, fill in the type. */
char tmp_name[32];
static unsigned int ubsan_var_id_num;
ASM_GENERATE_INTERNAL_LABEL (tmp_name, "Lubsan_data", ubsan_var_id_num++);
tree var = build_decl (UNKNOWN_LOCATION, VAR_DECL, get_identifier (tmp_name),
ret);
TREE_STATIC (var) = 1;
TREE_PUBLIC (var) = 0;
DECL_ARTIFICIAL (var) = 1;
DECL_IGNORED_P (var) = 1;
DECL_EXTERNAL (var) = 0;
vec<constructor_elt, va_gc> *v;
vec_alloc (v, i);
tree ctor = build_constructor (ret, v);
/* If desirable, set the __ubsan_source_location element. */
if (ploc != NULL)
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, ubsan_source_location (loc));
size_t nelts = vec_safe_length (saved_args);
for (i = 0; i < nelts; i++)
{
t = (*saved_args)[i];
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, t);
}
if (mismatch != NULL)
{
/* Append the pointer data. */
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, mismatch->align);
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, mismatch->ckind);
}
TREE_CONSTANT (ctor) = 1;
TREE_STATIC (ctor) = 1;
DECL_INITIAL (var) = ctor;
varpool_finalize_decl (var);
return var;
}
static tree handle_latent_entropy_attribute(tree *node, tree name,
tree args __unused,
int flags __unused,
bool *no_add_attrs)
{
tree type;
#if BUILDING_GCC_VERSION <= 4007
VEC(constructor_elt, gc) *vals;
#else
vec<constructor_elt, va_gc> *vals;
#endif
switch (TREE_CODE(*node)) {
default:
*no_add_attrs = true;
error("%qE attribute only applies to functions and variables",
name);
break;
case VAR_DECL:
if (DECL_INITIAL(*node)) {
*no_add_attrs = true;
error("variable %qD with %qE attribute must not be initialized",
*node, name);
break;
}
if (!TREE_STATIC(*node)) {
*no_add_attrs = true;
error("variable %qD with %qE attribute must not be local",
*node, name);
break;
}
type = TREE_TYPE(*node);
switch (TREE_CODE(type)) {
default:
*no_add_attrs = true;
error("variable %qD with %qE attribute must be an integer or a fixed length integer array type or a fixed sized structure with integer fields",
*node, name);
break;
case RECORD_TYPE: {
tree fld, lst = TYPE_FIELDS(type);
unsigned int nelt = 0;
for (fld = lst; fld; nelt++, fld = TREE_CHAIN(fld)) {
tree fieldtype;
fieldtype = TREE_TYPE(fld);
if (TREE_CODE(fieldtype) == INTEGER_TYPE)
continue;
*no_add_attrs = true;
error("structure variable %qD with %qE attribute has a non-integer field %qE",
*node, name, fld);
break;
}
if (fld)
break;
#if BUILDING_GCC_VERSION <= 4007
vals = VEC_alloc(constructor_elt, gc, nelt);
#else
vec_alloc(vals, nelt);
#endif
for (fld = lst; fld; fld = TREE_CHAIN(fld)) {
tree random_const, fld_t = TREE_TYPE(fld);
random_const = tree_get_random_const(fld_t);
CONSTRUCTOR_APPEND_ELT(vals, fld, random_const);
}
/* Initialize the fields with random constants */
DECL_INITIAL(*node) = build_constructor(type, vals);
break;
}
/* Initialize the variable with a random constant */
case INTEGER_TYPE:
DECL_INITIAL(*node) = tree_get_random_const(type);
break;
case ARRAY_TYPE: {
tree elt_type, array_size, elt_size;
unsigned int i, nelt;
HOST_WIDE_INT array_size_int, elt_size_int;
elt_type = TREE_TYPE(type);
elt_size = TYPE_SIZE_UNIT(TREE_TYPE(type));
array_size = TYPE_SIZE_UNIT(type);
if (TREE_CODE(elt_type) != INTEGER_TYPE || !array_size
|| TREE_CODE(array_size) != INTEGER_CST) {
*no_add_attrs = true;
error("array variable %qD with %qE attribute must be a fixed length integer array type",
*node, name);
break;
}
array_size_int = TREE_INT_CST_LOW(array_size);
elt_size_int = TREE_INT_CST_LOW(elt_size);
nelt = array_size_int / elt_size_int;
#if BUILDING_GCC_VERSION <= 4007
vals = VEC_alloc(constructor_elt, gc, nelt);
#else
vec_alloc(vals, nelt);
#endif
for (i = 0; i < nelt; i++) {
tree cst = size_int(i);
tree rand_cst = tree_get_random_const(elt_type);
CONSTRUCTOR_APPEND_ELT(vals, cst, rand_cst);
}
/*
* Initialize the elements of the array with random
* constants
*/
DECL_INITIAL(*node) = build_constructor(type, vals);
break;
}
}
break;
case FUNCTION_DECL:
break;
}
return NULL_TREE;
}
tree
ubsan_create_data (const char *name, location_t loc, ...)
{
va_list args;
tree ret, t;
tree fields[3];
VEC(tree, gc) *saved_args = NULL;
size_t i = 0;
/* Firstly, create a pointer to type descriptor type. */
tree td_type = ubsan_type_descriptor_type ();
TYPE_READONLY (td_type) = 1;
td_type = build_pointer_type (td_type);
/* Create the structure type. */
ret = make_node (RECORD_TYPE);
if (loc != UNKNOWN_LOCATION)
{
fields[i] = build_decl (UNKNOWN_LOCATION, FIELD_DECL, NULL_TREE,
ubsan_source_location_type ());
DECL_CONTEXT (fields[i]) = ret;
i++;
}
va_start (args, loc);
for (t = va_arg (args, tree); t != NULL_TREE;
i++, t = va_arg (args, tree))
{
gcc_checking_assert (i < 3);
/* Save the tree argument for later use. */
VEC_safe_push (tree, gc, saved_args, t);
fields[i] = build_decl (UNKNOWN_LOCATION, FIELD_DECL, NULL_TREE,
td_type);
DECL_CONTEXT (fields[i]) = ret;
if (i)
DECL_CHAIN (fields[i - 1]) = fields[i];
}
TYPE_FIELDS (ret) = fields[0];
TYPE_NAME (ret) = get_identifier (name);
layout_type (ret);
va_end (args);
/* Now, fill in the type. */
char tmp_name[32];
static unsigned int ubsan_var_id_num;
ASM_GENERATE_INTERNAL_LABEL (tmp_name, "Lubsan_data", ubsan_var_id_num++);
tree var = build_decl (UNKNOWN_LOCATION, VAR_DECL, get_identifier (tmp_name),
ret);
TREE_STATIC (var) = 1;
TREE_PUBLIC (var) = 0;
DECL_ARTIFICIAL (var) = 1;
DECL_IGNORED_P (var) = 1;
DECL_EXTERNAL (var) = 0;
VEC(constructor_elt, gc) *v;
v = VEC_alloc (constructor_elt, gc, i);
tree ctor = build_constructor (ret, v);
/* If desirable, set the __ubsan_source_location element. */
if (loc != UNKNOWN_LOCATION)
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, ubsan_source_location (loc));
size_t nelts = VEC_length (tree, saved_args);
for (i = 0; i < nelts; i++)
{
t = VEC_index (tree, saved_args, i);
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, t);
}
TREE_CONSTANT (ctor) = 1;
TREE_STATIC (ctor) = 1;
DECL_INITIAL (var) = ctor;
rest_of_decl_compilation (var, 1, 0);
return var;
}
static tree handle_latent_entropy_attribute(tree *node, tree name, tree args, int flags, bool *no_add_attrs)
{
tree type;
unsigned long long mask;
#if BUILDING_GCC_VERSION <= 4007
VEC(constructor_elt, gc) *vals;
#else
vec<constructor_elt, va_gc> *vals;
#endif
switch (TREE_CODE(*node)) {
default:
*no_add_attrs = true;
error("%qE attribute only applies to functions and variables", name);
break;
case VAR_DECL:
if (DECL_INITIAL(*node)) {
*no_add_attrs = true;
error("variable %qD with %qE attribute must not be initialized", *node, name);
break;
}
if (!TREE_STATIC(*node)) {
*no_add_attrs = true;
error("variable %qD with %qE attribute must not be local", *node, name);
break;
}
type = TREE_TYPE(*node);
switch (TREE_CODE(type)) {
default:
*no_add_attrs = true;
error("variable %qD with %qE attribute must be an integer or a fixed length integer array type or a fixed sized structure with integer fields", *node, name);
break;
case RECORD_TYPE: {
tree field;
unsigned int nelt = 0;
for (field = TYPE_FIELDS(type); field; nelt++, field = TREE_CHAIN(field)) {
tree fieldtype;
fieldtype = TREE_TYPE(field);
if (TREE_CODE(fieldtype) != INTEGER_TYPE) {
*no_add_attrs = true;
error("structure variable %qD with %qE attribute has a non-integer field %qE", *node, name, field);
break;
}
}
if (field)
break;
#if BUILDING_GCC_VERSION <= 4007
vals = VEC_alloc(constructor_elt, gc, nelt);
#else
vec_alloc(vals, nelt);
#endif
for (field = TYPE_FIELDS(type); field; field = TREE_CHAIN(field)) {
tree fieldtype;
fieldtype = TREE_TYPE(field);
mask = 1ULL << (TREE_INT_CST_LOW(TYPE_SIZE(fieldtype)) - 1);
mask = 2 * (mask - 1) + 1;
if (TYPE_UNSIGNED(fieldtype))
CONSTRUCTOR_APPEND_ELT(vals, field, build_int_cstu(fieldtype, mask & get_random_const()));
else
CONSTRUCTOR_APPEND_ELT(vals, field, build_int_cst(fieldtype, mask & get_random_const()));
}
DECL_INITIAL(*node) = build_constructor(type, vals);
//debug_tree(DECL_INITIAL(*node));
break;
}
case INTEGER_TYPE:
mask = 1ULL << (TREE_INT_CST_LOW(TYPE_SIZE(type)) - 1);
mask = 2 * (mask - 1) + 1;
if (TYPE_UNSIGNED(type))
DECL_INITIAL(*node) = build_int_cstu(type, mask & get_random_const());
else
DECL_INITIAL(*node) = build_int_cst(type, mask & get_random_const());
break;
case ARRAY_TYPE: {
tree elt_type, array_size, elt_size;
unsigned int i, nelt;
elt_type = TREE_TYPE(type);
elt_size = TYPE_SIZE_UNIT(TREE_TYPE(type));
array_size = TYPE_SIZE_UNIT(type);
if (TREE_CODE(elt_type) != INTEGER_TYPE || !array_size || TREE_CODE(array_size) != INTEGER_CST) {
*no_add_attrs = true;
error("array variable %qD with %qE attribute must be a fixed length integer array type", *node, name);
break;
}
nelt = TREE_INT_CST_LOW(array_size) / TREE_INT_CST_LOW(elt_size);
#if BUILDING_GCC_VERSION <= 4007
vals = VEC_alloc(constructor_elt, gc, nelt);
#else
vec_alloc(vals, nelt);
#endif
mask = 1ULL << (TREE_INT_CST_LOW(TYPE_SIZE(elt_type)) - 1);
mask = 2 * (mask - 1) + 1;
for (i = 0; i < nelt; i++)
if (TYPE_UNSIGNED(elt_type))
CONSTRUCTOR_APPEND_ELT(vals, size_int(i), build_int_cstu(elt_type, mask & get_random_const()));
else
CONSTRUCTOR_APPEND_ELT(vals, size_int(i), build_int_cst(elt_type, mask & get_random_const()));
DECL_INITIAL(*node) = build_constructor(type, vals);
//debug_tree(DECL_INITIAL(*node));
break;
}
}
break;
case FUNCTION_DECL:
break;
}
return NULL_TREE;
}
