}
}
- if (this->is_gc_root_)
+ static unsigned int counter;
+ char buf[100];
+ if (this->is_gc_root_ || this->is_slice_init_)
{
- // Build a decl for a GC root variable. GC roots are mutable, so they
- // cannot be represented as an immutable_struct in the backend.
- Bvariable* gc_root = gogo->backend()->gc_root_variable(btype, bexpr);
- bexpr = gogo->backend()->var_expression(gc_root, loc);
+ bool copy_to_heap = false;
+ if (this->is_gc_root_)
+ {
+ // Build a decl for a GC root variable. GC roots are mutable, so
+ // they cannot be represented as an immutable_struct in the
+ // backend.
+ static unsigned int root_counter;
+ snprintf(buf, sizeof buf, "gc%u", root_counter);
+ ++root_counter;
+ }
+ else
+ {
+ // Build a decl for a slice value initializer. An immutable slice
+ // value initializer may have to be copied to the heap if it
+ // contains pointers in a non-constant context.
+ snprintf(buf, sizeof buf, "C%u", counter);
+ ++counter;
+
+ Array_type* at = this->expr_->type()->array_type();
+ go_assert(at != NULL);
+
+ // If we are not copying the value to the heap, we will only
+ // initialize the value once, so we can use this directly
+ // rather than copying it. In that case we can't make it
+ // read-only, because the program is permitted to change it.
+ copy_to_heap = (at->element_type()->has_pointer()
+ && !context->is_const());
+ }
+ Bvariable* implicit =
+ gogo->backend()->implicit_variable(buf, btype, bexpr, copy_to_heap);
+ bexpr = gogo->backend()->var_expression(implicit, loc);
}
else if ((this->expr_->is_composite_literal()
|| this->expr_->string_expression() != NULL)
&& this->expr_->is_immutable())
{
// Build a decl for a constant constructor.
- static unsigned int counter;
- char buf[100];
snprintf(buf, sizeof buf, "C%u", counter);
++counter;
return error_mark_node;
}
+ Location loc = this->location();
Type* element_type = array_type->element_type();
if (this->valtype_ == NULL)
{
else
mpz_init_set_ui(lenval, this->indexes()->back() + 1);
}
- Location loc = this->location();
Type* int_type = Type::lookup_integer_type("int");
length = Expression::make_integer(&lenval, int_type, loc);
mpz_clear(lenval);
this->valtype_ = Type::make_array_type(element_type, length);
}
- tree values;
- Gogo* gogo = context->gogo();
- Btype* val_btype = this->valtype_->get_backend(gogo);
+ Expression_list* vals = this->vals();
if (this->vals() == NULL || this->vals()->empty())
{
- // We need to create a unique value.
- Btype* int_btype = Type::lookup_integer_type("int")->get_backend(gogo);
- Bexpression* zero = gogo->backend()->zero_expression(int_btype);
- std::vector<unsigned long> index(1, 0);
- std::vector<Bexpression*> val(1, zero);
- Bexpression* ctor =
- gogo->backend()->array_constructor_expression(val_btype, index, val,
- this->location());
- values = expr_to_tree(ctor);
+ // We need to create a unique value for the empty array literal.
+ vals = new Expression_list;
+ vals->push_back(NULL);
}
- else
- values = expr_to_tree(this->get_constructor(context, val_btype));
-
- if (values == error_mark_node)
- return error_mark_node;
+ Expression* array_val =
+ new Fixed_array_construction_expression(this->valtype_, this->indexes(),
+ vals, loc);
- bool is_constant_initializer = TREE_CONSTANT(values);
+ bool is_constant_initializer = array_val->is_immutable();
// We have to copy the initial values into heap memory if we are in
// a function or if the values are not constants. We also have to
|| (element_type->has_pointer()
&& !context->is_const()));
- if (is_constant_initializer)
- {
- tree tmp = build_decl(this->location().gcc_location(), VAR_DECL,
- create_tmp_var_name("C"), TREE_TYPE(values));
- DECL_EXTERNAL(tmp) = 0;
- TREE_PUBLIC(tmp) = 0;
- TREE_STATIC(tmp) = 1;
- DECL_ARTIFICIAL(tmp) = 1;
- if (copy_to_heap)
- {
- // If we are not copying the value to the heap, we will only
- // initialize the value once, so we can use this directly
- // rather than copying it. In that case we can't make it
- // read-only, because the program is permitted to change it.
- TREE_READONLY(tmp) = 1;
- TREE_CONSTANT(tmp) = 1;
- }
- DECL_INITIAL(tmp) = values;
- rest_of_decl_compilation(tmp, 1, 0);
- values = tmp;
- }
-
- tree space;
- tree set;
+ Expression* space;
if (!copy_to_heap)
{
- // the initializer will only run once.
- space = build_fold_addr_expr(values);
- set = NULL_TREE;
+ // The initializer will only run once.
+ space = Expression::make_unary(OPERATOR_AND, array_val, loc);
+ space->unary_expression()->set_is_slice_init();
}
else
- {
- Expression* alloc =
- context->gogo()->allocate_memory(this->valtype_, this->location());
- space = save_expr(alloc->get_tree(context));
-
- tree s = fold_convert(build_pointer_type(TREE_TYPE(values)), space);
- tree ref = build_fold_indirect_ref_loc(this->location().gcc_location(),
- s);
- TREE_THIS_NOTRAP(ref) = 1;
- set = build2(MODIFY_EXPR, void_type_node, ref, values);
- }
+ space = Expression::make_heap_expression(array_val, loc);
// Build a constructor for the slice.
- tree type_tree = type_to_tree(this->type()->get_backend(context->gogo()));
- if (type_tree == error_mark_node)
- return error_mark_node;
- go_assert(TREE_CODE(type_tree) == RECORD_TYPE);
-
- vec<constructor_elt, va_gc> *init;
- vec_alloc(init, 3);
-
- constructor_elt empty = {NULL, NULL};
- constructor_elt* elt = init->quick_push(empty);
- tree field = TYPE_FIELDS(type_tree);
- go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__values") == 0);
- elt->index = field;
- elt->value = fold_convert(TREE_TYPE(field), space);
-
- tree length_tree = this->valtype_->array_type()->length()->get_tree(context);
- elt = init->quick_push(empty);
- field = DECL_CHAIN(field);
- go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__count") == 0);
- elt->index = field;
- elt->value = fold_convert(TREE_TYPE(field), length_tree);
-
- elt = init->quick_push(empty);
- field = DECL_CHAIN(field);
- go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),"__capacity") == 0);
- elt->index = field;
- elt->value = fold_convert(TREE_TYPE(field), length_tree);
-
- tree constructor = build_constructor(type_tree, init);
- if (constructor == error_mark_node)
- return error_mark_node;
- if (!copy_to_heap)
- TREE_CONSTANT(constructor) = 1;
-
- if (set == NULL_TREE)
- return constructor;
- else
- return build2(COMPOUND_EXPR, type_tree, set, constructor);
+ Expression* len = this->valtype_->array_type()->length();
+ Expression* slice_val =
+ Expression::make_slice_value(this->type(), space, len, len, loc);
+ return slice_val->get_tree(context);
}
// Make a slice composite literal. This is used by the type
{ }
protected:
+ bool
+ do_is_immutable() const
+ { return true; }
+
Type*
do_type()
{ return Type::lookup_integer_type("uintptr"); }
projects / thirdparty / gcc.git / commitdiff
