CbC/CbC_gcc: gcc/go/gofrontend/gogo.h comparison

comparison gcc/go/gofrontend/gogo.h @ 131:84e7813d76e9

gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 07:37:49 +0900
parents	04ced10e8804
children	1830386684a0

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
 #include "go-linemap.h"
 class Traverse;
 class Statement_inserter;
 class Type;
-class Type_hash_identical;
 class Type_equal;
-class Type_identical;
 class Typed_identifier;
 class Typed_identifier_list;
 class Function_type;
 class Expression;
 class Expression_list;
 };
 // For sorting purposes.
 struct Import_init_lt {
-bool operator()(const Import_init* i1, const Import_init* i2)
+bool operator()(const Import_init* i1, const Import_init* i2) const
 {
 return i1->init_name() < i2->init_name();
 }
 };
 // Set the level of escape analysis debugging from a command line option.
 void
 set_debug_escape_level(int level)
 { this->debug_escape_level_ = level; }
+// Return the hash for debug escape analysis.
+std::string
+debug_escape_hash() const
+{ return this->debug_escape_hash_; }
+// Set the hash value for debug escape analysis.
+void
+set_debug_escape_hash(const std::string& s)
+{ this->debug_escape_hash_ = s; }
+// Return the size threshold used to determine whether to issue
+// a nil-check for a given pointer dereference. A threshold of -1
+// implies that all potentially faulting dereference ops should
+// be nil-checked. A positive threshold of N implies that a deref
+// of *P where P has size less than N doesn't need a nil check.
+int64_t
+nil_check_size_threshold() const
+{ return this->nil_check_size_threshold_; }
+// Set the nil-check size threshold, as described above.
+void
+set_nil_check_size_threshold(int64_t bytes)
+{ this->nil_check_size_threshold_ = bytes; }
 // Import a package.  FILENAME is the file name argument, LOCAL_NAME
 // is the local name to give to the package.  If LOCAL_NAME is empty
 // the declarations are added to the global scope.
 void
 import_package(const std::string& filename, const std::string& local_name,
 // Add notes about the escape level of a function's input and output
 // parameters for exporting and importing top level functions.
 void
 tag_function(Escape_context*, Named_object*);
+// Reclaim memory of escape analysis Nodes.
+void
+reclaim_escape_nodes();
 // Do all exports.
 void
 do_exports();
 // Add an import control function for an imported package to the
 std::string
 function_descriptor_name(Named_object*);
 // Return the name to use for a generated stub method.
 std::string
-stub_method_name(const std::string& method_name);
+stub_method_name(const Package*, const std::string& method_name);
 // Return the names of the hash and equality functions for TYPE.
 void
 specific_type_function_names(const Type*, const Named_type*,
 			       std::string* hash_name,
 is_erroneous_name(const std::string&);
 // Return a name to use for a thunk function.  A thunk function is
 // one we create during the compilation, for a go statement or a
 // defer statement or a method expression.
-static std::string
+std::string
 thunk_name();
 // Return whether an object is a thunk.
 static bool
 is_thunk(const Named_object*);
 // Return the name to use for an init function.
 std::string
 init_function_name();
 // Return the name to use for a nested function.
-static std::string
+std::string
-nested_function_name();
+nested_function_name(Named_object* enclosing);
-// Return the index of a nested function name.
-static int
-nested_function_num(const std::string&);
 // Return the name to use for a sink funciton.
 std::string
 sink_function_name();
 ptrmask_symbol_name(const std::string& ptrmask_sym_name);
 // Return the name to use for an interface method table.
 std::string
 interface_method_table_name(Interface_type*, Type*, bool is_pointer);
+// Return whether NAME is a special name that can not be passed to
+// unpack_hidden_name.  This is needed because various special names
+// use "..SUFFIX", but unpack_hidden_name just looks for '.'.
+static bool
+is_special_name(const std::string& name);
 private:
 // During parsing, we keep a stack of functions.  Each function on
 // the stack is one that we are currently parsing.  For each
 // function, we keep track of the current stack of blocks.
 // Register variables with the garbage collector.
 void
 register_gc_vars(const std::vector<Named_object*>&,
 std::vector<Bstatement*>&,
 Bfunction* init_bfunction);
+void
+propagate_writebarrierrec();
 Named_object*
 write_barrier_variable();
 Statement*
 // -fgo-compiling-runtime option.
 bool compiling_runtime_;
 // The level of escape analysis debug information to emit, from the
 // -fgo-debug-escape option.
 int debug_escape_level_;
+// A hash value for debug escape analysis, from the
+// -fgo-debug-escape-hash option. The analysis is run only on
+// functions with names that hash to the matching value.
+std::string debug_escape_hash_;
+// Nil-check size threshhold.
+int64_t nil_check_size_threshold_;
 // A list of types to verify.
 std::vector<Type*> verify_types_;
 // A list of interface types defined while parsing.
 std::vector<Interface_type*> interface_types_;
 // Type specific functions to write out.
 // Whether the result variables have names.
 bool
 results_are_named() const
 { return this->results_are_named_; }
+// Return the assembler name.
+const std::string&
+asm_name() const
+{ return this->asm_name_; }
 // Set the assembler name.
 void
 set_asm_name(const std::string& asm_name)
 { this->asm_name_ = asm_name; }
 // Set the pragmas for this function.
 void
 set_pragmas(unsigned int pragmas)
 {
 this->pragmas_ = pragmas;
+}
+// Return the index to use for a nested function.
+unsigned int
+next_nested_function_index()
+{
+++this->nested_functions_;
+return this->nested_functions_;
 }
 // Whether this method should not be included in the type
 // descriptor.
 bool
 export_func(Export*, const std::string& name) const;
 // Export a function with a type.
 static void
 export_func_with_type(Export*, const std::string& name,
-			const Function_type*);
+			const Function_type*, bool nointerface);
 // Import a function.
 static void
 import_func(Import*, std::string* pname, Typed_identifier** receiver,
 	      Typed_identifier_list** pparameters,
-	      Typed_identifier_list** presults, bool* is_varargs);
+	      Typed_identifier_list** presults, bool* is_varargs,
+	      bool* nointerface);
 private:
 // Type for mapping from label names to Label objects.
 typedef Unordered_map(std::string, Label*) Labels;
 // distinguish the defer stack for one function from another.  This
 // is NULL unless we actually need a defer stack.
 Temporary_statement* defer_stack_;
 // Pragmas for this function.  This is a set of GOPRAGMA bits.
 unsigned int pragmas_;
