| // ast-dump.cc -- AST debug dump. -*- 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. |
| |
| #include "go-system.h" |
| |
| #include <iostream> |
| #include <fstream> |
| #include <sstream> |
| |
| #include "gogo.h" |
| #include "expressions.h" |
| #include "statements.h" |
| #include "types.h" |
| #include "ast-dump.h" |
| #include "go-c.h" |
| #include "go-dump.h" |
| #include "go-diagnostics.h" |
| |
| // The -fgo-dump-ast flag to activate AST dumps. |
| |
| Go_dump ast_dump_flag("ast"); |
| |
| // This class is used to traverse the tree to look for blocks and |
| // function headers. |
| |
| class Ast_dump_traverse_blocks_and_functions : public Traverse |
| { |
| public: |
| Ast_dump_traverse_blocks_and_functions(Ast_dump_context* ast_dump_context) |
| : Traverse(traverse_blocks | traverse_functions | traverse_variables), |
| ast_dump_context_(ast_dump_context) |
| { } |
| |
| protected: |
| int |
| block(Block*); |
| |
| int |
| function(Named_object*); |
| |
| int |
| variable(Named_object*); |
| |
| private: |
| Ast_dump_context* ast_dump_context_; |
| }; |
| |
| // This class is used to traverse the tree to look for statements. |
| |
| class Ast_dump_traverse_statements : public Traverse |
| { |
| public: |
| Ast_dump_traverse_statements(Ast_dump_context* ast_dump_context) |
| : Traverse(traverse_statements), |
| ast_dump_context_(ast_dump_context) |
| { } |
| |
| protected: |
| int |
| statement(Block*, size_t* pindex, Statement*); |
| |
| private: |
| Ast_dump_context* ast_dump_context_; |
| }; |
| |
| // For each block we enclose it in brackets. |
| |
| int Ast_dump_traverse_blocks_and_functions::block(Block * block) |
| { |
| if (block == NULL) |
| { |
| this->ast_dump_context_->ostream() << std::endl; |
| return TRAVERSE_EXIT; |
| } |
| |
| this->ast_dump_context_->print_indent(); |
| this->ast_dump_context_->ostream() << "{" << std::endl; |
| this->ast_dump_context_->indent(); |
| |
| // Dump statememts. |
| Ast_dump_traverse_statements adts(this->ast_dump_context_); |
| block->traverse(&adts); |
| |
| this->ast_dump_context_->unindent(); |
| this->ast_dump_context_->print_indent(); |
| this->ast_dump_context_->ostream() << "}" << std::endl; |
| |
| return TRAVERSE_SKIP_COMPONENTS; |
| } |
| |
| // Dump each traversed statement. |
| |
| int |
| Ast_dump_traverse_statements::statement(Block* block, size_t* pindex, |
| Statement* statement) |
| { |
| statement->dump_statement(this->ast_dump_context_); |
| |
| if (statement->is_block_statement()) |
| { |
| Ast_dump_traverse_blocks_and_functions adtbf(this->ast_dump_context_); |
| statement->traverse(block, pindex, &adtbf); |
| } |
| |
| return TRAVERSE_SKIP_COMPONENTS; |
| } |
| |
| // Dump the function header. |
| |
| int |
| Ast_dump_traverse_blocks_and_functions::function(Named_object* no) |
| { |
| this->ast_dump_context_->ostream() << no->name(); |
| |
| go_assert(no->is_function()); |
| Function* func = no->func_value(); |
| |
| this->ast_dump_context_->ostream() << "("; |
| this->ast_dump_context_->dump_typed_identifier_list( |
| func->type()->parameters()); |
| |
| this->ast_dump_context_->ostream() << ")"; |
| |
| Function::Results* res = func->result_variables(); |
| if (res != NULL && !res->empty()) |
| { |
| this->ast_dump_context_->ostream() << " ("; |
| |
| for (Function::Results::const_iterator it = res->begin(); |
| it != res->end(); |
| it++) |
| { |
| if (it != res->begin()) |
| this->ast_dump_context_->ostream() << ","; |
| Named_object* rno = (*it); |
| |
| this->ast_dump_context_->ostream() << rno->name() << " "; |
| go_assert(rno->is_result_variable()); |
| Result_variable* resvar = rno->result_var_value(); |
| |
| this->ast_dump_context_->dump_type(resvar->type()); |
| |
| } |
| this->ast_dump_context_->ostream() << ")"; |
| } |
| |
| this->ast_dump_context_->ostream() << " : "; |
| this->ast_dump_context_->dump_type(func->type()); |
| this->ast_dump_context_->ostream() << std::endl; |
| |
| return TRAVERSE_CONTINUE; |
| } |
| |
| // Dump variable preinits |
| |
| int |
| Ast_dump_traverse_blocks_and_functions::variable(Named_object* no) |
| { |
| if (!no->is_variable()) |
| return TRAVERSE_CONTINUE; |
| |
| Variable* var = no->var_value(); |
| if (var->has_pre_init()) |
| { |
| this->ast_dump_context_->ostream() << "// preinit block for var " |
| << no->message_name() << "\n"; |
| var->preinit()->traverse(this); |
| } |
| |
| return TRAVERSE_CONTINUE; |
| } |
| |
| |
| |
| // Class Ast_dump_context. |
| |
| Ast_dump_context::Ast_dump_context(std::ostream* out /* = NULL */, |
| bool dump_subblocks /* = true */) |
| : indent_(0), dump_subblocks_(dump_subblocks), ostream_(out), gogo_(NULL) |
| { |
| } |
| |
| // Dump files will be named %basename%.dump.ast |
| |
| const char* kAstDumpFileExtension = ".dump.ast"; |
| |
| // Dump the internal representation. |
| |
| void |
| Ast_dump_context::dump(Gogo* gogo, const char* basename) |
| { |
| std::ofstream out; |
| std::string dumpname(basename); |
| dumpname += ".dump.ast"; |
| out.open(dumpname.c_str()); |
| |
| if (out.fail()) |
| { |
| go_error_at(Linemap::unknown_location(), |
| "cannot open %s:%m; %<-fgo-dump-ast%> ignored", |
| dumpname.c_str()); |
| return; |
| } |
| |
| this->gogo_ = gogo; |
| this->ostream_ = &out; |
| |
| Ast_dump_traverse_blocks_and_functions adtbf(this); |
| gogo->traverse(&adtbf); |
| |
| out.close(); |
| } |
| |
| // Dump a textual representation of a type to the |
| // the dump file. |
| |
| void |
| Ast_dump_context::dump_type(const Type* t) |
| { |
| if (t == NULL) |
| this->ostream() << "(nil type)"; |
| else |
| // FIXME: write a type pretty printer instead of |
| // using mangled names. |
| if (this->gogo_ != NULL) |
| this->ostream() << "(" << t->mangled_name(this->gogo_) << ")"; |
| } |
| |
| // Dump a textual representation of a block to the |
| // the dump file. |
| |
| void |
| Ast_dump_context::dump_block(Block* b) |
| { |
| Ast_dump_traverse_blocks_and_functions adtbf(this); |
| b->traverse(&adtbf); |
| } |
| |
| // Dump a textual representation of an expression to the |
| // the dump file. |
| |
| void |
| Ast_dump_context::dump_expression(const Expression* e) |
| { |
| e->dump_expression(this); |
| } |
| |
| // Dump a textual representation of an expression list to the |
| // the dump file. |
| |
| void |
| Ast_dump_context::dump_expression_list(const Expression_list* el, |
| bool as_pairs /* = false */) |
| { |
| if (el == NULL) |
| return; |
| |
| for (std::vector<Expression*>::const_iterator it = el->begin(); |
| it != el->end(); |
| it++) |
| { |
| if ( it != el->begin()) |
| this->ostream() << ","; |
| if (*it != NULL) |
| (*it)->dump_expression(this); |
| else |
| this->ostream() << "NULL"; |
| if (as_pairs) |
| { |
| this->ostream() << ":"; |
| ++it; |
| (*it)->dump_expression(this); |
| } |
| } |
| } |
| |
| // Dump a textual representation of a typed identifier to the |
| // the dump file. |
| |
| void |
| Ast_dump_context::dump_typed_identifier(const Typed_identifier* ti) |
| { |
| this->ostream() << ti->name() << " "; |
| this->dump_type(ti->type()); |
| } |
| |
| // Dump a textual representation of a typed identifier list to the |
| // the dump file. |
| |
| void |
| Ast_dump_context::dump_typed_identifier_list( |
| const Typed_identifier_list* ti_list) |
| { |
| if (ti_list == NULL) |
| return; |
| |
| for (Typed_identifier_list::const_iterator it = ti_list->begin(); |
| it != ti_list->end(); |
| it++) |
| { |
| if (it != ti_list->begin()) |
| this->ostream() << ","; |
| this->dump_typed_identifier(&(*it)); |
| } |
| } |
| |
| // Dump a textual representation of a temporary variable to the |
| // the dump file. |
| |
| void |
| Ast_dump_context::dump_temp_variable_name(const Statement* s) |
| { |
| go_assert(s->classification() == Statement::STATEMENT_TEMPORARY); |
| // Use the statement address as part of the name for the temporary variable. |
| this->ostream() << "tmp." << (uintptr_t) s; |
| } |
| |
| // Dump a textual representation of a label to the |
| // the dump file. |
| |
| void |
| Ast_dump_context::dump_label_name(const Unnamed_label* l) |
| { |
| // Use the unnamed label address as part of the name for the temporary |
| // variable. |
| this->ostream() << "label." << (uintptr_t) l; |
| } |
| |
| // Produce a textual representation of an operator symbol. |
| |
| static const char* |
| op_string(Operator op) |
| { |
| // FIXME: This should be in line with symbols that are parsed, |
| // exported and/or imported. |
| switch (op) |
| { |
| case OPERATOR_PLUS: |
| return "+"; |
| case OPERATOR_MINUS: |
| return "-"; |
| case OPERATOR_NOT: |
| return "!"; |
| case OPERATOR_XOR: |
| return "^"; |
| case OPERATOR_OR: |
| return "|"; |
| case OPERATOR_AND: |
| return "&"; |
| case OPERATOR_MULT: |
| return "*"; |
| case OPERATOR_OROR: |
| return "||"; |
| case OPERATOR_ANDAND: |
| return "&&"; |
| case OPERATOR_EQEQ: |
| return "=="; |
| case OPERATOR_NOTEQ: |
| return "!="; |
| case OPERATOR_LT: |
| return "<"; |
| case OPERATOR_LE: |
| return "<="; |
| case OPERATOR_GT: |
| return ">"; |
| case OPERATOR_GE: |
| return ">="; |
| case OPERATOR_DIV: |
| return "/"; |
| case OPERATOR_MOD: |
| return "%"; |
| case OPERATOR_LSHIFT: |
| return "<<"; |
| case OPERATOR_RSHIFT: |
| return "//"; |
| case OPERATOR_BITCLEAR: |
| return "&^"; |
| case OPERATOR_CHANOP: |
| return "<-"; |
| case OPERATOR_PLUSEQ: |
| return "+="; |
| case OPERATOR_MINUSEQ: |
| return "-="; |
| case OPERATOR_OREQ: |
| return "|="; |
| case OPERATOR_XOREQ: |
| return "^="; |
| case OPERATOR_MULTEQ: |
| return "*="; |
| case OPERATOR_DIVEQ: |
| return "/="; |
| case OPERATOR_MODEQ: |
| return "%="; |
| case OPERATOR_LSHIFTEQ: |
| return "<<="; |
| case OPERATOR_RSHIFTEQ: |
| return ">>="; |
| case OPERATOR_ANDEQ: |
| return "&="; |
| case OPERATOR_BITCLEAREQ: |
| return "&^="; |
| case OPERATOR_PLUSPLUS: |
| return "++"; |
| case OPERATOR_MINUSMINUS: |
| return "--"; |
| case OPERATOR_COLON: |
| return ":"; |
| case OPERATOR_COLONEQ: |
| return ":="; |
| case OPERATOR_SEMICOLON: |
| return ";"; |
| case OPERATOR_DOT: |
| return "."; |
| case OPERATOR_ELLIPSIS: |
| return "..."; |
| case OPERATOR_COMMA: |
| return ","; |
| case OPERATOR_LPAREN: |
| return "("; |
| case OPERATOR_RPAREN: |
| return ")"; |
| case OPERATOR_LCURLY: |
| return "{"; |
| case OPERATOR_RCURLY: |
| return "}"; |
| case OPERATOR_LSQUARE: |
| return "["; |
| case OPERATOR_RSQUARE: |
| return "]"; |
| default: |
| go_unreachable(); |
| } |
| return NULL; |
| } |
| |
| // Dump a textual representation of an operator to the |
| // the dump file. |
| |
| void |
| Ast_dump_context::dump_operator(Operator op) |
| { |
| this->ostream() << op_string(op); |
| } |
| |
| // Size of a single indent. |
| |
| const int Ast_dump_context::offset_ = 2; |
| |
| // Print indenting spaces to dump file. |
| |
| void |
| Ast_dump_context::print_indent() |
| { |
| for (int i = 0; i < this->indent_ * this->offset_; i++) |
| this->ostream() << " "; |
| } |
| |
| // Dump a textual representation of the ast to the |
| // the dump file. |
| |
| void Gogo::dump_ast(const char* basename) |
| { |
| if (::ast_dump_flag.is_enabled()) |
| { |
| Ast_dump_context adc; |
| adc.dump(this, basename); |
| } |
| } |
| |
| // Implementation of String_dump interface. |
| |
| void |
| Ast_dump_context::write_c_string(const char* s) |
| { |
| this->ostream() << s; |
| } |
| |
| void |
| Ast_dump_context::write_string(const std::string& s) |
| { |
| this->ostream() << s; |
| } |
| |
| // Dump statement to stream. |
| |
| void |
| Ast_dump_context::dump_to_stream(const Statement* stm, std::ostream* out) |
| { |
| Ast_dump_context adc(out, false); |
| stm->dump_statement(&adc); |
| } |
| |
| // Dump expression to stream. |
| |
| void |
| Ast_dump_context::dump_to_stream(const Expression* expr, std::ostream* out) |
| { |
| Ast_dump_context adc(out, false); |
| expr->dump_expression(&adc); |
| } |
| |
| // Dump an expression to std::cerr. This is intended to be used |
| // from within a debugging session. |
| |
| void |
| debug_go_expression(const Expression* expr) |
| { |
| if (expr == NULL) |
| std::cerr << "<null>"; |
| else |
| { |
| Ast_dump_context::dump_to_stream(expr, &std::cerr); |
| std::string lstr = Linemap::location_to_string(expr->location()); |
| std::cerr << " // loc " << lstr << std::endl; |
| } |
| } |
| |
| // Shallow dump of stmt to std::cerr. This is intended to be used |
| // from within a debugging session. |
| |
| void |
| debug_go_statement(const Statement* stmt) |
| { |
| if (stmt == NULL) |
| std::cerr << "<null>\n"; |
| else |
| { |
| std::string lstr = Linemap::location_to_string(stmt->location()); |
| Statement *ncstmt = const_cast<Statement*>(stmt); |
| Block_statement* bs = ncstmt->block_statement(); |
| if (bs != NULL) |
| std::cerr << "Block " << bs->block() |
| << " // location: " << lstr << std::endl; |
| else |
| Ast_dump_context::dump_to_stream(stmt, &std::cerr); |
| } |
| } |
| |
| // Deep dump of statement to std::cerr. This is intended to be used |
| // from within a debugging session. |
| |
| void |
| debug_go_statement_deep(const Statement* statement) |
| { |
| Ast_dump_context adc(&std::cerr, true); |
| statement->dump_statement(&adc); |
| } |
| |
| // Shallow dump of a block to std::cerr. This is intended to be used |
| // from within a debugging session. |
| |
| void |
| debug_go_block(const Block* block) |
| { |
| if (block == NULL) |
| std::cerr << "<null>"; |
| else |
| { |
| std::cerr << "Block " << block |
| << " (enclosing " << block->enclosing() << "):\n"; |
| const std::vector<Statement*>* stmts = block->statements(); |
| if (stmts != NULL) |
| { |
| for (size_t i = 0; i < stmts->size(); ++i) |
| { |
| debug_go_statement(stmts->at(i)); |
| } |
| } |
| } |
| } |
| |
| // Deep dump of a block to std:cerr. This is intended to be used |
| // from within a debugging session. |
| |
| void |
| debug_go_block_deep(const Block* block) |
| { |
| Ast_dump_context adc(&std::cerr, true); |
| Block* ncblock = const_cast<Block*>(block); |
| adc.dump_block(ncblock); |
| } |
| |
| class Type_dumper |
| { |
| typedef Unordered_map(const Type*, unsigned) idx_map; |
| public: |
| Type_dumper(const Type* type) |
| : top_(type), ntypes_(0) |
| { |
| this->worklist_.push_back(type); |
| } |
| |
| void visit(); |
| |
| std::string stringResult() { return ss_.str(); } |
| |
| private: |
| void emitpre(unsigned tag, const Type* addr); |
| void typeref(const char*, const Type*, const char *); |
| void visit_forward_declaration_type(const Forward_declaration_type* fdt); |
| void visit_function_type(const Function_type* ft); |
| void visit_struct_type(const Struct_type* st); |
| void visit_array_type(const Array_type* at); |
| void visit_map_type(const Map_type* mt); |
| void visit_channel_type(const Channel_type* mt); |
| void visit_interface_type(const Interface_type* mt); |
| void visit_methods(const Typed_identifier_list* methods, |
| const char *tag); |
| std::pair<bool, unsigned> lookup(const Type*); |
| |
| static const unsigned notag = 0xffffffff; |
| |
| private: |
| const Type* top_; |
| idx_map types_; |
| unsigned ntypes_; |
| std::list<const Type*> worklist_; |
| std::ostringstream ss_; |
| }; |
| |
| // Look up a type, installing it in 'types_'. Return is <found, N> |
| // where 'found' is true if type had been previously recorded, and N |
| // is the index/tag assigned to N. The input argument is appended to |
| // the work list if this is the first time we've seen it. |
| |
| std::pair<bool, unsigned> Type_dumper::lookup(const Type* t) |
| { |
| std::pair<const Type*, unsigned> entry = std::make_pair(t, this->ntypes_); |
| std::pair<idx_map::iterator, bool> ins = this->types_.insert(entry); |
| if (ins.second) |
| { |
| this->ntypes_++; |
| if (t != this->top_) |
| this->worklist_.push_back(t); |
| } |
| return std::make_pair(ins.second, ins.first->second); |
| } |
| |
| // Emit preamble prior to dumping a type, including the type |
| // pointer itself and the tag we've assigned it. If no |
| // tag is specified (via special "notag" value) and/or the |
| // pointer is null, then just emit an equivalent amount |
| // of spaces. |
| |
| void Type_dumper::emitpre(unsigned tag, const Type* ptr) |
| { |
| char tbuf[50], pbuf[50], buf[200]; |
| |
| tbuf[0] = '\0'; |
| if (tag != notag) |
| snprintf(tbuf, sizeof tbuf, "T%u", tag); |
| |
| pbuf[0] = '\0'; |
| if (ptr != NULL) |
| snprintf(pbuf, sizeof pbuf, "%p", (const void*) ptr); |
| |
| snprintf(buf, sizeof buf, "%8s %16s ", tbuf, pbuf); |
| this->ss_ << buf; |
| } |
| |
| // Emit a reference to a type into the dump buffer. In most cases this means |
| // just the type tag, but for named types we also emit the name, and for |
| // simple/primitive types (ex: int64) we emit the type itself. If "pref" is |
| // non-NULL, emit the string prior to the reference, and if "suf" is non-NULL, |
| // emit it following the reference. |
| |
| void Type_dumper::typeref(const char* pref, const Type* t, const char* suf) |
| { |
| if (pref != NULL) |
| this->ss_ << pref; |
| std::pair<bool, unsigned> p = this->lookup(t); |
| unsigned tag = p.second; |
| switch (t->classification()) |
| { |
| case Type::TYPE_NAMED: |
| { |
| const Named_type* nt = t->named_type(); |
| const Named_object* no = nt->named_object(); |
| this->ss_ << "'" << no->message_name() << "' -> "; |
| const Type* underlying = nt->real_type(); |
| this->typeref(NULL, underlying, NULL); |
| break; |
| } |
| case Type::TYPE_POINTER: |
| this->typeref("*", t->points_to(), NULL); |
| break; |
| case Type::TYPE_ERROR: |
| this->ss_ << "error_type"; |
| break; |
| case Type::TYPE_INTEGER: |
| { |
| const Integer_type* it = t->integer_type(); |
| if (it->is_abstract()) |
| this->ss_ << "abstract_int"; |
| else |
| this->ss_ << (it->is_unsigned() ? "u" : "") << "int" << it->bits(); |
| break; |
| } |
| case Type::TYPE_FLOAT: |
| { |
| const Float_type* ft = t->float_type(); |
| if (ft->is_abstract()) |
| this->ss_ << "abstract_float"; |
| else |
| this->ss_ << "float" << ft->bits(); |
| break; |
| } |
| case Type::TYPE_COMPLEX: |
| { |
| const Complex_type* ct = t->complex_type(); |
| if (ct->is_abstract()) |
| this->ss_ << "abstract_complex"; |
| else |
| this->ss_ << "complex" << ct->bits(); |
| break; |
| } |
| case Type::TYPE_BOOLEAN: |
| this->ss_ << "bool"; |
| break; |
| case Type::TYPE_STRING: |
| this->ss_ << "string"; |
| break; |
| case Type::TYPE_NIL: |
| this->ss_ << "nil_type"; |
| break; |
| case Type::TYPE_VOID: |
| this->ss_ << "void_type"; |
| break; |
| case Type::TYPE_FUNCTION: |
| case Type::TYPE_STRUCT: |
| case Type::TYPE_ARRAY: |
| case Type::TYPE_MAP: |
| case Type::TYPE_CHANNEL: |
| case Type::TYPE_FORWARD: |
| case Type::TYPE_INTERFACE: |
| this->ss_ << "T" << tag; |
| break; |
| |
| default: |
| // This is a debugging routine, so instead of a go_unreachable() |
| // issue a warning/error, to allow for the possibility that the |
| // compiler we're debugging is in a bad state. |
| this->ss_ << "<??? " << ((unsigned)t->classification()) << "> " |
| << "T" << tag; |
| } |
| if (suf != NULL) |
| this->ss_ << suf; |
| } |
| |
| void Type_dumper::visit_forward_declaration_type(const Forward_declaration_type* fdt) |
| { |
| this->ss_ << "forward_declaration_type "; |
| if (fdt->is_defined()) |
| this->typeref("-> ", fdt->real_type(), NULL); |
| else |
| this->ss_ << "'" << fdt->name() << "'"; |
| this->ss_ << "\n"; |
| } |
| |
| void Type_dumper::visit_function_type(const Function_type* ft) |
| { |
| this->ss_ << "function\n"; |
| const Typed_identifier* rec = ft->receiver(); |
| if (rec != NULL) |
| { |
| this->emitpre(notag, NULL); |
| this->typeref("receiver ", rec->type(), "\n"); |
| } |
| const Typed_identifier_list* parameters = ft->parameters(); |
| if (parameters != NULL) |
| { |
| for (Typed_identifier_list::const_iterator p = parameters->begin(); |
| p != parameters->end(); |
| ++p) |
| { |
| this->emitpre(notag, NULL); |
| this->typeref(" param ", p->type(), "\n"); |
| } |
| } |
| const Typed_identifier_list* results = ft->results(); |
| if (results != NULL) |
| { |
| for (Typed_identifier_list::const_iterator p = results->begin(); |
| p != results->end(); |
| ++p) |
| { |
| this->emitpre(notag, NULL); |
| this->typeref(" result ", p->type(), "\n"); |
| } |
| } |
| } |
| |
| void Type_dumper::visit_struct_type(const Struct_type* st) |
| { |
| this->ss_ << "struct\n"; |
| const Struct_field_list* fields = st->fields(); |
| if (fields != NULL) |
| { |
| for (Struct_field_list::const_iterator p = fields->begin(); |
| p != fields->end(); |
| ++p) |
| { |
| this->emitpre(notag, NULL); |
| this->typeref(" field ", p->type(), "\n"); |
| } |
| } |
| } |
| |
| void Type_dumper::visit_array_type(const Array_type* at) |
| { |
| this->ss_ << "array ["; |
| if (at->length() != NULL) |
| { |
| int64_t len = 0; |
| if (at->int_length(&len)) |
| this->ss_ << len; |
| } |
| this->typeref("] ", at->element_type(), "\n"); |
| } |
| |
| void Type_dumper::visit_map_type(const Map_type* mt) |
| { |
| this->ss_ << "map ["; |
| this->typeref(NULL, mt->key_type(), NULL); |
| this->typeref("] ", mt->val_type(), "\n"); |
| } |
| |
| void Type_dumper::visit_methods(const Typed_identifier_list* methods, |
| const char *tag) |
| { |
| if (tag != NULL) |
| { |
| this->emitpre(notag, NULL); |
| this->ss_ << tag << "\n"; |
| } |
| for (Typed_identifier_list::const_iterator p = methods->begin(); |
| p != methods->end(); |
| ++p) |
| { |
| this->emitpre(notag, NULL); |
| if (p->name().empty()) |
| this->typeref(" embedded method ", p->type(), "\n"); |
| else |
| { |
| this->ss_ << " method '" << p->name() << "' "; |
| this->typeref(NULL, p->type(), "\n"); |
| } |
| } |
| } |
| |
| void Type_dumper::visit_interface_type(const Interface_type* it) |
| { |
| const Typed_identifier_list* methods = |
| (it->methods_are_finalized() ? it->methods() : it->local_methods()); |
| if (methods == NULL) |
| { |
| this->ss_ << "empty_interface\n"; |
| return; |
| } |
| this->ss_ << "interface"; |
| if (! it->methods_are_finalized()) |
| { |
| this->ss_ << " [unfinalized]\n"; |
| visit_methods(it->local_methods(), NULL); |
| } |
| else |
| { |
| this->ss_ << "\n"; |
| visit_methods(it->local_methods(), "[parse_methods]"); |
| visit_methods(it->methods(), "[all_methods]"); |
| } |
| } |
| |
| void Type_dumper::visit_channel_type(const Channel_type* ct) |
| { |
| this->ss_ << "channel {"; |
| if (ct->may_send()) |
| this->ss_ << " send"; |
| if (ct->may_receive()) |
| this->ss_ << " receive"; |
| this->typeref(" } ", ct->element_type(), "\n"); |
| } |
| |
| void Type_dumper::visit() |
| { |
| while (! this->worklist_.empty()) { |
| const Type* t = this->worklist_.front(); |
| this->worklist_.pop_front(); |
| |
| std::pair<bool, unsigned> p = this->lookup(t); |
| unsigned tag = p.second; |
| this->emitpre(tag, t); |
| |
| switch(t->classification()) |
| { |
| case Type::TYPE_ERROR: |
| case Type::TYPE_INTEGER: |
| case Type::TYPE_FLOAT: |
| case Type::TYPE_COMPLEX: |
| case Type::TYPE_BOOLEAN: |
| case Type::TYPE_STRING: |
| case Type::TYPE_VOID: |
| case Type::TYPE_POINTER: |
| case Type::TYPE_NIL: |
| case Type::TYPE_NAMED: |
| this->typeref(NULL, t, "\n"); |
| break; |
| case Type::TYPE_FORWARD: |
| this->visit_forward_declaration_type(t->forward_declaration_type()); |
| break; |
| |
| case Type::TYPE_FUNCTION: |
| this->visit_function_type(t->function_type()); |
| break; |
| case Type::TYPE_STRUCT: |
| this->visit_struct_type(t->struct_type()); |
| break; |
| case Type::TYPE_ARRAY: |
| this->visit_array_type(t->array_type()); |
| break; |
| case Type::TYPE_MAP: |
| this->visit_map_type(t->map_type()); |
| break; |
| case Type::TYPE_CHANNEL: |
| this->visit_channel_type(t->channel_type()); |
| break; |
| case Type::TYPE_INTERFACE: |
| this->visit_interface_type(t->interface_type()); |
| break; |
| default: |
| // This is a debugging routine, so instead of a go_unreachable() |
| // issue a warning/error, to allow for the possibility that the |
| // compiler we're debugging is in a bad state. |
| this->ss_ << "<unknown/unrecognized classification " |
| << ((unsigned)t->classification()) << ">\n"; |
| } |
| } |
| } |
| |
| // Dump a Go type for debugging purposes. This is a deep as opposed |
| // to shallow dump; all of the types reachable from the specified |
| // type will be dumped in addition to the type itself. |
| |
| void debug_go_type(const Type* type) |
| { |
| if (type == NULL) |
| { |
| std::cerr << "<NULL type>\n"; |
| return; |
| } |
| Type_dumper dumper(type); |
| dumper.visit(); |
| std::cerr << dumper.stringResult(); |
| } |
| |
| void debug_go_type(Type* type) |
| { |
| const Type* ctype = type; |
| debug_go_type(ctype); |
| } |