#include "import.h"
#include "statements.h"
#include "lex.h"
+#include "runtime.h"
#include "backend.h"
#include "expressions.h"
+#include "ast-dump.h"
// Class Expression.
}
// This virtual function is called by the parser if the value of this
-// expression is being discarded. By default, we warn. Expressions
-// with side effects override.
+// expression is being discarded. By default, we give an error.
+// Expressions with side effects override.
void
Expression::do_discarding_value()
{
- this->warn_about_unused_value();
+ this->unused_value_error();
}
// This virtual function is called to export expressions. This will
go_unreachable();
}
-// Warn that the value of the expression is not used.
+// Give an error saying that the value of the expression is not used.
void
-Expression::warn_about_unused_value()
+Expression::unused_value_error()
{
- warning_at(this->location(), OPT_Wunused_value, "value computed is not used");
+ error_at(this->location(), "value computed is not used");
}
// Note that this expression is an error. This is called by children
else if (rhs_type->interface_type() != NULL)
return Expression::convert_interface_to_type(context, lhs_type, rhs_type,
rhs_tree, location);
- else if (lhs_type->is_open_array_type()
- && rhs_type->is_nil_type())
+ else if (lhs_type->is_slice_type() && rhs_type->is_nil_type())
{
// Assigning nil to an open array.
go_assert(TREE_CODE(lhs_type_tree) == RECORD_TYPE);
// Otherwise it is the interface method table for RHS_TYPE.
tree first_field_value;
if (lhs_is_empty)
- first_field_value = rhs_type->type_descriptor_pointer(gogo);
+ first_field_value = rhs_type->type_descriptor_pointer(gogo, location);
else
{
// Build the interface method table for this interface and this
if (for_type_guard)
{
// A type assertion fails when converting a nil interface.
- tree lhs_type_descriptor = lhs_type->type_descriptor_pointer(gogo);
+ tree lhs_type_descriptor = lhs_type->type_descriptor_pointer(gogo,
+ location);
static tree assert_interface_decl;
tree call = Gogo::call_builtin(&assert_interface_decl,
location,
// type assertion converting nil will always succeed.
go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__methods")
== 0);
- tree lhs_type_descriptor = lhs_type->type_descriptor_pointer(gogo);
+ tree lhs_type_descriptor = lhs_type->type_descriptor_pointer(gogo,
+ location);
static tree convert_interface_decl;
tree call = Gogo::call_builtin(&convert_interface_decl,
location,
// will panic with an appropriate runtime type error if the type is
// not valid.
- tree lhs_type_descriptor = lhs_type->type_descriptor_pointer(gogo);
+ tree lhs_type_descriptor = lhs_type->type_descriptor_pointer(gogo, location);
if (!DECL_P(rhs_tree))
rhs_tree = save_expr(rhs_tree);
Expression::get_interface_type_descriptor(context, rhs_type, rhs_tree,
location);
- tree rhs_inter_descriptor = rhs_type->type_descriptor_pointer(gogo);
+ tree rhs_inter_descriptor = rhs_type->type_descriptor_pointer(gogo,
+ location);
static tree check_interface_type_decl;
tree call = Gogo::call_builtin(&check_interface_type_decl,
sofar, ret);
}
+void
+Expression::dump_expression(Ast_dump_context* ast_dump_context) const
+{
+ this->do_dump_expression(ast_dump_context);
+}
+
// Error expressions. This are used to avoid cascading errors.
class Error_expression : public Expression
tree
do_get_tree(Translate_context*)
{ return error_mark_node; }
+
+ void
+ do_dump_expression(Ast_dump_context*) const;
};
+// Dump the ast representation for an error expression to a dump context.
+
+void
+Error_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
+{
+ ast_dump_context->ostream() << "_Error_" ;
+}
+
Expression*
Expression::make_error(source_location location)
{
do_get_tree(Translate_context*)
{ go_unreachable(); }
+ void do_dump_expression(Ast_dump_context*) const;
+
private:
// The type which we are representing as an expression.
Type* type_;
};
+void
+Type_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
+{
+ ast_dump_context->dump_type(this->type_);
+}
+
Expression*
Expression::make_type(Type* type, source_location location)
{
// if necessary.
Expression*
-Var_expression::do_lower(Gogo* gogo, Named_object* function, int)
+Var_expression::do_lower(Gogo* gogo, Named_object* function,
+ Statement_inserter* inserter, int)
{
if (this->variable_->is_variable())
{
// reference to a variable which is local to an enclosing
// function will be a reference to a field in a closure.
if (var->is_global())
- function = NULL;
- var->lower_init_expression(gogo, function);
+ {
+ function = NULL;
+ inserter = NULL;
+ }
+ var->lower_init_expression(gogo, function, inserter);
}
return this;
}
return ret;
}
+// Ast dump for variable expression.
+
+void
+Var_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
+{
+ ast_dump_context->ostream() << this->variable_->name() ;
+}
+
// Make a reference to a variable in an expression.
Expression*
// that here by adding a type cast. We need to use base() to push
// the circularity down one level.
tree ret = var_to_tree(bvar);
- if (POINTER_TYPE_P(TREE_TYPE(ret)) && VOID_TYPE_P(TREE_TYPE(TREE_TYPE(ret))))
+ if (!this->is_lvalue_
+ && POINTER_TYPE_P(TREE_TYPE(ret))
+ && VOID_TYPE_P(TREE_TYPE(TREE_TYPE(ret))))
{
Btype* type_btype = this->type()->base()->get_backend(context->gogo());
tree type_tree = type_to_tree(type_btype);
return ret;
}
+// Ast dump for temporary reference.
+
+void
+Temporary_reference_expression::do_dump_expression(
+ Ast_dump_context* ast_dump_context) const
+{
+ ast_dump_context->dump_temp_variable_name(this->statement_);
+}
+
// Make a reference to a temporary variable.
-Expression*
+Temporary_reference_expression*
Expression::make_temporary_reference(Temporary_statement* statement,
source_location location)
{
tree
do_get_tree(Translate_context*);
+ void
+ do_dump_expression(Ast_dump_context*) const;
+
private:
// The type of this sink variable.
Type* type_;
return this->var_;
}
+// Ast dump for sink expression.
+
+void
+Sink_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
+{
+ ast_dump_context->ostream() << "_" ;
+}
+
// Make a sink expression.
Expression*
return gogo->make_trampoline(fnaddr, closure_tree, this->location());
}
+// Ast dump for function.
+
+void
+Func_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
+{
+ ast_dump_context->ostream() << this->function_->name();
+ if (this->closure_ != NULL)
+ {
+ ast_dump_context->ostream() << " {closure = ";
+ this->closure_->dump_expression(ast_dump_context);
+ ast_dump_context->ostream() << "}";
+ }
+}
+
// Make a reference to a function in an expression.
Expression*
// Lower a reference to an unknown name.
Expression*
-Unknown_expression::do_lower(Gogo*, Named_object*, int)
+Unknown_expression::do_lower(Gogo*, Named_object*, Statement_inserter*, int)
{
source_location location = this->location();
Named_object* no = this->named_object_;
}
}
+// Dump the ast representation for an unknown expression to a dump context.
+
+void
+Unknown_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
+{
+ ast_dump_context->ostream() << "_Unknown_(" << this->named_object_->name()
+ << ")";
+}
+
// Make a reference to an unknown name.
Expression*
Expression::make_unknown_reference(Named_object* no, source_location location)
{
- go_assert(no->resolve()->is_unknown());
return new Unknown_expression(no, location);
}
do_export(Export* exp) const
{ exp->write_c_string(this->val_ ? "true" : "false"); }
+ void
+ do_dump_expression(Ast_dump_context* ast_dump_context) const
+ { ast_dump_context->ostream() << (this->val_ ? "true" : "false"); }
+
private:
// The constant.
bool val_;
return context->gogo()->go_string_constant_tree(this->val_);
}
-// Export a string expression.
+ // Write string literal to string dump.
void
-String_expression::do_export(Export* exp) const
+String_expression::export_string(String_dump* exp,
+ const String_expression* str)
{
std::string s;
- s.reserve(this->val_.length() * 4 + 2);
+ s.reserve(str->val_.length() * 4 + 2);
s += '"';
- for (std::string::const_iterator p = this->val_.begin();
- p != this->val_.end();
+ for (std::string::const_iterator p = str->val_.begin();
+ p != str->val_.end();
++p)
{
if (*p == '\\' || *p == '"')
exp->write_string(s);
}
+// Export a string expression.
+
+void
+String_expression::do_export(Export* exp) const
+{
+ String_expression::export_string(exp, this);
+}
+
// Import a string expression.
Expression*
return Expression::make_string(val, imp->location());
}
+// Ast dump for string expression.
+
+void
+String_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
+{
+ String_expression::export_string(ast_dump_context, this);
+}
+
// Make a string expression.
Expression*
static bool
check_constant(mpz_t val, Type*, source_location);
- // Write VAL to export data.
+ // Write VAL to string dump.
static void
- export_integer(Export* exp, const mpz_t val);
+ export_integer(String_dump* exp, const mpz_t val);
+
+ // Write VAL to dump context.
+ static void
+ dump_integer(Ast_dump_context* ast_dump_context, const mpz_t val);
protected:
bool
void
do_export(Export*) const;
+ void
+ do_dump_expression(Ast_dump_context*) const;
+
private:
// The integer value.
mpz_t val_;
// Write VAL to export data.
void
-Integer_expression::export_integer(Export* exp, const mpz_t val)
+Integer_expression::export_integer(String_dump* exp, const mpz_t val)
{
char* s = mpz_get_str(NULL, 10, val);
exp->write_c_string(s);
return ret;
}
}
+// Ast dump for integer expression.
+
+void
+Integer_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
+{
+ Integer_expression::export_integer(ast_dump_context, this->val_);
+}
// Build a new integer value.
// Write VAL to export data.
static void
- export_float(Export* exp, const mpfr_t val);
+ export_float(String_dump* exp, const mpfr_t val);
+
+ // Write VAL to dump file.
+ static void
+ dump_float(Ast_dump_context* ast_dump_context, const mpfr_t val);
protected:
bool
void
do_export(Export*) const;
+ void
+ do_dump_expression(Ast_dump_context*) const;
+
private:
// The floating point value.
mpfr_t val_;
return Expression::float_constant_tree(this->val_, type);
}
-// Write a floating point number to export data.
+// Write a floating point number to a string dump.
void
-Float_expression::export_float(Export *exp, const mpfr_t val)
+Float_expression::export_float(String_dump *exp, const mpfr_t val)
{
mp_exp_t exponent;
char* s = mpfr_get_str(NULL, &exponent, 10, 0, val, GMP_RNDN);
exp->write_c_string(" ");
}
+// Dump a floating point number to the dump file.
+
+void
+Float_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
+{
+ Float_expression::export_float(ast_dump_context, this->val_);
+}
+
// Make a float expression.
Expression*
static bool
check_constant(mpfr_t real, mpfr_t imag, Type*, source_location);
- // Write REAL/IMAG to export data.
+ // Write REAL/IMAG to string dump.
static void
- export_complex(Export* exp, const mpfr_t real, const mpfr_t val);
+ export_complex(String_dump* exp, const mpfr_t real, const mpfr_t val);
+ // Write REAL/IMAG to dump context.
+ static void
+ dump_complex(Ast_dump_context* ast_dump_context,
+ const mpfr_t real, const mpfr_t val);
+
protected:
bool
do_is_constant() const
void
do_export(Export*) const;
+ void
+ do_dump_expression(Ast_dump_context*) const;
+
private:
// The real part.
mpfr_t real_;
// Write REAL/IMAG to export data.
void
-Complex_expression::export_complex(Export* exp, const mpfr_t real,
+Complex_expression::export_complex(String_dump* exp, const mpfr_t real,
const mpfr_t imag)
{
if (!mpfr_zero_p(real))
exp->write_c_string(" ");
}
+// Dump a complex expression to the dump file.
+
+void
+Complex_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
+{
+ Complex_expression::export_complex(ast_dump_context,
+ this->real_,
+ this->imag_);
+}
+
// Make a complex expression.
Expression*
do_traverse(Traverse*);
Expression*
- do_lower(Gogo*, Named_object*, int);
+ do_lower(Gogo*, Named_object*, Statement_inserter*, int);
bool
do_is_constant() const
do_export(Export* exp) const
{ this->constant_->const_value()->expr()->export_expression(exp); }
+ void
+ do_dump_expression(Ast_dump_context*) const;
+
private:
// The constant.
Named_object* constant_;
// predeclared constant iota into an integer value.
Expression*
-Const_expression::do_lower(Gogo* gogo, Named_object*, int iota_value)
+Const_expression::do_lower(Gogo* gogo, Named_object*,
+ Statement_inserter*, int iota_value)
{
if (this->constant_->const_value()->expr()->classification()
== EXPRESSION_IOTA)
return ret;
}
+// Dump ast representation for constant expression.
+
+void
+Const_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
+{
+ ast_dump_context->ostream() << this->constant_->name();
+}
+
// Make a reference to a constant in an expression.
Expression*
void
do_export(Export* exp) const
{ exp->write_c_string("nil"); }
+
+ void
+ do_dump_expression(Ast_dump_context* ast_dump_context) const
+ { ast_dump_context->ostream() << "nil"; }
};
// Import a nil expression.
protected:
Expression*
- do_lower(Gogo*, Named_object*, int)
+ do_lower(Gogo*, Named_object*, Statement_inserter*, int)
{ go_unreachable(); }
// There should only ever be one of these.
Expression*
do_copy()
{ go_unreachable(); }
+
+ void
+ do_dump_expression(Ast_dump_context* ast_dump_context) const
+ { ast_dump_context->ostream() << "iota"; }
};
// Make an iota expression. This is only called for one case: the
do_traverse(Traverse* traverse);
Expression*
- do_lower(Gogo*, Named_object*, int);
+ do_lower(Gogo*, Named_object*, Statement_inserter*, int);
bool
do_is_constant() const
void
do_export(Export*) const;
+ void
+ do_dump_expression(Ast_dump_context*) const;
+
private:
// The type to convert to.
Type* type_;
// Convert to a constant at lowering time.
Expression*
-Type_conversion_expression::do_lower(Gogo*, Named_object*, int)
+Type_conversion_expression::do_lower(Gogo*, Named_object*,
+ Statement_inserter*, int)
{
Type* type = this->type_;
Expression* val = this->expr_;
mpfr_clear(imag);
}
- if (type->is_open_array_type() && type->named_type() == NULL)
+ if (type->is_slice_type() && type->named_type() == NULL)
{
Type* element_type = type->array_type()->element_type()->forwarded();
bool is_byte = element_type == Type::lookup_integer_type("uint8");
len);
}
}
- else if (type->is_open_array_type() && expr_type->is_string_type())
+ else if (type->is_slice_type() && expr_type->is_string_type())
{
Type* e = type->array_type()->element_type()->forwarded();
go_assert(e->integer_type() != NULL);
return Expression::make_cast(type, val, imp->location());
}
+// Dump ast representation for a type conversion expression.
+
+void
+Type_conversion_expression::do_dump_expression(
+ Ast_dump_context* ast_dump_context) const
+{
+ ast_dump_context->dump_type(this->type_);
+ ast_dump_context->ostream() << "(";
+ ast_dump_context->dump_expression(this->expr_);
+ ast_dump_context->ostream() << ") ";
+}
+
// Make a type cast expression.
Expression*
void
do_determine_type(const Type_context*)
- { }
+ { this->expr_->determine_type_no_context(); }
Expression*
do_copy()
tree
do_get_tree(Translate_context*);
+ void
+ do_dump_expression(Ast_dump_context*) const;
+
private:
// The type to convert to.
Type* type_;
source_location loc = this->location();
bool use_view_convert = false;
- if (t->is_open_array_type())
+ if (t->is_slice_type())
{
- go_assert(et->is_open_array_type());
+ go_assert(et->is_slice_type());
use_view_convert = true;
}
else if (t->map_type() != NULL)
go_assert((et->points_to() != NULL
&& et->points_to()->channel_type() != NULL)
|| et->is_nil_type());
- else if (t->is_unsafe_pointer_type())
+ else if (t->points_to() != NULL)
go_assert(et->points_to() != NULL || et->is_nil_type());
else if (et->is_unsafe_pointer_type())
go_assert(t->points_to() != NULL);
return fold_convert_loc(loc, type_tree, expr_tree);
}
+// Dump ast representation for an unsafe type conversion expression.
+
+void
+Unsafe_type_conversion_expression::do_dump_expression(
+ Ast_dump_context* ast_dump_context) const
+{
+ ast_dump_context->dump_type(this->type_);
+ ast_dump_context->ostream() << "(";
+ ast_dump_context->dump_expression(this->expr_);
+ ast_dump_context->ostream() << ") ";
+}
+
// Make an unsafe type conversion expression.
Expression*
public:
Unary_expression(Operator op, Expression* expr, source_location location)
: Expression(EXPRESSION_UNARY, location),
- op_(op), escapes_(true), expr_(expr)
+ op_(op), escapes_(true), create_temp_(false), expr_(expr)
{ }
// Return the operator.
this->escapes_ = false;
}
+ // Record that this is an address expression which should create a
+ // temporary variable if necessary. This is used for method calls.
+ void
+ set_create_temp()
+ {
+ go_assert(this->op_ == OPERATOR_AND);
+ this->create_temp_ = true;
+ }
+
// Apply unary opcode OP to UVAL, setting VAL. Return true if this
// could be done, false if not.
static bool
{ return Expression::traverse(&this->expr_, traverse); }
Expression*
- do_lower(Gogo*, Named_object*, int);
+ do_lower(Gogo*, Named_object*, Statement_inserter*, int);
bool
do_is_constant() const;
void
do_export(Export*) const;
+ void
+ do_dump_expression(Ast_dump_context*) const;
+
private:
// The unary operator to apply.
Operator op_;
// Normally true. False if this is an address expression which does
// not escape the current function.
bool escapes_;
+ // True if this is an address expression which should create a
+ // temporary variable if necessary.
+ bool create_temp_;
// The operand.
Expression* expr_;
};
// instead.
Expression*
-Unary_expression::do_lower(Gogo*, Named_object*, int)
+Unary_expression::do_lower(Gogo*, Named_object*, Statement_inserter*, int)
{
source_location loc = this->location();
Operator op = this->op_;
case OPERATOR_AND:
if (!this->expr_->is_addressable())
- this->report_error(_("invalid operand for unary %<&%>"));
+ {
+ if (!this->create_temp_)
+ this->report_error(_("invalid operand for unary %<&%>"));
+ }
else
this->expr_->address_taken(this->escapes_);
break;
return fold_build1_loc(loc, BIT_NOT_EXPR, TREE_TYPE(expr), expr);
case OPERATOR_AND:
- // We should not see a non-constant constructor here; cases
- // where we would see one should have been moved onto the heap
- // at parse time. Taking the address of a nonconstant
- // constructor will not do what the programmer expects.
- go_assert(TREE_CODE(expr) != CONSTRUCTOR || TREE_CONSTANT(expr));
- go_assert(TREE_CODE(expr) != ADDR_EXPR);
+ if (!this->create_temp_)
+ {
+ // We should not see a non-constant constructor here; cases
+ // where we would see one should have been moved onto the
+ // heap at parse time. Taking the address of a nonconstant
+ // constructor will not do what the programmer expects.
+ go_assert(TREE_CODE(expr) != CONSTRUCTOR || TREE_CONSTANT(expr));
+ go_assert(TREE_CODE(expr) != ADDR_EXPR);
+ }
// Build a decl for a constant constructor.
if (TREE_CODE(expr) == CONSTRUCTOR && TREE_CONSTANT(expr))
expr = decl;
}
+ if (this->create_temp_
+ && !TREE_ADDRESSABLE(TREE_TYPE(expr))
+ && !DECL_P(expr)
+ && TREE_CODE(expr) != INDIRECT_REF
+ && TREE_CODE(expr) != COMPONENT_REF)
+ {
+ tree tmp = create_tmp_var(TREE_TYPE(expr), get_name(expr));
+ DECL_IGNORED_P(tmp) = 1;
+ DECL_INITIAL(tmp) = expr;
+ TREE_ADDRESSABLE(tmp) = 1;
+ return build2_loc(loc, COMPOUND_EXPR,
+ build_pointer_type(TREE_TYPE(expr)),
+ build1_loc(loc, DECL_EXPR, void_type_node, tmp),
+ build_fold_addr_expr_loc(loc, tmp));
+ }
+
return build_fold_addr_expr_loc(loc, expr);
case OPERATOR_MULT:
return Expression::make_unary(op, expr, imp->location());
}
+// Dump ast representation of an unary expression.
+
+void
+Unary_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
+{
+ ast_dump_context->dump_operator(this->op_);
+ ast_dump_context->ostream() << "(";
+ ast_dump_context->dump_expression(this->expr_);
+ ast_dump_context->ostream() << ") ";
+}
+
// Make a unary expression.
Expression*
// constants.
Expression*
-Binary_expression::do_lower(Gogo*, Named_object*, int)
+Binary_expression::do_lower(Gogo*, Named_object*, Statement_inserter*, int)
{
source_location location = this->location();
Operator op = this->op_;
return Expression::make_string(left_string + right_string, location);
}
+ // Special case for shift of a floating point constant.
+ if (op == OPERATOR_LSHIFT || op == OPERATOR_RSHIFT)
+ {
+ mpfr_t left_val;
+ mpfr_init(left_val);
+ Type* left_type;
+ mpz_t right_val;
+ mpz_init(right_val);
+ Type* right_type;
+ if (left->float_constant_value(left_val, &left_type)
+ && right->integer_constant_value(false, right_val, &right_type)
+ && mpfr_integer_p(left_val)
+ && (left_type == NULL
+ || left_type->is_abstract()
+ || left_type->integer_type() != NULL))
+ {
+ mpz_t left_int;
+ mpz_init(left_int);
+ mpfr_get_z(left_int, left_val, GMP_RNDN);
+
+ mpz_t val;
+ mpz_init(val);
+
+ Expression* ret = NULL;
+ if (Binary_expression::eval_integer(op, left_type, left_int,
+ right_type, right_val,
+ location, val))
+ ret = Expression::make_integer(&val, left_type, location);
+
+ mpz_clear(left_int);
+ mpz_clear(val);
+
+ if (ret != NULL)
+ {
+ mpfr_clear(left_val);
+ mpz_clear(right_val);
+ return ret;
+ }
+ }
+
+ mpfr_clear(left_val);
+ mpz_clear(right_val);
+ }
+
return this;
}
if (this->op_ == OPERATOR_OROR || this->op_ == OPERATOR_ANDAND)
this->right_->discarding_value();
else
- this->warn_about_unused_value();
+ this->unused_value_error();
}
// Get type.
// Set the context for the left hand operand.
if (is_shift_op)
{
- // The right hand operand plays no role in determining the type
- // of the left hand operand. A shift of an abstract integer in
- // a string context gets special treatment, which may be a
- // language bug.
- if (subcontext.type != NULL
- && subcontext.type->is_string_type()
- && tleft->is_abstract())
- error_at(this->location(), "shift of non-integer operand");
+ // The right hand operand of a shift plays no role in
+ // determining the type of the left hand operand.
}
else if (!tleft->is_abstract())
subcontext.type = tleft;
this->left_->determine_type(&subcontext);
- // The context for the right hand operand is the same as for the
- // left hand operand, except for a shift operator.
if (is_shift_op)
{
+ // We may have inherited an unusable type for the shift operand.
+ // Give a useful error if that happened.
+ if (tleft->is_abstract()
+ && subcontext.type != NULL
+ && (this->left_->type()->integer_type() == NULL
+ || (subcontext.type->integer_type() == NULL
+ && subcontext.type->float_type() == NULL
+ && subcontext.type->complex_type() == NULL)))
+ this->report_error(("invalid context-determined non-integer type "
+ "for shift operand"));
+
+ // The context for the right hand operand is the same as for the
+ // left hand operand, except for a shift operator.
subcontext.type = Type::lookup_integer_type("uint");
subcontext.may_be_abstract = false;
}
return Expression::make_binary(op, left, right, imp->location());
}
+// Dump ast representation of a binary expression.
+
+void
+Binary_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
+{
+ ast_dump_context->ostream() << "(";
+ ast_dump_context->dump_expression(this->left_);
+ ast_dump_context->ostream() << " ";
+ ast_dump_context->dump_operator(this->op_);
+ ast_dump_context->ostream() << " ";
+ ast_dump_context->dump_expression(this->right_);
+ ast_dump_context->ostream() << ") ";
+}
+
// Make a binary expression.
Expression*
}
arg = fold_convert_loc(location, ptr_type_node, arg);
- tree descriptor = right_type->type_descriptor_pointer(context->gogo());
+ tree descriptor = right_type->type_descriptor_pointer(context->gogo(),
+ location);
if (left_type->interface_type()->is_empty())
{
int
Bound_method_expression::do_traverse(Traverse* traverse)
{
- if (Expression::traverse(&this->expr_, traverse) == TRAVERSE_EXIT)
- return TRAVERSE_EXIT;
- return Expression::traverse(&this->method_, traverse);
+ return Expression::traverse(&this->expr_, traverse);
}
// Return the type of a bound method expression. The type of this
Type*
Bound_method_expression::do_type()
{
- return this->method_->type();
+ if (this->method_->is_function())
+ return this->method_->func_value()->type();
+ else if (this->method_->is_function_declaration())
+ return this->method_->func_declaration_value()->type();
+ else
+ return Type::make_error_type();
}
// Determine the types of a method expression.
void
Bound_method_expression::do_determine_type(const Type_context*)
{
- this->method_->determine_type_no_context();
- Type* mtype = this->method_->type();
- Function_type* fntype = mtype == NULL ? NULL : mtype->function_type();
+ Function_type* fntype = this->type()->function_type();
if (fntype == NULL || !fntype->is_method())
this->expr_->determine_type_no_context();
else
void
Bound_method_expression::do_check_types(Gogo*)
{
- Type* type = this->method_->type()->deref();
- if (type == NULL
- || type->function_type() == NULL
- || !type->function_type()->is_method())
+ if (!this->method_->is_function()
+ && !this->method_->is_function_declaration())
this->report_error(_("object is not a method"));
else
{
- Type* rtype = type->function_type()->receiver()->type()->deref();
+ Type* rtype = this->type()->function_type()->receiver()->type()->deref();
Type* etype = (this->expr_type_ != NULL
? this->expr_type_
: this->expr_->type());
return error_mark_node;
}
+// Dump ast representation of a bound method expression.
+
+void
+Bound_method_expression::do_dump_expression(Ast_dump_context* ast_dump_context)
+ const
+{
+ if (this->expr_type_ != NULL)
+ ast_dump_context->ostream() << "(";
+ ast_dump_context->dump_expression(this->expr_);
+ if (this->expr_type_ != NULL)
+ {
+ ast_dump_context->ostream() << ":";
+ ast_dump_context->dump_type(this->expr_type_);
+ ast_dump_context->ostream() << ")";
+ }
+
+ ast_dump_context->ostream() << "." << this->method_->name();
+}
+
// Make a method expression.
Bound_method_expression*
-Expression::make_bound_method(Expression* expr, Expression* method,
+Expression::make_bound_method(Expression* expr, Named_object* method,
source_location location)
{
return new Bound_method_expression(expr, method, location);
protected:
// This overrides Call_expression::do_lower.
Expression*
- do_lower(Gogo*, Named_object*, int);
+ do_lower(Gogo*, Named_object*, Statement_inserter*, int);
bool
do_is_constant() const;
bool
do_complex_constant_value(mpfr_t, mpfr_t, Type**) const;
+ void
+ do_discarding_value();
+
Type*
do_type();
static Type*
complex_type(Type*);
+ Expression*
+ lower_make();
+
+ bool
+ check_int_value(Expression*);
+
// A pointer back to the general IR structure. This avoids a global
// variable, or passing it around everywhere.
Gogo* gogo_;
// specific expressions. We also convert to a constant if we can.
Expression*
-Builtin_call_expression::do_lower(Gogo* gogo, Named_object* function, int)
+Builtin_call_expression::do_lower(Gogo* gogo, Named_object* function,
+ Statement_inserter* inserter, int)
{
+ if (this->classification() == EXPRESSION_ERROR)
+ return this;
+
if (this->is_varargs() && this->code_ != BUILTIN_APPEND)
{
this->report_error(_("invalid use of %<...%> with builtin function"));
}
}
else if (this->code_ == BUILTIN_MAKE)
- {
- const Expression_list* args = this->args();
- if (args == NULL || args->size() < 1)
- this->report_error(_("not enough arguments"));
- else
- {
- Expression* arg = args->front();
- if (!arg->is_type_expression())
- {
- error_at(arg->location(), "expected type");
- this->set_is_error();
- }
- else
- {
- Expression_list* newargs;
- if (args->size() == 1)
- newargs = NULL;
- else
- {
- newargs = new Expression_list();
- Expression_list::const_iterator p = args->begin();
- ++p;
- for (; p != args->end(); ++p)
- newargs->push_back(*p);
- }
- return Expression::make_make(arg->type(), newargs,
- this->location());
- }
- }
- }
+ return this->lower_make();
else if (this->is_constant())
{
// We can only lower len and cap if there are no function calls
if (args == NULL || args->empty())
return this;
Type* slice_type = args->front()->type();
- if (!slice_type->is_open_array_type())
+ if (!slice_type->is_slice_type())
{
error_at(args->front()->location(), "argument 1 must be a slice");
this->set_is_error();
return this;
}
- return this->lower_varargs(gogo, function, slice_type, 2);
+ this->lower_varargs(gogo, function, inserter, slice_type, 2);
}
return this;
}
-// Return the type of the real or imag functions, given the type of
-// the argument. We need to map complex to float, complex64 to
-// float32, and complex128 to float64, so it has to be done by name.
-// This returns NULL if it can't figure out the type.
+// Lower a make expression.
-Type*
-Builtin_call_expression::real_imag_type(Type* arg_type)
+Expression*
+Builtin_call_expression::lower_make()
{
- if (arg_type == NULL || arg_type->is_abstract())
- return NULL;
- Named_type* nt = arg_type->named_type();
- if (nt == NULL)
- return NULL;
- while (nt->real_type()->named_type() != NULL)
- nt = nt->real_type()->named_type();
- if (nt->name() == "complex64")
- return Type::lookup_float_type("float32");
- else if (nt->name() == "complex128")
- return Type::lookup_float_type("float64");
- else
- return NULL;
-}
+ source_location loc = this->location();
-// Return the type of the complex function, given the type of one of the
-// argments. Like real_imag_type, we have to map by name.
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() < 1)
+ {
+ this->report_error(_("not enough arguments"));
+ return Expression::make_error(this->location());
+ }
-Type*
-Builtin_call_expression::complex_type(Type* arg_type)
-{
- if (arg_type == NULL || arg_type->is_abstract())
- return NULL;
- Named_type* nt = arg_type->named_type();
- if (nt == NULL)
- return NULL;
- while (nt->real_type()->named_type() != NULL)
- nt = nt->real_type()->named_type();
- if (nt->name() == "float32")
- return Type::lookup_complex_type("complex64");
- else if (nt->name() == "float64")
- return Type::lookup_complex_type("complex128");
- else
- return NULL;
-}
+ Expression_list::const_iterator parg = args->begin();
-// Return a single argument, or NULL if there isn't one.
+ Expression* first_arg = *parg;
+ if (!first_arg->is_type_expression())
+ {
+ error_at(first_arg->location(), "expected type");
+ this->set_is_error();
+ return Expression::make_error(this->location());
+ }
+ Type* type = first_arg->type();
-Expression*
-Builtin_call_expression::one_arg() const
+ bool is_slice = false;
+ bool is_map = false;
+ bool is_chan = false;
+ if (type->is_slice_type())
+ is_slice = true;
+ else if (type->map_type() != NULL)
+ is_map = true;
+ else if (type->channel_type() != NULL)
+ is_chan = true;
+ else
+ {
+ this->report_error(_("invalid type for make function"));
+ return Expression::make_error(this->location());
+ }
+
+ ++parg;
+ Expression* len_arg;
+ if (parg == args->end())
+ {
+ if (is_slice)
+ {
+ this->report_error(_("length required when allocating a slice"));
+ return Expression::make_error(this->location());
+ }
+
+ mpz_t zval;
+ mpz_init_set_ui(zval, 0);
+ len_arg = Expression::make_integer(&zval, NULL, loc);
+ mpz_clear(zval);
+ }
+ else
+ {
+ len_arg = *parg;
+ if (!this->check_int_value(len_arg))
+ {
+ this->report_error(_("bad size for make"));
+ return Expression::make_error(this->location());
+ }
+ ++parg;
+ }
+
+ Expression* cap_arg = NULL;
+ if (is_slice && parg != args->end())
+ {
+ cap_arg = *parg;
+ if (!this->check_int_value(cap_arg))
+ {
+ this->report_error(_("bad capacity when making slice"));
+ return Expression::make_error(this->location());
+ }
+ ++parg;
+ }
+
+ if (parg != args->end())
+ {
+ this->report_error(_("too many arguments to make"));
+ return Expression::make_error(this->location());
+ }
+
+ source_location type_loc = first_arg->location();
+ Expression* type_arg;
+ if (is_slice || is_chan)
+ type_arg = Expression::make_type_descriptor(type, type_loc);
+ else if (is_map)
+ type_arg = Expression::make_map_descriptor(type->map_type(), type_loc);
+ else
+ go_unreachable();
+
+ Expression* call;
+ if (is_slice)
+ {
+ if (cap_arg == NULL)
+ call = Runtime::make_call(Runtime::MAKESLICE1, loc, 2, type_arg,
+ len_arg);
+ else
+ call = Runtime::make_call(Runtime::MAKESLICE2, loc, 3, type_arg,
+ len_arg, cap_arg);
+ }
+ else if (is_map)
+ call = Runtime::make_call(Runtime::MAKEMAP, loc, 2, type_arg, len_arg);
+ else if (is_chan)
+ call = Runtime::make_call(Runtime::MAKECHAN, loc, 2, type_arg, len_arg);
+ else
+ go_unreachable();
+
+ return Expression::make_unsafe_cast(type, call, loc);
+}
+
+// Return whether an expression has an integer value. Report an error
+// if not. This is used when handling calls to the predeclared make
+// function.
+
+bool
+Builtin_call_expression::check_int_value(Expression* e)
+{
+ if (e->type()->integer_type() != NULL)
+ return true;
+
+ // Check for a floating point constant with integer value.
+ mpfr_t fval;
+ mpfr_init(fval);
+
+ Type* dummy;
+ if (e->float_constant_value(fval, &dummy) && mpfr_integer_p(fval))
+ {
+ mpz_t ival;
+ mpz_init(ival);
+
+ bool ok = false;
+
+ mpfr_clear_overflow();
+ mpfr_clear_erangeflag();
+ mpfr_get_z(ival, fval, GMP_RNDN);
+ if (!mpfr_overflow_p()
+ && !mpfr_erangeflag_p()
+ && mpz_sgn(ival) >= 0)
+ {
+ Named_type* ntype = Type::lookup_integer_type("int");
+ Integer_type* inttype = ntype->integer_type();
+ mpz_t max;
+ mpz_init_set_ui(max, 1);
+ mpz_mul_2exp(max, max, inttype->bits() - 1);
+ ok = mpz_cmp(ival, max) < 0;
+ mpz_clear(max);
+ }
+ mpz_clear(ival);
+
+ if (ok)
+ {
+ mpfr_clear(fval);
+ return true;
+ }
+ }
+
+ mpfr_clear(fval);
+
+ return false;
+}
+
+// Return the type of the real or imag functions, given the type of
+// the argument. We need to map complex to float, complex64 to
+// float32, and complex128 to float64, so it has to be done by name.
+// This returns NULL if it can't figure out the type.
+
+Type*
+Builtin_call_expression::real_imag_type(Type* arg_type)
+{
+ if (arg_type == NULL || arg_type->is_abstract())
+ return NULL;
+ Named_type* nt = arg_type->named_type();
+ if (nt == NULL)
+ return NULL;
+ while (nt->real_type()->named_type() != NULL)
+ nt = nt->real_type()->named_type();
+ if (nt->name() == "complex64")
+ return Type::lookup_float_type("float32");
+ else if (nt->name() == "complex128")
+ return Type::lookup_float_type("float64");
+ else
+ return NULL;
+}
+
+// Return the type of the complex function, given the type of one of the
+// argments. Like real_imag_type, we have to map by name.
+
+Type*
+Builtin_call_expression::complex_type(Type* arg_type)
+{
+ if (arg_type == NULL || arg_type->is_abstract())
+ return NULL;
+ Named_type* nt = arg_type->named_type();
+ if (nt == NULL)
+ return NULL;
+ while (nt->real_type()->named_type() != NULL)
+ nt = nt->real_type()->named_type();
+ if (nt->name() == "float32")
+ return Type::lookup_complex_type("complex64");
+ else if (nt->name() == "float64")
+ return Type::lookup_complex_type("complex128");
+ else
+ return NULL;
+}
+
+// Return a single argument, or NULL if there isn't one.
+
+Expression*
+Builtin_call_expression::one_arg() const
{
const Expression_list* args = this->args();
if (args->size() != 1)
if (arg_type->points_to() != NULL
&& arg_type->points_to()->array_type() != NULL
- && !arg_type->points_to()->is_open_array_type())
+ && !arg_type->points_to()->is_slice_type())
arg_type = arg_type->points_to();
if (arg_type->array_type() != NULL
if (arg_type->points_to() != NULL
&& arg_type->points_to()->array_type() != NULL
- && !arg_type->points_to()->is_open_array_type())
+ && !arg_type->points_to()->is_slice_type())
arg_type = arg_type->points_to();
if (arg_type->array_type() != NULL
return false;
}
+// Give an error if we are discarding the value of an expression which
+// should not normally be discarded. We don't give an error for
+// discarding the value of an ordinary function call, but we do for
+// builtin functions, purely for consistency with the gc compiler.
+
+void
+Builtin_call_expression::do_discarding_value()
+{
+ switch (this->code_)
+ {
+ case BUILTIN_INVALID:
+ default:
+ go_unreachable();
+
+ case BUILTIN_APPEND:
+ case BUILTIN_CAP:
+ case BUILTIN_COMPLEX:
+ case BUILTIN_IMAG:
+ case BUILTIN_LEN:
+ case BUILTIN_MAKE:
+ case BUILTIN_NEW:
+ case BUILTIN_REAL:
+ case BUILTIN_ALIGNOF:
+ case BUILTIN_OFFSETOF:
+ case BUILTIN_SIZEOF:
+ this->unused_value_error();
+ break;
+
+ case BUILTIN_CLOSE:
+ case BUILTIN_COPY:
+ case BUILTIN_PANIC:
+ case BUILTIN_PRINT:
+ case BUILTIN_PRINTLN:
+ case BUILTIN_RECOVER:
+ break;
+ }
+}
+
// Return the type.
Type*
Type* arg_type = this->one_arg()->type();
if (arg_type->points_to() != NULL
&& arg_type->points_to()->array_type() != NULL
- && !arg_type->points_to()->is_open_array_type())
+ && !arg_type->points_to()->is_slice_type())
arg_type = arg_type->points_to();
if (this->code_ == BUILTIN_CAP)
{
|| type->channel_type() != NULL
|| type->map_type() != NULL
|| type->function_type() != NULL
- || type->is_open_array_type())
+ || type->is_slice_type())
;
else
this->report_error(_("unsupported argument type to "
break;
Type* e1;
- if (arg1_type->is_open_array_type())
+ if (arg1_type->is_slice_type())
e1 = arg1_type->array_type()->element_type();
else
{
}
Type* e2;
- if (arg2_type->is_open_array_type())
+ if (arg2_type->is_slice_type())
e2 = arg2_type->array_type()->element_type();
else if (arg2_type->is_string_type())
e2 = Type::lookup_integer_type("uint8");
this->report_error(_("too many arguments"));
break;
}
+
+ // The language permits appending a string to a []byte, as a
+ // special case.
+ if (args->back()->type()->is_string_type())
+ {
+ const Array_type* at = args->front()->type()->array_type();
+ const Type* e = at->element_type()->forwarded();
+ if (e == Type::lookup_integer_type("uint8"))
+ break;
+ }
+
std::string reason;
if (!Type::are_assignable(args->front()->type(), args->back()->type(),
&reason))
{
arg_type = arg_type->points_to();
go_assert(arg_type->array_type() != NULL
- && !arg_type->is_open_array_type());
+ && !arg_type->is_slice_type());
go_assert(POINTER_TYPE_P(TREE_TYPE(arg_tree)));
arg_tree = build_fold_indirect_ref(arg_tree);
}
fnname = "__go_print_interface";
}
}
- else if (type->is_open_array_type())
+ else if (type->is_slice_type())
{
static tree print_slice_fndecl;
pfndecl = &print_slice_fndecl;
Type* arg2_type = arg2->type();
tree arg2_val;
tree arg2_len;
- if (arg2_type->is_open_array_type())
+ if (arg2_type->is_slice_type())
{
at = arg2_type->array_type();
arg2_tree = save_expr(arg2_tree);
return error_mark_node;
Array_type* at = arg1->type()->array_type();
- Type* element_type = at->element_type();
+ Type* element_type = at->element_type()->forwarded();
- arg2_tree = Expression::convert_for_assignment(context, at,
- arg2->type(),
- arg2_tree,
- location);
- if (arg2_tree == error_mark_node)
- return error_mark_node;
+ tree arg2_val;
+ tree arg2_len;
+ tree element_size;
+ if (arg2->type()->is_string_type()
+ && element_type == Type::lookup_integer_type("uint8"))
+ {
+ arg2_tree = save_expr(arg2_tree);
+ arg2_val = String_type::bytes_tree(gogo, arg2_tree);
+ arg2_len = String_type::length_tree(gogo, arg2_tree);
+ element_size = size_int(1);
+ }
+ else
+ {
+ arg2_tree = Expression::convert_for_assignment(context, at,
+ arg2->type(),
+ arg2_tree,
+ location);
+ if (arg2_tree == error_mark_node)
+ return error_mark_node;
+
+ arg2_tree = save_expr(arg2_tree);
+
+ arg2_val = at->value_pointer_tree(gogo, arg2_tree);
+ arg2_len = at->length_tree(gogo, arg2_tree);
+
+ Btype* element_btype = element_type->get_backend(gogo);
+ tree element_type_tree = type_to_tree(element_btype);
+ if (element_type_tree == error_mark_node)
+ return error_mark_node;
+ element_size = TYPE_SIZE_UNIT(element_type_tree);
+ }
- arg2_tree = save_expr(arg2_tree);
- tree arg2_val = at->value_pointer_tree(gogo, arg2_tree);
- tree arg2_len = at->length_tree(gogo, arg2_tree);
- if (arg2_val == error_mark_node || arg2_len == error_mark_node)
- return error_mark_node;
arg2_val = fold_convert_loc(location, ptr_type_node, arg2_val);
arg2_len = fold_convert_loc(location, size_type_node, arg2_len);
-
- tree element_type_tree = type_to_tree(element_type->get_backend(gogo));
- if (element_type_tree == error_mark_node)
- return error_mark_node;
- tree element_size = TYPE_SIZE_UNIT(element_type_tree);
element_size = fold_convert_loc(location, size_type_node,
element_size);
+ if (arg2_val == error_mark_node
+ || arg2_len == error_mark_node
+ || element_size == error_mark_node)
+ return error_mark_node;
+
// We rebuild the decl each time since the slice types may
// change.
tree append_fndecl = NULL_TREE;
// Lower a call statement.
Expression*
-Call_expression::do_lower(Gogo* gogo, Named_object* function, int)
+Call_expression::do_lower(Gogo* gogo, Named_object* function,
+ Statement_inserter* inserter, int)
{
- // A type case can look like a function call.
+ source_location loc = this->location();
+
+ // A type cast can look like a function call.
if (this->fn_->is_type_expression()
&& this->args_ != NULL
&& this->args_->size() == 1)
return Expression::make_cast(this->fn_->type(), this->args_->front(),
- this->location());
+ loc);
// Recognize a call to a builtin function.
Func_expression* fne = this->fn_->func_expression();
&& fne->named_object()->is_function_declaration()
&& fne->named_object()->func_declaration_value()->type()->is_builtin())
return new Builtin_call_expression(gogo, this->fn_, this->args_,
- this->is_varargs_, this->location());
+ this->is_varargs_, loc);
// Handle an argument which is a call to a function which returns
// multiple results.
}
}
+ // If this call returns multiple results, create a temporary
+ // variable for each result.
+ size_t rc = this->result_count();
+ if (rc > 1 && this->results_ == NULL)
+ {
+ std::vector<Temporary_statement*>* temps =
+ new std::vector<Temporary_statement*>;
+ temps->reserve(rc);
+ const Typed_identifier_list* results =
+ this->fn_->type()->function_type()->results();
+ for (Typed_identifier_list::const_iterator p = results->begin();
+ p != results->end();
+ ++p)
+ {
+ Temporary_statement* temp = Statement::make_temporary(p->type(),
+ NULL, loc);
+ inserter->insert(temp);
+ temps->push_back(temp);
+ }
+ this->results_ = temps;
+ }
+
// Handle a call to a varargs function by packaging up the extra
// parameters.
if (this->fn_->type()->function_type() != NULL
const Typed_identifier_list* parameters = fntype->parameters();
go_assert(parameters != NULL && !parameters->empty());
Type* varargs_type = parameters->back().type();
- return this->lower_varargs(gogo, function, varargs_type,
- parameters->size());
+ this->lower_varargs(gogo, function, inserter, varargs_type,
+ parameters->size());
+ }
+
+ // If this is call to a method, call the method directly passing the
+ // object as the first parameter.
+ Bound_method_expression* bme = this->fn_->bound_method_expression();
+ if (bme != NULL)
+ {
+ Named_object* method = bme->method();
+ Expression* first_arg = bme->first_argument();
+
+ // We always pass a pointer when calling a method.
+ if (first_arg->type()->points_to() == NULL
+ && !first_arg->type()->is_error())
+ {
+ first_arg = Expression::make_unary(OPERATOR_AND, first_arg, loc);
+ // We may need to create a temporary variable so that we can
+ // take the address. We can't do that here because it will
+ // mess up the order of evaluation.
+ Unary_expression* ue = static_cast<Unary_expression*>(first_arg);
+ ue->set_create_temp();
+ }
+
+ // If we are calling a method which was inherited from an
+ // embedded struct, and the method did not get a stub, then the
+ // first type may be wrong.
+ Type* fatype = bme->first_argument_type();
+ if (fatype != NULL)
+ {
+ if (fatype->points_to() == NULL)
+ fatype = Type::make_pointer_type(fatype);
+ first_arg = Expression::make_unsafe_cast(fatype, first_arg, loc);
+ }
+
+ Expression_list* new_args = new Expression_list();
+ new_args->push_back(first_arg);
+ if (this->args_ != NULL)
+ {
+ for (Expression_list::const_iterator p = this->args_->begin();
+ p != this->args_->end();
+ ++p)
+ new_args->push_back(*p);
+ }
+
+ // We have to change in place because this structure may be
+ // referenced by Call_result_expressions. We can't delete the
+ // old arguments, because we may be traversing them up in some
+ // caller. FIXME.
+ this->args_ = new_args;
+ this->fn_ = Expression::make_func_reference(method, NULL,
+ bme->location());
}
return this;
// calling; the last of these parameters will be the varargs
// parameter.
-Expression*
+void
Call_expression::lower_varargs(Gogo* gogo, Named_object* function,
+ Statement_inserter* inserter,
Type* varargs_type, size_t param_count)
{
if (this->varargs_are_lowered_)
- return this;
+ return;
source_location loc = this->location();
go_assert(param_count > 0);
- go_assert(varargs_type->is_open_array_type());
+ go_assert(varargs_type->is_slice_type());
size_t arg_count = this->args_ == NULL ? 0 : this->args_->size();
if (arg_count < param_count - 1)
{
// Not enough arguments; will be caught in check_types.
- return this;
+ return;
}
Expression_list* old_args = this->args_;
else if (this->is_varargs_)
{
this->report_error(_("too many arguments"));
- return this;
+ return;
}
else
{
}
Expression* val =
Expression::make_slice_composite_literal(varargs_type, vals, loc);
+ gogo->lower_expression(function, inserter, &val);
new_args->push_back(val);
}
}
// Builtin_call_expression which refer to them. FIXME.
this->args_ = new_args;
this->varargs_are_lowered_ = true;
-
- // Lower all the new subexpressions.
- Expression* ret = this;
- gogo->lower_expression(function, &ret);
- go_assert(ret == this);
- return ret;
}
-// Get the function type. Returns NULL if we don't know the type. If
-// this returns NULL, and if_ERROR is true, issues an error.
+// Get the function type. This can return NULL in error cases.
Function_type*
Call_expression::get_function_type() const
return fntype->results()->size();
}
+// Return the temporary which holds a result.
+
+Temporary_statement*
+Call_expression::result(size_t i) const
+{
+ go_assert(this->results_ != NULL
+ && this->results_->size() > i);
+ return (*this->results_)[i];
+}
+
// Return whether this is a call to the predeclared function recover.
bool
go_unreachable();
}
+// We have found an error with this call expression; return true if
+// we should report it.
+
+bool
+Call_expression::issue_error()
+{
+ if (this->issued_error_)
+ return false;
+ else
+ {
+ this->issued_error_ = true;
+ return true;
+ }
+}
+
// Get the type.
Type*
Typed_identifier_list::const_iterator pt;
if (parameters != NULL)
pt = parameters->begin();
+ bool first = true;
for (Expression_list::const_iterator pa = this->args_->begin();
pa != this->args_->end();
++pa)
{
+ if (first)
+ {
+ first = false;
+ // If this is a method, the first argument is the
+ // receiver.
+ if (fntype != NULL && fntype->is_method())
+ {
+ Type* rtype = fntype->receiver()->type();
+ // The receiver is always passed as a pointer.
+ if (rtype->points_to() == NULL)
+ rtype = Type::make_pointer_type(rtype);
+ Type_context subcontext(rtype, false);
+ (*pa)->determine_type(&subcontext);
+ continue;
+ }
+ }
+
if (parameters != NULL && pt != parameters->end())
{
Type_context subcontext(pt->type(), false);
bool issued_error)
{
std::string reason;
- if (!Type::are_assignable(parameter_type, argument_type, &reason))
+ bool ok;
+ if (this->are_hidden_fields_ok_)
+ ok = Type::are_assignable_hidden_ok(parameter_type, argument_type,
+ &reason);
+ else
+ ok = Type::are_assignable(parameter_type, argument_type, &reason);
+ if (!ok)
{
if (!issued_error)
{
return;
}
- if (fntype->is_method())
+ bool is_method = fntype->is_method();
+ if (is_method)
{
- // We don't support pointers to methods, so the function has to
- // be a bound method expression.
- Bound_method_expression* bme = this->fn_->bound_method_expression();
- if (bme == NULL)
- {
- this->report_error(_("method call without object"));
- return;
- }
- Type* first_arg_type = bme->first_argument()->type();
- if (first_arg_type->points_to() == NULL)
+ go_assert(this->args_ != NULL && !this->args_->empty());
+ Type* rtype = fntype->receiver()->type();
+ Expression* first_arg = this->args_->front();
+ // The language permits copying hidden fields for a method
+ // receiver. We dereference the values since receivers are
+ // always passed as pointers.
+ std::string reason;
+ if (!Type::are_assignable_hidden_ok(rtype->deref(),
+ first_arg->type()->deref(),
+ &reason))
{
- // When passing a value, we need to check that we are
- // permitted to copy it. The language permits copying
- // hidden fields for a method receiver.
- std::string reason;
- if (!Type::are_assignable_hidden_ok(fntype->receiver()->type(),
- first_arg_type, &reason))
+ if (reason.empty())
+ this->report_error(_("incompatible type for receiver"));
+ else
{
- if (reason.empty())
- this->report_error(_("incompatible type for receiver"));
- else
- {
- error_at(this->location(),
- "incompatible type for receiver (%s)",
- reason.c_str());
- this->set_is_error();
- }
+ error_at(this->location(),
+ "incompatible type for receiver (%s)",
+ reason.c_str());
+ this->set_is_error();
}
}
}
this->report_error(_("not enough arguments"));
}
else if (parameters == NULL)
- this->report_error(_("too many arguments"));
+ {
+ if (!is_method || this->args_->size() > 1)
+ this->report_error(_("too many arguments"));
+ }
else
{
int i = 0;
- Typed_identifier_list::const_iterator pt = parameters->begin();
- for (Expression_list::const_iterator pa = this->args_->begin();
- pa != this->args_->end();
- ++pa, ++pt, ++i)
- {
- if (pt == parameters->end())
+ Expression_list::const_iterator pa = this->args_->begin();
+ if (is_method)
+ ++pa;
+ for (Typed_identifier_list::const_iterator pt = parameters->begin();
+ pt != parameters->end();
+ ++pt, ++pa, ++i)
+ {
+ if (pa == this->args_->end())
{
- this->report_error(_("too many arguments"));
+ this->report_error(_("not enough arguments"));
return;
}
this->check_argument_type(i + 1, pt->type(), (*pa)->type(),
(*pa)->location(), false);
}
- if (pt != parameters->end())
- this->report_error(_("not enough arguments"));
+ if (pa != this->args_->end())
+ this->report_error(_("too many arguments"));
}
}
// Return whether we have to use a temporary variable to ensure that
// we evaluate this call expression in order. If the call returns no
-// results then it will inevitably be executed last. If the call
-// returns more than one result then it will be used with Call_result
-// expressions. So we only have to use a temporary variable if the
-// call returns exactly one result.
+// results then it will inevitably be executed last.
bool
Call_expression::do_must_eval_in_order() const
{
- return this->result_count() == 1;
-}
-
-// Get the function and the first argument to use when calling a bound
-// method.
-
-tree
-Call_expression::bound_method_function(Translate_context* context,
- Bound_method_expression* bound_method,
- tree* first_arg_ptr)
-{
- Expression* first_argument = bound_method->first_argument();
- tree first_arg = first_argument->get_tree(context);
- if (first_arg == error_mark_node)
- return error_mark_node;
-
- // We always pass a pointer to the first argument when calling a
- // method.
- if (first_argument->type()->points_to() == NULL)
- {
- tree pointer_to_arg_type = build_pointer_type(TREE_TYPE(first_arg));
- if (TREE_ADDRESSABLE(TREE_TYPE(first_arg))
- || DECL_P(first_arg)
- || TREE_CODE(first_arg) == INDIRECT_REF
- || TREE_CODE(first_arg) == COMPONENT_REF)
- {
- first_arg = build_fold_addr_expr(first_arg);
- if (DECL_P(first_arg))
- TREE_ADDRESSABLE(first_arg) = 1;
- }
- else
- {
- tree tmp = create_tmp_var(TREE_TYPE(first_arg),
- get_name(first_arg));
- DECL_IGNORED_P(tmp) = 0;
- DECL_INITIAL(tmp) = first_arg;
- first_arg = build2(COMPOUND_EXPR, pointer_to_arg_type,
- build1(DECL_EXPR, void_type_node, tmp),
- build_fold_addr_expr(tmp));
- TREE_ADDRESSABLE(tmp) = 1;
- }
- if (first_arg == error_mark_node)
- return error_mark_node;
- }
-
- Type* fatype = bound_method->first_argument_type();
- if (fatype != NULL)
- {
- if (fatype->points_to() == NULL)
- fatype = Type::make_pointer_type(fatype);
- Btype* bfatype = fatype->get_backend(context->gogo());
- first_arg = fold_convert(type_to_tree(bfatype), first_arg);
- if (first_arg == error_mark_node
- || TREE_TYPE(first_arg) == error_mark_node)
- return error_mark_node;
- }
-
- *first_arg_ptr = first_arg;
-
- return bound_method->method()->get_tree(context);
+ return this->result_count() > 0;
}
// Get the function and the first argument to use when calling an
source_location location = this->location();
Func_expression* func = this->fn_->func_expression();
- Bound_method_expression* bound_method = this->fn_->bound_method_expression();
Interface_field_reference_expression* interface_method =
this->fn_->interface_field_reference_expression();
const bool has_closure = func != NULL && func->closure() != NULL;
- const bool is_method = bound_method != NULL || interface_method != NULL;
- go_assert(!fntype->is_method() || is_method);
+ const bool is_interface_method = interface_method != NULL;
int nargs;
tree* args;
if (this->args_ == NULL || this->args_->empty())
{
- nargs = is_method ? 1 : 0;
+ nargs = is_interface_method ? 1 : 0;
args = nargs == 0 ? NULL : new tree[nargs];
}
+ else if (fntype->parameters() == NULL || fntype->parameters()->empty())
+ {
+ // Passing a receiver parameter.
+ go_assert(!is_interface_method
+ && fntype->is_method()
+ && this->args_->size() == 1);
+ nargs = 1;
+ args = new tree[nargs];
+ args[0] = this->args_->front()->get_tree(context);
+ }
else
{
const Typed_identifier_list* params = fntype->parameters();
- go_assert(params != NULL);
nargs = this->args_->size();
- int i = is_method ? 1 : 0;
+ int i = is_interface_method ? 1 : 0;
nargs += i;
args = new tree[nargs];
Typed_identifier_list::const_iterator pp = params->begin();
- Expression_list::const_iterator pe;
- for (pe = this->args_->begin();
- pe != this->args_->end();
- ++pe, ++pp, ++i)
+ Expression_list::const_iterator pe = this->args_->begin();
+ if (!is_interface_method && fntype->is_method())
+ {
+ args[i] = (*pe)->get_tree(context);
+ ++pe;
+ ++i;
+ }
+ for (; pe != this->args_->end(); ++pe, ++pp, ++i)
{
go_assert(pp != params->end());
tree arg_val = (*pe)->get_tree(context);
tree fn;
if (has_closure)
fn = func->get_tree_without_closure(gogo);
- else if (!is_method)
+ else if (!is_interface_method)
fn = this->fn_->get_tree(context);
- else if (bound_method != NULL)
- fn = this->bound_method_function(context, bound_method, &args[0]);
- else if (interface_method != NULL)
- fn = this->interface_method_function(context, interface_method, &args[0]);
else
- go_unreachable();
+ fn = this->interface_method_function(context, interface_method, &args[0]);
if (fn == error_mark_node || TREE_TYPE(fn) == error_mark_node)
{
ret = build1(NOP_EXPR, rettype, ret);
}
- // If there is more than one result, we will refer to the call
- // multiple times.
- if (fntype->results() != NULL && fntype->results()->size() > 1)
- ret = save_expr(ret);
+ if (this->results_ != NULL)
+ ret = this->set_results(context, ret);
this->tree_ = ret;
return ret;
}
+// Set the result variables if this call returns multiple results.
+
+tree
+Call_expression::set_results(Translate_context* context, tree call_tree)
+{
+ tree stmt_list = NULL_TREE;
+
+ call_tree = save_expr(call_tree);
+
+ if (TREE_CODE(TREE_TYPE(call_tree)) != RECORD_TYPE)
+ {
+ go_assert(saw_errors());
+ return call_tree;
+ }
+
+ source_location loc = this->location();
+ tree field = TYPE_FIELDS(TREE_TYPE(call_tree));
+ size_t rc = this->result_count();
+ for (size_t i = 0; i < rc; ++i, field = DECL_CHAIN(field))
+ {
+ go_assert(field != NULL_TREE);
+
+ Temporary_statement* temp = this->result(i);
+ Temporary_reference_expression* ref =
+ Expression::make_temporary_reference(temp, loc);
+ ref->set_is_lvalue();
+ tree temp_tree = ref->get_tree(context);
+ if (temp_tree == error_mark_node)
+ continue;
+
+ tree val_tree = build3_loc(loc, COMPONENT_REF, TREE_TYPE(field),
+ call_tree, field, NULL_TREE);
+ tree set_tree = build2_loc(loc, MODIFY_EXPR, void_type_node, temp_tree,
+ val_tree);
+
+ append_to_statement_list(set_tree, &stmt_list);
+ }
+ go_assert(field == NULL_TREE);
+
+ return save_expr(stmt_list);
+}
+
+// Dump ast representation for a call expressin.
+
+void
+Call_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
+{
+ this->fn_->dump_expression(ast_dump_context);
+ ast_dump_context->ostream() << "(";
+ if (args_ != NULL)
+ ast_dump_context->dump_expression_list(this->args_);
+
+ ast_dump_context->ostream() << ") ";
+}
+
// Make a call expression.
Call_expression*
tree
do_get_tree(Translate_context*);
+ void
+ do_dump_expression(Ast_dump_context*) const;
+
private:
// The underlying call expression.
Expression* call_;
Function_type* fntype = ce->get_function_type();
if (fntype == NULL)
{
+ if (ce->issue_error())
+ {
+ if (!ce->fn()->type()->is_error())
+ this->report_error(_("expected function"));
+ }
this->set_is_error();
return Type::make_error_type();
}
const Typed_identifier_list* results = fntype->results();
- if (results == NULL)
+ if (results == NULL || results->size() < 2)
{
- this->report_error(_("number of results does not match "
- "number of values"));
+ if (ce->issue_error())
+ this->report_error(_("number of results does not match "
+ "number of values"));
return Type::make_error_type();
}
Typed_identifier_list::const_iterator pr = results->begin();
}
if (pr == results->end())
{
- this->report_error(_("number of results does not match "
- "number of values"));
+ if (ce->issue_error())
+ this->report_error(_("number of results does not match "
+ "number of values"));
return Type::make_error_type();
}
return pr->type();
this->call_->determine_type_no_context();
}
-// Return the tree.
+// Return the tree. We just refer to the temporary set by the call
+// expression. We don't do this at lowering time because it makes it
+// hard to evaluate the call at the right time.
tree
Call_result_expression::do_get_tree(Translate_context* context)
{
- tree call_tree = this->call_->get_tree(context);
- if (call_tree == error_mark_node)
- return error_mark_node;
- if (TREE_CODE(TREE_TYPE(call_tree)) != RECORD_TYPE)
- {
- go_assert(saw_errors());
- return error_mark_node;
- }
- tree field = TYPE_FIELDS(TREE_TYPE(call_tree));
- for (unsigned int i = 0; i < this->index_; ++i)
- {
- go_assert(field != NULL_TREE);
- field = DECL_CHAIN(field);
- }
- go_assert(field != NULL_TREE);
- return build3(COMPONENT_REF, TREE_TYPE(field), call_tree, field, NULL_TREE);
+ Call_expression* ce = this->call_->call_expression();
+ go_assert(ce != NULL);
+ Temporary_statement* ts = ce->result(this->index_);
+ Expression* ref = Expression::make_temporary_reference(ts, this->location());
+ return ref->get_tree(context);
+}
+
+// Dump ast representation for a call result expression.
+
+void
+Call_result_expression::do_dump_expression(Ast_dump_context* ast_dump_context)
+ const
+{
+ // FIXME: Wouldn't it be better if the call is assigned to a temporary
+ // (struct) and the fields are referenced instead.
+ ast_dump_context->ostream() << this->index_ << "@(";
+ ast_dump_context->dump_expression(this->call_);
+ ast_dump_context->ostream() << ")";
}
// Make a reference to a single result of a call which returns
// expression into an array index, a string index, or a map index.
Expression*
-Index_expression::do_lower(Gogo*, Named_object*, int)
+Index_expression::do_lower(Gogo*, Named_object*, Statement_inserter*, int)
{
source_location location = this->location();
Expression* left = this->left_;
return Expression::make_array_index(left, start, end, location);
else if (type->points_to() != NULL
&& type->points_to()->array_type() != NULL
- && !type->points_to()->is_open_array_type())
+ && !type->points_to()->is_slice_type())
{
Expression* deref = Expression::make_unary(OPERATOR_MULT, left,
location);
}
}
+// Write an indexed expression (expr[expr:expr] or expr[expr]) to a
+// dump context
+
+void
+Index_expression::dump_index_expression(Ast_dump_context* ast_dump_context,
+ const Expression* expr,
+ const Expression* start,
+ const Expression* end)
+{
+ expr->dump_expression(ast_dump_context);
+ ast_dump_context->ostream() << "[";
+ start->dump_expression(ast_dump_context);
+ if (end != NULL)
+ {
+ ast_dump_context->ostream() << ":";
+ end->dump_expression(ast_dump_context);
+ }
+ ast_dump_context->ostream() << "]";
+}
+
+// Dump ast representation for an index expression.
+
+void
+Index_expression::do_dump_expression(Ast_dump_context* ast_dump_context)
+ const
+{
+ Index_expression::dump_index_expression(ast_dump_context, this->left_,
+ this->start_, this->end_);
+}
+
// Make an index expression.
Expression*
tree
do_get_tree(Translate_context*);
+ void
+ do_dump_expression(Ast_dump_context*) const;
+
private:
// The array we are getting a value from.
Expression* array_;
this->type_ = Type::make_error_type();
else if (this->end_ == NULL)
this->type_ = type->element_type();
- else if (type->is_open_array_type())
+ else if (type->is_slice_type())
{
// A slice of a slice has the same type as the original
// slice.
this->report_error(_("index must be integer"));
if (this->end_ != NULL
&& this->end_->type()->integer_type() == NULL
- && !this->end_->is_nil_expression())
+ && !this->end_->type()->is_error()
+ && !this->end_->is_nil_expression()
+ && !this->end_->is_error_expression())
this->report_error(_("slice end must be integer"));
Array_type* array_type = this->array_->type()->array_type();
// A slice of an array requires an addressable array. A slice of a
// slice is always possible.
- if (this->end_ != NULL && !array_type->is_open_array_type())
+ if (this->end_ != NULL && !array_type->is_slice_type())
{
if (!this->array_->is_addressable())
this->report_error(_("array is not addressable"));
return false;
// An index into a slice is addressable.
- if (this->array_->type()->is_open_array_type())
+ if (this->array_->type()->is_slice_type())
return true;
// An index into an array is addressable if the array is
constructor);
}
+// Dump ast representation for an array index expression.
+
+void
+Array_index_expression::do_dump_expression(Ast_dump_context* ast_dump_context)
+ const
+{
+ Index_expression::dump_index_expression(ast_dump_context, this->array_,
+ this->start_, this->end_);
+}
+
// Make an array index expression. END may be NULL.
Expression*
tree
do_get_tree(Translate_context*);
+ void
+ do_dump_expression(Ast_dump_context*) const;
+
private:
// The string we are getting a value from.
Expression* string_;
}
}
+// Dump ast representation for a string index expression.
+
+void
+String_index_expression::do_dump_expression(Ast_dump_context* ast_dump_context)
+ const
+{
+ Index_expression::dump_index_expression(ast_dump_context, this->string_,
+ this->start_, this->end_);
+}
+
// Make a string index expression. END may be NULL.
Expression*
return ret;
}
+// Dump ast representation for a map index expression
+
+void
+Map_index_expression::do_dump_expression(Ast_dump_context* ast_dump_context)
+ const
+{
+ Index_expression::dump_index_expression(ast_dump_context,
+ this->map_, this->index_, NULL);
+}
+
// Make a map index expression.
Map_index_expression*
NULL_TREE);
}
+// Dump ast representation for a field reference expression.
+
+void
+Field_reference_expression::do_dump_expression(
+ Ast_dump_context* ast_dump_context) const
+{
+ this->expr_->dump_expression(ast_dump_context);
+ ast_dump_context->ostream() << "." << this->field_index_;
+}
+
// Make a reference to a qualified identifier in an expression.
Field_reference_expression*
go_unreachable();
}
+// Dump ast representation for an interface field reference.
+
+void
+Interface_field_reference_expression::do_dump_expression(
+ Ast_dump_context* ast_dump_context) const
+{
+ this->expr_->dump_expression(ast_dump_context);
+ ast_dump_context->ostream() << "." << this->name_;
+}
+
// Make a reference to a field in an interface.
Expression*
{ return Expression::traverse(&this->left_, traverse); }
Expression*
- do_lower(Gogo*, Named_object*, int);
+ do_lower(Gogo*, Named_object*, Statement_inserter*, int);
Expression*
do_copy()
this->location());
}
+ void
+ do_dump_expression(Ast_dump_context* ast_dump_context) const;
+
private:
Expression*
lower_method_expression(Gogo*);
// hand side.
Expression*
-Selector_expression::do_lower(Gogo* gogo, Named_object*, int)
+Selector_expression::do_lower(Gogo* gogo, Named_object*, Statement_inserter*,
+ int)
{
Expression* left = this->left_;
if (left->is_type_expression())
}
}
+ gogo->start_block(location);
+
Call_expression* call = Expression::make_call(bm, args,
method_type->is_varargs(),
location);
size_t count = call->result_count();
Statement* s;
if (count == 0)
- s = Statement::make_statement(call);
+ s = Statement::make_statement(call, true);
else
{
Expression_list* retvals = new Expression_list();
}
gogo->add_statement(s);
+ Block* b = gogo->finish_block(location);
+
+ gogo->add_block(b, location);
+
+ // Lower the call in case there are multiple results.
+ gogo->lower_block(no, b);
+
gogo->finish_function(location);
return Expression::make_func_reference(no, NULL, location);
}
+// Dump the ast for a selector expression.
+
+void
+Selector_expression::do_dump_expression(Ast_dump_context* ast_dump_context)
+ const
+{
+ ast_dump_context->dump_expression(this->left_);
+ ast_dump_context->ostream() << ".";
+ ast_dump_context->ostream() << this->name_;
+}
+
// Make a selector expression.
Expression*
tree
do_get_tree(Translate_context*);
+ void
+ do_dump_expression(Ast_dump_context*) const;
+
private:
// The type we are allocating.
Type* type_;
return fold_convert(build_pointer_type(type_tree), space);
}
-// Make an allocation expression.
-
-Expression*
-Expression::make_allocation(Type* type, source_location location)
-{
- return new Allocation_expression(type, location);
-}
-
-// Implement the builtin function make.
-
-class Make_expression : public Expression
-{
- public:
- Make_expression(Type* type, Expression_list* args, source_location location)
- : Expression(EXPRESSION_MAKE, location),
- type_(type), args_(args)
- { }
-
- protected:
- int
- do_traverse(Traverse* traverse);
-
- Type*
- do_type()
- { return this->type_; }
-
- void
- do_determine_type(const Type_context*);
-
- void
- do_check_types(Gogo*);
-
- Expression*
- do_copy()
- {
- return new Make_expression(this->type_, this->args_->copy(),
- this->location());
- }
-
- tree
- do_get_tree(Translate_context*);
-
- private:
- // The type we are making.
- Type* type_;
- // The arguments to pass to the make routine.
- Expression_list* args_;
-};
-
-// Traversal.
-
-int
-Make_expression::do_traverse(Traverse* traverse)
-{
- if (this->args_ != NULL
- && this->args_->traverse(traverse) == TRAVERSE_EXIT)
- return TRAVERSE_EXIT;
- if (Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
- return TRAVERSE_EXIT;
- return TRAVERSE_CONTINUE;
-}
-
-// Set types of arguments.
-
-void
-Make_expression::do_determine_type(const Type_context*)
-{
- if (this->args_ != NULL)
- {
- Type_context context(Type::lookup_integer_type("int"), false);
- for (Expression_list::const_iterator pe = this->args_->begin();
- pe != this->args_->end();
- ++pe)
- (*pe)->determine_type(&context);
- }
-}
-
-// Check types for a make expression.
+// Dump ast representation for an allocation expression.
void
-Make_expression::do_check_types(Gogo*)
-{
- if (this->type_->channel_type() == NULL
- && this->type_->map_type() == NULL
- && (this->type_->array_type() == NULL
- || this->type_->array_type()->length() != NULL))
- this->report_error(_("invalid type for make function"));
- else if (!this->type_->check_make_expression(this->args_, this->location()))
- this->set_is_error();
-}
-
-// Return a tree for a make expression.
-
-tree
-Make_expression::do_get_tree(Translate_context* context)
+Allocation_expression::do_dump_expression(Ast_dump_context* ast_dump_context)
+ const
{
- return this->type_->make_expression_tree(context, this->args_,
- this->location());
+ ast_dump_context->ostream() << "new(";
+ ast_dump_context->dump_type(this->type_);
+ ast_dump_context->ostream() << ")";
}
-// Make a make expression.
+// Make an allocation expression.
Expression*
-Expression::make_make(Type* type, Expression_list* args,
- source_location location)
+Expression::make_allocation(Type* type, source_location location)
{
- return new Make_expression(type, args, location);
+ return new Allocation_expression(type, location);
}
// Construct a struct.
void
do_export(Export*) const;
+ void
+ do_dump_expression(Ast_dump_context*) const;
+
private:
// The type of the struct to construct.
Type* type_;
exp->write_c_string(")");
}
+// Dump ast representation of a struct construction expression.
+
+void
+Struct_construction_expression::do_dump_expression(
+ Ast_dump_context* ast_dump_context) const
+{
+ ast_dump_context->dump_type(this->type_);
+ ast_dump_context->ostream() << "{";
+ ast_dump_context->dump_expression_list(this->vals_);
+ ast_dump_context->ostream() << "}";
+}
+
// Make a struct composite literal. This used by the thunk code.
Expression*
tree
get_constructor_tree(Translate_context* context, tree type_tree);
+ void
+ do_dump_expression(Ast_dump_context*) const;
+
private:
// The type of the array to construct.
Type* type_;
}
Expression* length = at->length();
- if (length != NULL)
+ if (length != NULL && !length->is_error_expression())
{
mpz_t val;
mpz_init(val);
exp->write_c_string(")");
}
+// Dump ast representation of an array construction expressin.
+
+void
+Array_construction_expression::do_dump_expression(
+ Ast_dump_context* ast_dump_context) const
+{
+ Expression* length = this->type_->array_type() != NULL ?
+ this->type_->array_type()->length() : NULL;
+
+ ast_dump_context->ostream() << "[" ;
+ if (length != NULL)
+ {
+ ast_dump_context->dump_expression(length);
+ }
+ ast_dump_context->ostream() << "]" ;
+ ast_dump_context->dump_type(this->type_);
+ ast_dump_context->ostream() << "{" ;
+ ast_dump_context->dump_expression_list(this->vals_);
+ ast_dump_context->ostream() << "}" ;
+
+}
+
// Construct a fixed array.
class Fixed_array_construction_expression :
tree
do_get_tree(Translate_context*);
+
+ void
+ do_dump_expression(Ast_dump_context*);
};
// Return a tree for constructing a fixed array.
return this->get_constructor_tree(context, type_to_tree(btype));
}
+// Dump ast representation of an array construction expressin.
+
+void
+Fixed_array_construction_expression::do_dump_expression(
+ Ast_dump_context* ast_dump_context)
+{
+
+ ast_dump_context->ostream() << "[";
+ ast_dump_context->dump_expression (this->type()->array_type()->length());
+ ast_dump_context->ostream() << "]";
+ ast_dump_context->dump_type(this->type());
+ ast_dump_context->ostream() << "{";
+ ast_dump_context->dump_expression_list(this->vals());
+ ast_dump_context->ostream() << "}";
+
+}
// Construct an open array.
class Open_array_construction_expression : public Array_construction_expression
Expression::make_slice_composite_literal(Type* type, Expression_list* vals,
source_location location)
{
- go_assert(type->is_open_array_type());
+ go_assert(type->is_slice_type());
return new Open_array_construction_expression(type, vals, location);
}
void
do_export(Export*) const;
+ void
+ do_dump_expression(Ast_dump_context*) const;
+
private:
// The type of the map to construct.
Type* type_;
valaddr = build_fold_addr_expr(tmp);
}
- tree descriptor = gogo->map_descriptor(mt);
+ tree descriptor = mt->map_descriptor_pointer(gogo, loc);
tree type_tree = type_to_tree(this->type_->get_backend(gogo));
if (type_tree == error_mark_node)
exp->write_c_string(")");
}
+// Dump ast representation for a map construction expression.
+
+void
+Map_construction_expression::do_dump_expression(
+ Ast_dump_context* ast_dump_context) const
+{
+ ast_dump_context->ostream() << "{" ;
+ ast_dump_context->dump_expression_list(this->vals_, true);
+ ast_dump_context->ostream() << "}";
+}
+
// A general composite literal. This is lowered to a type specific
// version.
do_traverse(Traverse* traverse);
Expression*
- do_lower(Gogo*, Named_object*, int);
+ do_lower(Gogo*, Named_object*, Statement_inserter*, int);
Expression*
do_copy()
this->location());
}
+ void
+ do_dump_expression(Ast_dump_context*) const;
+
private:
Expression*
lower_struct(Gogo*, Type*);
make_array(Type*, Expression_list*);
Expression*
- lower_map(Gogo*, Named_object*, Type*);
+ lower_map(Gogo*, Named_object*, Statement_inserter*, Type*);
// The type of the composite literal.
Type* type_;
// the type.
Expression*
-Composite_literal_expression::do_lower(Gogo* gogo, Named_object* function, int)
+Composite_literal_expression::do_lower(Gogo* gogo, Named_object* function,
+ Statement_inserter* inserter, int)
{
Type* type = this->type_;
else if (type->array_type() != NULL)
return this->lower_array(type);
else if (type->map_type() != NULL)
- return this->lower_map(gogo, function, type);
+ return this->lower_map(gogo, function, inserter, type);
else
{
error_at(this->location(),
{
const Struct_field* sf = st->field(fre->field_index());
name = sf->field_name();
+
+ // See below. FIXME.
+ if (!Gogo::is_hidden_name(name)
+ && name[0] >= 'a'
+ && name[0] <= 'z')
+ {
+ if (gogo->lookup_global(name.c_str()) != NULL)
+ name = gogo->pack_hidden_name(name, false);
+ }
+
char buf[20];
snprintf(buf, sizeof buf, "%u", fre->field_index());
size_t buflen = strlen(buf);
// A predefined name won't be packed. If it starts with a
// lower case letter we need to check for that case, because
- // the field name will be packed.
+ // the field name will be packed. FIXME.
if (!Gogo::is_hidden_name(name)
&& name[0] >= 'a'
&& name[0] <= 'z')
Expression*
Composite_literal_expression::lower_map(Gogo* gogo, Named_object* function,
+ Statement_inserter* inserter,
Type* type)
{
source_location location = this->location();
if ((*p)->unknown_expression() != NULL)
{
(*p)->unknown_expression()->clear_is_composite_literal_key();
- gogo->lower_expression(function, &*p);
+ gogo->lower_expression(function, inserter, &*p);
go_assert((*p)->is_error_expression());
return Expression::make_error(location);
}
return new Map_construction_expression(type, this->vals_, location);
}
+// Dump ast representation for a composite literal expression.
+
+void
+Composite_literal_expression::do_dump_expression(
+ Ast_dump_context* ast_dump_context) const
+{
+ ast_dump_context->ostream() << "composite(";
+ ast_dump_context->dump_type(this->type_);
+ ast_dump_context->ostream() << ", {";
+ ast_dump_context->dump_expression_list(this->vals_, this->has_keys_);
+ ast_dump_context->ostream() << "})";
+}
+
// Make a composite literal expression.
Expression*
this->location());
}
+// Dump ast representation for a type guard expression.
+
+void
+Type_guard_expression::do_dump_expression(Ast_dump_context* ast_dump_context)
+ const
+{
+ this->expr_->dump_expression(ast_dump_context);
+ ast_dump_context->ostream() << ".";
+ ast_dump_context->dump_type(this->type_);
+}
+
// Make a type guard expression.
Expression*
do_export(Export*) const
{ go_unreachable(); }
+ void
+ do_dump_expression(Ast_dump_context*) const;
+
private:
// The composite literal which is being put on the heap.
Expression* expr_;
return ret;
}
+// Dump ast representation for a heap composite expression.
+
+void
+Heap_composite_expression::do_dump_expression(
+ Ast_dump_context* ast_dump_context) const
+{
+ ast_dump_context->ostream() << "&(";
+ ast_dump_context->dump_expression(this->expr_);
+ ast_dump_context->ostream() << ")";
+}
+
// Allocate a composite literal on the heap.
Expression*
this->for_select_, this->location());
}
+// Dump ast representation for a receive expression.
+
+void
+Receive_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
+{
+ ast_dump_context->ostream() << " <- " ;
+ ast_dump_context->dump_expression(channel_);
+}
+
// Make a receive expression.
Receive_expression*
tree
do_get_tree(Translate_context* context)
- { return this->type_->type_descriptor_pointer(context->gogo()); }
+ {
+ return this->type_->type_descriptor_pointer(context->gogo(),
+ this->location());
+ }
+
+ void
+ do_dump_expression(Ast_dump_context*) const;
private:
// The type for which this is the descriptor.
Type* type_;
};
+// Dump ast representation for a type descriptor expression.
+
+void
+Type_descriptor_expression::do_dump_expression(
+ Ast_dump_context* ast_dump_context) const
+{
+ ast_dump_context->dump_type(this->type_);
+}
+
// Make a type descriptor expression.
Expression*
tree
do_get_tree(Translate_context* context);
+ void
+ do_dump_expression(Ast_dump_context*) const;
+
private:
// The type for which we are getting information.
Type* type_;
}
}
+// Dump ast representation for a type info expression.
+
+void
+Type_info_expression::do_dump_expression(
+ Ast_dump_context* ast_dump_context) const
+{
+ ast_dump_context->ostream() << "typeinfo(";
+ ast_dump_context->dump_type(this->type_);
+ ast_dump_context->ostream() << ",";
+ ast_dump_context->ostream() <<
+ (this->type_info_ == TYPE_INFO_ALIGNMENT ? "alignment"
+ : this->type_info_ == TYPE_INFO_FIELD_ALIGNMENT ? "field alignment"
+ : this->type_info_ == TYPE_INFO_SIZE ? "size "
+ : "unknown");
+ ast_dump_context->ostream() << ")";
+}
+
// Make a type info expression.
Expression*
tree
do_get_tree(Translate_context* context);
+ void
+ do_dump_expression(Ast_dump_context*) const;
+
private:
// The type of the struct.
Struct_type* type_;
byte_position(struct_field_tree));
}
+// Dump ast representation for a struct field offset expression.
+
+void
+Struct_field_offset_expression::do_dump_expression(
+ Ast_dump_context* ast_dump_context) const
+{
+ ast_dump_context->ostream() << "unsafe.Offsetof(";
+ ast_dump_context->dump_type(this->type_);
+ ast_dump_context->ostream() << '.';
+ ast_dump_context->ostream() <<
+ Gogo::message_name(this->field_->field_name());
+ ast_dump_context->ostream() << ")";
+}
+
// Make an expression for a struct field offset.
Expression*
return new Struct_field_offset_expression(type, field);
}
+// An expression which evaluates to a pointer to the map descriptor of
+// a map type.
+
+class Map_descriptor_expression : public Expression
+{
+ public:
+ Map_descriptor_expression(Map_type* type, source_location location)
+ : Expression(EXPRESSION_MAP_DESCRIPTOR, location),
+ type_(type)
+ { }
+
+ protected:
+ Type*
+ do_type()
+ { return Type::make_pointer_type(Map_type::make_map_descriptor_type()); }
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ tree
+ do_get_tree(Translate_context* context)
+ {
+ return this->type_->map_descriptor_pointer(context->gogo(),
+ this->location());
+ }
+
+ void
+ do_dump_expression(Ast_dump_context*) const;
+
+ private:
+ // The type for which this is the descriptor.
+ Map_type* type_;
+};
+
+// Dump ast representation for a map descriptor expression.
+
+void
+Map_descriptor_expression::do_dump_expression(
+ Ast_dump_context* ast_dump_context) const
+{
+ ast_dump_context->ostream() << "map_descriptor(";
+ ast_dump_context->dump_type(this->type_);
+ ast_dump_context->ostream() << ")";
+}
+
+// Make a map descriptor expression.
+
+Expression*
+Expression::make_map_descriptor(Map_type* type, source_location location)
+{
+ return new Map_descriptor_expression(type, location);
+}
+
// An expression which evaluates to the address of an unnamed label.
class Label_addr_expression : public Expression
return expr_to_tree(this->label_->get_addr(context, this->location()));
}
+ void
+ do_dump_expression(Ast_dump_context* ast_dump_context) const
+ { ast_dump_context->ostream() << this->label_->name(); }
+
private:
// The label whose address we are taking.
Label* label_;