+// Number of nested functions defined within this function.
+unsigned int nested_functions_;
 // True if this function is sink-named.  No code is generated.
 bool is_sink_ : 1;
 // True if the result variables are named.
 bool results_are_named_ : 1;
 // True if this function is a stub method created for an unnamed
 Location
 location() const
 { return this->location_; }
+// Return whether this function declaration is a method.
+bool
+is_method() const;
 const std::string&
 asm_name() const
 { return this->asm_name_; }
 // Set the assembler name.
 void
 set_asm_name(const std::string& asm_name)
 { this->asm_name_ = asm_name; }
+// Return the pragmas for this function.
+unsigned int
+pragmas() const
+{ return this->pragmas_; }
 // Set the pragmas for this function.
 void
 set_pragmas(unsigned int pragmas)
 {
 this->pragmas_ = pragmas;
 }
+// Whether this method should not be included in the type
+// descriptor.
+bool
+nointerface() const;
+// Record that this method should not be included in the type
+// descriptor.
+void
+set_nointerface();
 // Return an expression for the function descriptor, given the named
 // object for this function.  This may only be called for functions
 // without a closure.  This will be an immutable struct with one
 // field that points to the function's code.
 build_backend_descriptor(Gogo*);
 // Export a function declaration.
 void
 export_func(Export* exp, const std::string& name) const
