1 // backend.h -- Go frontend interface to backend -*- C++ -*-
3 // Copyright 2011 The Go Authors. All rights reserved.
4 // Use of this source code is governed by a BSD-style
5 // license that can be found in the LICENSE file.
10 // Pointers to these types are created by the backend, passed to the
11 // frontend, and passed back to the backend. The types must be
12 // defined by the backend using these names.
14 // The backend representation of a type.
17 // The backend represention of an expression.
20 // The backend representation of a statement.
23 // The backend representation of a function definition.
26 // The backend representation of a block.
29 // The backend representation of a variable.
32 // The backend representation of a label.
35 // The backend interface. This is a pure abstract class that a
36 // specific backend will implement.
41 virtual ~Backend() { }
43 // Name/type/location. Used for function parameters, struct fields,
45 struct Btyped_identifier
52 : name(), btype(NULL
), location(UNKNOWN_LOCATION
)
55 Btyped_identifier(const std::string
& a_name
, Btype
* a_btype
,
57 : name(a_name
), btype(a_btype
), location(a_location
)
63 // Produce an error type. Actually the backend could probably just
64 // crash if this is called.
68 // Get a void type. This is used in (at least) two ways: 1) as the
69 // return type of a function with no result parameters; 2)
70 // unsafe.Pointer is represented as *void.
74 // Get the unnamed boolean type.
78 // Get an unnamed integer type with the given signedness and number
81 integer_type(bool is_unsigned
, int bits
) = 0;
83 // Get an unnamed floating point type with the given number of bits
86 float_type(int bits
) = 0;
88 // Get an unnamed complex type with the given number of bits (64 or 128).
90 complex_type(int bits
) = 0;
92 // Get a pointer type.
94 pointer_type(Btype
* to_type
) = 0;
96 // Get a function type. The receiver, parameter, and results are
97 // generated from the types in the Function_type. The Function_type
98 // is provided so that the names are available.
100 function_type(const Btyped_identifier
& receiver
,
101 const std::vector
<Btyped_identifier
>& parameters
,
102 const std::vector
<Btyped_identifier
>& results
,
103 Location location
) = 0;
105 // Get a struct type.
107 struct_type(const std::vector
<Btyped_identifier
>& fields
) = 0;
109 // Get an array type.
111 array_type(Btype
* element_type
, Bexpression
* length
) = 0;
113 // Create a placeholder pointer type. This is used for a named
114 // pointer type, since in Go a pointer type may refer to itself.
115 // NAME is the name of the type, and the location is where the named
116 // type is defined. This function is also used for unnamed function
117 // types with multiple results, in which case the type has no name
118 // and NAME will be empty. FOR_FUNCTION is true if this is for a Go
119 // function type, which corresponds to a C/C++ pointer to function
120 // type. The return value will later be passed as the first
121 // parameter to set_placeholder_pointer_type or
122 // set_placeholder_function_type.
124 placeholder_pointer_type(const std::string
& name
, Location
,
125 bool for_function
) = 0;
127 // Fill in a placeholder pointer type as a pointer. This takes a
128 // type returned by placeholder_pointer_type and arranges for it to
129 // point to the type that TO_TYPE points to (that is, PLACEHOLDER
130 // becomes the same type as TO_TYPE). Returns true on success,
133 set_placeholder_pointer_type(Btype
* placeholder
, Btype
* to_type
) = 0;
135 // Fill in a placeholder pointer type as a function. This takes a
136 // type returned by placeholder_pointer_type and arranges for it to
137 // become a real Go function type (which corresponds to a C/C++
138 // pointer to function type). FT will be something returned by the
139 // function_type method. Returns true on success, false on failure.
141 set_placeholder_function_type(Btype
* placeholder
, Btype
* ft
) = 0;
143 // Create a placeholder struct type. This is used for a named
144 // struct type, as with placeholder_pointer_type. It is also used
145 // for interface types, in which case NAME will be the empty string.
147 placeholder_struct_type(const std::string
& name
, Location
) = 0;
149 // Fill in a placeholder struct type. This takes a type returned by
150 // placeholder_struct_type and arranges for it to become a real
151 // struct type. The parameter is as for struct_type. Returns true
152 // on success, false on failure.
154 set_placeholder_struct_type(Btype
* placeholder
,
155 const std::vector
<Btyped_identifier
>& fields
)
158 // Create a placeholder array type. This is used for a named array
159 // type, as with placeholder_pointer_type, to handle cases like
162 placeholder_array_type(const std::string
& name
, Location
) = 0;
164 // Fill in a placeholder array type. This takes a type returned by
165 // placeholder_array_type and arranges for it to become a real array
166 // type. The parameters are as for array_type. Returns true on
167 // success, false on failure.
169 set_placeholder_array_type(Btype
* placeholder
, Btype
* element_type
,
170 Bexpression
* length
) = 0;
172 // Return a named version of a type. The location is the location
173 // of the type definition. This will not be called for a type
174 // created via placeholder_pointer_type, placeholder_struct_type, or
175 // placeholder_array_type.. (It may be called for a pointer,
176 // struct, or array type in a case like "type P *byte; type Q P".)
178 named_type(const std::string
& name
, Btype
*, Location
) = 0;
180 // Create a marker for a circular pointer type. Go pointer and
181 // function types can refer to themselves in ways that are not
182 // permitted in C/C++. When a circular type is found, this function
183 // is called for the circular reference. This permits the backend
184 // to decide how to handle such a type. PLACEHOLDER is the
185 // placeholder type which has already been created; if the backend
186 // is prepared to handle a circular pointer type, it may simply
187 // return PLACEHOLDER. FOR_FUNCTION is true if this is for a
190 // For "type P *P" the sequence of calls will be
191 // bt1 = placeholder_pointer_type();
192 // bt2 = circular_pointer_type(bt1, false);
193 // set_placeholder_pointer_type(bt1, bt2);
195 circular_pointer_type(Btype
* placeholder
, bool for_function
) = 0;
197 // Return whether the argument could be a special type created by
198 // circular_pointer_type. This is used to introduce explicit type
199 // conversions where needed. If circular_pointer_type returns its
200 // PLACEHOLDER parameter, this may safely always return false.
202 is_circular_pointer_type(Btype
*) = 0;
204 // Return the size of a type.
206 type_size(Btype
*) = 0;
208 // Return the alignment of a type.
210 type_alignment(Btype
*) = 0;
212 // Return the alignment of a struct field of this type. This is
213 // normally the same as type_alignment, but not always.
215 type_field_alignment(Btype
*) = 0;
217 // Return the offset of field INDEX in a struct type. INDEX is the
218 // entry in the FIELDS std::vector parameter of struct_type or
219 // set_placeholder_struct_type.
221 type_field_offset(Btype
*, size_t index
) = 0;
225 // Return an expression for a zero value of the given type. This is
226 // used for cases such as local variable initialization and
227 // converting nil to other types.
229 zero_expression(Btype
*) = 0;
233 // Create an error statement. This is used for cases which should
234 // not occur in a correct program, in order to keep the compilation
235 // going without crashing.
237 error_statement() = 0;
239 // Create an expression statement.
241 expression_statement(Bexpression
*) = 0;
243 // Create a variable initialization statement. This initializes a
244 // local variable at the point in the program flow where it is
247 init_statement(Bvariable
* var
, Bexpression
* init
) = 0;
249 // Create an assignment statement.
251 assignment_statement(Bexpression
* lhs
, Bexpression
* rhs
,
254 // Create a return statement, passing the representation of the
255 // function and the list of values to return.
257 return_statement(Bfunction
*, const std::vector
<Bexpression
*>&,
260 // Create an if statement. ELSE_BLOCK may be NULL.
262 if_statement(Bexpression
* condition
, Bblock
* then_block
, Bblock
* else_block
,
265 // Create a switch statement where the case values are constants.
266 // CASES and STATEMENTS must have the same number of entries. If
267 // VALUE matches any of the list in CASES[i], which will all be
268 // integers, then STATEMENTS[i] is executed. STATEMENTS[i] will
269 // either end with a goto statement or will fall through into
270 // STATEMENTS[i + 1]. CASES[i] is empty for the default clause,
271 // which need not be last.
273 switch_statement(Bexpression
* value
,
274 const std::vector
<std::vector
<Bexpression
*> >& cases
,
275 const std::vector
<Bstatement
*>& statements
,
278 // Create a single statement from two statements.
280 compound_statement(Bstatement
*, Bstatement
*) = 0;
282 // Create a single statement from a list of statements.
284 statement_list(const std::vector
<Bstatement
*>&) = 0;
288 // Create a block. The frontend will call this function when it
289 // starts converting a block within a function. FUNCTION is the
290 // current function. ENCLOSING is the enclosing block; it will be
291 // NULL for the top-level block in a function. VARS is the list of
292 // local variables defined within this block; each entry will be
293 // created by the local_variable function. START_LOCATION is the
294 // location of the start of the block, more or less the location of
295 // the initial curly brace. END_LOCATION is the location of the end
296 // of the block, more or less the location of the final curly brace.
297 // The statements will be added after the block is created.
299 block(Bfunction
* function
, Bblock
* enclosing
,
300 const std::vector
<Bvariable
*>& vars
,
301 Location start_location
, Location end_location
) = 0;
303 // Add the statements to a block. The block is created first. Then
304 // the statements are created. Then the statements are added to the
305 // block. This will called exactly once per block. The vector may
306 // be empty if there are no statements.
308 block_add_statements(Bblock
*, const std::vector
<Bstatement
*>&) = 0;
310 // Return the block as a statement. This is used to include a block
311 // in a list of statements.
313 block_statement(Bblock
*) = 0;
317 // Create an error variable. This is used for cases which should
318 // not occur in a correct program, in order to keep the compilation
319 // going without crashing.
321 error_variable() = 0;
323 // Create a global variable. PACKAGE_NAME is the name of the
324 // package where the variable is defined. UNIQUE_PREFIX is the
325 // prefix for that package, from the -fgo-prefix option. NAME is
326 // the name of the variable. BTYPE is the type of the variable.
327 // IS_EXTERNAL is true if the variable is defined in some other
328 // package. IS_HIDDEN is true if the variable is not exported (name
329 // begins with a lower case letter). LOCATION is where the variable
332 global_variable(const std::string
& package_name
,
333 const std::string
& unique_prefix
,
334 const std::string
& name
,
338 Location location
) = 0;
340 // A global variable will 1) be initialized to zero, or 2) be
341 // initialized to a constant value, or 3) be initialized in the init
342 // function. In case 2, the frontend will call
343 // global_variable_set_init to set the initial value. If this is
344 // not called, the backend should initialize a global variable to 0.
345 // The init function may then assign a value to it.
347 global_variable_set_init(Bvariable
*, Bexpression
*) = 0;
349 // Create a local variable. The frontend will create the local
350 // variables first, and then create the block which contains them.
351 // FUNCTION is the function in which the variable is defined. NAME
352 // is the name of the variable. TYPE is the type. IS_ADDRESS_TAKEN
353 // is true if the address of this variable is taken (this implies
354 // that the address does not escape the function, as otherwise the
355 // variable would be on the heap). LOCATION is where the variable
356 // is defined. For each local variable the frontend will call
357 // init_statement to set the initial value.
359 local_variable(Bfunction
* function
, const std::string
& name
, Btype
* type
,
360 bool is_address_taken
, Location location
) = 0;
362 // Create a function parameter. This is an incoming parameter, not
363 // a result parameter (result parameters are treated as local
364 // variables). The arguments are as for local_variable.
366 parameter_variable(Bfunction
* function
, const std::string
& name
,
367 Btype
* type
, bool is_address_taken
,
368 Location location
) = 0;
370 // Create a temporary variable. A temporary variable has no name,
371 // just a type. We pass in FUNCTION and BLOCK in case they are
372 // needed. If INIT is not NULL, the variable should be initialized
373 // to that value. Otherwise the initial value is irrelevant--the
374 // backend does not have to explicitly initialize it to zero.
375 // ADDRESS_IS_TAKEN is true if the programs needs to take the
376 // address of this temporary variable. LOCATION is the location of
377 // the statement or expression which requires creating the temporary
378 // variable, and may not be very useful. This function should
379 // return a variable which can be referenced later and should set
380 // *PSTATEMENT to a statement which initializes the variable.
382 temporary_variable(Bfunction
*, Bblock
*, Btype
*, Bexpression
* init
,
383 bool address_is_taken
, Location location
,
384 Bstatement
** pstatement
) = 0;
386 // Create a named immutable initialized data structure. This is
387 // used for type descriptors and map descriptors. This returns a
388 // Bvariable because it corresponds to an initialized const global
391 // NAME is the name to use for the initialized global variable which
392 // this call will create.
394 // IS_COMMON is true if NAME may be defined by several packages, and
395 // the linker should merge all such definitions. If IS_COMMON is
396 // false, NAME should be defined in only one file. In general
397 // IS_COMMON will be true for the type descriptor of an unnamed type
398 // or a builtin type.
400 // TYPE will be a struct type; the type of the returned expression
401 // must be a pointer to this struct type.
403 // We must create the named structure before we know its
404 // initializer, because the initializer may refer to its own
405 // address. After calling this the frontend will call
406 // immutable_struct_set_init.
408 immutable_struct(const std::string
& name
, bool is_common
, Btype
* type
,
411 // Set the initial value of a variable created by immutable_struct.
412 // The NAME, IS_COMMON, TYPE, and location parameters are the same
413 // ones passed to immutable_struct. INITIALIZER will be a composite
414 // literal of type TYPE. It will not contain any function calls or
415 // anything else which can not be put into a read-only data section.
416 // It may contain the address of variables created by
419 immutable_struct_set_init(Bvariable
*, const std::string
& name
,
420 bool is_common
, Btype
* type
, Location
,
421 Bexpression
* initializer
) = 0;
423 // Create a reference to a named immutable initialized data
424 // structure defined in some other package. This will be a
425 // structure created by a call to immutable_struct with the same
426 // NAME and TYPE and with IS_COMMON passed as false. This
427 // corresponds to an extern const global variable in C.
429 immutable_struct_reference(const std::string
& name
, Btype
* type
,
434 // Create a new label. NAME will be empty if this is a label
435 // created by the frontend for a loop construct. The location is
436 // where the the label is defined.
438 label(Bfunction
*, const std::string
& name
, Location
) = 0;
440 // Create a statement which defines a label. This statement will be
441 // put into the codestream at the point where the label should be
444 label_definition_statement(Blabel
*) = 0;
446 // Create a goto statement to a label.
448 goto_statement(Blabel
*, Location
) = 0;
450 // Create an expression for the address of a label. This is used to
451 // get the return address of a deferred function which may call
454 label_address(Blabel
*, Location
) = 0;
457 // The backend interface has to define this function.
459 extern Backend
* go_get_backend();
461 // FIXME: Temporary helper functions while converting to new backend
464 extern Btype
* tree_to_type(tree
);
465 extern Bexpression
* tree_to_expr(tree
);
466 extern Bstatement
* tree_to_stat(tree
);
467 extern Bfunction
* tree_to_function(tree
);
468 extern Bblock
* tree_to_block(tree
);
469 extern tree
type_to_tree(Btype
*);
470 extern tree
expr_to_tree(Bexpression
*);
471 extern tree
stat_to_tree(Bstatement
*);
472 extern tree
block_to_tree(Bblock
*);
473 extern tree
var_to_tree(Bvariable
*);
475 #endif // !defined(GO_BACKEND_H)