blob: b6011053e695dfebea7eccd8fe954e67bd91e548 [file] [log] [blame]
// 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
#include <gmp.h>
#include <mpfr.h>
#include <mpc.h>
#include "operator.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 or declaration.
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(Linemap::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. This should return
// not the type of a Go function (which is a pointer to a struct)
// but the type of a C function pointer (which will be used as the
// type of the first field of the struct). If there is more than
// one result, RESULT_STRUCT is a struct type to hold the results,
// and RESULTS may be ignored; if there are zero or one results,
// RESULT_STRUCT is NULL.
virtual Btype*
function_type(const Btyped_identifier& receiver,
const std::vector<Btyped_identifier>& parameters,
const std::vector<Btyped_identifier>& results,
Btype* result_struct,
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 C
// pointer to function type. A Go func type is represented as a
// pointer to a struct, and the first field of the struct is a C
// pointer to function. 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 int64_t
type_size(Btype*) = 0;
// Return the alignment of a type.
virtual int64_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 int64_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 int64_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;
// Create an error expression. This is used for cases which should
// not occur in a correct program, in order to keep the compilation
// going without crashing.
virtual Bexpression*
error_expression() = 0;
// Create a nil pointer expression.
virtual Bexpression*
nil_pointer_expression() = 0;
// Create a reference to a variable.
virtual Bexpression*
var_expression(Bvariable* var, Location) = 0;
// Create an expression that indirects through the pointer expression EXPR
// (i.e., return the expression for *EXPR). KNOWN_VALID is true if the pointer
// is known to point to a valid memory location. BTYPE is the expected type
// of the indirected EXPR.
virtual Bexpression*
indirect_expression(Btype* btype, Bexpression* expr, bool known_valid,
Location) = 0;
// Return an expression that declares a constant named NAME with the
// constant value VAL in BTYPE.
virtual Bexpression*
named_constant_expression(Btype* btype, const std::string& name,
Bexpression* val, Location) = 0;
// Return an expression for the multi-precision integer VAL in BTYPE.
virtual Bexpression*
integer_constant_expression(Btype* btype, mpz_t val) = 0;
// Return an expression for the floating point value VAL in BTYPE.
virtual Bexpression*
float_constant_expression(Btype* btype, mpfr_t val) = 0;
// Return an expression for the complex value VAL in BTYPE.
virtual Bexpression*
complex_constant_expression(Btype* btype, mpc_t val) = 0;
// Return an expression for the string value VAL.
virtual Bexpression*
string_constant_expression(const std::string& val) = 0;
// Return an expression for the boolean value VAL.
virtual Bexpression*
boolean_constant_expression(bool val) = 0;
// Return an expression for the real part of BCOMPLEX.
virtual Bexpression*
real_part_expression(Bexpression* bcomplex, Location) = 0;
// Return an expression for the imaginary part of BCOMPLEX.
virtual Bexpression*
imag_part_expression(Bexpression* bcomplex, Location) = 0;
// Return an expression for the complex number (BREAL, BIMAG).
virtual Bexpression*
complex_expression(Bexpression* breal, Bexpression* bimag, Location) = 0;
// Return an expression that converts EXPR to TYPE.
virtual Bexpression*
convert_expression(Btype* type, Bexpression* expr, Location) = 0;
// Create an expression for the address of a function. This is used to
// get the address of the code for a function.
virtual Bexpression*
function_code_expression(Bfunction*, Location) = 0;
// Create an expression that takes the address of an expression.
virtual Bexpression*
address_expression(Bexpression*, Location) = 0;
// Return an expression for the field at INDEX in BSTRUCT.
virtual Bexpression*
struct_field_expression(Bexpression* bstruct, size_t index, Location) = 0;
// Create an expression that executes BSTAT before BEXPR.
virtual Bexpression*
compound_expression(Bstatement* bstat, Bexpression* bexpr, Location) = 0;
// Return an expression that executes THEN_EXPR if CONDITION is true, or
// ELSE_EXPR otherwise and returns the result as type BTYPE, within the
// specified function FUNCTION. ELSE_EXPR may be NULL. BTYPE may be NULL.
virtual Bexpression*
conditional_expression(Bfunction* function, Btype* btype,
Bexpression* condition, Bexpression* then_expr,
Bexpression* else_expr, Location) = 0;
// Return an expression for the unary operation OP EXPR.
// Supported values of OP are (from operators.h):
// MINUS, NOT, XOR.
virtual Bexpression*
unary_expression(Operator op, Bexpression* expr, Location) = 0;
// Return an expression for the binary operation LEFT OP RIGHT.
// Supported values of OP are (from operators.h):
// EQEQ, NOTEQ, LT, LE, GT, GE, PLUS, MINUS, OR, XOR, MULT, DIV, MOD,
// LSHIFT, RSHIFT, AND, NOT.
virtual Bexpression*
binary_expression(Operator op, Bexpression* left, Bexpression* right,
Location) = 0;
// Return an expression that constructs BTYPE with VALS. BTYPE must be the
// backend representation a of struct. VALS must be in the same order as the
// corresponding fields in BTYPE.
virtual Bexpression*
constructor_expression(Btype* btype, const std::vector<Bexpression*>& vals,
Location) = 0;
// Return an expression that constructs an array of BTYPE with INDEXES and
// VALS. INDEXES and VALS must have the same amount of elements. Each index
// in INDEXES must be in the same order as the corresponding value in VALS.
virtual Bexpression*
array_constructor_expression(Btype* btype,
const std::vector<unsigned long>& indexes,
const std::vector<Bexpression*>& vals,
Location) = 0;
// Return an expression for the address of BASE[INDEX].
// BASE has a pointer type. This is used for slice indexing.
virtual Bexpression*
pointer_offset_expression(Bexpression* base, Bexpression* index,
Location) = 0;
// Return an expression for ARRAY[INDEX] as an l-value. ARRAY is a valid
// fixed-length array, not a slice.
virtual Bexpression*
array_index_expression(Bexpression* array, Bexpression* index, Location) = 0;
// Create an expression for a call to FN with ARGS, taking place within
// caller CALLER.
virtual Bexpression*
call_expression(Bfunction *caller, Bexpression* fn,
const std::vector<Bexpression*>& args,
Bexpression* static_chain, Location) = 0;
// Return an expression that allocates SIZE bytes on the stack.
virtual Bexpression*
stack_allocation_expression(int64_t size, Location) = 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 within the specified function.
virtual Bstatement*
expression_statement(Bfunction*, Bexpression*) = 0;
// Create a variable initialization statement in the specified
// function. This initializes a local variable at the point in the
// program flow where it is declared.
virtual Bstatement*
init_statement(Bfunction*, Bvariable* var, Bexpression* init) = 0;
// Create an assignment statement within the specified function.
virtual Bstatement*
assignment_statement(Bfunction*, 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 within a function. ELSE_BLOCK may be NULL.
virtual Bstatement*
if_statement(Bfunction*, 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. FUNCTION is the current function.
virtual Bstatement*
switch_statement(Bfunction* function, 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;
// Create a statement that attempts to execute BSTAT and calls EXCEPT_STMT if
// an exception occurs. EXCEPT_STMT may be NULL. FINALLY_STMT may be NULL and
// if not NULL, it will always be executed. This is used for handling defers
// in Go functions. In C++, the resulting code is of this form:
// try { BSTAT; } catch { EXCEPT_STMT; } finally { FINALLY_STMT; }
virtual Bstatement*
exception_handler_statement(Bstatement* bstat, Bstatement* except_stmt,
Bstatement* finally_stmt, Location) = 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. NAME is the package-qualified name of
// the variable. ASM_NAME is the encoded identifier for the
// variable, incorporating the package, and made safe for the
// assembler. 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& name,
const std::string& asm_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. DECL_VAR, if not
// null, gives the location at which the value of this variable may
// be found, typically used to create an inner-scope reference to an
// outer-scope variable, to extend the lifetime of the variable beyond
// the inner scope. 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,
Bvariable* decl_var, 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 static chain parameter. This is the closure parameter.
virtual Bvariable*
static_chain_variable(Bfunction* function, const std::string& name,
Btype* type, 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 an implicit variable that is compiler-defined. This is
// used when generating GC data and roots, when storing the values
// of a slice constructor, and for the zero value of types. This returns a
// Bvariable because it corresponds to an initialized variable in C.
//
// NAME is the name to use for the initialized variable this will create.
//
// ASM_NAME is encoded assembler-friendly version of the name, or the
// empty string if no encoding is needed.
//
// TYPE is the type of the implicit variable.
//
// IS_HIDDEN will be true if the descriptor should only be visible
// within the current object.
//
// IS_CONSTANT is true if the implicit variable should be treated like it is
// immutable. For slice initializers, if the values must be copied to the
// heap, the variable IS_CONSTANT.
//
// IS_COMMON is true if the implicit variable should
// be treated as a common variable (multiple definitions with
// different sizes permitted in different object files, all merged
// into the largest definition at link time); this will be true for
// the zero value. IS_HIDDEN and IS_COMMON will never both be true.
//
// If ALIGNMENT is not zero, it is the desired alignment of the variable.
virtual Bvariable*
implicit_variable(const std::string& name, const std::string& asm_name,
Btype* type, bool is_hidden, bool is_constant,
bool is_common, int64_t alignment) = 0;
// Set the initial value of a variable created by implicit_variable.
// This must be called even if there is no initializer, i.e., INIT is NULL.
// The NAME, TYPE, IS_HIDDEN, IS_CONSTANT, and IS_COMMON parameters are
// the same ones passed to implicit_variable. INIT will be a composite
// literal of type TYPE. It will not contain any function calls or anything
// else that can not be put into a read-only data section.
// It may contain the address of variables created by implicit_variable.
//
// If IS_COMMON is true, INIT will be NULL, and the
// variable should be initialized to all zeros.
virtual void
implicit_variable_set_init(Bvariable*, const std::string& name, Btype* type,
bool is_hidden, bool is_constant, bool is_common,
Bexpression* init) = 0;
// Create a reference to a named implicit variable defined in some
// other package. This will be a variable created by a call to
// implicit_variable with the same NAME, ASM_NAME and TYPE and with
// IS_COMMON passed as false. This corresponds to an extern global
// variable in C.
virtual Bvariable*
implicit_variable_reference(const std::string& name,
const std::string& asm_name,
Btype* type) = 0;
// Create a named immutable initialized data structure. This is
// used for type descriptors, map descriptors, and function
// descriptors. This returns a Bvariable because it corresponds to
// an initialized const variable in C.
//
// NAME is the name to use for the initialized global variable which
// this call will create.
//
// ASM_NAME is the encoded, assembler-friendly version of NAME, or
// the empty string if no encoding is needed.
//
// IS_HIDDEN will be true if the descriptor should only be visible
// within the current object.
//
// 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. IS_HIDDEN and IS_COMMON will never both be
// true.
//
// 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,
const std::string& asm_name,
bool is_hidden, bool is_common,
Btype* type, Location) = 0;
// Set the initial value of a variable created by immutable_struct.
// The NAME, IS_HIDDEN, 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 that 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_hidden, 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, ASM_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,
const std::string& asm_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 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;
// Functions.
// Create an error function. This is used for cases which should
// not occur in a correct program, in order to keep the compilation
// going without crashing.
virtual Bfunction*
error_function() = 0;
// Declare or define a function of FNTYPE.
// NAME is the Go name of the function. ASM_NAME, if not the empty string, is
// the name that should be used in the symbol table; this will be non-empty if
// a magic extern comment is used.
// IS_VISIBLE is true if this function should be visible outside of the
// current compilation unit. IS_DECLARATION is true if this is a function
// declaration rather than a definition; the function definition will be in
// another compilation unit.
// IS_INLINABLE is true if the function can be inlined.
// DISABLE_SPLIT_STACK is true if this function may not split the stack; this
// is used for the implementation of recover.
// DOES_NOT_RETURN is true for a function that does not return; this is used
// for the implementation of panic.
// IN_UNIQUE_SECTION is true if this function should be put into a unique
// location if possible; this is used for field tracking.
virtual Bfunction*
function(Btype* fntype, const std::string& name, const std::string& asm_name,
bool is_visible, bool is_declaration, bool is_inlinable,
bool disable_split_stack, bool does_not_return,
bool in_unique_section, Location) = 0;
// Create a statement that runs all deferred calls for FUNCTION. This should
// be a statement that looks like this in C++:
// finish:
// try { DEFER_RETURN; } catch { CHECK_DEFER; goto finish; }
virtual Bstatement*
function_defer_statement(Bfunction* function, Bexpression* undefer,
Bexpression* check_defer, Location) = 0;
// Record PARAM_VARS as the variables to use for the parameters of FUNCTION.
// This will only be called for a function definition. Returns true on
// success, false on failure.
virtual bool
function_set_parameters(Bfunction* function,
const std::vector<Bvariable*>& param_vars) = 0;
// Set the function body for FUNCTION using the code in CODE_STMT. Returns
// true on success, false on failure.
virtual bool
function_set_body(Bfunction* function, Bstatement* code_stmt) = 0;
// Look up a named built-in function in the current backend implementation.
// Returns NULL if no built-in function by that name exists.
virtual Bfunction*
lookup_builtin(const std::string&) = 0;
// Utility.
// Write the definitions for all TYPE_DECLS, CONSTANT_DECLS,
// FUNCTION_DECLS, and VARIABLE_DECLS declared globally.
virtual void
write_global_definitions(const std::vector<Btype*>& type_decls,
const std::vector<Bexpression*>& constant_decls,
const std::vector<Bfunction*>& function_decls,
const std::vector<Bvariable*>& variable_decls) = 0;
// Write SIZE bytes of export data from BYTES to the proper
// section in the output object file.
virtual void
write_export_data(const char* bytes, unsigned int size) = 0;
};
#endif // !defined(GO_BACKEND_H)