-{ Function::export_func_with_type(exp, name, this->fntype_); }
+{
+Function::export_func_with_type(exp, name, this->fntype_,
+				    this->is_method() && this->nointerface());
+}
 // Check that the types used in this declaration's signature are defined.
 void
 check_types() const;
 void
 set_in_unique_section()
 {
 go_assert(this->is_global_);
 this->in_unique_section_ = true;
+}
+// Return the top-level declaration for this variable.
+Statement*
+toplevel_decl()
+{ return this->toplevel_decl_; }
+// Set the top-level declaration for this variable. Only used for local
+// variables
+void
+set_toplevel_decl(Statement* s)
+{
+go_assert(!this->is_global_ && !this->is_parameter_ && !this->is_receiver_);
+this->toplevel_decl_ = s;
 }
 // Traverse the initializer expression.
 int
 traverse_expression(Traverse*, unsigned int traverse_mask);
 // used for field tracking.
 bool in_unique_section_ : 1;
 // Whether this variable escapes the function it is created in.  This is
 // true until shown otherwise.
 bool escapes_ : 1;
+// The top-level declaration for this variable. Only used for local
+// variables. Must be a Temporary_statement if not NULL.
+Statement* toplevel_decl_;
 };
 // A variable which is really the name for a function return value, or
 // part of one.
 { }
 Type*
 type() const
 { return this->type_; }
+void
+set_type(Type* t);
 Expression*
 expr() const
 { return this->expr_; }
 class Traverse
 {
 public:
 // These bitmasks say what to traverse.
-static const unsigned int traverse_variables =    0x1;
+static const unsigned int traverse_variables =          0x1;
-static const unsigned int traverse_constants =    0x2;
+static const unsigned int traverse_constants =          0x2;
-static const unsigned int traverse_functions =    0x4;
+static const unsigned int traverse_functions =          0x4;
-static const unsigned int traverse_blocks =       0x8;
+static const unsigned int traverse_blocks =             0x8;
-static const unsigned int traverse_statements =  0x10;
+static const unsigned int traverse_statements =        0x10;
-static const unsigned int traverse_expressions = 0x20;
+static const unsigned int traverse_expressions =       0x20;
-static const unsigned int traverse_types =       0x40;
+static const unsigned int traverse_types =             0x40;
+static const unsigned int traverse_func_declarations = 0x80;
 Traverse(unsigned int traverse_mask)
 : traverse_mask_(traverse_mask), types_seen_(NULL), expressions_seen_(NULL)
 { }
 // If traverse_types is set in the mask, this is called for every
 // type in the tree.
 virtual int
 type(Type*);
+// If traverse_func_declarations is set in the mask, this is called
+// for every function declarations in the tree.
+virtual int
+function_declaration(Named_object*);
 private:
 // A hash table for types we have seen during this traversal.  Note
 // that this uses the default hash functions for pointers rather
 // than Type_hash_identical and Type_identical.  This is because for
 // current statement during a traversal.
 class Statement_inserter
 {
 public:
+typedef Unordered_set(Statement*) Statements;
 // Empty constructor.
 Statement_inserter()
-: block_(NULL), pindex_(NULL), gogo_(NULL), var_(NULL)
+: block_(NULL), pindex_(NULL), gogo_(NULL), var_(NULL),
+statements_added_(NULL)
 { }
 // Constructor for a statement in a block.
-Statement_inserter(Block* block, size_t *pindex)
+Statement_inserter(Block* block, size_t *pindex, Statements *added = NULL)
-: block_(block), pindex_(pindex), gogo_(NULL), var_(NULL)
+: block_(block), pindex_(pindex), gogo_(NULL), var_(NULL),
+statements_added_(added)
 { }
 // Constructor for a global variable.
-Statement_inserter(Gogo* gogo, Variable* var)
+Statement_inserter(Gogo* gogo, Variable* var, Statements *added = NULL)
-: block_(NULL), pindex_(NULL), gogo_(gogo), var_(var)
+: block_(NULL), pindex_(NULL), gogo_(gogo), var_(var),
+statements_added_(added)
 { go_assert(var->is_global()); }
 // We use the default copy constructor and assignment operator.
 // Insert S before the statement we are traversing, or before the
 // The IR, needed when looking at an initializer expression for a
 // global variable.
 Gogo* gogo_;
 // The global variable, when looking at an initializer expression.
 Variable* var_;
+// If non-null, a set to record new statements inserted (non-owned).
+Statements* statements_added_;
 };
 // When translating the gogo IR into the backend data structure, this
 // is the context we pass down the blocks and statements.

Mercurial > hg > CbC > CbC_gcc

comparison gcc/go/gofrontend/gogo.h @ 131:84e7813d76e9