| 1 |
// ast-dump.cc -- AST debug dump. -*- C++ -*- |
| 2 |
|
| 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. |
| 6 |
|
| 7 |
#include "go-system.h" |
| 8 |
|
| 9 |
#include <iostream> |
| 10 |
#include <fstream> |
| 11 |
#include <sstream> |
| 12 |
|
| 13 |
#include "gogo.h" |
| 14 |
#include "expressions.h" |
| 15 |
#include "statements.h" |
| 16 |
#include "types.h" |
| 17 |
#include "ast-dump.h" |
| 18 |
#include "go-c.h" |
| 19 |
#include "go-dump.h" |
| 20 |
#include "go-diagnostics.h" |
| 21 |
|
| 22 |
// The -fgo-dump-ast flag to activate AST dumps. |
| 23 |
|
| 24 |
Go_dump ast_dump_flag("ast"); |
| 25 |
|
| 26 |
// This class is used to traverse the tree to look for blocks and |
| 27 |
// function headers. |
| 28 |
|
| 29 |
class Ast_dump_traverse_blocks_and_functions : public Traverse |
| 30 |
{ |
| 31 |
public: |
| 32 |
Ast_dump_traverse_blocks_and_functions(Ast_dump_context* ast_dump_context) |
| 33 |
: Traverse(traverse_blocks | traverse_functions | traverse_variables), |
| 34 |
ast_dump_context_(ast_dump_context) |
| 35 |
{ } |
| 36 |
|
| 37 |
protected: |
| 38 |
int |
| 39 |
block(Block*); |
| 40 |
|
| 41 |
int |
| 42 |
function(Named_object*); |
| 43 |
|
| 44 |
int |
| 45 |
variable(Named_object*); |
| 46 |
|
| 47 |
private: |
| 48 |
Ast_dump_context* ast_dump_context_; |
| 49 |
}; |
| 50 |
|
| 51 |
// This class is used to traverse the tree to look for statements. |
| 52 |
|
| 53 |
class Ast_dump_traverse_statements : public Traverse |
| 54 |
{ |
| 55 |
public: |
| 56 |
Ast_dump_traverse_statements(Ast_dump_context* ast_dump_context) |
| 57 |
: Traverse(traverse_statements), |
| 58 |
ast_dump_context_(ast_dump_context) |
| 59 |
{ } |
| 60 |
|
| 61 |
protected: |
| 62 |
int |
| 63 |
statement(Block*, size_t* pindex, Statement*); |
| 64 |
|
| 65 |
private: |
| 66 |
Ast_dump_context* ast_dump_context_; |
| 67 |
}; |
| 68 |
|
| 69 |
// For each block we enclose it in brackets. |
| 70 |
|
| 71 |
int Ast_dump_traverse_blocks_and_functions::block(Block * block) |
| 72 |
{ |
| 73 |
if (block == NULL) |
| 74 |
{ |
| 75 |
this->ast_dump_context_->ostream() << std::endl; |
| 76 |
return TRAVERSE_EXIT; |
| 77 |
} |
| 78 |
|
| 79 |
this->ast_dump_context_->print_indent(); |
| 80 |
this->ast_dump_context_->ostream() << "{" << std::endl; |
| 81 |
this->ast_dump_context_->indent(); |
| 82 |
|
| 83 |
// Dump statememts. |
| 84 |
Ast_dump_traverse_statements adts(this->ast_dump_context_); |
| 85 |
block->traverse(&adts); |
| 86 |
|
| 87 |
this->ast_dump_context_->unindent(); |
| 88 |
this->ast_dump_context_->print_indent(); |
| 89 |
this->ast_dump_context_->ostream() << "}" << std::endl; |
| 90 |
|
| 91 |
return TRAVERSE_SKIP_COMPONENTS; |
| 92 |
} |
| 93 |
|
| 94 |
// Dump each traversed statement. |
| 95 |
|
| 96 |
int |
| 97 |
Ast_dump_traverse_statements::statement(Block* block, size_t* pindex, |
| 98 |
Statement* statement) |
| 99 |
{ |
| 100 |
statement->dump_statement(this->ast_dump_context_); |
| 101 |
|
| 102 |
if (statement->is_block_statement()) |
| 103 |
{ |
| 104 |
Ast_dump_traverse_blocks_and_functions adtbf(this->ast_dump_context_); |
| 105 |
statement->traverse(block, pindex, &adtbf); |
| 106 |
} |
| 107 |
|
| 108 |
return TRAVERSE_SKIP_COMPONENTS; |
| 109 |
} |
| 110 |
|
| 111 |
// Dump the function header. |
| 112 |
|
| 113 |
int |
| 114 |
Ast_dump_traverse_blocks_and_functions::function(Named_object* no) |
| 115 |
{ |
| 116 |
this->ast_dump_context_->ostream() << no->name(); |
| 117 |
|
| 118 |
go_assert(no->is_function()); |
| 119 |
Function* func = no->func_value(); |
| 120 |
|
| 121 |
this->ast_dump_context_->ostream() << "("; |
| 122 |
this->ast_dump_context_->dump_typed_identifier_list( |
| 123 |
func->type()->parameters()); |
| 124 |
|
| 125 |
this->ast_dump_context_->ostream() << ")"; |
| 126 |
|
| 127 |
Function::Results* res = func->result_variables(); |
| 128 |
if (res != NULL && !res->empty()) |
| 129 |
{ |
| 130 |
this->ast_dump_context_->ostream() << " ("; |
| 131 |
|
| 132 |
for (Function::Results::const_iterator it = res->begin(); |
| 133 |
it != res->end(); |
| 134 |
it++) |
| 135 |
{ |
| 136 |
if (it != res->begin()) |
| 137 |
this->ast_dump_context_->ostream() << ","; |
| 138 |
Named_object* rno = (*it); |
| 139 |
|
| 140 |
this->ast_dump_context_->ostream() << rno->name() << " "; |
| 141 |
go_assert(rno->is_result_variable()); |
| 142 |
Result_variable* resvar = rno->result_var_value(); |
| 143 |
|
| 144 |
this->ast_dump_context_->dump_type(resvar->type()); |
| 145 |
|
| 146 |
} |
| 147 |
this->ast_dump_context_->ostream() << ")"; |
| 148 |
} |
| 149 |
|
| 150 |
this->ast_dump_context_->ostream() << " : "; |
| 151 |
this->ast_dump_context_->dump_type(func->type()); |
| 152 |
this->ast_dump_context_->ostream() << std::endl; |
| 153 |
|
| 154 |
return TRAVERSE_CONTINUE; |
| 155 |
} |
| 156 |
|
| 157 |
// Dump variable preinits |
| 158 |
|
| 159 |
int |
| 160 |
Ast_dump_traverse_blocks_and_functions::variable(Named_object* no) |
| 161 |
{ |
| 162 |
if (!no->is_variable()) |
| 163 |
return TRAVERSE_CONTINUE; |
| 164 |
|
| 165 |
Variable* var = no->var_value(); |
| 166 |
if (var->has_pre_init()) |
| 167 |
{ |
| 168 |
this->ast_dump_context_->ostream() << "// preinit block for var " |
| 169 |
<< no->message_name() << "\n"; |
| 170 |
var->preinit()->traverse(this); |
| 171 |
} |
| 172 |
|
| 173 |
return TRAVERSE_CONTINUE; |
| 174 |
} |
| 175 |
|
| 176 |
|
| 177 |
|
| 178 |
// Class Ast_dump_context. |
| 179 |
|
| 180 |
Ast_dump_context::Ast_dump_context(std::ostream* out /* = NULL */, |
| 181 |
bool dump_subblocks /* = true */) |
| 182 |
: indent_(0), dump_subblocks_(dump_subblocks), ostream_(out), gogo_(NULL) |
| 183 |
{ |
| 184 |
} |
| 185 |
|
| 186 |
// Dump files will be named %basename%.dump.ast |
| 187 |
|
| 188 |
const char* kAstDumpFileExtension = ".dump.ast"; |
| 189 |
|
| 190 |
// Dump the internal representation. |
| 191 |
|
| 192 |
void |
| 193 |
Ast_dump_context::dump(Gogo* gogo, const char* basename) |
| 194 |
{ |
| 195 |
std::ofstream out; |
| 196 |
std::string dumpname(basename); |
| 197 |
dumpname += ".dump.ast"; |
| 198 |
out.open(dumpname.c_str()); |
| 199 |
|
| 200 |
if (out.fail()) |
| 201 |
{ |
| 202 |
go_error_at(Linemap::unknown_location(), |
| 203 |
"cannot open %s:%m; %<-fgo-dump-ast%> ignored", |
| 204 |
dumpname.c_str()); |
| 205 |
return; |
| 206 |
} |
| 207 |
|
| 208 |
this->gogo_ = gogo; |
| 209 |
this->ostream_ = &out; |
| 210 |
|
| 211 |
Ast_dump_traverse_blocks_and_functions adtbf(this); |
| 212 |
gogo->traverse(&adtbf); |
| 213 |
|
| 214 |
out.close(); |
| 215 |
} |
| 216 |
|
| 217 |
// Dump a textual representation of a type to the |
| 218 |
// the dump file. |
| 219 |
|
| 220 |
void |
| 221 |
Ast_dump_context::dump_type(const Type* t) |
| 222 |
{ |
| 223 |
if (t == NULL) |
| 224 |
this->ostream() << "(nil type)"; |
| 225 |
else |
| 226 |
this->ostream() << "(" << t->message_name() << ")"; |
| 227 |
} |
| 228 |
|
| 229 |
// Dump a textual representation of a block to the |
| 230 |
// the dump file. |
| 231 |
|
| 232 |
void |
| 233 |
Ast_dump_context::dump_block(Block* b) |
| 234 |
{ |
| 235 |
Ast_dump_traverse_blocks_and_functions adtbf(this); |
| 236 |
b->traverse(&adtbf); |
| 237 |
} |
| 238 |
|
| 239 |
// Dump a textual representation of an expression to the |
| 240 |
// the dump file. |
| 241 |
|
| 242 |
void |
| 243 |
Ast_dump_context::dump_expression(const Expression* e) |
| 244 |
{ |
| 245 |
e->dump_expression(this); |
| 246 |
} |
| 247 |
|
| 248 |
// Dump a textual representation of an expression list to the |
| 249 |
// the dump file. |
| 250 |
|
| 251 |
void |
| 252 |
Ast_dump_context::dump_expression_list(const Expression_list* el, |
| 253 |
bool as_pairs /* = false */) |
| 254 |
{ |
| 255 |
if (el == NULL) |
| 256 |
return; |
| 257 |
|
| 258 |
for (std::vector<Expression*>::const_iterator it = el->begin(); |
| 259 |
it != el->end(); |
| 260 |
it++) |
| 261 |
{ |
| 262 |
if ( it != el->begin()) |
| 263 |
this->ostream() << ","; |
| 264 |
if (*it != NULL) |
| 265 |
(*it)->dump_expression(this); |
| 266 |
else |
| 267 |
this->ostream() << "NULL"; |
| 268 |
if (as_pairs) |
| 269 |
{ |
| 270 |
this->ostream() << ":"; |
| 271 |
++it; |
| 272 |
(*it)->dump_expression(this); |
| 273 |
} |
| 274 |
} |
| 275 |
} |
| 276 |
|
| 277 |
// Dump a textual representation of a typed identifier to the |
| 278 |
// the dump file. |
| 279 |
|
| 280 |
void |
| 281 |
Ast_dump_context::dump_typed_identifier(const Typed_identifier* ti) |
| 282 |
{ |
| 283 |
this->ostream() << ti->name() << " "; |
| 284 |
this->dump_type(ti->type()); |
| 285 |
} |
| 286 |
|
| 287 |
// Dump a textual representation of a typed identifier list to the |
| 288 |
// the dump file. |
| 289 |
|
| 290 |
void |
| 291 |
Ast_dump_context::dump_typed_identifier_list( |
| 292 |
const Typed_identifier_list* ti_list) |
| 293 |
{ |
| 294 |
if (ti_list == NULL) |
| 295 |
return; |
| 296 |
|
| 297 |
for (Typed_identifier_list::const_iterator it = ti_list->begin(); |
| 298 |
it != ti_list->end(); |
| 299 |
it++) |
| 300 |
{ |
| 301 |
if (it != ti_list->begin()) |
| 302 |
this->ostream() << ","; |
| 303 |
this->dump_typed_identifier(&(*it)); |
| 304 |
} |
| 305 |
} |
| 306 |
|
| 307 |
// Dump a textual representation of a temporary variable to the |
| 308 |
// the dump file. |
| 309 |
|
| 310 |
void |
| 311 |
Ast_dump_context::dump_temp_variable_name(const Statement* s) |
| 312 |
{ |
| 313 |
go_assert(s->classification() == Statement::STATEMENT_TEMPORARY); |
| 314 |
// Use the statement address as part of the name for the temporary variable. |
| 315 |
this->ostream() << "tmp." << (uintptr_t) s; |
| 316 |
} |
| 317 |
|
| 318 |
// Dump a textual representation of a label to the |
| 319 |
// the dump file. |
| 320 |
|
| 321 |
void |
| 322 |
Ast_dump_context::dump_label_name(const Unnamed_label* l) |
| 323 |
{ |
| 324 |
// Use the unnamed label address as part of the name for the temporary |
| 325 |
// variable. |
| 326 |
this->ostream() << "label." << (uintptr_t) l; |
| 327 |
} |
| 328 |
|
| 329 |
// Produce a textual representation of an operator symbol. |
| 330 |
|
| 331 |
static const char* |
| 332 |
op_string(Operator op) |
| 333 |
{ |
| 334 |
// FIXME: This should be in line with symbols that are parsed, |
| 335 |
// exported and/or imported. |
| 336 |
switch (op) |
| 337 |
{ |
| 338 |
case OPERATOR_PLUS: |
| 339 |
return "+"; |
| 340 |
case OPERATOR_MINUS: |
| 341 |
return "-"; |
| 342 |
case OPERATOR_NOT: |
| 343 |
return "!"; |
| 344 |
case OPERATOR_XOR: |
| 345 |
return "^"; |
| 346 |
case OPERATOR_OR: |
| 347 |
return "|"; |
| 348 |
case OPERATOR_AND: |
| 349 |
return "&"; |
| 350 |
case OPERATOR_MULT: |
| 351 |
return "*"; |
| 352 |
case OPERATOR_OROR: |
| 353 |
return "||"; |
| 354 |
case OPERATOR_ANDAND: |
| 355 |
return "&&"; |
| 356 |
case OPERATOR_EQEQ: |
| 357 |
return "=="; |
| 358 |
case OPERATOR_NOTEQ: |
| 359 |
return "!="; |
| 360 |
case OPERATOR_LT: |
| 361 |
return "<"; |
| 362 |
case OPERATOR_LE: |
| 363 |
return "<="; |
| 364 |
case OPERATOR_GT: |
| 365 |
return ">"; |
| 366 |
case OPERATOR_GE: |
| 367 |
return ">="; |
| 368 |
case OPERATOR_DIV: |
| 369 |
return "/"; |
| 370 |
case OPERATOR_MOD: |
| 371 |
return "%"; |
| 372 |
case OPERATOR_LSHIFT: |
| 373 |
return "<<"; |
| 374 |
case OPERATOR_RSHIFT: |
| 375 |
return "//"; |
| 376 |
case OPERATOR_BITCLEAR: |
| 377 |
return "&^"; |
| 378 |
case OPERATOR_CHANOP: |
| 379 |
return "<-"; |
| 380 |
case OPERATOR_PLUSEQ: |
| 381 |
return "+="; |
| 382 |
case OPERATOR_MINUSEQ: |
| 383 |
return "-="; |
| 384 |
case OPERATOR_OREQ: |
| 385 |
return "|="; |
| 386 |
case OPERATOR_XOREQ: |
| 387 |
return "^="; |
| 388 |
case OPERATOR_MULTEQ: |
| 389 |
return "*="; |
| 390 |
case OPERATOR_DIVEQ: |
| 391 |
return "/="; |
| 392 |
case OPERATOR_MODEQ: |
| 393 |
return "%="; |
| 394 |
case OPERATOR_LSHIFTEQ: |
| 395 |
return "<<="; |
| 396 |
case OPERATOR_RSHIFTEQ: |
| 397 |
return ">>="; |
| 398 |
case OPERATOR_ANDEQ: |
| 399 |
return "&="; |
| 400 |
case OPERATOR_BITCLEAREQ: |
| 401 |
return "&^="; |
| 402 |
case OPERATOR_PLUSPLUS: |
| 403 |
return "++"; |
| 404 |
case OPERATOR_MINUSMINUS: |
| 405 |
return "--"; |
| 406 |
case OPERATOR_COLON: |
| 407 |
return ":"; |
| 408 |
case OPERATOR_COLONEQ: |
| 409 |
return ":="; |
| 410 |
case OPERATOR_SEMICOLON: |
| 411 |
return ";"; |
| 412 |
case OPERATOR_DOT: |
| 413 |
return "."; |
| 414 |
case OPERATOR_ELLIPSIS: |
| 415 |
return "..."; |
| 416 |
case OPERATOR_COMMA: |
| 417 |
return ","; |
| 418 |
case OPERATOR_LPAREN: |
| 419 |
return "("; |
| 420 |
case OPERATOR_RPAREN: |
| 421 |
return ")"; |
| 422 |
case OPERATOR_LCURLY: |
| 423 |
return "{"; |
| 424 |
case OPERATOR_RCURLY: |
| 425 |
return "}"; |
| 426 |
case OPERATOR_LSQUARE: |
| 427 |
return "["; |
| 428 |
case OPERATOR_RSQUARE: |
| 429 |
return "]"; |
| 430 |
default: |
| 431 |
go_unreachable(); |
| 432 |
} |
| 433 |
return NULL; |
| 434 |
} |
| 435 |
|
| 436 |
// Dump a textual representation of an operator to the |
| 437 |
// the dump file. |
| 438 |
|
| 439 |
void |
| 440 |
Ast_dump_context::dump_operator(Operator op) |
| 441 |
{ |
| 442 |
this->ostream() << op_string(op); |
| 443 |
} |
| 444 |
|
| 445 |
// Size of a single indent. |
| 446 |
|
| 447 |
const int Ast_dump_context::offset_ = 2; |
| 448 |
|
| 449 |
// Print indenting spaces to dump file. |
| 450 |
|
| 451 |
void |
| 452 |
Ast_dump_context::print_indent() |
| 453 |
{ |
| 454 |
for (int i = 0; i < this->indent_ * this->offset_; i++) |
| 455 |
this->ostream() << " "; |
| 456 |
} |
| 457 |
|
| 458 |
// Dump a textual representation of the ast to the |
| 459 |
// the dump file. |
| 460 |
|
| 461 |
void Gogo::dump_ast(const char* basename) |
| 462 |
{ |
| 463 |
if (::ast_dump_flag.is_enabled()) |
| 464 |
{ |
| 465 |
Ast_dump_context adc; |
| 466 |
adc.dump(this, basename); |
| 467 |
} |
| 468 |
} |
| 469 |
|
| 470 |
// Implementation of String_dump interface. |
| 471 |
|
| 472 |
void |
| 473 |
Ast_dump_context::write_c_string(const char* s) |
| 474 |
{ |
| 475 |
this->ostream() << s; |
| 476 |
} |
| 477 |
|
| 478 |
void |
| 479 |
Ast_dump_context::write_string(const std::string& s) |
| 480 |
{ |
| 481 |
this->ostream() << s; |
| 482 |
} |
| 483 |
|
| 484 |
// Dump statement to stream. |
| 485 |
|
| 486 |
void |
| 487 |
Ast_dump_context::dump_to_stream(const Statement* stm, std::ostream* out) |
| 488 |
{ |
| 489 |
Ast_dump_context adc(out, false); |
| 490 |
stm->dump_statement(&adc); |
| 491 |
} |
| 492 |
|
| 493 |
// Dump expression to stream. |
| 494 |
|
| 495 |
void |
| 496 |
Ast_dump_context::dump_to_stream(const Expression* expr, std::ostream* out) |
| 497 |
{ |
| 498 |
Ast_dump_context adc(out, false); |
| 499 |
expr->dump_expression(&adc); |
| 500 |
} |
| 501 |
|
| 502 |
// Dump an expression to std::cerr. This is intended to be used |
| 503 |
// from within a debugging session. |
| 504 |
|
| 505 |
void |
| 506 |
debug_go_expression(const Expression* expr) |
| 507 |
{ |
| 508 |
if (expr == NULL) |
| 509 |
std::cerr << "<null>"; |
| 510 |
else |
| 511 |
{ |
| 512 |
Ast_dump_context::dump_to_stream(expr, &std::cerr); |
| 513 |
std::string lstr = Linemap::location_to_string(expr->location()); |
| 514 |
std::cerr << " // loc " << lstr << std::endl; |
| 515 |
} |
| 516 |
} |
| 517 |
|
| 518 |
// Shallow dump of stmt to std::cerr. This is intended to be used |
| 519 |
// from within a debugging session. |
| 520 |
|
| 521 |
void |
| 522 |
debug_go_statement(const Statement* stmt) |
| 523 |
{ |
| 524 |
if (stmt == NULL) |
| 525 |
std::cerr << "<null>\n"; |
| 526 |
else |
| 527 |
{ |
| 528 |
std::string lstr = Linemap::location_to_string(stmt->location()); |
| 529 |
Statement *ncstmt = const_cast<Statement*>(stmt); |
| 530 |
Block_statement* bs = ncstmt->block_statement(); |
| 531 |
if (bs != NULL) |
| 532 |
std::cerr << "Block " << bs->block() |
| 533 |
<< " // location: " << lstr << std::endl; |
| 534 |
else |
| 535 |
Ast_dump_context::dump_to_stream(stmt, &std::cerr); |
| 536 |
} |
| 537 |
} |
| 538 |
|
| 539 |
// Deep dump of statement to std::cerr. This is intended to be used |
| 540 |
// from within a debugging session. |
| 541 |
|
| 542 |
void |
| 543 |
debug_go_statement_deep(const Statement* statement) |
| 544 |
{ |
| 545 |
Ast_dump_context adc(&std::cerr, true); |
| 546 |
statement->dump_statement(&adc); |
| 547 |
} |
| 548 |
|
| 549 |
// Shallow dump of a block to std::cerr. This is intended to be used |
| 550 |
// from within a debugging session. |
| 551 |
|
| 552 |
void |
| 553 |
debug_go_block(const Block* block) |
| 554 |
{ |
| 555 |
if (block == NULL) |
| 556 |
std::cerr << "<null>"; |
| 557 |
else |
| 558 |
{ |
| 559 |
std::cerr << "Block " << block |
| 560 |
<< " (enclosing " << block->enclosing() << "):\n"; |
| 561 |
const std::vector<Statement*>* stmts = block->statements(); |
| 562 |
if (stmts != NULL) |
| 563 |
{ |
| 564 |
for (size_t i = 0; i < stmts->size(); ++i) |
| 565 |
{ |
| 566 |
debug_go_statement(stmts->at(i)); |
| 567 |
} |
| 568 |
} |
| 569 |
} |
| 570 |
} |
| 571 |
|
| 572 |
// Deep dump of a block to std:cerr. This is intended to be used |
| 573 |
// from within a debugging session. |
| 574 |
|
| 575 |
void |
| 576 |
debug_go_block_deep(const Block* block) |
| 577 |
{ |
| 578 |
Ast_dump_context adc(&std::cerr, true); |
| 579 |
Block* ncblock = const_cast<Block*>(block); |
| 580 |
adc.dump_block(ncblock); |
| 581 |
} |
| 582 |
|
| 583 |
class Type_dumper |
| 584 |
{ |
| 585 |
typedef Unordered_map(const Type*, unsigned) idx_map; |
| 586 |
public: |
| 587 |
Type_dumper(const Type* type) |
| 588 |
: top_(type), ntypes_(0) |
| 589 |
{ |
| 590 |
this->worklist_.push_back(type); |
| 591 |
} |
| 592 |
|
| 593 |
void visit(); |
| 594 |
|
| 595 |
std::string stringResult() { return ss_.str(); } |
| 596 |
|
| 597 |
private: |
| 598 |
void emitpre(unsigned tag, const Type* addr); |
| 599 |
void typeref(const char*, const Type*, const char *); |
| 600 |
void visit_forward_declaration_type(const Forward_declaration_type* fdt); |
| 601 |
void visit_function_type(const Function_type* ft); |
| 602 |
void visit_struct_type(const Struct_type* st); |
| 603 |
void visit_array_type(const Array_type* at); |
| 604 |
void visit_map_type(const Map_type* mt); |
| 605 |
void visit_channel_type(const Channel_type* mt); |
| 606 |
void visit_interface_type(const Interface_type* mt); |
| 607 |
void visit_methods(const Typed_identifier_list* methods, |
| 608 |
const char *tag); |
| 609 |
std::pair<bool, unsigned> lookup(const Type*); |
| 610 |
|
| 611 |
static const unsigned notag = 0xffffffff; |
| 612 |
|
| 613 |
private: |
| 614 |
const Type* top_; |
| 615 |
idx_map types_; |
| 616 |
unsigned ntypes_; |
| 617 |
std::list<const Type*> worklist_; |
| 618 |
std::ostringstream ss_; |
| 619 |
}; |
| 620 |
|
| 621 |
// Look up a type, installing it in 'types_'. Return is <found, N> |
| 622 |
// where 'found' is true if type had been previously recorded, and N |
| 623 |
// is the index/tag assigned to N. The input argument is appended to |
| 624 |
// the work list if this is the first time we've seen it. |
| 625 |
|
| 626 |
std::pair<bool, unsigned> Type_dumper::lookup(const Type* t) |
| 627 |
{ |
| 628 |
std::pair<const Type*, unsigned> entry = std::make_pair(t, this->ntypes_); |
| 629 |
std::pair<idx_map::iterator, bool> ins = this->types_.insert(entry); |
| 630 |
if (ins.second) |
| 631 |
{ |
| 632 |
this->ntypes_++; |
| 633 |
if (t != this->top_) |
| 634 |
this->worklist_.push_back(t); |
| 635 |
} |
| 636 |
return std::make_pair(ins.second, ins.first->second); |
| 637 |
} |
| 638 |
|
| 639 |
// Emit preamble prior to dumping a type, including the type |
| 640 |
// pointer itself and the tag we've assigned it. If no |
| 641 |
// tag is specified (via special "notag" value) and/or the |
| 642 |
// pointer is null, then just emit an equivalent amount |
| 643 |
// of spaces. |
| 644 |
|
| 645 |
void Type_dumper::emitpre(unsigned tag, const Type* ptr) |
| 646 |
{ |
| 647 |
char tbuf[50], pbuf[50], buf[200]; |
| 648 |
|
| 649 |
tbuf[0] = '\0'; |
| 650 |
if (tag != notag) |
| 651 |
snprintf(tbuf, sizeof tbuf, "T%u", tag); |
| 652 |
|
| 653 |
pbuf[0] = '\0'; |
| 654 |
if (ptr != NULL) |
| 655 |
snprintf(pbuf, sizeof pbuf, "%p", (const void*) ptr); |
| 656 |
|
| 657 |
snprintf(buf, sizeof buf, "%8s %16s ", tbuf, pbuf); |
| 658 |
this->ss_ << buf; |
| 659 |
} |
| 660 |
|
| 661 |
// Emit a reference to a type into the dump buffer. In most cases this means |
| 662 |
// just the type tag, but for named types we also emit the name, and for |
| 663 |
// simple/primitive types (ex: int64) we emit the type itself. If "pref" is |
| 664 |
// non-NULL, emit the string prior to the reference, and if "suf" is non-NULL, |
| 665 |
// emit it following the reference. |
| 666 |
|
| 667 |
void Type_dumper::typeref(const char* pref, const Type* t, const char* suf) |
| 668 |
{ |
| 669 |
if (pref != NULL) |
| 670 |
this->ss_ << pref; |
| 671 |
std::pair<bool, unsigned> p = this->lookup(t); |
| 672 |
unsigned tag = p.second; |
| 673 |
switch (t->classification()) |
| 674 |
{ |
| 675 |
case Type::TYPE_NAMED: |
| 676 |
{ |
| 677 |
const Named_type* nt = t->named_type(); |
| 678 |
const Named_object* no = nt->named_object(); |
| 679 |
this->ss_ << "'" << no->message_name() << "' -> "; |
| 680 |
const Type* underlying = nt->real_type(); |
| 681 |
this->typeref(NULL, underlying, NULL); |
| 682 |
break; |
| 683 |
} |
| 684 |
case Type::TYPE_POINTER: |
| 685 |
this->typeref("*", t->points_to(), NULL); |
| 686 |
break; |
| 687 |
case Type::TYPE_ERROR: |
| 688 |
this->ss_ << "error_type"; |
| 689 |
break; |
| 690 |
case Type::TYPE_INTEGER: |
| 691 |
{ |
| 692 |
const Integer_type* it = t->integer_type(); |
| 693 |
if (it->is_abstract()) |
| 694 |
this->ss_ << "abstract_int"; |
| 695 |
else |
| 696 |
this->ss_ << (it->is_unsigned() ? "u" : "") << "int" << it->bits(); |
| 697 |
break; |
| 698 |
} |
| 699 |
case Type::TYPE_FLOAT: |
| 700 |
{ |
| 701 |
const Float_type* ft = t->float_type(); |
| 702 |
if (ft->is_abstract()) |
| 703 |
this->ss_ << "abstract_float"; |
| 704 |
else |
| 705 |
this->ss_ << "float" << ft->bits(); |
| 706 |
break; |
| 707 |
} |
| 708 |
case Type::TYPE_COMPLEX: |
| 709 |
{ |
| 710 |
const Complex_type* ct = t->complex_type(); |
| 711 |
if (ct->is_abstract()) |
| 712 |
this->ss_ << "abstract_complex"; |
| 713 |
else |
| 714 |
this->ss_ << "complex" << ct->bits(); |
| 715 |
break; |
| 716 |
} |
| 717 |
case Type::TYPE_BOOLEAN: |
| 718 |
this->ss_ << "bool"; |
| 719 |
break; |
| 720 |
case Type::TYPE_STRING: |
| 721 |
this->ss_ << "string"; |
| 722 |
break; |
| 723 |
case Type::TYPE_NIL: |
| 724 |
this->ss_ << "nil_type"; |
| 725 |
break; |
| 726 |
case Type::TYPE_VOID: |
| 727 |
this->ss_ << "void_type"; |
| 728 |
break; |
| 729 |
case Type::TYPE_FUNCTION: |
| 730 |
case Type::TYPE_STRUCT: |
| 731 |
case Type::TYPE_ARRAY: |
| 732 |
case Type::TYPE_MAP: |
| 733 |
case Type::TYPE_CHANNEL: |
| 734 |
case Type::TYPE_FORWARD: |
| 735 |
case Type::TYPE_INTERFACE: |
| 736 |
this->ss_ << "T" << tag; |
| 737 |
break; |
| 738 |
|
| 739 |
default: |
| 740 |
// This is a debugging routine, so instead of a go_unreachable() |
| 741 |
// issue a warning/error, to allow for the possibility that the |
| 742 |
// compiler we're debugging is in a bad state. |
| 743 |
this->ss_ << "<??? " << ((unsigned)t->classification()) << "> " |
| 744 |
<< "T" << tag; |
| 745 |
} |
| 746 |
if (suf != NULL) |
| 747 |
this->ss_ << suf; |
| 748 |
} |
| 749 |
|
| 750 |
void Type_dumper::visit_forward_declaration_type(const Forward_declaration_type* fdt) |
| 751 |
{ |
| 752 |
this->ss_ << "forward_declaration_type "; |
| 753 |
if (fdt->is_defined()) |
| 754 |
this->typeref("-> ", fdt->real_type(), NULL); |
| 755 |
else |
| 756 |
this->ss_ << "'" << fdt->name() << "'"; |
| 757 |
this->ss_ << "\n"; |
| 758 |
} |
| 759 |
|
| 760 |
void Type_dumper::visit_function_type(const Function_type* ft) |
| 761 |
{ |
| 762 |
this->ss_ << "function\n"; |
| 763 |
const Typed_identifier* rec = ft->receiver(); |
| 764 |
if (rec != NULL) |
| 765 |
{ |
| 766 |
this->emitpre(notag, NULL); |
| 767 |
this->typeref("receiver ", rec->type(), "\n"); |
| 768 |
} |
| 769 |
const Typed_identifier_list* parameters = ft->parameters(); |
| 770 |
if (parameters != NULL) |
| 771 |
{ |
| 772 |
for (Typed_identifier_list::const_iterator p = parameters->begin(); |
| 773 |
p != parameters->end(); |
| 774 |
++p) |
| 775 |
{ |
| 776 |
this->emitpre(notag, NULL); |
| 777 |
this->typeref(" param ", p->type(), "\n"); |
| 778 |
} |
| 779 |
} |
| 780 |
const Typed_identifier_list* results = ft->results(); |
| 781 |
if (results != NULL) |
| 782 |
{ |
| 783 |
for (Typed_identifier_list::const_iterator p = results->begin(); |
| 784 |
p != results->end(); |
| 785 |
++p) |
| 786 |
{ |
| 787 |
this->emitpre(notag, NULL); |
| 788 |
this->typeref(" result ", p->type(), "\n"); |
| 789 |
} |
| 790 |
} |
| 791 |
} |
| 792 |
|
| 793 |
void Type_dumper::visit_struct_type(const Struct_type* st) |
| 794 |
{ |
| 795 |
this->ss_ << "struct\n"; |
| 796 |
const Struct_field_list* fields = st->fields(); |
| 797 |
if (fields != NULL) |
| 798 |
{ |
| 799 |
for (Struct_field_list::const_iterator p = fields->begin(); |
| 800 |
p != fields->end(); |
| 801 |
++p) |
| 802 |
{ |
| 803 |
this->emitpre(notag, NULL); |
| 804 |
this->typeref(" field ", p->type(), "\n"); |
| 805 |
} |
| 806 |
} |
| 807 |
} |
| 808 |
|
| 809 |
void Type_dumper::visit_array_type(const Array_type* at) |
| 810 |
{ |
| 811 |
this->ss_ << "array ["; |
| 812 |
if (at->length() != NULL) |
| 813 |
{ |
| 814 |
int64_t len = 0; |
| 815 |
if (at->int_length(&len)) |
| 816 |
this->ss_ << len; |
| 817 |
} |
| 818 |
this->typeref("] ", at->element_type(), "\n"); |
| 819 |
} |
| 820 |
|
| 821 |
void Type_dumper::visit_map_type(const Map_type* mt) |
| 822 |
{ |
| 823 |
this->ss_ << "map ["; |
| 824 |
this->typeref(NULL, mt->key_type(), NULL); |
| 825 |
this->typeref("] ", mt->val_type(), "\n"); |
| 826 |
} |
| 827 |
|
| 828 |
void Type_dumper::visit_methods(const Typed_identifier_list* methods, |
| 829 |
const char *tag) |
| 830 |
{ |
| 831 |
if (tag != NULL) |
| 832 |
{ |
| 833 |
this->emitpre(notag, NULL); |
| 834 |
this->ss_ << tag << "\n"; |
| 835 |
} |
| 836 |
for (Typed_identifier_list::const_iterator p = methods->begin(); |
| 837 |
p != methods->end(); |
| 838 |
++p) |
| 839 |
{ |
| 840 |
this->emitpre(notag, NULL); |
| 841 |
if (p->name().empty()) |
| 842 |
this->typeref(" embedded method ", p->type(), "\n"); |
| 843 |
else |
| 844 |
{ |
| 845 |
this->ss_ << " method '" << p->name() << "' "; |
| 846 |
this->typeref(NULL, p->type(), "\n"); |
| 847 |
} |
| 848 |
} |
| 849 |
} |
| 850 |
|
| 851 |
void Type_dumper::visit_interface_type(const Interface_type* it) |
| 852 |
{ |
| 853 |
const Typed_identifier_list* methods = |
| 854 |
(it->methods_are_finalized() ? it->methods() : it->local_methods()); |
| 855 |
if (methods == NULL) |
| 856 |
{ |
| 857 |
this->ss_ << "empty_interface\n"; |
| 858 |
return; |
| 859 |
} |
| 860 |
this->ss_ << "interface"; |
| 861 |
if (! it->methods_are_finalized()) |
| 862 |
{ |
| 863 |
this->ss_ << " [unfinalized]\n"; |
| 864 |
visit_methods(it->local_methods(), NULL); |
| 865 |
} |
| 866 |
else |
| 867 |
{ |
| 868 |
this->ss_ << "\n"; |
| 869 |
visit_methods(it->local_methods(), "[parse_methods]"); |
| 870 |
visit_methods(it->methods(), "[all_methods]"); |
| 871 |
} |
| 872 |
} |
| 873 |
|
| 874 |
void Type_dumper::visit_channel_type(const Channel_type* ct) |
| 875 |
{ |
| 876 |
this->ss_ << "channel {"; |
| 877 |
if (ct->may_send()) |
| 878 |
this->ss_ << " send"; |
| 879 |
if (ct->may_receive()) |
| 880 |
this->ss_ << " receive"; |
| 881 |
this->typeref(" } ", ct->element_type(), "\n"); |
| 882 |
} |
| 883 |
|
| 884 |
void Type_dumper::visit() |
| 885 |
{ |
| 886 |
while (! this->worklist_.empty()) { |
| 887 |
const Type* t = this->worklist_.front(); |
| 888 |
this->worklist_.pop_front(); |
| 889 |
|
| 890 |
std::pair<bool, unsigned> p = this->lookup(t); |
| 891 |
unsigned tag = p.second; |
| 892 |
this->emitpre(tag, t); |
| 893 |
|
| 894 |
switch(t->classification()) |
| 895 |
{ |
| 896 |
case Type::TYPE_ERROR: |
| 897 |
case Type::TYPE_INTEGER: |
| 898 |
case Type::TYPE_FLOAT: |
| 899 |
case Type::TYPE_COMPLEX: |
| 900 |
case Type::TYPE_BOOLEAN: |
| 901 |
case Type::TYPE_STRING: |
| 902 |
case Type::TYPE_VOID: |
| 903 |
case Type::TYPE_POINTER: |
| 904 |
case Type::TYPE_NIL: |
| 905 |
case Type::TYPE_NAMED: |
| 906 |
this->typeref(NULL, t, "\n"); |
| 907 |
break; |
| 908 |
case Type::TYPE_FORWARD: |
| 909 |
this->visit_forward_declaration_type(t->forward_declaration_type()); |
| 910 |
break; |
| 911 |
|
| 912 |
case Type::TYPE_FUNCTION: |
| 913 |
this->visit_function_type(t->function_type()); |
| 914 |
break; |
| 915 |
case Type::TYPE_STRUCT: |
| 916 |
this->visit_struct_type(t->struct_type()); |
| 917 |
break; |
| 918 |
case Type::TYPE_ARRAY: |
| 919 |
this->visit_array_type(t->array_type()); |
| 920 |
break; |
| 921 |
case Type::TYPE_MAP: |
| 922 |
this->visit_map_type(t->map_type()); |
| 923 |
break; |
| 924 |
case Type::TYPE_CHANNEL: |
| 925 |
this->visit_channel_type(t->channel_type()); |
| 926 |
break; |
| 927 |
case Type::TYPE_INTERFACE: |
| 928 |
this->visit_interface_type(t->interface_type()); |
| 929 |
break; |
| 930 |
default: |
| 931 |
// This is a debugging routine, so instead of a go_unreachable() |
| 932 |
// issue a warning/error, to allow for the possibility that the |
| 933 |
// compiler we're debugging is in a bad state. |
| 934 |
this->ss_ << "<unknown/unrecognized classification " |
| 935 |
<< ((unsigned)t->classification()) << ">\n"; |
| 936 |
} |
| 937 |
} |
| 938 |
} |
| 939 |
|
| 940 |
// Dump a Go type for debugging purposes. This is a deep as opposed |
| 941 |
// to shallow dump; all of the types reachable from the specified |
| 942 |
// type will be dumped in addition to the type itself. |
| 943 |
|
| 944 |
void debug_go_type(const Type* type) |
| 945 |
{ |
| 946 |
if (type == NULL) |
| 947 |
{ |
| 948 |
std::cerr << "<NULL type>\n"; |
| 949 |
return; |
| 950 |
} |
| 951 |
Type_dumper dumper(type); |
| 952 |
dumper.visit(); |
| 953 |
std::cerr << dumper.stringResult(); |
| 954 |
} |
| 955 |
|
| 956 |
void debug_go_type(Type* type) |
| 957 |
{ |
| 958 |
const Type* ctype = type; |
| 959 |
debug_go_type(ctype); |
| 960 |
} |