Changeset cde1bf9
- Timestamp:
- Nov 26, 2020, 5:20:30 PM (4 years ago)
- Branches:
- ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum
- Children:
- 849de65
- Parents:
- af333e3 (diff), 6e7b969 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)links above to see all the changes relative to each parent. - Files:
-
- 1 added
- 4 edited
-
doc/theses/andrew_beach_MMath/Makefile (modified) (1 diff)
-
doc/theses/andrew_beach_MMath/cfalab.sty (modified) (2 diffs)
-
doc/theses/andrew_beach_MMath/existing.tex (added)
-
doc/theses/andrew_beach_MMath/thesis.tex (modified) (1 diff)
-
src/SymTab/Mangler.cc (modified) (41 diffs)
Legend:
- Unmodified
- Added
- Removed
-
doc/theses/andrew_beach_MMath/Makefile
raf333e3 rcde1bf9 31 31 ${GLOSSARY} ${BUILD}/${BASE} 32 32 ${LATEX} ${BASE} 33 ${LATEX} ${BASE}34 33 35 34 ${DOC}: ${BUILD}/${DOC} -
doc/theses/andrew_beach_MMath/cfalab.sty
raf333e3 rcde1bf9 27 27 % Cforall with the forall symbol. 28 28 \newsymbolcmd\CFA{\textsf{C}\raisebox{\depth}{\rotatebox{180}{\textsf{A}}}} 29 % C++ with kerning. (No standard number support.) 30 \newsymbolcmd\CPP{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}} 31 32 % This is executed very early in the \begin{document} code. 33 \AtEndPreamble{ 34 \@ifpackageloaded{hyperref}{ 35 % Convert symbols to pdf compatable forms when required. 36 \pdfstringdefDisableCommands{ 37 \def\CFA{CFA} 38 \def\CPP{C++} 39 } 40 }{} 41 } 29 42 30 43 % The CFA listings language. Based off of ANCI C and including GCC extensions. … … 72 85 \renewcommand\textunderscore{\csuse{cfalab@textunderscore@#1}}} 73 86 74 % This is executed very early in the \begin{document} code.75 \AtEndPreamble{76 \@ifpackageloaded{hyperref}{77 % Convert symbols to pdf compatable forms when required.78 \pdfstringdefDisableCommands{79 \def\CFA{CFA}80 }81 }{}82 }83 84 87 \endinput -
doc/theses/andrew_beach_MMath/thesis.tex
raf333e3 rcde1bf9 50 50 % MAIN BODY 51 51 %---------------------------------------------------------------------- 52 \input{existing} 53 \input{features} 52 54 \input{unwinding} 55 \input{future} 53 56 54 57 %====================================================================== -
src/SymTab/Mangler.cc
raf333e3 rcde1bf9 10 10 // Created On : Sun May 17 21:40:29 2015 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Sat Feb 15 13:55:12202013 // Update Count : 3312 // Last Modified On : Wed Nov 18 12:01:38 2020 13 // Update Count : 64 14 14 // 15 15 #include "Mangler.h" … … 65 65 void postvisit( const QualifiedType * qualType ); 66 66 67 std::string get_mangleName() { return mangleName .str(); }67 std::string get_mangleName() { return mangleName; } 68 68 private: 69 std:: ostringstream mangleName;///< Mangled name being constructed69 std::string mangleName; ///< Mangled name being constructed 70 70 typedef std::map< std::string, std::pair< int, int > > VarMapType; 71 71 VarMapType varNums; ///< Map of type variables to indices … … 127 127 isTopLevel = false; 128 128 } // if 129 mangleName <<Encoding::manglePrefix;129 mangleName += Encoding::manglePrefix; 130 130 const CodeGen::OperatorInfo * opInfo = CodeGen::operatorLookup( declaration->get_name() ); 131 131 if ( opInfo ) { 132 mangleName << opInfo->outputName.size() <<opInfo->outputName;132 mangleName += std::to_string( opInfo->outputName.size() ) + opInfo->outputName; 133 133 } else { 134 mangleName << declaration->name.size() <<declaration->name;134 mangleName += std::to_string( declaration->name.size() ) + declaration->name; 135 135 } // if 136 136 maybeAccept( declaration->get_type(), *visitor ); … … 139 139 // so they need a different name mangling 140 140 if ( declaration->get_linkage() == LinkageSpec::AutoGen ) { 141 mangleName <<Encoding::autogen;141 mangleName += Encoding::autogen; 142 142 } else if ( declaration->get_linkage() == LinkageSpec::Intrinsic ) { 143 mangleName <<Encoding::intrinsic;143 mangleName += Encoding::intrinsic; 144 144 } else { 145 145 // if we add another kind of overridable function, this has to change … … 160 160 void Mangler_old::postvisit( const VoidType * voidType ) { 161 161 printQualifiers( voidType ); 162 mangleName <<Encoding::void_t;162 mangleName += Encoding::void_t; 163 163 } 164 164 … … 166 166 printQualifiers( basicType ); 167 167 assertf( basicType->kind < BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->kind ); 168 mangleName <<Encoding::basicTypes[ basicType->kind ];168 mangleName += Encoding::basicTypes[ basicType->kind ]; 169 169 } 170 170 … … 172 172 printQualifiers( pointerType ); 173 173 // mangle void (*f)() and void f() to the same name to prevent overloading on functions and function pointers 174 if ( ! dynamic_cast<FunctionType *>( pointerType->base ) ) mangleName <<Encoding::pointer;174 if ( ! dynamic_cast<FunctionType *>( pointerType->base ) ) mangleName += Encoding::pointer; 175 175 maybeAccept( pointerType->base, *visitor ); 176 176 } … … 179 179 // TODO: encode dimension 180 180 printQualifiers( arrayType ); 181 mangleName << Encoding::array <<"0";181 mangleName += Encoding::array + "0"; 182 182 maybeAccept( arrayType->base, *visitor ); 183 183 } … … 204 204 void Mangler_old::postvisit( const FunctionType * functionType ) { 205 205 printQualifiers( functionType ); 206 mangleName <<Encoding::function;206 mangleName += Encoding::function; 207 207 // turn on inFunctionType so that printQualifiers does not print most qualifiers for function parameters, 208 208 // since qualifiers on outermost parameter type do not differentiate function types, e.g., … … 211 211 inFunctionType = true; 212 212 std::list< Type* > returnTypes = getTypes( functionType->returnVals ); 213 if (returnTypes.empty()) mangleName <<Encoding::void_t;213 if (returnTypes.empty()) mangleName += Encoding::void_t; 214 214 else acceptAll( returnTypes, *visitor ); 215 mangleName <<"_";215 mangleName += "_"; 216 216 std::list< Type* > paramTypes = getTypes( functionType->parameters ); 217 217 acceptAll( paramTypes, *visitor ); 218 mangleName <<"_";218 mangleName += "_"; 219 219 } 220 220 … … 222 222 printQualifiers( refType ); 223 223 224 mangleName << prefix << refType->name.length() <<refType->name;224 mangleName += prefix + std::to_string( refType->name.length() ) + refType->name; 225 225 226 226 if ( mangleGenericParams ) { 227 227 const std::list< Expression* > & params = refType->parameters; 228 228 if ( ! params.empty() ) { 229 mangleName <<"_";229 mangleName += "_"; 230 230 for ( const Expression * param : params ) { 231 231 const TypeExpr * paramType = dynamic_cast< const TypeExpr * >( param ); … … 233 233 maybeAccept( paramType->type, *visitor ); 234 234 } 235 mangleName <<"_";235 mangleName += "_"; 236 236 } 237 237 } … … 262 262 // are first found and prefixing with the appropriate encoding for the type class. 263 263 assertf( varNum->second.second < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", varNum->second.second ); 264 mangleName << Encoding::typeVariables[varNum->second.second] << varNum->second.first;264 mangleName += Encoding::typeVariables[varNum->second.second] + std::to_string( varNum->second.first ); 265 265 } // if 266 266 } … … 268 268 void Mangler_old::postvisit( const TraitInstType * inst ) { 269 269 printQualifiers( inst ); 270 mangleName << inst->name.size() <<inst->name;270 mangleName += std::to_string( inst->name.size() ) + inst->name; 271 271 } 272 272 273 273 void Mangler_old::postvisit( const TupleType * tupleType ) { 274 274 printQualifiers( tupleType ); 275 mangleName << Encoding::tuple << tupleType->types.size();275 mangleName += Encoding::tuple + std::to_string( tupleType->types.size() ); 276 276 acceptAll( tupleType->types, *visitor ); 277 277 } … … 280 280 printQualifiers( varArgsType ); 281 281 static const std::string vargs = "__builtin_va_list"; 282 mangleName << Encoding::type << vargs.size() <<vargs;282 mangleName += Encoding::type + std::to_string( vargs.size() ) + vargs; 283 283 } 284 284 285 285 void Mangler_old::postvisit( const ZeroType * ) { 286 mangleName <<Encoding::zero;286 mangleName += Encoding::zero; 287 287 } 288 288 289 289 void Mangler_old::postvisit( const OneType * ) { 290 mangleName <<Encoding::one;290 mangleName += Encoding::one; 291 291 } 292 292 … … 296 296 // N marks the start of a qualified type 297 297 inQualifiedType = true; 298 mangleName <<Encoding::qualifiedTypeStart;298 mangleName += Encoding::qualifiedTypeStart; 299 299 } 300 300 maybeAccept( qualType->parent, *visitor ); … … 303 303 // E marks the end of a qualified type 304 304 inQualifiedType = false; 305 mangleName <<Encoding::qualifiedTypeEnd;305 mangleName += Encoding::qualifiedTypeEnd; 306 306 } 307 307 } … … 315 315 assertf(false, "Mangler_old should not visit typedecl: %s", toCString(decl)); 316 316 assertf( decl->kind < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->kind ); 317 mangleName << Encoding::typeVariables[ decl->kind ] << ( decl->name.length() ) <<decl->name;317 mangleName += Encoding::typeVariables[ decl->kind ] + std::to_string( decl->name.length() ) + decl->name; 318 318 } 319 319 … … 330 330 std::list< std::string > assertionNames; 331 331 int dcount = 0, fcount = 0, vcount = 0, acount = 0; 332 mangleName <<Encoding::forall;332 mangleName += Encoding::forall; 333 333 for ( const TypeDecl * i : type->forall ) { 334 334 switch ( i->kind ) { … … 354 354 } // for 355 355 } // for 356 mangleName << dcount << "_" << fcount << "_" << vcount << "_" << acount << "_"; 357 std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) ); 358 mangleName << "_"; 356 mangleName += std::to_string( dcount ) + "_" + std::to_string( fcount ) + "_" + std::to_string( vcount ) + "_" + std::to_string( acount ) + "_"; 357 for(const auto & a : assertionNames) mangleName += a; 358 // std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) ); 359 mangleName += "_"; 359 360 } // if 360 361 if ( ! inFunctionType ) { 361 362 // these qualifiers do not distinguish the outermost type of a function parameter 362 363 if ( type->get_const() ) { 363 mangleName <<Encoding::qualifiers.at(Type::Const);364 mangleName += Encoding::qualifiers.at(Type::Const); 364 365 } // if 365 366 if ( type->get_volatile() ) { 366 mangleName <<Encoding::qualifiers.at(Type::Volatile);367 mangleName += Encoding::qualifiers.at(Type::Volatile); 367 368 } // if 368 369 // Removed due to restrict not affecting function compatibility in GCC 369 370 // if ( type->get_isRestrict() ) { 370 // mangleName <<"E";371 // mangleName += "E"; 371 372 // } // if 372 373 if ( type->get_atomic() ) { 373 mangleName <<Encoding::qualifiers.at(Type::Atomic);374 mangleName += Encoding::qualifiers.at(Type::Atomic); 374 375 } // if 375 376 } 376 377 if ( type->get_mutex() ) { 377 mangleName <<Encoding::qualifiers.at(Type::Mutex);378 mangleName += Encoding::qualifiers.at(Type::Mutex); 378 379 } // if 379 380 if ( inFunctionType ) { … … 383 384 } 384 385 } 385 } 386 } // namespace 386 387 } // namespace Mangler 387 388 } // namespace SymTab … … 417 418 void postvisit( const ast::QualifiedType * qualType ); 418 419 419 std::string get_mangleName() { return mangleName .str(); }420 std::string get_mangleName() { return mangleName; } 420 421 private: 421 std:: ostringstream mangleName;///< Mangled name being constructed422 std::string mangleName; ///< Mangled name being constructed 422 423 typedef std::map< std::string, std::pair< int, int > > VarMapType; 423 424 VarMapType varNums; ///< Map of type variables to indices … … 470 471 isTopLevel = false; 471 472 } // if 472 mangleName <<Encoding::manglePrefix;473 mangleName += Encoding::manglePrefix; 473 474 const CodeGen::OperatorInfo * opInfo = CodeGen::operatorLookup( decl->name ); 474 475 if ( opInfo ) { 475 mangleName << opInfo->outputName.size() <<opInfo->outputName;476 mangleName += std::to_string( opInfo->outputName.size() ) + opInfo->outputName; 476 477 } else { 477 mangleName << decl->name.size() <<decl->name;478 mangleName += std::to_string( decl->name.size() ) + decl->name; 478 479 } // if 479 480 maybeAccept( decl->get_type(), *visitor ); … … 482 483 // so they need a different name mangling 483 484 if ( decl->linkage == ast::Linkage::AutoGen ) { 484 mangleName <<Encoding::autogen;485 mangleName += Encoding::autogen; 485 486 } else if ( decl->linkage == ast::Linkage::Intrinsic ) { 486 mangleName <<Encoding::intrinsic;487 mangleName += Encoding::intrinsic; 487 488 } else { 488 489 // if we add another kind of overridable function, this has to change … … 503 504 void Mangler_new::postvisit( const ast::VoidType * voidType ) { 504 505 printQualifiers( voidType ); 505 mangleName <<Encoding::void_t;506 mangleName += Encoding::void_t; 506 507 } 507 508 … … 509 510 printQualifiers( basicType ); 510 511 assertf( basicType->kind < ast::BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->kind ); 511 mangleName <<Encoding::basicTypes[ basicType->kind ];512 mangleName += Encoding::basicTypes[ basicType->kind ]; 512 513 } 513 514 … … 515 516 printQualifiers( pointerType ); 516 517 // mangle void (*f)() and void f() to the same name to prevent overloading on functions and function pointers 517 if ( ! pointerType->base.as<ast::FunctionType>() ) mangleName <<Encoding::pointer;518 if ( ! pointerType->base.as<ast::FunctionType>() ) mangleName += Encoding::pointer; 518 519 maybe_accept( pointerType->base.get(), *visitor ); 519 520 } … … 522 523 // TODO: encode dimension 523 524 printQualifiers( arrayType ); 524 mangleName << Encoding::array <<"0";525 mangleName += Encoding::array + "0"; 525 526 maybeAccept( arrayType->base.get(), *visitor ); 526 527 } … … 545 546 void Mangler_new::postvisit( const ast::FunctionType * functionType ) { 546 547 printQualifiers( functionType ); 547 mangleName <<Encoding::function;548 mangleName += Encoding::function; 548 549 // turn on inFunctionType so that printQualifiers does not print most qualifiers for function parameters, 549 550 // since qualifiers on outermost parameter type do not differentiate function types, e.g., … … 551 552 GuardValue( inFunctionType ); 552 553 inFunctionType = true; 553 if (functionType->returns.empty()) mangleName <<Encoding::void_t;554 if (functionType->returns.empty()) mangleName += Encoding::void_t; 554 555 else accept_each( functionType->returns, *visitor ); 555 mangleName <<"_";556 mangleName += "_"; 556 557 accept_each( functionType->params, *visitor ); 557 mangleName <<"_";558 mangleName += "_"; 558 559 } 559 560 … … 561 562 printQualifiers( refType ); 562 563 563 mangleName << prefix << refType->name.length() <<refType->name;564 mangleName += prefix + std::to_string( refType->name.length() ) + refType->name; 564 565 565 566 if ( mangleGenericParams ) { 566 567 if ( ! refType->params.empty() ) { 567 mangleName <<"_";568 mangleName += "_"; 568 569 for ( const ast::Expr * param : refType->params ) { 569 570 auto paramType = dynamic_cast< const ast::TypeExpr * >( param ); … … 571 572 maybeAccept( paramType->type.get(), *visitor ); 572 573 } 573 mangleName <<"_";574 mangleName += "_"; 574 575 } 575 576 } … … 600 601 // are first found and prefixing with the appropriate encoding for the type class. 601 602 assertf( varNum->second.second < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", varNum->second.second ); 602 mangleName << Encoding::typeVariables[varNum->second.second] << varNum->second.first;603 mangleName += Encoding::typeVariables[varNum->second.second] + std::to_string( varNum->second.first ); 603 604 } // if 604 605 } … … 606 607 void Mangler_new::postvisit( const ast::TraitInstType * inst ) { 607 608 printQualifiers( inst ); 608 mangleName << inst->name.size() <<inst->name;609 mangleName += std::to_string( inst->name.size() ) + inst->name; 609 610 } 610 611 611 612 void Mangler_new::postvisit( const ast::TupleType * tupleType ) { 612 613 printQualifiers( tupleType ); 613 mangleName << Encoding::tuple << tupleType->types.size();614 mangleName += Encoding::tuple + std::to_string( tupleType->types.size() ); 614 615 accept_each( tupleType->types, *visitor ); 615 616 } … … 618 619 printQualifiers( varArgsType ); 619 620 static const std::string vargs = "__builtin_va_list"; 620 mangleName << Encoding::type << vargs.size() <<vargs;621 mangleName += Encoding::type + std::to_string( vargs.size() ) + vargs; 621 622 } 622 623 623 624 void Mangler_new::postvisit( const ast::ZeroType * ) { 624 mangleName <<Encoding::zero;625 mangleName += Encoding::zero; 625 626 } 626 627 627 628 void Mangler_new::postvisit( const ast::OneType * ) { 628 mangleName <<Encoding::one;629 mangleName += Encoding::one; 629 630 } 630 631 … … 634 635 // N marks the start of a qualified type 635 636 inQualifiedType = true; 636 mangleName <<Encoding::qualifiedTypeStart;637 mangleName += Encoding::qualifiedTypeStart; 637 638 } 638 639 maybeAccept( qualType->parent.get(), *visitor ); … … 641 642 // E marks the end of a qualified type 642 643 inQualifiedType = false; 643 mangleName <<Encoding::qualifiedTypeEnd;644 mangleName += Encoding::qualifiedTypeEnd; 644 645 } 645 646 } … … 653 654 assertf(false, "Mangler_new should not visit typedecl: %s", toCString(decl)); 654 655 assertf( decl->kind < ast::TypeDecl::Kind::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->kind ); 655 mangleName << Encoding::typeVariables[ decl->kind ] << ( decl->name.length() ) <<decl->name;656 mangleName += Encoding::typeVariables[ decl->kind ] + std::to_string( decl->name.length() ) + decl->name; 656 657 } 657 658 … … 669 670 std::list< std::string > assertionNames; 670 671 int dcount = 0, fcount = 0, vcount = 0, acount = 0; 671 mangleName <<Encoding::forall;672 mangleName += Encoding::forall; 672 673 for ( const ast::TypeDecl * decl : ptype->forall ) { 673 674 switch ( decl->kind ) { … … 693 694 } // for 694 695 } // for 695 mangleName << dcount << "_" << fcount << "_" << vcount << "_" << acount << "_"; 696 std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) ); 697 mangleName << "_"; 696 mangleName += std::to_string( dcount ) + "_" + std::to_string( fcount ) + "_" + std::to_string( vcount ) + "_" + std::to_string( acount ) + "_"; 697 for(const auto & a : assertionNames) mangleName += a; 698 // std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) ); 699 mangleName += "_"; 698 700 } // if 699 701 } // if … … 701 703 // these qualifiers do not distinguish the outermost type of a function parameter 702 704 if ( type->is_const() ) { 703 mangleName <<Encoding::qualifiers.at(Type::Const);705 mangleName += Encoding::qualifiers.at(Type::Const); 704 706 } // if 705 707 if ( type->is_volatile() ) { 706 mangleName <<Encoding::qualifiers.at(Type::Volatile);708 mangleName += Encoding::qualifiers.at(Type::Volatile); 707 709 } // if 708 710 // Removed due to restrict not affecting function compatibility in GCC 709 711 // if ( type->get_isRestrict() ) { 710 // mangleName <<"E";712 // mangleName += "E"; 711 713 // } // if 712 714 if ( type->is_atomic() ) { 713 mangleName <<Encoding::qualifiers.at(Type::Atomic);715 mangleName += Encoding::qualifiers.at(Type::Atomic); 714 716 } // if 715 717 } 716 718 if ( type->is_mutex() ) { 717 mangleName <<Encoding::qualifiers.at(Type::Mutex);719 mangleName += Encoding::qualifiers.at(Type::Mutex); 718 720 } // if 719 721 if ( inFunctionType ) {
Note: See TracChangeset
for help on using the changeset viewer.
