Subversion Repositories openrisc

// 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 <gmp.h>

#include <mpfr.h>

#include "operator.h"

class Gogo;

class Translate_context;

class Traverse;

class Statement_inserter;

class Type;

struct Type_context;

class Function_type;

class Map_type;

class Struct_type;

class Struct_field;

class Expression_list;

class Var_expression;

class Temporary_reference_expression;

class Set_and_use_temporary_expression;

class String_expression;

class Binary_expression;

class Call_expression;

class Func_expression;

class Unknown_expression;

class Index_expression;

class Map_index_expression;

class Bound_method_expression;

class Field_reference_expression;

class Interface_field_reference_expression;

class Type_guard_expression;

class Receive_expression;

class Named_object;

class Export;

class Import;

class Temporary_statement;

class Label;

class Ast_dump_context;

class String_dump;

// 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_CONST_REFERENCE,

    EXPRESSION_VAR_REFERENCE,

    EXPRESSION_TEMPORARY_REFERENCE,

    EXPRESSION_SET_AND_USE_TEMPORARY,

    EXPRESSION_SINK,

    EXPRESSION_FUNC_REFERENCE,

    EXPRESSION_UNKNOWN_REFERENCE,

    EXPRESSION_BOOLEAN,

    EXPRESSION_STRING,

    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_OPEN_ARRAY_CONSTRUCTION,

    EXPRESSION_MAP_CONSTRUCTION,

    EXPRESSION_COMPOSITE_LITERAL,

    EXPRESSION_HEAP_COMPOSITE,

    EXPRESSION_RECEIVE,

    EXPRESSION_TYPE_DESCRIPTOR,

    EXPRESSION_TYPE_INFO,

    EXPRESSION_STRUCT_FIELD_OFFSET,

    EXPRESSION_MAP_DESCRIPTOR,

    EXPRESSION_LABEL_ADDR

  };

  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 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 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.

  static Expression*

  make_func_reference(Named_object*, Expression* closure, 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 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.  TYPE should be NULL for an

  // abstract type.

  static Expression*

  make_integer(const mpz_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 mpfr_t* real, const mpfr_t* imag, 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.

  static Bound_method_expression*

  make_bound_method(Expression* object, Named_object* method, Location);

  // Make an index or slice expression.  This is a parser expression

  // which represents LEFT[START:END].  END may be NULL, meaning an

  // index rather than a slice.  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,

             Location);

  // Make an array index expression.  END may be NULL, in which case

  // this is an lvalue.

  static Expression*

  make_array_index(Expression* array, Expression* start, Expression* end,

                   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.

  static Expression*

  make_composite_literal(Type*, int depth, bool has_keys, Expression_list*,

                         Location);

  // Make a struct composite literal.

  static Expression*

  make_struct_composite_literal(Type*, Expression_list*, Location);

  // Make a slice composite literal.

  static Expression*

  make_slice_composite_literal(Type*, Expression_list*, Location);

  // Take a composite literal and allocate it on the heap.

  static Expression*

  make_heap_composite(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 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

    };

  static Expression*

  make_type_info(Type* type, Type_info);

  // 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 the map

  // descriptor for TYPE.

  static Expression*

  make_map_descriptor(Map_type* type, Location);

  // Make an expression which evaluates to the address of an unnamed

  // label.

  static Expression*

  make_label_addr(Label*, 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(); }

  // If this is not a constant expression with integral type, return

  // false.  If it is one, return true, and set VAL to the value.  VAL

  // should already be initialized.  If this returns true, it sets

  // *PTYPE to the type of the value, or NULL for an abstract type.

  // If IOTA_IS_CONSTANT is true, then an iota expression is assumed

  // to have its final value.

  bool

  integer_constant_value(bool iota_is_constant, mpz_t val, Type** ptype) const;

  // If this is not a constant expression with floating point type,

  // return false.  If it is one, return true, and set VAL to the

  // value.  VAL should already be initialized.  If this returns true,

  // it sets *PTYPE to the type of the value, or NULL for an abstract

  // type.

  bool

  float_constant_value(mpfr_t val, Type** ptype) const;

  // If this is not a constant expression with complex type, return

  // false.  If it is one, return true, and set REAL and IMAG to the

  // value.  REAL and IMAG should already be initialized.  If this

  // return strue, it sets *PTYPE to the type of the value, or NULL

  // for an abstract type.

  bool

  complex_constant_value(mpfr_t real, mpfr_t imag, Type** ptype) const;

  // 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.

  void

  discarding_value()

  { 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 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>(); }

  // 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 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 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 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 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 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 receive expression, return the Receive_expression

  // structure.  Otherwise, return NULL.

  Receive_expression*

  receive_expression()

  { return this->convert<Receive_expression, EXPRESSION_RECEIVE>(); }

  // 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 reference to a local variable.

  bool

  is_local_variable() const;

  // 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); }

  // 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 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); }

  // 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 tree for this expression.

  tree

  get_tree(Translate_context*);

  // Return a tree handling any conversions which must be done during

  // assignment.

  static tree

  convert_for_assignment(Translate_context*, Type* lhs_type, Type* rhs_type,

                         tree rhs_tree, Location location);

  // Return a tree converting a value of one interface type to another

  // interface type.  If FOR_TYPE_GUARD is true this is for a type

  // assertion.

  static tree

  convert_interface_to_interface(Translate_context*, Type* lhs_type,

                                 Type* rhs_type, tree rhs_tree,

                                 bool for_type_guard, Location);

  // Return a tree implementing the comparison LHS_TREE OP RHS_TREE.

  // TYPE is the type of both sides.

  static tree

  comparison_tree(Translate_context*, Operator op, Type* left_type,

                  tree left_tree, Type* right_type, tree right_tree,

                  Location);

  // Return a tree for the multi-precision integer VAL in TYPE.

  static tree

  integer_constant_tree(mpz_t val, tree type);

  // Return a tree for the floating point value VAL in TYPE.

  static tree

  float_constant_tree(mpfr_t val, tree type);

  // Return a tree for the complex value REAL/IMAG in TYPE.

  static tree

  complex_constant_tree(mpfr_t real, mpfr_t imag, tree type);

  // Export the expression.  This is only used for constants.  It will

  // be used for things like values of named constants and sizes of

  // arrays.

  void

  export_expression(Export* exp) const

  { this->do_export(exp); }

  // Import an expression.

  static Expression*

  import_expression(Import*);

  // Return a tree which checks that VAL, of arbitrary integer type,

  // is non-negative and is not more than the maximum value of

  // BOUND_TYPE.  If SOFAR is not NULL, it is or'red into the result.

  // The return value may be NULL if SOFAR is NULL.

  static tree

  check_bounds(tree val, tree bound_type, tree sofar, 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 whether this is a constant expression.

  virtual bool

  do_is_constant() const

  { return false; }

  // Return whether this is a constant expression of integral type,

  // and set VAL to the value.

  virtual bool

  do_integer_constant_value(bool, mpz_t, Type**) const

  { return false; }

  // Return whether this is a constant expression of floating point

  // type, and set VAL to the value.

  virtual bool

  do_float_constant_value(mpfr_t, Type**) const

  { return false; }

  // Return whether this is a constant expression of complex type, and

  // set REAL and IMAGE to the value.

  virtual bool

  do_complex_constant_value(mpfr_t, mpfr_t, Type**) 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 void

  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 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 whether this expression must be evaluated