diff options
Diffstat (limited to 'gcc-4.8.1/gcc/go/gofrontend/backend.h')
| -rw-r--r-- | gcc-4.8.1/gcc/go/gofrontend/backend.h | 479 |
1 files changed, 0 insertions, 479 deletions
diff --git a/gcc-4.8.1/gcc/go/gofrontend/backend.h b/gcc-4.8.1/gcc/go/gofrontend/backend.h deleted file mode 100644 index fe6db743c..000000000 --- a/gcc-4.8.1/gcc/go/gofrontend/backend.h +++ /dev/null @@ -1,479 +0,0 @@ -// backend.h -- Go frontend interface to backend -*- C++ -*- - -// Copyright 2011 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_BACKEND_H -#define GO_BACKEND_H - -// Pointers to these types are created by the backend, passed to the -// frontend, and passed back to the backend. The types must be -// defined by the backend using these names. - -// The backend representation of a type. -class Btype; - -// The backend represention of an expression. -class Bexpression; - -// The backend representation of a statement. -class Bstatement; - -// The backend representation of a function definition. -class Bfunction; - -// The backend representation of a block. -class Bblock; - -// The backend representation of a variable. -class Bvariable; - -// The backend representation of a label. -class Blabel; - -// The backend interface. This is a pure abstract class that a -// specific backend will implement. - -class Backend -{ - public: - virtual ~Backend() { } - - // Name/type/location. Used for function parameters, struct fields, - // interface methods. - struct Btyped_identifier - { - std::string name; - Btype* btype; - Location location; - - Btyped_identifier() - : name(), btype(NULL), location(UNKNOWN_LOCATION) - { } - - Btyped_identifier(const std::string& a_name, Btype* a_btype, - Location a_location) - : name(a_name), btype(a_btype), location(a_location) - { } - }; - - // Types. - - // Produce an error type. Actually the backend could probably just - // crash if this is called. - virtual Btype* - error_type() = 0; - - // Get a void type. This is used in (at least) two ways: 1) as the - // return type of a function with no result parameters; 2) - // unsafe.Pointer is represented as *void. - virtual Btype* - void_type() = 0; - - // Get the unnamed boolean type. - virtual Btype* - bool_type() = 0; - - // Get an unnamed integer type with the given signedness and number - // of bits. - virtual Btype* - integer_type(bool is_unsigned, int bits) = 0; - - // Get an unnamed floating point type with the given number of bits - // (32 or 64). - virtual Btype* - float_type(int bits) = 0; - - // Get an unnamed complex type with the given number of bits (64 or 128). - virtual Btype* - complex_type(int bits) = 0; - - // Get a pointer type. - virtual Btype* - pointer_type(Btype* to_type) = 0; - - // Get a function type. The receiver, parameter, and results are - // generated from the types in the Function_type. The Function_type - // is provided so that the names are available. - virtual Btype* - function_type(const Btyped_identifier& receiver, - const std::vector<Btyped_identifier>& parameters, - const std::vector<Btyped_identifier>& results, - Location location) = 0; - - // Get a struct type. - virtual Btype* - struct_type(const std::vector<Btyped_identifier>& fields) = 0; - - // Get an array type. - virtual Btype* - array_type(Btype* element_type, Bexpression* length) = 0; - - // Create a placeholder pointer type. This is used for a named - // pointer type, since in Go a pointer type may refer to itself. - // NAME is the name of the type, and the location is where the named - // type is defined. This function is also used for unnamed function - // types with multiple results, in which case the type has no name - // and NAME will be empty. FOR_FUNCTION is true if this is for a Go - // function type, which corresponds to a C/C++ pointer to function - // type. The return value will later be passed as the first - // parameter to set_placeholder_pointer_type or - // set_placeholder_function_type. - virtual Btype* - placeholder_pointer_type(const std::string& name, Location, - bool for_function) = 0; - - // Fill in a placeholder pointer type as a pointer. This takes a - // type returned by placeholder_pointer_type and arranges for it to - // point to the type that TO_TYPE points to (that is, PLACEHOLDER - // becomes the same type as TO_TYPE). Returns true on success, - // false on failure. - virtual bool - set_placeholder_pointer_type(Btype* placeholder, Btype* to_type) = 0; - - // Fill in a placeholder pointer type as a function. This takes a - // type returned by placeholder_pointer_type and arranges for it to - // become a real Go function type (which corresponds to a C/C++ - // pointer to function type). FT will be something returned by the - // function_type method. Returns true on success, false on failure. - virtual bool - set_placeholder_function_type(Btype* placeholder, Btype* ft) = 0; - - // Create a placeholder struct type. This is used for a named - // struct type, as with placeholder_pointer_type. It is also used - // for interface types, in which case NAME will be the empty string. - virtual Btype* - placeholder_struct_type(const std::string& name, Location) = 0; - - // Fill in a placeholder struct type. This takes a type returned by - // placeholder_struct_type and arranges for it to become a real - // struct type. The parameter is as for struct_type. Returns true - // on success, false on failure. - virtual bool - set_placeholder_struct_type(Btype* placeholder, - const std::vector<Btyped_identifier>& fields) - = 0; - - // Create a placeholder array type. This is used for a named array - // type, as with placeholder_pointer_type, to handle cases like - // type A []*A. - virtual Btype* - placeholder_array_type(const std::string& name, Location) = 0; - - // Fill in a placeholder array type. This takes a type returned by - // placeholder_array_type and arranges for it to become a real array - // type. The parameters are as for array_type. Returns true on - // success, false on failure. - virtual bool - set_placeholder_array_type(Btype* placeholder, Btype* element_type, - Bexpression* length) = 0; - - // Return a named version of a type. The location is the location - // of the type definition. This will not be called for a type - // created via placeholder_pointer_type, placeholder_struct_type, or - // placeholder_array_type.. (It may be called for a pointer, - // struct, or array type in a case like "type P *byte; type Q P".) - virtual Btype* - named_type(const std::string& name, Btype*, Location) = 0; - - // Create a marker for a circular pointer type. Go pointer and - // function types can refer to themselves in ways that are not - // permitted in C/C++. When a circular type is found, this function - // is called for the circular reference. This permits the backend - // to decide how to handle such a type. PLACEHOLDER is the - // placeholder type which has already been created; if the backend - // is prepared to handle a circular pointer type, it may simply - // return PLACEHOLDER. FOR_FUNCTION is true if this is for a - // function type. - // - // For "type P *P" the sequence of calls will be - // bt1 = placeholder_pointer_type(); - // bt2 = circular_pointer_type(bt1, false); - // set_placeholder_pointer_type(bt1, bt2); - virtual Btype* - circular_pointer_type(Btype* placeholder, bool for_function) = 0; - - // Return whether the argument could be a special type created by - // circular_pointer_type. This is used to introduce explicit type - // conversions where needed. If circular_pointer_type returns its - // PLACEHOLDER parameter, this may safely always return false. - virtual bool - is_circular_pointer_type(Btype*) = 0; - - // Return the size of a type. - virtual size_t - type_size(Btype*) = 0; - - // Return the alignment of a type. - virtual size_t - type_alignment(Btype*) = 0; - - // Return the alignment of a struct field of this type. This is - // normally the same as type_alignment, but not always. - virtual size_t - type_field_alignment(Btype*) = 0; - - // Return the offset of field INDEX in a struct type. INDEX is the - // entry in the FIELDS std::vector parameter of struct_type or - // set_placeholder_struct_type. - virtual size_t - type_field_offset(Btype*, size_t index) = 0; - - // Expressions. - - // Return an expression for a zero value of the given type. This is - // used for cases such as local variable initialization and - // converting nil to other types. - virtual Bexpression* - zero_expression(Btype*) = 0; - - // Statements. - - // Create an error statement. This is used for cases which should - // not occur in a correct program, in order to keep the compilation - // going without crashing. - virtual Bstatement* - error_statement() = 0; - - // Create an expression statement. - virtual Bstatement* - expression_statement(Bexpression*) = 0; - - // Create a variable initialization statement. This initializes a - // local variable at the point in the program flow where it is - // declared. - virtual Bstatement* - init_statement(Bvariable* var, Bexpression* init) = 0; - - // Create an assignment statement. - virtual Bstatement* - assignment_statement(Bexpression* lhs, Bexpression* rhs, - Location) = 0; - - // Create a return statement, passing the representation of the - // function and the list of values to return. - virtual Bstatement* - return_statement(Bfunction*, const std::vector<Bexpression*>&, - Location) = 0; - - // Create an if statement. ELSE_BLOCK may be NULL. - virtual Bstatement* - if_statement(Bexpression* condition, Bblock* then_block, Bblock* else_block, - Location) = 0; - - // Create a switch statement where the case values are constants. - // CASES and STATEMENTS must have the same number of entries. If - // VALUE matches any of the list in CASES[i], which will all be - // integers, then STATEMENTS[i] is executed. STATEMENTS[i] will - // either end with a goto statement or will fall through into - // STATEMENTS[i + 1]. CASES[i] is empty for the default clause, - // which need not be last. - virtual Bstatement* - switch_statement(Bexpression* value, - const std::vector<std::vector<Bexpression*> >& cases, - const std::vector<Bstatement*>& statements, - Location) = 0; - - // Create a single statement from two statements. - virtual Bstatement* - compound_statement(Bstatement*, Bstatement*) = 0; - - // Create a single statement from a list of statements. - virtual Bstatement* - statement_list(const std::vector<Bstatement*>&) = 0; - - // Blocks. - - // Create a block. The frontend will call this function when it - // starts converting a block within a function. FUNCTION is the - // current function. ENCLOSING is the enclosing block; it will be - // NULL for the top-level block in a function. VARS is the list of - // local variables defined within this block; each entry will be - // created by the local_variable function. START_LOCATION is the - // location of the start of the block, more or less the location of - // the initial curly brace. END_LOCATION is the location of the end - // of the block, more or less the location of the final curly brace. - // The statements will be added after the block is created. - virtual Bblock* - block(Bfunction* function, Bblock* enclosing, - const std::vector<Bvariable*>& vars, - Location start_location, Location end_location) = 0; - - // Add the statements to a block. The block is created first. Then - // the statements are created. Then the statements are added to the - // block. This will called exactly once per block. The vector may - // be empty if there are no statements. - virtual void - block_add_statements(Bblock*, const std::vector<Bstatement*>&) = 0; - - // Return the block as a statement. This is used to include a block - // in a list of statements. - virtual Bstatement* - block_statement(Bblock*) = 0; - - // Variables. - - // Create an error variable. This is used for cases which should - // not occur in a correct program, in order to keep the compilation - // going without crashing. - virtual Bvariable* - error_variable() = 0; - - // Create a global variable. PACKAGE_NAME is the name of the - // package where the variable is defined. PKGPATH is the package - // path for that package, from the -fgo-pkgpath or -fgo-prefix - // option. NAME is the name of the variable. BTYPE is the type of - // the variable. IS_EXTERNAL is true if the variable is defined in - // some other package. IS_HIDDEN is true if the variable is not - // exported (name begins with a lower case letter). - // IN_UNIQUE_SECTION is true if the variable should be put into a - // unique section if possible; this is intended to permit the linker - // to garbage collect the variable if it is not referenced. - // LOCATION is where the variable was defined. - virtual Bvariable* - global_variable(const std::string& package_name, - const std::string& pkgpath, - const std::string& name, - Btype* btype, - bool is_external, - bool is_hidden, - bool in_unique_section, - Location location) = 0; - - // A global variable will 1) be initialized to zero, or 2) be - // initialized to a constant value, or 3) be initialized in the init - // function. In case 2, the frontend will call - // global_variable_set_init to set the initial value. If this is - // not called, the backend should initialize a global variable to 0. - // The init function may then assign a value to it. - virtual void - global_variable_set_init(Bvariable*, Bexpression*) = 0; - - // Create a local variable. The frontend will create the local - // variables first, and then create the block which contains them. - // FUNCTION is the function in which the variable is defined. NAME - // is the name of the variable. TYPE is the type. IS_ADDRESS_TAKEN - // is true if the address of this variable is taken (this implies - // that the address does not escape the function, as otherwise the - // variable would be on the heap). LOCATION is where the variable - // is defined. For each local variable the frontend will call - // init_statement to set the initial value. - virtual Bvariable* - local_variable(Bfunction* function, const std::string& name, Btype* type, - bool is_address_taken, Location location) = 0; - - // Create a function parameter. This is an incoming parameter, not - // a result parameter (result parameters are treated as local - // variables). The arguments are as for local_variable. - virtual Bvariable* - parameter_variable(Bfunction* function, const std::string& name, - Btype* type, bool is_address_taken, - Location location) = 0; - - // Create a temporary variable. A temporary variable has no name, - // just a type. We pass in FUNCTION and BLOCK in case they are - // needed. If INIT is not NULL, the variable should be initialized - // to that value. Otherwise the initial value is irrelevant--the - // backend does not have to explicitly initialize it to zero. - // ADDRESS_IS_TAKEN is true if the programs needs to take the - // address of this temporary variable. LOCATION is the location of - // the statement or expression which requires creating the temporary - // variable, and may not be very useful. This function should - // return a variable which can be referenced later and should set - // *PSTATEMENT to a statement which initializes the variable. - virtual Bvariable* - temporary_variable(Bfunction*, Bblock*, Btype*, Bexpression* init, - bool address_is_taken, Location location, - Bstatement** pstatement) = 0; - - // Create a named immutable initialized data structure. This is - // used for type descriptors and map descriptors. This returns a - // Bvariable because it corresponds to an initialized const global - // variable in C. - // - // NAME is the name to use for the initialized global variable which - // this call will create. - // - // IS_COMMON is true if NAME may be defined by several packages, and - // the linker should merge all such definitions. If IS_COMMON is - // false, NAME should be defined in only one file. In general - // IS_COMMON will be true for the type descriptor of an unnamed type - // or a builtin type. - // - // TYPE will be a struct type; the type of the returned expression - // must be a pointer to this struct type. - // - // We must create the named structure before we know its - // initializer, because the initializer may refer to its own - // address. After calling this the frontend will call - // immutable_struct_set_init. - virtual Bvariable* - immutable_struct(const std::string& name, bool is_common, Btype* type, - Location) = 0; - - // Set the initial value of a variable created by immutable_struct. - // The NAME, IS_COMMON, TYPE, and location parameters are the same - // ones passed to immutable_struct. INITIALIZER will be a composite - // literal of type TYPE. It will not contain any function calls or - // anything else which can not be put into a read-only data section. - // It may contain the address of variables created by - // immutable_struct. - virtual void - immutable_struct_set_init(Bvariable*, const std::string& name, - bool is_common, Btype* type, Location, - Bexpression* initializer) = 0; - - // Create a reference to a named immutable initialized data - // structure defined in some other package. This will be a - // structure created by a call to immutable_struct with the same - // NAME and TYPE and with IS_COMMON passed as false. This - // corresponds to an extern const global variable in C. - virtual Bvariable* - immutable_struct_reference(const std::string& name, Btype* type, - Location) = 0; - - // Labels. - - // Create a new label. NAME will be empty if this is a label - // created by the frontend for a loop construct. The location is - // where the the label is defined. - virtual Blabel* - label(Bfunction*, const std::string& name, Location) = 0; - - // Create a statement which defines a label. This statement will be - // put into the codestream at the point where the label should be - // defined. - virtual Bstatement* - label_definition_statement(Blabel*) = 0; - - // Create a goto statement to a label. - virtual Bstatement* - goto_statement(Blabel*, Location) = 0; - - // Create an expression for the address of a label. This is used to - // get the return address of a deferred function which may call - // recover. - virtual Bexpression* - label_address(Blabel*, Location) = 0; -}; - -// The backend interface has to define this function. - -extern Backend* go_get_backend(); - -// FIXME: Temporary helper functions while converting to new backend -// interface. - -extern Btype* tree_to_type(tree); -extern Bexpression* tree_to_expr(tree); -extern Bstatement* tree_to_stat(tree); -extern Bfunction* tree_to_function(tree); -extern Bblock* tree_to_block(tree); -extern tree type_to_tree(Btype*); -extern tree expr_to_tree(Bexpression*); -extern tree stat_to_tree(Bstatement*); -extern tree block_to_tree(Bblock*); -extern tree var_to_tree(Bvariable*); - -#endif // !defined(GO_BACKEND_H) |