blob: a18322cfb91a4866e3dc14f5a7b16ec50e962a80 [file] [log] [blame]
// expressions.h -- Go frontend expression handling. -*- C++ -*-
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
#ifndef GO_EXPRESSIONS_H
#define GO_EXPRESSIONS_H
#include <mpfr.h>
#include <mpc.h>
#include "operator.h"
#include "runtime.h"
class Gogo;
class Translate_context;
class Traverse;
class Statement_inserter;
class Type;
class Method;
struct Type_context;
class Integer_type;
class Float_type;
class Complex_type;
class Function_type;
class Map_type;
class Struct_type;
class Struct_field;
class Expression_list;
class Var_expression;
class Enclosed_var_expression;
class Temporary_reference_expression;
class Set_and_use_temporary_expression;
class String_expression;
class Type_conversion_expression;
class Unsafe_type_conversion_expression;
class Unary_expression;
class Binary_expression;
class String_concat_expression;
class Call_expression;
class Builtin_call_expression;
class Call_result_expression;
class Func_expression;
class Func_descriptor_expression;
class Unknown_expression;
class Index_expression;
class Array_index_expression;
class String_index_expression;
class Map_index_expression;
class Bound_method_expression;
class Field_reference_expression;
class Interface_field_reference_expression;
class Allocation_expression;
class Composite_literal_expression;
class Struct_construction_expression;
class Array_construction_expression;
class Fixed_array_construction_expression;
class Slice_construction_expression;
class Map_construction_expression;
class Type_guard_expression;
class Heap_expression;
class Receive_expression;
class Conditional_expression;
class Compound_expression;
class Numeric_constant;
class Named_object;
class Export_function_body;
class Import_expression;
class Temporary_statement;
class Label;
class Ast_dump_context;
class String_dump;
// The precision to use for complex values represented as an mpc_t.
const int mpc_precision = 256;
// The base class for all expressions.
class Expression
{
public:
// The types of expressions.
enum Expression_classification
{
EXPRESSION_ERROR,
EXPRESSION_TYPE,
EXPRESSION_UNARY,
EXPRESSION_BINARY,
EXPRESSION_STRING_CONCAT,
EXPRESSION_CONST_REFERENCE,
EXPRESSION_VAR_REFERENCE,
EXPRESSION_ENCLOSED_VAR_REFERENCE,
EXPRESSION_TEMPORARY_REFERENCE,
EXPRESSION_SET_AND_USE_TEMPORARY,
EXPRESSION_SINK,
EXPRESSION_FUNC_REFERENCE,
EXPRESSION_FUNC_DESCRIPTOR,
EXPRESSION_FUNC_CODE_REFERENCE,
EXPRESSION_UNKNOWN_REFERENCE,
EXPRESSION_BOOLEAN,
EXPRESSION_STRING,
EXPRESSION_STRING_INFO,
EXPRESSION_INTEGER,
EXPRESSION_FLOAT,
EXPRESSION_COMPLEX,
EXPRESSION_NIL,
EXPRESSION_IOTA,
EXPRESSION_CALL,
EXPRESSION_CALL_RESULT,
EXPRESSION_BOUND_METHOD,
EXPRESSION_INDEX,
EXPRESSION_ARRAY_INDEX,
EXPRESSION_STRING_INDEX,
EXPRESSION_MAP_INDEX,
EXPRESSION_SELECTOR,
EXPRESSION_FIELD_REFERENCE,
EXPRESSION_INTERFACE_FIELD_REFERENCE,
EXPRESSION_ALLOCATION,
EXPRESSION_TYPE_GUARD,
EXPRESSION_CONVERSION,
EXPRESSION_UNSAFE_CONVERSION,
EXPRESSION_STRUCT_CONSTRUCTION,
EXPRESSION_FIXED_ARRAY_CONSTRUCTION,
EXPRESSION_SLICE_CONSTRUCTION,
EXPRESSION_MAP_CONSTRUCTION,
EXPRESSION_COMPOSITE_LITERAL,
EXPRESSION_HEAP,
EXPRESSION_RECEIVE,
EXPRESSION_TYPE_DESCRIPTOR,
EXPRESSION_GC_SYMBOL,
EXPRESSION_PTRMASK_SYMBOL,
EXPRESSION_TYPE_INFO,
EXPRESSION_SLICE_INFO,
EXPRESSION_SLICE_VALUE,
EXPRESSION_INTERFACE_INFO,
EXPRESSION_INTERFACE_VALUE,
EXPRESSION_INTERFACE_MTABLE,
EXPRESSION_STRUCT_FIELD_OFFSET,
EXPRESSION_LABEL_ADDR,
EXPRESSION_CONDITIONAL,
EXPRESSION_COMPOUND,
EXPRESSION_BACKEND
};
Expression(Expression_classification, Location);
virtual ~Expression();
// Make an error expression. This is used when a parse error occurs
// to prevent cascading errors.
static Expression*
make_error(Location);
// Make an expression which is really a type. This is used during
// parsing.
static Expression*
make_type(Type*, Location);
// Make a unary expression.
static Expression*
make_unary(Operator, Expression*, Location);
// Make a binary expression.
static Expression*
make_binary(Operator, Expression*, Expression*, Location);
// Make a string concatenation expression.
static Expression*
make_string_concat(Expression_list*);
// Make a reference to a constant in an expression.
static Expression*
make_const_reference(Named_object*, Location);
// Make a reference to a variable in an expression.
static Expression*
make_var_reference(Named_object*, Location);
// Make a reference to a variable within an enclosing function.
static Expression*
make_enclosing_var_reference(Expression*, Named_object*, Location);
// Make a reference to a temporary variable. Temporary variables
// are always created by a single statement, which is what we use to
// refer to them.
static Temporary_reference_expression*
make_temporary_reference(Temporary_statement*, Location);
// Make an expressions which sets a temporary variable and then
// evaluates to a reference to that temporary variable. This is
// used to set a temporary variable while retaining the order of
// evaluation.
static Set_and_use_temporary_expression*
make_set_and_use_temporary(Temporary_statement*, Expression*, Location);
// Make a sink expression--a reference to the blank identifier _.
static Expression*
make_sink(Location);
// Make a reference to a function in an expression. This returns a
// pointer to the struct holding the address of the function
// followed by any closed-over variables.
static Expression*
make_func_reference(Named_object*, Expression* closure, Location);
// Make a function descriptor, an immutable struct with a single
// field that points to the function code. This may only be used
// with functions that do not have closures. FN is the function for
// which we are making the descriptor.
static Func_descriptor_expression*
make_func_descriptor(Named_object* fn);
// Make a reference to the code of a function. This is used to set
// descriptor and closure fields.
static Expression*
make_func_code_reference(Named_object*, Location);
// Make a reference to an unknown name. In a correct program this
// will always be lowered to a real const/var/func reference.
static Unknown_expression*
make_unknown_reference(Named_object*, Location);
// Make a constant bool expression.
static Expression*
make_boolean(bool val, Location);
// Make a constant string expression.
static Expression*
make_string(const std::string&, Location);
// Make an expression that evaluates to some characteristic of an string.
// For simplicity, the enum values must match the field indexes in the
// underlying struct.
enum String_info
{
// The underlying data in the string.
STRING_INFO_DATA,
// The length of the string.
STRING_INFO_LENGTH
};
static Expression*
make_string_info(Expression* string, String_info, Location);
// Make a character constant expression. TYPE should be NULL for an
// abstract type.
static Expression*
make_character(const mpz_t*, Type*, Location);
// Make a constant integer expression from a multi-precision
// integer. TYPE should be NULL for an abstract type.
static Expression*
make_integer_z(const mpz_t*, Type*, Location);
// Make a constant integer expression from an unsigned long. TYPE
// should be NULL for an abstract type.
static Expression*
make_integer_ul(unsigned long, Type*, Location);
// Make a constant integer expression from a signed long. TYPE
// should be NULL for an abstract type.
static Expression*
make_integer_sl(long, Type*, Location);
// Make a constant integer expression from an int64_t. TYPE should
// be NULL for an abstract type.
static Expression*
make_integer_int64(int64_t, Type*, Location);
// Make a constant float expression. TYPE should be NULL for an
// abstract type.
static Expression*
make_float(const mpfr_t*, Type*, Location);
// Make a constant complex expression. TYPE should be NULL for an
// abstract type.
static Expression*
make_complex(const mpc_t*, Type*, Location);
// Make a nil expression.
static Expression*
make_nil(Location);
// Make an iota expression. This is used for the predeclared
// constant iota.
static Expression*
make_iota();
// Make a call expression.
static Call_expression*
make_call(Expression* func, Expression_list* args, bool is_varargs,
Location);
// Make a reference to a specific result of a call expression which
// returns a tuple.
static Expression*
make_call_result(Call_expression*, unsigned int index);
// Make an expression which is a method bound to its first
// parameter. METHOD is the method being called, FUNCTION is the
// function to call.
static Bound_method_expression*
make_bound_method(Expression* object, const Method* method,
Named_object* function, Location);
// Make an index or slice expression. This is a parser expression
// which represents LEFT[START:END:CAP]. END may be NULL, meaning an
// index rather than a slice. CAP may be NULL, meaning we use the default
// capacity of LEFT. At parse time we may not know the type of LEFT.
// After parsing this is lowered to an array index, a string index,
// or a map index.
static Expression*
make_index(Expression* left, Expression* start, Expression* end,
Expression* cap, Location);
// Make an array index expression. END may be NULL, in which case
// this is an lvalue. CAP may be NULL, in which case it defaults
// to cap(ARRAY).
static Expression*
make_array_index(Expression* array, Expression* start, Expression* end,
Expression* cap, Location);
// Make a string index expression. END may be NULL. This is never
// an lvalue.
static Expression*
make_string_index(Expression* string, Expression* start, Expression* end,
Location);
// Make a map index expression. This is an lvalue.
static Map_index_expression*
make_map_index(Expression* map, Expression* val, Location);
// Make a selector. This is a parser expression which represents
// LEFT.NAME. At parse time we may not know the type of the left
// hand side.
static Expression*
make_selector(Expression* left, const std::string& name, Location);
// Make a reference to a field in a struct.
static Field_reference_expression*
make_field_reference(Expression*, unsigned int field_index, Location);
// Make a reference to a field of an interface, with an associated
// object.
static Expression*
make_interface_field_reference(Expression*, const std::string&,
Location);
// Make an allocation expression.
static Expression*
make_allocation(Type*, Location);
// Make a type guard expression.
static Expression*
make_type_guard(Expression*, Type*, Location);
// Make a type cast expression.
static Expression*
make_cast(Type*, Expression*, Location);
// Make an unsafe type cast expression. This is only used when
// passing parameter to builtin functions that are part of the Go
// runtime.
static Expression*
make_unsafe_cast(Type*, Expression*, Location);
// Make a composite literal. The DEPTH parameter is how far down we
// are in a list of composite literals with omitted types. HAS_KEYS
// is true if the expression list has keys alternating with values.
// ALL_ARE_NAMES is true if all the keys could be struct field
// names.
static Expression*
make_composite_literal(Type*, int depth, bool has_keys, Expression_list*,
bool all_are_names, Location);
// Make a struct composite literal.
static Expression*
make_struct_composite_literal(Type*, Expression_list*, Location);
// Make an array composite literal.
static Expression*
make_array_composite_literal(Type*, Expression_list*, Location);
// Make a slice composite literal.
static Slice_construction_expression*
make_slice_composite_literal(Type*, Expression_list*, Location);
// Take an expression and allocate it on the heap.
static Expression*
make_heap_expression(Expression*, Location);
// Make a receive expression. VAL is NULL for a unary receive.
static Receive_expression*
make_receive(Expression* channel, Location);
// Make an expression which evaluates to the address of the type
// descriptor for TYPE.
static Expression*
make_type_descriptor(Type* type, Location);
// Make an expression which evaluates to the address of the gc
// symbol for TYPE.
static Expression*
make_gc_symbol(Type* type);
// Make an expression that evaluates to the address of a ptrmask
// symbol for TYPE. For most types this will be the same as
// make_gc_symbol, but for larger types make_gc_symbol will return a
// gcprog while this will return a ptrmask.
static Expression*
make_ptrmask_symbol(Type* type);
// Make an expression which evaluates to some characteristic of a
// type. These are only used for type descriptors, so there is no
// location parameter.
enum Type_info
{
// The size of a value of the type.
TYPE_INFO_SIZE,
// The required alignment of a value of the type.
TYPE_INFO_ALIGNMENT,
// The required alignment of a value of the type when used as a
// field in a struct.
TYPE_INFO_FIELD_ALIGNMENT,
// The size of the prefix of a value of the type that contains
// all the pointers. This is 0 for a type that contains no
// pointers. It is always <= TYPE_INFO_SIZE.
TYPE_INFO_BACKEND_PTRDATA,
// Like TYPE_INFO_BACKEND_PTRDATA, but the ptrdata value that we
// want to store in a type descriptor. They are the same for
// most types, but can differ for a type that uses a gcprog.
TYPE_INFO_DESCRIPTOR_PTRDATA
};
static Expression*
make_type_info(Type* type, Type_info);
// Make an expression that evaluates to some characteristic of a
// slice. For simplicity, the enum values must match the field indexes
// in the underlying struct.
enum Slice_info
{
// The underlying data of the slice.
SLICE_INFO_VALUE_POINTER,
// The length of the slice.
SLICE_INFO_LENGTH,
// The capacity of the slice.
SLICE_INFO_CAPACITY
};
static Expression*
make_slice_info(Expression* slice, Slice_info, Location);
// Make an expression for a slice value.
static Expression*
make_slice_value(Type*, Expression* valptr, Expression* len, Expression* cap,
Location);
// Make an expression that evaluates to some characteristic of an
// interface. For simplicity, the enum values must match the field indexes
// in the underlying struct.
enum Interface_info
{
// The type descriptor of an empty interface.
INTERFACE_INFO_TYPE_DESCRIPTOR = 0,
// The methods of an interface.
INTERFACE_INFO_METHODS = 0,
// The first argument to pass to an interface method.
INTERFACE_INFO_OBJECT
};
static Expression*
make_interface_info(Expression* iface, Interface_info, Location);
// Make an expression for an interface value.
static Expression*
make_interface_value(Type*, Expression*, Expression*, Location);
// Make an expression that builds a reference to the interface method table
// for TYPE that satisfies interface ITYPE. IS_POINTER is true if this is a
// reference to the interface method table for the pointer receiver type.
static Expression*
make_interface_mtable_ref(Interface_type* itype, Type* type,
bool is_pointer, Location);
// Make an expression which evaluates to the offset of a field in a
// struct. This is only used for type descriptors, so there is no
// location parameter.
static Expression*
make_struct_field_offset(Struct_type*, const Struct_field*);
// Make an expression which evaluates to the address of an unnamed
// label.
static Expression*
make_label_addr(Label*, Location);
// Make a conditional expression.
static Expression*
make_conditional(Expression*, Expression*, Expression*, Location);
// Make a compound expression.
static Expression*
make_compound(Expression*, Expression*, Location);
// Make a backend expression.
static Expression*
make_backend(Bexpression*, Type*, Location);
enum Nil_check_classification
{
// Use the default policy for deciding if this deref needs a check.
NIL_CHECK_DEFAULT,
// An explicit check is required for this dereference operation.
NIL_CHECK_NEEDED,
// No check needed for this dereference operation.
NIL_CHECK_NOT_NEEDED,
// A type error or error construct was encountered when determining
// whether this deref needs an explicit check.
NIL_CHECK_ERROR_ENCOUNTERED
};
// Make a dereference expression.
static Expression*
make_dereference(Expression*, Nil_check_classification, Location);
// Return the expression classification.
Expression_classification
classification() const
{ return this->classification_; }
// Return the location of the expression.
Location
location() const
{ return this->location_; }
// Return whether this is a constant expression.
bool
is_constant() const
{ return this->do_is_constant(); }
// Return whether this expression can be used as a static
// initializer. This is true for an expression that has only
// numbers and pointers to global variables or composite literals
// that do not require runtime initialization. It is false if we
// must generate code to compute this expression when it is used to
// initialize a global variable. This is not a language-level
// concept, but an implementation-level one. If this expression is
// used to initialize a global variable, this is true if we can pass
// an initializer to the backend, false if we must generate code to
// initialize the variable. It is always safe for this method to
// return false, but the resulting code may be less efficient.
bool
is_static_initializer() const
{ return this->do_is_static_initializer(); }
// If this is not a numeric constant, return false. If it is one,
// return true, and set VAL to hold the value.
bool
numeric_constant_value(Numeric_constant* val) const
{ return this->do_numeric_constant_value(val); }
// If this is not a constant expression with string type, return
// false. If it is one, return true, and set VAL to the value.
bool
string_constant_value(std::string* val) const
{ return this->do_string_constant_value(val); }
// This is called if the value of this expression is being
// discarded. This issues warnings about computed values being
// unused. This returns true if all is well, false if it issued an
// error message.
bool
discarding_value()
{ return this->do_discarding_value(); }
// Return whether this is an error expression.
bool
is_error_expression() const
{ return this->classification_ == EXPRESSION_ERROR; }
// Return whether this expression really represents a type.
bool
is_type_expression() const
{ return this->classification_ == EXPRESSION_TYPE; }
// If this is a variable reference, return the Var_expression
// structure. Otherwise, return NULL. This is a controlled dynamic
// cast.
Var_expression*
var_expression()
{ return this->convert<Var_expression, EXPRESSION_VAR_REFERENCE>(); }
const Var_expression*
var_expression() const
{ return this->convert<const Var_expression, EXPRESSION_VAR_REFERENCE>(); }
// If this is a enclosed_variable reference, return the
// Enclosed_var_expression structure. Otherwise, return NULL.
// This is a controlled dynamic cast.
Enclosed_var_expression*
enclosed_var_expression()
{ return this->convert<Enclosed_var_expression,
EXPRESSION_ENCLOSED_VAR_REFERENCE>(); }
const Enclosed_var_expression*
enclosed_var_expression() const
{ return this->convert<const Enclosed_var_expression,
EXPRESSION_ENCLOSED_VAR_REFERENCE>(); }
// If this is a reference to a temporary variable, return the
// Temporary_reference_expression. Otherwise, return NULL.
Temporary_reference_expression*
temporary_reference_expression()
{
return this->convert<Temporary_reference_expression,
EXPRESSION_TEMPORARY_REFERENCE>();
}
// If this is a set-and-use-temporary, return the
// Set_and_use_temporary_expression. Otherwise, return NULL.
Set_and_use_temporary_expression*
set_and_use_temporary_expression()
{
return this->convert<Set_and_use_temporary_expression,
EXPRESSION_SET_AND_USE_TEMPORARY>();
}
// Return whether this is a sink expression.
bool
is_sink_expression() const
{ return this->classification_ == EXPRESSION_SINK; }
// If this is a string expression, return the String_expression
// structure. Otherwise, return NULL.
String_expression*
string_expression()
{ return this->convert<String_expression, EXPRESSION_STRING>(); }
// If this is a conversion expression, return the Type_conversion_expression
// structure. Otherwise, return NULL.
Type_conversion_expression*
conversion_expression()
{ return this->convert<Type_conversion_expression, EXPRESSION_CONVERSION>(); }
// If this is an unsafe conversion expression, return the
// Unsafe_type_conversion_expression structure. Otherwise, return NULL.
Unsafe_type_conversion_expression*
unsafe_conversion_expression()
{
return this->convert<Unsafe_type_conversion_expression,
EXPRESSION_UNSAFE_CONVERSION>();
}
// Return whether this is the expression nil.
bool
is_nil_expression() const
{ return this->classification_ == EXPRESSION_NIL; }
// If this is an indirection through a pointer, return the
// expression being pointed through. Otherwise return this.
Expression*
deref();
// If this is a unary expression, return the Unary_expression
// structure. Otherwise return NULL.
Unary_expression*
unary_expression()
{ return this->convert<Unary_expression, EXPRESSION_UNARY>(); }
// If this is a binary expression, return the Binary_expression
// structure. Otherwise return NULL.
Binary_expression*
binary_expression()
{ return this->convert<Binary_expression, EXPRESSION_BINARY>(); }
// If this is a string concatenation expression, return the
// String_concat_expression structure. Otherwise, return NULL.
String_concat_expression*
string_concat_expression()
{
return this->convert<String_concat_expression, EXPRESSION_STRING_CONCAT>();
}
// If this is a call expression, return the Call_expression
// structure. Otherwise, return NULL. This is a controlled dynamic
// cast.
Call_expression*
call_expression()
{ return this->convert<Call_expression, EXPRESSION_CALL>(); }
// If this is a call_result expression, return the Call_result_expression
// structure. Otherwise, return NULL. This is a controlled dynamic
// cast.
Call_result_expression*
call_result_expression()
{ return this->convert<Call_result_expression, EXPRESSION_CALL_RESULT>(); }
// If this is an expression which refers to a function, return the
// Func_expression structure. Otherwise, return NULL.
Func_expression*
func_expression()
{ return this->convert<Func_expression, EXPRESSION_FUNC_REFERENCE>(); }
const Func_expression*
func_expression() const
{ return this->convert<const Func_expression, EXPRESSION_FUNC_REFERENCE>(); }
// If this is an expression which refers to an unknown name, return
// the Unknown_expression structure. Otherwise, return NULL.
Unknown_expression*
unknown_expression()
{ return this->convert<Unknown_expression, EXPRESSION_UNKNOWN_REFERENCE>(); }
const Unknown_expression*
unknown_expression() const
{
return this->convert<const Unknown_expression,
EXPRESSION_UNKNOWN_REFERENCE>();
}
// If this is an index expression, return the Index_expression
// structure. Otherwise, return NULL.
Index_expression*
index_expression()
{ return this->convert<Index_expression, EXPRESSION_INDEX>(); }
// If this is an expression which refers to indexing in a array,
// return the Array_index_expression structure. Otherwise, return
// NULL.
Array_index_expression*
array_index_expression()
{ return this->convert<Array_index_expression, EXPRESSION_ARRAY_INDEX>(); }
// If this is an expression which refers to indexing in a string,
// return the String_index_expression structure. Otherwise, return
// NULL.
String_index_expression*
string_index_expression()
{ return this->convert<String_index_expression, EXPRESSION_STRING_INDEX>(); }
// If this is an expression which refers to indexing in a map,
// return the Map_index_expression structure. Otherwise, return
// NULL.
Map_index_expression*
map_index_expression()
{ return this->convert<Map_index_expression, EXPRESSION_MAP_INDEX>(); }
// If this is a bound method expression, return the
// Bound_method_expression structure. Otherwise, return NULL.
Bound_method_expression*
bound_method_expression()
{ return this->convert<Bound_method_expression, EXPRESSION_BOUND_METHOD>(); }
// If this is a reference to a field in a struct, return the
// Field_reference_expression structure. Otherwise, return NULL.
Field_reference_expression*
field_reference_expression()
{
return this->convert<Field_reference_expression,
EXPRESSION_FIELD_REFERENCE>();
}
// If this is a reference to a field in an interface, return the
// Interface_field_reference_expression structure. Otherwise,
// return NULL.
Interface_field_reference_expression*
interface_field_reference_expression()
{
return this->convert<Interface_field_reference_expression,
EXPRESSION_INTERFACE_FIELD_REFERENCE>();
}
// If this is an allocation expression, return the Allocation_expression
// structure. Otherwise, return NULL.
Allocation_expression*
allocation_expression()
{ return this->convert<Allocation_expression, EXPRESSION_ALLOCATION>(); }
// If this is a general composite literal, return the
// Composite_literal_expression structure. Otherwise, return NULL.
Composite_literal_expression*
complit()
{
return this->convert<Composite_literal_expression,
EXPRESSION_COMPOSITE_LITERAL>();
}
// If this is a struct composite literal, return the
// Struct_construction_expression structure. Otherwise, return NULL.
Struct_construction_expression*
struct_literal()
{
return this->convert<Struct_construction_expression,
EXPRESSION_STRUCT_CONSTRUCTION>();
}
// If this is a array composite literal, return the
// Array_construction_expression structure. Otherwise, return NULL.
Fixed_array_construction_expression*
array_literal()
{
return this->convert<Fixed_array_construction_expression,
EXPRESSION_FIXED_ARRAY_CONSTRUCTION>();
}
// If this is a slice composite literal, return the
// Slice_construction_expression structure. Otherwise, return NULL.
Slice_construction_expression*
slice_literal()
{
return this->convert<Slice_construction_expression,
EXPRESSION_SLICE_CONSTRUCTION>();
}
// If this is a map composite literal, return the
// Map_construction_expression structure. Otherwise, return NULL.
Map_construction_expression*
map_literal()
{
return this->convert<Map_construction_expression,
EXPRESSION_MAP_CONSTRUCTION>();
}
// If this is a type guard expression, return the
// Type_guard_expression structure. Otherwise, return NULL.
Type_guard_expression*
type_guard_expression()
{ return this->convert<Type_guard_expression, EXPRESSION_TYPE_GUARD>(); }
// If this is a heap expression, returhn the Heap_expression structure.
// Otherwise, return NULL.
Heap_expression*
heap_expression()
{ return this->convert<Heap_expression, EXPRESSION_HEAP>(); }
// If this is a receive expression, return the Receive_expression
// structure. Otherwise, return NULL.
Receive_expression*
receive_expression()
{ return this->convert<Receive_expression, EXPRESSION_RECEIVE>(); }
// If this is a conditional expression, return the Conditional_expression
// structure. Otherwise, return NULL.
Conditional_expression*
conditional_expression()
{ return this->convert<Conditional_expression, EXPRESSION_CONDITIONAL>(); }
// If this is a compound expression, return the Compound_expression structure.
// Otherwise, return NULL.
Compound_expression*
compound_expression()
{ return this->convert<Compound_expression, EXPRESSION_COMPOUND>(); }
// Return true if this is a composite literal.
bool
is_composite_literal() const;
// Return true if this is a composite literal which is not constant.
bool
is_nonconstant_composite_literal() const;
// Return true if this is a variable or temporary variable.
bool
is_variable() const;
// Return true if this is a reference to a local variable.
bool
is_local_variable() const;
// Return true if two expressions refer to the same variable or
// struct field.
static bool
is_same_variable(Expression*, Expression*);
// Make the builtin function descriptor type, so that it can be
// converted.
static void
make_func_descriptor_type();
// Traverse an expression.
static int
traverse(Expression**, Traverse*);
// Traverse subexpressions of this expression.
int
traverse_subexpressions(Traverse*);
// Lower an expression. This is called immediately after parsing.
// FUNCTION is the function we are in; it will be NULL for an
// expression initializing a global variable. INSERTER may be used
// to insert statements before the statement or initializer
// containing this expression; it is normally used to create
// temporary variables. IOTA_VALUE is the value that we should give
// to any iota expressions. This function must resolve expressions
// which could not be fully parsed into their final form. It
// returns the same Expression or a new one.
Expression*
lower(Gogo* gogo, Named_object* function, Statement_inserter* inserter,
int iota_value)
{ return this->do_lower(gogo, function, inserter, iota_value); }
// Flatten an expression. This is called after order_evaluation.
// FUNCTION is the function we are in; it will be NULL for an
// expression initializing a global variable. INSERTER may be used
// to insert statements before the statement or initializer
// containing this expression; it is normally used to create
// temporary variables. This function must resolve expressions
// which could not be fully parsed into their final form. It
// returns the same Expression or a new one.
Expression*
flatten(Gogo* gogo, Named_object* function, Statement_inserter* inserter)
{ return this->do_flatten(gogo, function, inserter); }
// Determine the real type of an expression with abstract integer,
// floating point, or complex type. TYPE_CONTEXT describes the
// expected type.
void
determine_type(const Type_context*);
// Check types in an expression.
void
check_types(Gogo* gogo)
{ this->do_check_types(gogo); }
// Determine the type when there is no context.
void
determine_type_no_context();
// Return the current type of the expression. This may be changed
// by determine_type.
Type*
type()
{ return this->do_type(); }
// Return a copy of an expression.
Expression*
copy()
{ return this->do_copy(); }
// Return the cost of this statement for inlining purposes.
int
inlining_cost() const
{ return this->do_inlining_cost(); }
// Return whether the expression is addressable--something which may
// be used as the operand of the unary & operator.
bool
is_addressable() const
{ return this->do_is_addressable(); }
// Note that we are taking the address of this expression. ESCAPES
// is true if this address escapes the current function.
void
address_taken(bool escapes)
{ this->do_address_taken(escapes); }
// Note that a nil check must be issued for this expression.
void
issue_nil_check()
{ this->do_issue_nil_check(); }
// Return whether this expression must be evaluated in order
// according to the order of evaluation rules. This is basically
// true of all expressions with side-effects.
bool
must_eval_in_order() const
{ return this->do_must_eval_in_order(); }
// Return whether subexpressions of this expression must be
// evaluated in order. This is true of index expressions and
// pointer indirections. This sets *SKIP to the number of
// subexpressions to skip during traversing, as index expressions
// only requiring moving the index, not the array.
bool
must_eval_subexpressions_in_order(int* skip) const
{
*skip = 0;
return this->do_must_eval_subexpressions_in_order(skip);
}
// Return the backend representation for this expression.
Bexpression*
get_backend(Translate_context*);
// Return an expression handling any conversions which must be done during
// assignment.
static Expression*
convert_for_assignment(Gogo*, Type* lhs_type, Expression* rhs,
Location location);
// Return an expression converting a value of one interface type to another
// interface type. If FOR_TYPE_GUARD is true this is for a type
// assertion.
static Expression*
convert_interface_to_interface(Type* lhs_type,
Expression* rhs, bool for_type_guard,
Location);
// Return a backend expression implementing the comparison LEFT OP RIGHT.
// TYPE is the type of both sides.
static Bexpression*
comparison(Translate_context*, Type* result_type, Operator op,
Expression* left, Expression* right, Location);
// Return the backend expression for the numeric constant VAL.
static Bexpression*
backend_numeric_constant_expression(Translate_context*,
Numeric_constant* val);
// Export the expression.
void
export_expression(Export_function_body* efb) const
{ this->do_export(efb); }
// Import an expression. The location should be used for the
// returned expression. Errors should be reported using the
// Import's location method.
static Expression*
import_expression(Import_expression*, Location);
// Return an expression which checks that VAL, of arbitrary integer type,
// is non-negative and is not more than the maximum integer value.
static Expression*
check_bounds(Expression* val, Location);
// Dump an expression to a dump constext.
void
dump_expression(Ast_dump_context*) const;
protected:
// May be implemented by child class: traverse the expressions.
virtual int
do_traverse(Traverse*);
// Return a lowered expression.
virtual Expression*
do_lower(Gogo*, Named_object*, Statement_inserter*, int)
{ return this; }
// Return a flattened expression.
virtual Expression*
do_flatten(Gogo*, Named_object*, Statement_inserter*)
{ return this; }
// Return whether this is a constant expression.
virtual bool
do_is_constant() const
{ return false; }
// Return whether this expression can be used as a constant
// initializer.
virtual bool
do_is_static_initializer() const
{ return false; }
// Return whether this is a constant expression of numeric type, and
// set the Numeric_constant to the value.
virtual bool
do_numeric_constant_value(Numeric_constant*) const
{ return false; }
// Return whether this is a constant expression of string type, and
// set VAL to the value.
virtual bool
do_string_constant_value(std::string*) const
{ return false; }
// Called by the parser if the value is being discarded.
virtual bool
do_discarding_value();
// Child class holds type.
virtual Type*
do_type() = 0;
// Child class implements determining type information.
virtual void
do_determine_type(const Type_context*) = 0;
// Child class implements type checking if needed.
virtual void
do_check_types(Gogo*)
{ }
// Child class implements copying.
virtual Expression*
do_copy() = 0;
// Child class implements determining the cost of this statement for
// inlining. The default cost is high, so we only need to define
// this method for expressions that can be inlined.
virtual int
do_inlining_cost() const
{ return 0x100000; }
// Child class implements whether the expression is addressable.
virtual bool
do_is_addressable() const
{ return false; }
// Child class implements taking the address of an expression.
virtual void
do_address_taken(bool)
{ }
// Child class implements issuing a nil check if the address is taken.
virtual void
do_issue_nil_check()
{ }
// Child class implements whether this expression must be evaluated
// in order.
virtual bool
do_must_eval_in_order() const
{ return false; }
// Child class implements whether this expressions requires that
// subexpressions be evaluated in order. The child implementation
// may set *SKIP if it should be non-zero.
virtual bool
do_must_eval_subexpressions_in_order(int* /* skip */) const
{ return false; }
// Child class implements conversion to backend representation.
virtual Bexpression*
do_get_backend(Translate_context*) = 0;
// Child class implements export.
virtual void
do_export(Export_function_body*) const;
// For children to call to give an error for an unused value.
void
unused_value_error();
// For children to call when they detect that they are in error.
void
set_is_error();
// For children to call to report an error conveniently.
void
report_error(const char*);
// Child class implements dumping to a dump context.
virtual void
do_dump_expression(Ast_dump_context*) const = 0;
// Varargs lowering creates a slice object (unnamed compiler temp)
// to contain the variable length collection of values. The enum
// below tells the lowering routine whether it can mark that temp
// as non-escaping or not. For general varargs calls it is not always
// safe to stack-allocated the storage, but for specific cases (ex:
// call to append()) it is legal.
enum Slice_storage_escape_disp
{
SLICE_STORAGE_MAY_ESCAPE,
SLICE_STORAGE_DOES_NOT_ESCAPE
};
private:
// Convert to the desired statement classification, or return NULL.
// This is a controlled dynamic cast.
template<typename Expression_class,
Expression_classification expr_classification>
Expression_class*
convert()
{
return (this->classification_ == expr_classification
? static_cast<Expression_class*>(this)
: NULL);
}
template<typename Expression_class,
Expression_classification expr_classification>
const Expression_class*
convert() const
{
return (this->classification_ == expr_classification
? static_cast<const Expression_class*>(this)
: NULL);
}
static Expression*
convert_type_to_interface(Type*, Expression*, Location);
static Expression*
get_interface_type_descriptor(Expression*);
static Expression*
convert_interface_to_type(Type*, Expression*, Location);
// The expression classification.
Expression_classification classification_;
// The location in the input file.
Location location_;
};
// A list of Expressions.
class Expression_list
{
public:
Expression_list()
: entries_()
{ }
// Return whether the list is empty.
bool
empty() const
{ return this->entries_.empty(); }
// Return the number of entries in the list.
size_t
size() const
{ return this->entries_.size(); }
// Add an entry to the end of the list.
void
push_back(Expression* expr)
{ this->entries_.push_back(expr); }
void
append(Expression_list* add)
{ this->entries_.insert(this->entries_.end(), add->begin(), add->end()); }
// Reserve space in the list.
void
reserve(size_t size)
{ this->entries_.reserve(size); }
// Traverse the expressions in the list.
int
traverse(Traverse*);
// Copy the list.
Expression_list*
copy();
// Return true if the list contains an error expression.
bool
contains_error() const;
// Retrieve an element by index.
Expression*&
at(size_t i)
{ return this->entries_.at(i); }
// Return the first and last elements.
Expression*&
front()
{ return this->entries_.front(); }
Expression*
front() const
{ return this->entries_.front(); }
Expression*&
back()
{ return this->entries_.back(); }
Expression*
back() const
{ return this->entries_.back(); }
// Iterators.
typedef std::vector<Expression*>::iterator iterator;
typedef std::vector<Expression*>::const_iterator const_iterator;
iterator
begin()
{ return this->entries_.begin(); }
const_iterator
begin() const
{ return this->entries_.begin(); }
iterator
end()
{ return this->entries_.end(); }
const_iterator
end() const
{ return this->entries_.end(); }
// Erase an entry.
void
erase(iterator p)
{ this->entries_.erase(p); }
private:
std::vector<Expression*> entries_;
};
// An abstract base class for an expression which is only used by the
// parser, and is lowered in the lowering pass.
class Parser_expression : public Expression
{
public:
Parser_expression(Expression_classification classification,
Location location)
: Expression(classification, location)
{ }
protected:
virtual Expression*
do_lower(Gogo*, Named_object*, Statement_inserter*, int) = 0;
Type*
do_type();
void
do_determine_type(const Type_context*)
{ go_unreachable(); }
void
do_check_types(Gogo*)
{ go_unreachable(); }
Bexpression*
do_get_backend(Translate_context*)
{ go_unreachable(); }
};
// An expression which is simply a variable.
class Var_expression : public Expression
{
public:
Var_expression(Named_object* variable, Location location)
: Expression(EXPRESSION_VAR_REFERENCE, location),
variable_(variable)
{ }
// Return the variable.
Named_object*
named_object() const
{ return this->variable_; }
protected:
Expression*
do_lower(Gogo*, Named_object*, Statement_inserter*, int);
Type*
do_type();
void
do_determine_type(const Type_context*);
Expression*
do_copy()
{ return this; }
int
do_inlining_cost() const;
void
do_export(Export_function_body*) const;
bool
do_is_addressable() const
{ return true; }
void
do_address_taken(bool);
Bexpression*
do_get_backend(Translate_context*);
void
do_dump_expression(Ast_dump_context*) const;
private:
// The variable we are referencing.
Named_object* variable_;
};
// A reference to a variable within an enclosing function.
class Enclosed_var_expression : public Expression
{
public:
Enclosed_var_expression(Expression* reference, Named_object* variable,
Location location)
: Expression(EXPRESSION_ENCLOSED_VAR_REFERENCE, location),
reference_(reference), variable_(variable)
{ }
// The reference to the enclosed variable. This will be an indirection of the
// the field stored within closure variable.
Expression*
reference() const
{ return this->reference_; }
// The variable being enclosed and referenced.
Named_object*
variable() const
{ return this->variable_; }
protected:
int
do_traverse(Traverse*);
Expression*
do_lower(Gogo*, Named_object*, Statement_inserter*, int);
Expression*
do_flatten(Gogo*, Named_object*, Statement_inserter*);
Type*
do_type()
{ return this->reference_->type(); }
void
do_determine_type(const Type_context* context)
{ return this->reference_->determine_type(context); }
Expression*
do_copy()
{ return this; }
bool
do_is_addressable() const
{ return this->reference_->is_addressable(); }
void
do_address_taken(bool escapes);
Bexpression*
do_get_backend(Translate_context* context)
{ return this->reference_->get_backend(context); }
void
do_dump_expression(Ast_dump_context*) const;
private:
// The reference to the enclosed variable.
Expression* reference_;
// The variable being enclosed.
Named_object* variable_;
};
// A reference to a temporary variable.
class Temporary_reference_expression : public Expression
{
public:
Temporary_reference_expression(Temporary_statement* statement,
Location location)
: Expression(EXPRESSION_TEMPORARY_REFERENCE, location),
statement_(statement), is_lvalue_(false)
{ }
// The temporary that this expression refers to.
Temporary_statement*
statement() const
{ return this->statement_; }
// Indicate that this reference appears on the left hand side of an
// assignment statement.
void
set_is_lvalue()
{ this->is_lvalue_ = true; }
protected:
Type*
do_type();
void
do_determine_type(const Type_context*)
{ }
Expression*
do_copy()
{ return make_temporary_reference(this->statement_, this->location()); }
bool
do_is_addressable() const
{ return true; }
void
do_address_taken(bool);
Bexpression*
do_get_backend(Translate_context*);
void
do_dump_expression(Ast_dump_context*) const;
private:
// The statement where the temporary variable is defined.
Temporary_statement* statement_;
// Whether this reference appears on the left hand side of an
// assignment statement.
bool is_lvalue_;
};
// Set and use a temporary variable.
class Set_and_use_temporary_expression : public Expression
{
public:
Set_and_use_temporary_expression(Temporary_statement* statement,
Expression* expr, Location location)
: Expression(EXPRESSION_SET_AND_USE_TEMPORARY, location),
statement_(statement), expr_(expr)
{ }
// Return the temporary.
Temporary_statement*
temporary() const
{ return this->statement_; }
// Return the expression.
Expression*
expression() const
{ return this->expr_; }
protected:
int
do_traverse(Traverse* traverse)
{ return Expression::traverse(&this->expr_, traverse); }
Type*
do_type();
void
do_determine_type(const Type_context*);
Expression*
do_copy()
{
return make_set_and_use_temporary(this->statement_, this->expr_,
this->location());
}
bool
do_is_addressable() const
{ return true; }
void
do_address_taken(bool);
Bexpression*
do_get_backend(Translate_context*);
void
do_dump_expression(Ast_dump_context*) const;
private:
// The statement where the temporary variable is defined.
Temporary_statement* statement_;
// The expression to assign to the temporary.
Expression* expr_;
};
// A string expression.
class String_expression : public Expression
{
public:
String_expression(const std::string& val, Location location)
: Expression(EXPRESSION_STRING, location),
val_(val), type_(NULL)
{ }
const std::string&
val() const
{ return this->val_; }
static Expression*
do_import(Import_expression*, Location);
protected:
bool
do_is_constant() const
{ return true; }
bool
do_is_static_initializer() const
{ return true; }
bool
do_string_constant_value(std::string* val) const
{
*val = this->val_;
return true;
}
Type*
do_type();
void
do_determine_type(const Type_context*);
Expression*
do_copy()
{ return this; }
Bexpression*
do_get_backend(Translate_context*);
// Write string literal to a string dump.
static void
export_string(String_dump* exp, const String_expression* str);
// Set the inlining cost a bit high since inlining may cause
// duplicated string literals.
int
do_inlining_cost() const
{ return 5; }
void
do_export(Export_function_body*) const;
void
do_dump_expression(Ast_dump_context*) const;
private:
// The string value. This is immutable.
const std::string val_;
// The type as determined by context.
Type* type_;
};
// A type conversion expression.
class Type_conversion_expression : public Expression
{
public:
Type_conversion_expression(Type* type, Expression* expr,
Location location)
: Expression(EXPRESSION_CONVERSION, location),
type_(type), expr_(expr), may_convert_function_types_(false)
{ }
// Return the type to which we are converting.
Type*
type() const
{ return this->type_; }
// Return the expression which we are converting.
Expression*
expr() const
{ return this->expr_; }
// Permit converting from one function type to another. This is
// used internally for method expressions.
void
set_may_convert_function_types()
{
this->may_convert_function_types_ = true;
}
// Import a type conversion expression.
static Expression*
do_import(Import_expression*, Location);
protected:
int
do_traverse(Traverse* traverse);
Expression*
do_lower(Gogo*, Named_object*, Statement_inserter*, int);
Expression*
do_flatten(Gogo*, Named_object*, Statement_inserter*);
bool
do_is_constant() const;
bool
do_is_static_initializer() const;
bool
do_numeric_constant_value(Numeric_constant*) const;
bool
do_string_constant_value(std::string*) const;
Type*
do_type()
{ return this->type_; }
void
do_determine_type(const Type_context*);
void
do_check_types(Gogo*);
Expression*
do_copy();
Bexpression*
do_get_backend(Translate_context* context);
int
do_inlining_cost() const;
void
do_export(Export_function_body*) const;
void
do_dump_expression(Ast_dump_context*) const;
private:
// The type to convert to.
Type* type_;
// The expression to convert.
Expression* expr_;
// True if this is permitted to convert function types. This is
// used internally for method expressions.
bool may_convert_function_types_;
};
// An unsafe type conversion, used to pass values to builtin functions.
class Unsafe_type_conversion_expression : public Expression
{
public:
Unsafe_type_conversion_expression(Type* type, Expression* expr,
Location location)
: Expression(EXPRESSION_UNSAFE_CONVERSION, location),
type_(type), expr_(expr)
{ }
Expression*
expr() const
{ return this->expr_; }
protected:
int
do_traverse(Traverse* traverse);
bool
do_is_static_initializer() const;
Type*
do_type()
{ return this->type_; }
void
do_determine_type(const Type_context*)
{ this->expr_->determine_type_no_context(); }
Expression*
do_copy();
Bexpression*
do_get_backend(Translate_context*);
void
do_dump_expression(Ast_dump_context*) const;
private:
// The type to convert to.
Type* type_;
// The expression to convert.
Expression* expr_;
};
// A Unary expression.
class Unary_expression : public Expression
{
public:
Unary_expression(Operator op, Expression* expr, Location location)
: Expression(EXPRESSION_UNARY, location),
op_(op), escapes_(true), create_temp_(false), is_gc_root_(false),
is_slice_init_(false), expr_(expr),
issue_nil_check_(NIL_CHECK_DEFAULT)
{ }
// Return the operator.
Operator
op() const
{ return this->op_; }
// Return the operand.
Expression*
operand() const
{ return this->expr_; }
// Record that an address expression does not escape.
void
set_does_not_escape()
{
go_assert(this->op_ == OPERATOR_AND);
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;
}
// Record that this is an address expression of a GC root, which is a
// mutable composite literal. This used for registering GC variables.
void
set_is_gc_root()
{
go_assert(this->op_ == OPERATOR_AND);
this->is_gc_root_ = true;
}
// Record that this is an address expression of a slice value initializer,
// which is mutable if the values are not copied to the heap.
void
set_is_slice_init()
{
go_assert(this->op_ == OPERATOR_AND);
this->is_slice_init_ = true;
}
// Call the address_taken method on the operand if necessary.
void
check_operand_address_taken(Gogo*);
// Apply unary opcode OP to UNC, setting NC. Return true if this
// could be done, false if not. On overflow, issues an error and
// sets *ISSUED_ERROR.
static bool
eval_constant(Operator op, const Numeric_constant* unc,
Location, Numeric_constant* nc, bool *issued_error);
static Expression*
do_import(Import_expression*, Location);
// Declare that this deref does or does not require an explicit nil check.
void
set_requires_nil_check(bool needed)
{
go_assert(this->op_ == OPERATOR_MULT);
if (needed)
this->issue_nil_check_ = NIL_CHECK_NEEDED;
else
this->issue_nil_check_ = NIL_CHECK_NOT_NEEDED;
}
protected:
int
do_traverse(Traverse* traverse)
{ return Expression::traverse(&this->expr_, traverse); }
Expression*
do_lower(Gogo*, Named_object*, Statement_inserter*, int);
Expression*
do_flatten(Gogo*, Named_object*, Statement_inserter*);
bool
do_is_constant() const;
bool
do_is_static_initializer() const;
bool
do_numeric_constant_value(Numeric_constant*) const;
Type*
do_type();
void
do_determine_type(const Type_context*);
void
do_check_types(Gogo*);
Expression*
do_copy()
{
return Expression::make_unary(this->op_, this->expr_->copy(),
this->location());
}
bool
do_must_eval_subexpressions_in_order(int*) const
{ return this->op_ == OPERATOR_MULT; }
bool
do_is_addressable() const
{ return this->op_ == OPERATOR_MULT; }
Bexpression*
do_get_backend(Translate_context*);
int
do_inlining_cost() const
{ return 1; }
void
do_export(Export_function_body*) const;
void
do_dump_expression(Ast_dump_context*) const;
void
do_issue_nil_check()
{
if (this->op_ == OPERATOR_MULT)
this->set_requires_nil_check(true);
}
private:
static bool
base_is_static_initializer(Expression*);
// Return a determination as to whether this dereference expression
// requires a nil check.
Nil_check_classification
requires_nil_check(Gogo*);
// 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_;
// True if this is an address expression for a GC root. A GC root is a
// special struct composite literal that is mutable when addressed, meaning
// it cannot be represented as an immutable_struct in the backend.
bool is_gc_root_;
// True if this is an address expression for a slice value with an immutable
// initializer. The initializer for a slice's value pointer has an array
// type, meaning it cannot be represented as an immutable_struct in the
// backend.
bool is_slice_init_;
// The operand.
Expression* expr_;
// Whether or not to issue a nil check for this expression if its address
// is being taken.
Nil_check_classification issue_nil_check_;
};
// A binary expression.
class Binary_expression : public Expression
{
public:
Binary_expression(Operator op, Expression* left, Expression* right,
Location location)
: Expression(EXPRESSION_BINARY, location),
op_(op), left_(left), right_(right), type_(NULL)
{ }
// Return the operator.
Operator
op()
{ return this->op_; }
// Return the left hand expression.
Expression*
left()
{ return this->left_; }
// Return the right hand expression.
Expression*
right()
{ return this->right_; }
// Apply binary opcode OP to LEFT_NC and RIGHT_NC, setting NC.
// Return true if this could be done, false if not. Issue errors at
// LOCATION as appropriate, and sets *ISSUED_ERROR if it did.
static bool
eval_constant(Operator op, Numeric_constant* left_nc,
Numeric_constant* right_nc, Location location,
Numeric_constant* nc, bool* issued_error);
// Compare constants LEFT_NC and RIGHT_NC according to OP, setting
// *RESULT. Return true if this could be done, false if not. Issue
// errors at LOCATION as appropriate.
static bool
compare_constant(Operator op, Numeric_constant* left_nc,
Numeric_constant* right_nc, Location location,
bool* result);
static Expression*
do_import(Import_expression*, Location);
// Report an error if OP can not be applied to TYPE. Return whether
// it can. OTYPE is the type of the other operand.
static bool
check_operator_type(Operator op, Type* type, Type* otype, Location);
// Set *RESULT_TYPE to the resulting type when OP is applied to
// operands of type LEFT_TYPE and RIGHT_TYPE. Return true on
// success, false on failure.
static bool
operation_type(Operator op, Type* left_type, Type* right_type,
Type** result_type);
protected:
int
do_traverse(Traverse* traverse);
Expression*
do_lower(Gogo*, Named_object*, Statement_inserter*, int);
Expression*
do_flatten(Gogo*, Named_object*, Statement_inserter*);
bool
do_is_constant() const
{ return this->left_->is_constant() && this->right_->is_constant(); }
bool
do_is_static_initializer() const;
bool
do_numeric_constant_value(Numeric_constant*) const;
bool
do_discarding_value();
Type*
do_type();
void
do_determine_type(const Type_context*);
void
do_check_types(Gogo*);
Expression*
do_copy()
{
return Expression::make_binary(this->op_, this->left_->copy(),
this->right_->copy(), this->location());
}
Bexpression*
do_get_backend(Translate_context*);
int
do_inlining_cost() const
{ return 1; }
void
do_export(Export_function_body*) const;
void
do_dump_expression(Ast_dump_context*) const;
private:
static bool
cmp_to_bool(Operator op, int cmp);
static bool
eval_integer(Operator op, const Numeric_constant*, const Numeric_constant*,
Location, Numeric_constant*);
static bool
eval_float(Operator op, const Numeric_constant*, const Numeric_constant*,
Location, Numeric_constant*);
static bool
eval_complex(Operator op, const Numeric_constant*, const Numeric_constant*,
Location, Numeric_constant*);
static bool
compare_integer(const Numeric_constant*, const Numeric_constant*, int*);
static bool
compare_float(const Numeric_constant*, const Numeric_constant *, int*);
static bool
compare_complex(const Numeric_constant*, const Numeric_constant*, int*);
Expression*
lower_struct_comparison(Gogo*, Statement_inserter*);
Expression*
lower_array_comparison(Gogo*, Statement_inserter*);
Expression*
lower_interface_value_comparison(Gogo*, Statement_inserter*);
Expression*
lower_compare_to_memcmp(Gogo*, Statement_inserter*);
Expression*
operand_address(Statement_inserter*, Expression*);
// The binary operator to apply.
Operator op_;
// The left hand side operand.
Expression* left_;
// The right hand side operand.
Expression* right_;
// The type of a comparison operation.
Type* type_;
};
// A string concatenation expression. This is a sequence of strings
// added together. It is created when lowering Binary_expression.
class String_concat_expression : public Expression
{
public:
String_concat_expression(Expression_list* exprs)
: Expression(EXPRESSION_STRING_CONCAT, exprs->front()->location()),
exprs_(exprs)
{ }
// Return the list of string expressions to be concatenated.
Expression_list*
exprs()
{ return this->exprs_; }
protected:
int
do_traverse(Traverse* traverse)
{ return this->exprs_->traverse(traverse); }
Expression*
do_lower(Gogo*, Named_object*, Statement_inserter*, int)
{ return this; }
Expression*
do_flatten(Gogo*, Named_object*, Statement_inserter*);
bool
do_is_constant() const;
bool
do_is_static_initializer() const;
Type*
do_type();
void
do_determine_type(const Type_context*);
void
do_check_types(Gogo*);
Expression*
do_copy()
{ return Expression::make_string_concat(this->exprs_->copy()); }
Bexpression*
do_get_backend(Translate_context*)
{ go_unreachable(); }
void
do_export(Export_function_body*) const
{ go_unreachable(); }
void
do_dump_expression(Ast_dump_context*) const;
private:
// The string expressions to concatenate.
Expression_list* exprs_;
};
// A call expression. The go statement needs to dig inside this.
class Call_expression : public Expression
{
public:
Call_expression(Expression* fn, Expression_list* args, bool is_varargs,
Location location)
: Expression(EXPRESSION_CALL, location),
fn_(fn), args_(args), type_(NULL), call_(NULL), call_temp_(NULL)
, expected_result_count_(0), is_varargs_(is_varargs),
varargs_are_lowered_(false), types_are_determined_(false),
is_deferred_(false), is_concurrent_(false), issued_error_(false),
is_multi_value_arg_(false), is_flattened_(false)
{ }
// The function to call.
Expression*
fn() const
{ return this->fn_; }
// The arguments.
Expression_list*
args()
{ return this->args_; }
const Expression_list*
args() const
{ return this->args_; }
// Get the function type.
Function_type*
get_function_type() const;
// Return the number of values this call will return.
size_t
result_count() const;
// Return the temporary variable that holds the results. This is
// only valid after the expression has been lowered, and is only
// valid for calls which return multiple results.
Temporary_statement*
results() const;
// Set the number of results expected from this call. This is used
// when the call appears in a context that expects multiple results,
// such as a, b = f().
void
set_expected_result_count(size_t);
// Return whether this is a call to the predeclared function
// recover.
bool
is_recover_call() const;
// Set the argument for a call to recover.
void
set_recover_arg(Expression*);
// Whether the last argument is a varargs argument (f(a...)).
bool
is_varargs() const
{ return this->is_varargs_; }
// Return whether varargs have already been lowered.
bool
varargs_are_lowered() const
{ return this->varargs_are_lowered_; }
// Note that varargs have already been lowered.
void
set_varargs_are_lowered()
{ this->varargs_are_lowered_ = true; }
// Whether this call is being deferred.
bool
is_deferred() const
{ return this->is_deferred_; }
// Note that the call is being deferred.
void
set_is_deferred()
{ this->is_deferred_ = true; }
// Whether this call is concurrently executed.
bool
is_concurrent() const
{ return this->is_concurrent_; }
// Note that the call is concurrently executed.
void
set_is_concurrent()
{ this->is_concurrent_ = true; }
// We have found an error with this call expression; return true if
// we should report it.
bool
issue_error();
// Whether or not this call contains errors, either in the call or the
// arguments to the call.
bool
is_erroneous_call();
// Whether this call returns multiple results that are used as an
// multi-valued argument.
bool
is_multi_value_arg() const
{ return this->is_multi_value_arg_; }
// Note this call is used as a multi-valued argument.
void
set_is_multi_value_arg()
{ this->is_multi_value_arg_ = true; }
// Whether this is a call to builtin function.
virtual bool
is_builtin()
{ return false; }
// Convert to a Builtin_call_expression, or return NULL.
inline Builtin_call_expression*
builtin_call_expression();
protected:
int
do_traverse(Traverse*);
virtual Expression*
do_lower(Gogo*, Named_object*, Statement_inserter*, int);
virtual Expression*
do_flatten(Gogo*, Named_object*, Statement_inserter*);
bool
do_discarding_value()
{ return true; }
virtual Type*
do_type();
virtual void
do_determine_type(const Type_context*);
virtual void
do_check_types(Gogo*);
Expression*
do_copy();
bool
do_must_eval_in_order() const;
virtual Bexpression*
do_get_backend(Translate_context*);
virtual bool
do_is_recover_call() const;
virtual void
do_set_recover_arg(Expression*);
// Let a builtin expression change the argument list.
void
set_args(Expression_list* args)
{ this->args_ = args; }
// Let a builtin expression lower varargs.
void
lower_varargs(Gogo*, Named_object* function, Statement_inserter* inserter,
Type* varargs_type, size_t param_count,
Slice_storage_escape_disp escape_disp);
// Let a builtin expression check whether types have been
// determined.
bool
determining_types();
void
do_dump_expression(Ast_dump_context*) const;
private:
bool
check_argument_type(int, const Type*, const Type*, Location, bool);
Expression*
lower_to_builtin(Named_object**, const char*, int);
Expression*
interface_method_function(Interface_field_reference_expression*,
Expression**, Location);
Bexpression*
set_results(Translate_context*);
// The function to call.
Expression* fn_;
// The arguments to pass. This may be NULL if there are no
// arguments.
Expression_list* args_;
// The type of the expression, to avoid recomputing it.
Type* type_;
// The backend expression for the call, used for a call which returns a tuple.
Bexpression* call_;
// A temporary variable to store this call if the function returns a tuple.
Temporary_statement* call_temp_;
// If not 0, the number of results expected from this call, when
// used in a context that expects multiple values.
size_t expected_result_count_;
// True if the last argument is a varargs argument (f(a...)).
bool is_varargs_;
// True if varargs have already been lowered.
bool varargs_are_lowered_;
// True if types have been determined.
bool types_are_determined_;
// True if the call is an argument to a defer statement.
bool is_deferred_;
// True if the call is an argument to a go statement.
bool is_concurrent_;
// True if we reported an error about a mismatch between call
// results and uses. This is to avoid producing multiple errors
// when there are multiple Call_result_expressions.
bool issued_error_;
// True if this call is used as an argument that returns multiple results.
bool is_multi_value_arg_;
// True if this expression has already been flattened.
bool is_flattened_;
};
// A call expression to a builtin function.
class Builtin_call_expression : public Call_expression
{
public:
Builtin_call_expression(Gogo* gogo, Expression* fn, Expression_list* args,
bool is_varargs, Location location);
// The builtin functions.
enum Builtin_function_code
{
BUILTIN_INVALID,
// Predeclared builtin functions.
BUILTIN_APPEND,
BUILTIN_CAP,
BUILTIN_CLOSE,
BUILTIN_COMPLEX,
BUILTIN_COPY,
BUILTIN_DELETE,
BUILTIN_IMAG,
BUILTIN_LEN,
BUILTIN_MAKE,
BUILTIN_NEW,
BUILTIN_PANIC,
BUILTIN_PRINT,
BUILTIN_PRINTLN,
BUILTIN_REAL,
BUILTIN_RECOVER,
// Builtin functions from the unsafe package.
BUILTIN_ALIGNOF,
BUILTIN_OFFSETOF,
BUILTIN_SIZEOF
};
Builtin_function_code
code()
{ return this->code_; }
// This overrides Call_expression::is_builtin.
bool
is_builtin()
{ return true; }
// Return whether EXPR, of array type, is a constant if passed to
// len or cap.
static bool
array_len_is_constant(Expression* expr);
Expression*
flatten_append(Gogo*, Named_object*, Statement_inserter*, Expression*,
Block*);
protected:
// This overrides Call_expression::do_lower.
Expression*
do_lower(Gogo*, Named_object*, Statement_inserter*, int);
Expression*
do_flatten(Gogo*, Named_object*, Statement_inserter*);
bool
do_is_constant() const;
bool
do_numeric_constant_value(Numeric_constant*) const;
bool
do_discarding_value();
Type*
do_type();
void
do_determine_type(const Type_context*);
void
do_check_types(Gogo*);
Expression*
do_copy();
Bexpression*
do_get_backend(Translate_context*);
void
do_export(Export_function_body*) const;
virtual bool
do_is_recover_call() const;
virtual void
do_set_recover_arg(Expression*);
private:
Expression*
one_arg() const;
bool
check_one_arg();
static Type*
real_imag_type(Type*);
static Type*
complex_type(Type*);
Expression*
lower_make(Statement_inserter*);
bool
check_int_value(Expression*, bool is_length, bool* small);
// A pointer back to the general IR structure. This avoids a global
// variable, or passing it around everywhere.
Gogo* gogo_;
// The builtin function being called.
Builtin_function_code code_;
// Used to stop endless loops when the length of an array uses len
// or cap of the array itself.
mutable bool seen_;
// Whether the argument is set for calls to BUILTIN_RECOVER.
bool recover_arg_is_set_;
};
inline Builtin_call_expression*
Call_expression::builtin_call_expression()
{
return (this->is_builtin()
? static_cast<Builtin_call_expression*>(this)
: NULL);
}
// A single result from a call which returns multiple results.
class Call_result_expression : public Expression
{
public:
Call_result_expression(Call_expression* call, unsigned int index)
: Expression(EXPRESSION_CALL_RESULT, call->location()),
call_(call), index_(index)
{ }
Expression*
call() const
{ return this->call_; }
unsigned int
index() const
{ return this->index_; }
protected:
int
do_traverse(Traverse*);
Type*
do_type();
void
do_determine_type(const Type_context*);
void
do_check_types(Gogo*);
Expression*
do_copy()
{
return new Call_result_expression(this->call_->call_expression(),
this->index_);
}
bool
do_must_eval_in_order() const
{ return true; }
Bexpression*
do_get_backend(Translate_context*);
void
do_dump_expression(Ast_dump_context*) const;
private:
// The underlying call expression.
Expression* call_;
// Which result we want.
unsigned int index_;
};
// An expression which represents a pointer to a function.
class Func_expression : public Expression
{
public:
Func_expression(Named_object* function, Expression* closure,
Location location)
: Expression(EXPRESSION_FUNC_REFERENCE, location),
function_(function), closure_(closure),
runtime_code_(Runtime::NUMBER_OF_FUNCTIONS)
{ }
// Return the object associated with the function.
Named_object*
named_object() const
{ return this->function_; }
// Return the closure for this function. This will return NULL if
// the function has no closure, which is the normal case.
Expression*
closure()
{ return this->closure_; }
// Return whether this is a reference to a runtime function.
bool
is_runtime_function() const
{ return this->runtime_code_ != Runtime::NUMBER_OF_FUNCTIONS; }
// Return the runtime code for this function expression.
// Returns Runtime::NUMBER_OF_FUNCTIONS if this is not a reference to a
// runtime function.
Runtime::Function
runtime_code() const
{ return this->runtime_code_; }
// Set the runtime code for this function expression.
void
set_runtime_code(Runtime::Function code)
{ this->runtime_code_ = code; }
// Return a backend expression for the code of a function.
static Bexpression*
get_code_pointer(Gogo*, Named_object* function, Location loc);
protected:
int
do_traverse(Traverse*);
Type*
do_type();
void
do_determine_type(const Type_context*)
{
if (this->closure_ != NULL)
this->closure_->determine_type_no_context();
}
Expression*
do_copy()
{
return Expression::make_func_reference(this->function_,
(this->closure_ == NULL
? NULL
: this->closure_->copy()),
this->location());
}
Bexpression*
do_get_backend(Translate_context*);
void
do_dump_expression(Ast_dump_context*) const;
private:
// The function itself.
Named_object* function_;
// A closure. This is normally NULL. For a nested function, it may
// be a struct holding pointers to all the variables referenced by
// this function and defined in enclosing functions.
Expression* closure_;
// The runtime code for the referenced function.
Runtime::Function runtime_code_;
};
// A function descriptor. A function descriptor is a struct with a
// single field pointing to the function code. This is used for
// functions without closures.
class Func_descriptor_expression : public Expression
{
public:
Func_descriptor_expression(Named_object* fn);
// Make the function descriptor type, so that it can be converted.
static void
make_func_descriptor_type();
protected:
int
do_traverse(Traverse*);
Type*
do_type();
void
do_determine_type(const Type_context*)
{ }
Expression*
do_copy()
{ return Expression::make_func_descriptor(this->fn_); }
bool
do_is_addressable() const
{ return true; }
Bexpression*
do_get_backend(Translate_context*);
void
do_dump_expression(Ast_dump_context* context) const;
private:
// The type of all function descriptors.
static Type* descriptor_type;
// The function for which this is the descriptor.
Named_object* fn_;
// The descriptor variable.
Bvariable* dvar_;
};
// A reference to an unknown name.
class Unknown_expression : public Parser_expression
{
public:
Unknown_expression(Named_object* named_object, Location location)
: Parser_expression(EXPRESSION_UNKNOWN_REFERENCE, location),
named_object_(named_object), no_error_message_(false),
is_composite_literal_key_(false)
{ }
// The associated named object.
Named_object*
named_object() const
{ return this->named_object_; }
// The name of the identifier which was unknown.
const std::string&
name() const;
// Call this to indicate that we should not give an error if this
// name is never defined. This is used to avoid knock-on errors
// during an erroneous parse.
void
set_no_error_message()
{ this->no_error_message_ = true; }
// Note that this expression is being used as the key in a composite
// literal, so it may be OK if it is not resolved.
void
set_is_composite_literal_key()
{ this->is_composite_literal_key_ = true; }
// Note that this expression should no longer be treated as a
// composite literal key.
void
clear_is_composite_literal_key()
{ this->is_composite_literal_key_ = false; }
protected:
Expression*
do_lower(Gogo*, Named_object*, Statement_inserter*, int);
Expression*
do_copy()
{ return new Unknown_expression(this->named_object_, this->location()); }
void
do_dump_expression(Ast_dump_context*) const;
private:
// The unknown name.
Named_object* named_object_;
// True if we should not give errors if this is undefined. This is
// used if there was a parse failure.
bool no_error_message_;
// True if this is the key in a composite literal.
bool is_composite_literal_key_;
};
// An index expression. This is lowered to an array index, a string
// index, or a map index.
class Index_expression : public Parser_expression
{
public:
Index_expression(Expression* left, Expression* start, Expression* end,
Expression* cap, Location location)
: Parser_expression(EXPRESSION_INDEX, location),
left_(left), start_(start), end_(end), cap_(cap)
{ }
// Dump an index expression, i.e. an expression of the form
// expr[expr], expr[expr:expr], or expr[expr:expr:expr] to a dump context.
static void
dump_index_expression(Ast_dump_context*, const Expression* expr,
const Expression* start, const Expression* end,
const Expression* cap);
protected:
int
do_traverse(Traverse*);
Expression*
do_lower(Gogo*, Named_object*, Statement_inserter*, int);
Expression*
do_copy()
{
return new Index_expression(this->left_->copy(), this->start_->copy(),
(this->end_ == NULL
? NULL
: this->end_->copy()),
(this->cap_ == NULL
? NULL
: this->cap_->copy()),
this->location());
}
// This shouldn't be called--we don't know yet.
bool
do_must_eval_subexpressions_in_order(int*) const
{ go_unreachable(); }
void
do_dump_expression(Ast_dump_context*) const;
void
do_issue_nil_check()
{ this->left_->issue_nil_check(); }
private:
// The expression being indexed.
Expression* left_;
// The first index.
Expression* start_;
// The second index. This is NULL for an index, non-NULL for a
// slice.
Expression* end_;
// The capacity argument. This is NULL for indices and slices that use the
// default capacity, non-NULL for indices and slices that specify the
// capacity.
Expression* cap_;
};
// An array index. This is used for both indexing and slicing.
class Array_index_expression : public Expression
{
public:
Array_index_expression(Expression* array, Expression* start,
Expression* end, Expression* cap, Location location)
: Expression(EXPRESSION_ARRAY_INDEX, location),
array_(array), start_(start), end_(end), cap_(cap), type_(NULL),
is_lvalue_(false)
{ }
// Return the array.
Expression*
array()
{ return this->array_; }
const Expression*
array() const
{ return this->array_; }
// Return the index of a simple index expression, or the start index
// of a slice expression.
Expression*
start()
{ return this->start_; }
const Expression*
start() const
{ return this->start_; }
// Return the end index of a slice expression. This is NULL for a
// simple index expression.
Expression*
end()
{ return this->end_; }
const Expression*
end() const
{ return this->end_; }
// Return whether this array index expression appears in an lvalue
// (left hand side of assignment) context.
bool
is_lvalue() const
{ return this->is_lvalue_; }
// Update this array index expression to indicate that it appears
// in a left-hand-side or lvalue context.
void
set_is_lvalue()
{ this->is_lvalue_ = true; }
protected:
int
do_traverse(Traverse*);
Expression*
do_flatten(Gogo*, Named_object*, Statement_inserter*);
Type*
do_type();
void
do_determine_type(const Type_context*);
void
do_check_types(Gogo*);
Expression*
do_copy()
{
return Expression::make_array_index(this->array_->copy(),
this->start_->copy(),
(this->end_ == NULL
? NULL
: this->end_->copy()),
(this->cap_ == NULL
? NULL
: this->cap_->copy()),
this->location());
}
bool
do_must_eval_subexpressions_in_order(int* skip) const;
bool
do_is_addressable() const;
void
do_address_taken(bool escapes);
void
do_issue_nil_check()
{ this->array_->issue_nil_check(); }
Bexpression*
do_get_backend(Translate_context*);
void
do_dump_expression(Ast_dump_context*) const;
private:
// The array we are getting a value from.
Expression* array_;
// The start or only index.
Expression* start_;
// The end index of a slice. This may be NULL for a simple array
// index, or it may be a nil expression for the length of the array.
Expression* end_;
// The capacity argument of a slice. This may be NULL for an array index or
// slice.
Expression* cap_;
// The type of the expression.
Type* type_;
// Whether expr appears in an lvalue context.
bool is_lvalue_;
};
// A string index. This is used for both indexing and slicing.
class String_index_expression : public Expression
{
public:
String_index_expression(Expression* string, Expression* start,
Expression* end, Location location)
: Expression(EXPRESSION_STRING_INDEX, location),
string_(string), start_(start), end_(end)
{ }
// Return the string being indexed.
Expression*
string() const
{ return this->string_; }
protected:
int
do_traverse(Traverse*);
Expression*
do_flatten(Gogo*, Named_object*, Statement_inserter*);
Type*
do_type();
void
do_determine_type(const Type_context*);
void
do_check_types(Gogo*);
Expression*
do_copy()
{
return Expression::make_string_index(this->string_->copy(),
this->start_->copy(),
(this->end_ == NULL
? NULL
: this->end_->copy()),
this->location());
}
bool
do_must_eval_subexpressions_in_order(int*) const
{ return true; }
Bexpression*
do_get_backend(Translate_context*);
void
do_dump_expression(Ast_dump_context*) const;
private:
// The string we are getting a value from.
Expression* string_;
// The start or only index.
Expression* start_;
// The end index of a slice. This may be NULL for a single index,
// or it may be a nil expression for the length of the string.
Expression* end_;
};
// An index into a map.
class Map_index_expression : public Expression
{
public:
Map_index_expression(Expression* map, Expression* index,
Location location)
: Expression(EXPRESSION_MAP_INDEX, location),
map_(map), index_(index), value_pointer_(NULL)
{ }
// Return the map.
Expression*
map()
{ return this->map_; }
const Expression*
map() const
{ return this->map_; }
// Return the index.
Expression*
index()
{ return this->index_; }
const Expression*
index() const
{ return this->index_; }
// Get the type of the map being indexed.
Map_type*
get_map_type() const;
// Return an expression for the map index. This returns an
// expression that evaluates to a pointer to a value in the map. If
// the key is not present in the map, this will return a pointer to
// the zero value.
Expression*
get_value_pointer(Gogo*);