X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FAsmWriter.cpp;h=4acf55bf89c952135d64a102510ecdffc2a2b689;hb=652f032ce9d57dbe613bbd57f76e1f54056e6b11;hp=8e5de342561a2d644d4014ea80aa0e5b5809afe2;hpb=c6f3ae5c66c8e0dab6a2bd9601d0e253ef9ba794;p=oota-llvm.git diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp index 8e5de342561..4acf55bf89c 100644 --- a/lib/VMCore/AsmWriter.cpp +++ b/lib/VMCore/AsmWriter.cpp @@ -3,98 +3,122 @@ // This library implements the functionality defined in llvm/Assembly/Writer.h // // Note that these routines must be extremely tolerant of various errors in the -// LLVM code, because of of the primary uses of it is for debugging -// transformations. +// LLVM code, because it can be used for debugging transformations. // //===----------------------------------------------------------------------===// #include "llvm/Assembly/CachedWriter.h" #include "llvm/Assembly/Writer.h" +#include "llvm/Assembly/PrintModulePass.h" #include "llvm/SlotCalculator.h" +#include "llvm/DerivedTypes.h" +#include "llvm/Instruction.h" #include "llvm/Module.h" -#include "llvm/Function.h" -#include "llvm/GlobalVariable.h" -#include "llvm/BasicBlock.h" #include "llvm/Constants.h" #include "llvm/iMemory.h" #include "llvm/iTerminators.h" #include "llvm/iPHINode.h" #include "llvm/iOther.h" #include "llvm/SymbolTable.h" -#include "llvm/Argument.h" +#include "llvm/Support/CFG.h" #include "Support/StringExtras.h" #include "Support/STLExtras.h" #include -using std::string; -using std::map; -using std::vector; -using std::ostream; -static void WriteAsOperandInternal(ostream &Out, const Value *V, bool PrintName, - map &TypeTable, +static RegisterPass +X("printm", "Print module to stderr",PassInfo::Analysis|PassInfo::Optimization); +static RegisterPass +Y("print","Print function to stderr",PassInfo::Analysis|PassInfo::Optimization); + +static void WriteAsOperandInternal(std::ostream &Out, const Value *V, + bool PrintName, + std::map &TypeTable, SlotCalculator *Table); static const Module *getModuleFromVal(const Value *V) { - if (const Argument *MA = dyn_cast(V)) + if (const Argument *MA = dyn_cast(V)) return MA->getParent() ? MA->getParent()->getParent() : 0; - else if (const BasicBlock *BB = dyn_cast(V)) + else if (const BasicBlock *BB = dyn_cast(V)) return BB->getParent() ? BB->getParent()->getParent() : 0; - else if (const Instruction *I = dyn_cast(V)) { + else if (const Instruction *I = dyn_cast(V)) { const Function *M = I->getParent() ? I->getParent()->getParent() : 0; return M ? M->getParent() : 0; - } else if (const GlobalValue *GV = dyn_cast(V)) + } else if (const GlobalValue *GV = dyn_cast(V)) return GV->getParent(); return 0; } static SlotCalculator *createSlotCalculator(const Value *V) { assert(!isa(V) && "Can't create an SC for a type!"); - if (const Argument *FA = dyn_cast(V)) { + if (const Argument *FA = dyn_cast(V)) { return new SlotCalculator(FA->getParent(), true); - } else if (const Instruction *I = dyn_cast(V)) { + } else if (const Instruction *I = dyn_cast(V)) { return new SlotCalculator(I->getParent()->getParent(), true); - } else if (const BasicBlock *BB = dyn_cast(V)) { + } else if (const BasicBlock *BB = dyn_cast(V)) { return new SlotCalculator(BB->getParent(), true); - } else if (const GlobalVariable *GV = dyn_cast(V)){ + } else if (const GlobalVariable *GV = dyn_cast(V)){ return new SlotCalculator(GV->getParent(), true); - } else if (const Function *Func = dyn_cast(V)) { + } else if (const Function *Func = dyn_cast(V)) { return new SlotCalculator(Func, true); } return 0; } +// getLLVMName - Turn the specified string into an 'LLVM name', which is either +// prefixed with % (if the string only contains simple characters) or is +// surrounded with ""'s (if it has special chars in it). +static std::string getLLVMName(const std::string &Name) { + assert(!Name.empty() && "Cannot get empty name!"); + + // First character cannot start with a number... + if (Name[0] >= '0' && Name[0] <= '9') + return "\"" + Name + "\""; + + // Scan to see if we have any characters that are not on the "white list" + for (unsigned i = 0, e = Name.size(); i != e; ++i) { + char C = Name[i]; + assert(C != '"' && "Illegal character in LLVM value name!"); + if ((C < 'a' || C > 'z') && (C < 'A' || C > 'Z') && (C < '0' || C > '9') && + C != '-' && C != '.' && C != '_') + return "\"" + Name + "\""; + } + + // If we get here, then the identifier is legal to use as a "VarID". + return "%"+Name; +} + // If the module has a symbol table, take all global types and stuff their // names into the TypeNames map. // static void fillTypeNameTable(const Module *M, - map &TypeNames) { - if (M && M->hasSymbolTable()) { - const SymbolTable *ST = M->getSymbolTable(); - SymbolTable::const_iterator PI = ST->find(Type::TypeTy); - if (PI != ST->end()) { - SymbolTable::type_const_iterator I = PI->second.begin(); - for (; I != PI->second.end(); ++I) { - // As a heuristic, don't insert pointer to primitive types, because - // they are used too often to have a single useful name. - // - const Type *Ty = cast(I->second); - if (!isa(Ty) || - !cast(Ty)->getElementType()->isPrimitiveType()) - TypeNames.insert(std::make_pair(Ty, "%"+I->first)); - } + std::map &TypeNames) { + if (!M) return; + const SymbolTable &ST = M->getSymbolTable(); + SymbolTable::const_iterator PI = ST.find(Type::TypeTy); + if (PI != ST.end()) { + SymbolTable::type_const_iterator I = PI->second.begin(); + for (; I != PI->second.end(); ++I) { + // As a heuristic, don't insert pointer to primitive types, because + // they are used too often to have a single useful name. + // + const Type *Ty = cast(I->second); + if (!isa(Ty) || + !cast(Ty)->getElementType()->isPrimitiveType()) + TypeNames.insert(std::make_pair(Ty, getLLVMName(I->first))); } } } -static string calcTypeName(const Type *Ty, vector &TypeStack, - map &TypeNames) { +static std::string calcTypeName(const Type *Ty, + std::vector &TypeStack, + std::map &TypeNames){ if (Ty->isPrimitiveType()) return Ty->getDescription(); // Base case // Check to see if the type is named. - map::iterator I = TypeNames.find(Ty); + std::map::iterator I = TypeNames.find(Ty); if (I != TypeNames.end()) return I->second; // Check to see if the Type is already on the stack... @@ -110,10 +134,10 @@ static string calcTypeName(const Type *Ty, vector &TypeStack, TypeStack.push_back(Ty); // Recursive case: Add us to the stack.. - string Result; + std::string Result; switch (Ty->getPrimitiveID()) { case Type::FunctionTyID: { - const FunctionType *FTy = cast(Ty); + const FunctionType *FTy = cast(Ty); Result = calcTypeName(FTy->getReturnType(), TypeStack, TypeNames) + " ("; for (FunctionType::ParamTypes::const_iterator I = FTy->getParamTypes().begin(), @@ -130,7 +154,7 @@ static string calcTypeName(const Type *Ty, vector &TypeStack, break; } case Type::StructTyID: { - const StructType *STy = cast(Ty); + const StructType *STy = cast(Ty); Result = "{ "; for (StructType::ElementTypes::const_iterator I = STy->getElementTypes().begin(), @@ -143,18 +167,20 @@ static string calcTypeName(const Type *Ty, vector &TypeStack, break; } case Type::PointerTyID: - Result = calcTypeName(cast(Ty)->getElementType(), + Result = calcTypeName(cast(Ty)->getElementType(), TypeStack, TypeNames) + "*"; break; case Type::ArrayTyID: { - const ArrayType *ATy = cast(Ty); + const ArrayType *ATy = cast(Ty); Result = "[" + utostr(ATy->getNumElements()) + " x "; Result += calcTypeName(ATy->getElementType(), TypeStack, TypeNames) + "]"; break; } + case Type::OpaqueTyID: + Result = "opaque"; + break; default: - assert(0 && "Unhandled case in getTypeProps!"); - Result = ""; + Result = ""; } TypeStack.pop_back(); // Remove self from stack... @@ -165,23 +191,23 @@ static string calcTypeName(const Type *Ty, vector &TypeStack, // printTypeInt - The internal guts of printing out a type that has a // potentially named portion. // -static ostream &printTypeInt(ostream &Out, const Type *Ty, - map &TypeNames) { +static std::ostream &printTypeInt(std::ostream &Out, const Type *Ty, + std::map &TypeNames) { // Primitive types always print out their description, regardless of whether // they have been named or not. // if (Ty->isPrimitiveType()) return Out << Ty->getDescription(); // Check to see if the type is named. - map::iterator I = TypeNames.find(Ty); + std::map::iterator I = TypeNames.find(Ty); if (I != TypeNames.end()) return Out << I->second; // Otherwise we have a type that has not been named but is a derived type. // Carefully recurse the type hierarchy to print out any contained symbolic // names. // - vector TypeStack; - string TypeName = calcTypeName(Ty, TypeStack, TypeNames); + std::vector TypeStack; + std::string TypeName = calcTypeName(Ty, TypeStack, TypeNames); TypeNames.insert(std::make_pair(Ty, TypeName));//Cache type name for later use return Out << TypeName; } @@ -191,13 +217,14 @@ static ostream &printTypeInt(ostream &Out, const Type *Ty, // type, iff there is an entry in the modules symbol table for the specified // type or one of it's component types. This is slower than a simple x << Type; // -ostream &WriteTypeSymbolic(ostream &Out, const Type *Ty, const Module *M) { +std::ostream &WriteTypeSymbolic(std::ostream &Out, const Type *Ty, + const Module *M) { Out << " "; // If they want us to print out a type, attempt to make it symbolic if there // is a symbol table in the module... - if (M && M->hasSymbolTable()) { - map TypeNames; + if (M) { + std::map TypeNames; fillTypeNameTable(M, TypeNames); return printTypeInt(Out, Ty, TypeNames); @@ -206,8 +233,9 @@ ostream &WriteTypeSymbolic(ostream &Out, const Type *Ty, const Module *M) { } } -static void WriteConstantInt(ostream &Out, const Constant *CV, bool PrintName, - map &TypeTable, +static void WriteConstantInt(std::ostream &Out, const Constant *CV, + bool PrintName, + std::map &TypeTable, SlotCalculator *Table) { if (const ConstantBool *CB = dyn_cast(CV)) { Out << (CB == ConstantBool::True ? "true" : "false"); @@ -229,7 +257,7 @@ static void WriteConstantInt(ostream &Out, const Constant *CV, bool PrintName, // if ((StrVal[0] >= '0' && StrVal[0] <= '9') || ((StrVal[0] == '-' || StrVal[0] == '+') && - (StrVal[0] >= '0' && StrVal[0] <= '9'))) + (StrVal[1] >= '0' && StrVal[1] <= '9'))) // Reparse stringized version! if (atof(StrVal.c_str()) == CFP->getValue()) { Out << StrVal; return; @@ -248,6 +276,11 @@ static void WriteConstantInt(ostream &Out, const Constant *CV, bool PrintName, Out << "0x" << utohexstr(*(uint64_t*)Ptr); } else if (const ConstantArray *CA = dyn_cast(CV)) { + if (CA->getNumOperands() > 5 && CA->isNullValue()) { + Out << "zeroinitializer"; + return; + } + // As a special case, print the array as a string if it is an array of // ubytes or an array of sbytes with positive values. // @@ -264,11 +297,9 @@ static void WriteConstantInt(ostream &Out, const Constant *CV, bool PrintName, if (isString) { Out << "c\""; for (unsigned i = 0; i < CA->getNumOperands(); ++i) { - unsigned char C = (ETy == Type::SByteTy) ? - (unsigned char)cast(CA->getOperand(i))->getValue() : - (unsigned char)cast(CA->getOperand(i))->getValue(); + unsigned char C = cast(CA->getOperand(i))->getRawValue(); - if (isprint(C)) { + if (isprint(C) && C != '"' && C != '\\') { Out << C; } else { Out << '\\' @@ -295,6 +326,11 @@ static void WriteConstantInt(ostream &Out, const Constant *CV, bool PrintName, Out << " ]"; } } else if (const ConstantStruct *CS = dyn_cast(CV)) { + if (CS->getNumOperands() > 5 && CS->isNullValue()) { + Out << "zeroinitializer"; + return; + } + Out << "{"; if (CS->getNumOperands()) { Out << " "; @@ -316,10 +352,10 @@ static void WriteConstantInt(ostream &Out, const Constant *CV, bool PrintName, } else if (isa(CV)) { Out << "null"; - } else if (ConstantPointerRef *PR = dyn_cast(CV)) { + } else if (const ConstantPointerRef *PR = dyn_cast(CV)) { const GlobalValue *V = PR->getValue(); if (V->hasName()) { - Out << "%" << V->getName(); + Out << getLLVMName(V->getName()); } else if (Table) { int Slot = Table->getValSlot(V); if (Slot >= 0) @@ -329,8 +365,25 @@ static void WriteConstantInt(ostream &Out, const Constant *CV, bool PrintName, } else { Out << ""; } + + } else if (const ConstantExpr *CE = dyn_cast(CV)) { + Out << CE->getOpcodeName() << " ("; + + for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) { + printTypeInt(Out, (*OI)->getType(), TypeTable); + WriteAsOperandInternal(Out, *OI, PrintName, TypeTable, Table); + if (OI+1 != CE->op_end()) + Out << ", "; + } + + if (CE->getOpcode() == Instruction::Cast) { + Out << " to "; + printTypeInt(Out, CE->getType(), TypeTable); + } + Out << ")"; + } else { - assert(0 && "Unrecognized constant value!!!"); + Out << ""; } } @@ -339,21 +392,22 @@ static void WriteConstantInt(ostream &Out, const Constant *CV, bool PrintName, // ostream. This can be useful when you just want to print int %reg126, not the // whole instruction that generated it. // -static void WriteAsOperandInternal(ostream &Out, const Value *V, bool PrintName, - map &TypeTable, +static void WriteAsOperandInternal(std::ostream &Out, const Value *V, + bool PrintName, + std::map &TypeTable, SlotCalculator *Table) { Out << " "; if (PrintName && V->hasName()) { - Out << "%" << V->getName(); + Out << getLLVMName(V->getName()); } else { - if (const Constant *CV = dyn_cast(V)) { + if (const Constant *CV = dyn_cast(V)) { WriteConstantInt(Out, CV, PrintName, TypeTable, Table); } else { int Slot; if (Table) { Slot = Table->getValSlot(V); } else { - if (const Type *Ty = dyn_cast(V)) { + if (const Type *Ty = dyn_cast(V)) { Out << Ty->getDescription(); return; } @@ -377,30 +431,30 @@ static void WriteAsOperandInternal(ostream &Out, const Value *V, bool PrintName, // ostream. This can be useful when you just want to print int %reg126, not the // whole instruction that generated it. // -ostream &WriteAsOperand(ostream &Out, const Value *V, bool PrintType, - bool PrintName, SlotCalculator *Table) { - map TypeNames; - const Module *M = getModuleFromVal(V); +std::ostream &WriteAsOperand(std::ostream &Out, const Value *V, bool PrintType, + bool PrintName, const Module *Context) { + std::map TypeNames; + if (Context == 0) Context = getModuleFromVal(V); - if (M && M->hasSymbolTable()) - fillTypeNameTable(M, TypeNames); + if (Context) + fillTypeNameTable(Context, TypeNames); if (PrintType) printTypeInt(Out, V->getType(), TypeNames); - WriteAsOperandInternal(Out, V, PrintName, TypeNames, Table); + WriteAsOperandInternal(Out, V, PrintName, TypeNames, 0); return Out; } class AssemblyWriter { - ostream &Out; + std::ostream &Out; SlotCalculator &Table; const Module *TheModule; - map TypeNames; + std::map TypeNames; public: - inline AssemblyWriter(ostream &o, SlotCalculator &Tab, const Module *M) + inline AssemblyWriter(std::ostream &o, SlotCalculator &Tab, const Module *M) : Out(o), Table(Tab), TheModule(M) { // If the module has a symbol table, take all global types and stuff their @@ -413,7 +467,7 @@ public: inline void write(const GlobalVariable *G) { printGlobal(G); } inline void write(const Function *F) { printFunction(F); } inline void write(const BasicBlock *BB) { printBasicBlock(BB); } - inline void write(const Instruction *I) { printInstruction(I); } + inline void write(const Instruction *I) { printInstruction(*I); } inline void write(const Constant *CPV) { printConstant(CPV); } inline void write(const Type *Ty) { printType(Ty); } @@ -427,31 +481,31 @@ private : void printFunction(const Function *F); void printArgument(const Argument *FA); void printBasicBlock(const BasicBlock *BB); - void printInstruction(const Instruction *I); + void printInstruction(const Instruction &I); // printType - Go to extreme measures to attempt to print out a short, // symbolic version of a type name. // - ostream &printType(const Type *Ty) { + std::ostream &printType(const Type *Ty) { return printTypeInt(Out, Ty, TypeNames); } // printTypeAtLeastOneLevel - Print out one level of the possibly complex type // without considering any symbolic types that we may have equal to it. // - ostream &printTypeAtLeastOneLevel(const Type *Ty); + std::ostream &printTypeAtLeastOneLevel(const Type *Ty); // printInfoComment - Print a little comment after the instruction indicating // which slot it occupies. - void printInfoComment(const Value *V); + void printInfoComment(const Value &V); }; // printTypeAtLeastOneLevel - Print out one level of the possibly complex type // without considering any symbolic types that we may have equal to it. // -ostream &AssemblyWriter::printTypeAtLeastOneLevel(const Type *Ty) { - if (FunctionType *FTy = dyn_cast(Ty)) { +std::ostream &AssemblyWriter::printTypeAtLeastOneLevel(const Type *Ty) { + if (const FunctionType *FTy = dyn_cast(Ty)) { printType(FTy->getReturnType()) << " ("; for (FunctionType::ParamTypes::const_iterator I = FTy->getParamTypes().begin(), @@ -465,7 +519,7 @@ ostream &AssemblyWriter::printTypeAtLeastOneLevel(const Type *Ty) { Out << "..."; } Out << ")"; - } else if (StructType *STy = dyn_cast(Ty)) { + } else if (const StructType *STy = dyn_cast(Ty)) { Out << "{ "; for (StructType::ElementTypes::const_iterator I = STy->getElementTypes().begin(), @@ -475,13 +529,16 @@ ostream &AssemblyWriter::printTypeAtLeastOneLevel(const Type *Ty) { printType(*I); } Out << " }"; - } else if (PointerType *PTy = dyn_cast(Ty)) { + } else if (const PointerType *PTy = dyn_cast(Ty)) { printType(PTy->getElementType()) << "*"; - } else if (ArrayType *ATy = dyn_cast(Ty)) { + } else if (const ArrayType *ATy = dyn_cast(Ty)) { Out << "[" << ATy->getNumElements() << " x "; printType(ATy->getElementType()) << "]"; + } else if (const OpaqueType *OTy = dyn_cast(Ty)) { + Out << "opaque"; } else { - assert(Ty->isPrimitiveType() && "Unknown derived type!"); + if (!Ty->isPrimitiveType()) + Out << ""; printType(Ty); } return Out; @@ -496,24 +553,42 @@ void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType, void AssemblyWriter::printModule(const Module *M) { + switch (M->getEndianness()) { + case Module::LittleEndian: Out << "target endian = little\n"; break; + case Module::BigEndian: Out << "target endian = big\n"; break; + case Module::AnyEndianness: break; + } + switch (M->getPointerSize()) { + case Module::Pointer32: Out << "target pointersize = 32\n"; break; + case Module::Pointer64: Out << "target pointersize = 64\n"; break; + case Module::AnyPointerSize: break; + } + // Loop over the symbol table, emitting all named constants... - if (M->hasSymbolTable()) - printSymbolTable(*M->getSymbolTable()); + printSymbolTable(M->getSymbolTable()); - for_each(M->gbegin(), M->gend(), - bind_obj(this, &AssemblyWriter::printGlobal)); + for (Module::const_giterator I = M->gbegin(), E = M->gend(); I != E; ++I) + printGlobal(I); - Out << "implementation\n"; + Out << "\nimplementation ; Functions:\n"; // Output all of the functions... - for_each(M->begin(), M->end(), bind_obj(this,&AssemblyWriter::printFunction)); + for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) + printFunction(I); } void AssemblyWriter::printGlobal(const GlobalVariable *GV) { - if (GV->hasName()) Out << "%" << GV->getName() << " = "; + if (GV->hasName()) Out << getLLVMName(GV->getName()) << " = "; - if (GV->hasInternalLinkage()) Out << "internal "; - if (!GV->hasInitializer()) Out << "uninitialized "; + if (!GV->hasInitializer()) + Out << "external "; + else + switch (GV->getLinkage()) { + case GlobalValue::InternalLinkage: Out << "internal "; break; + case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break; + case GlobalValue::AppendingLinkage: Out << "appending "; break; + case GlobalValue::ExternalLinkage: break; + } Out << (GV->isConstant() ? "constant " : "global "); printType(GV->getType()->getElementType()); @@ -521,7 +596,7 @@ void AssemblyWriter::printGlobal(const GlobalVariable *GV) { if (GV->hasInitializer()) writeOperand(GV->getInitializer(), false, false); - printInfoComment(GV); + printInfoComment(*GV); Out << "\n"; } @@ -536,10 +611,10 @@ void AssemblyWriter::printSymbolTable(const SymbolTable &ST) { for (; I != End; ++I) { const Value *V = I->second; - if (const Constant *CPV = dyn_cast(V)) { + if (const Constant *CPV = dyn_cast(V)) { printConstant(CPV); - } else if (const Type *Ty = dyn_cast(V)) { - Out << "\t%" << I->first << " = type "; + } else if (const Type *Ty = dyn_cast(V)) { + Out << "\t" << getLLVMName(I->first) << " = type "; // Make sure we print out at least one level of the type structure, so // that we do not get %FILE = type %FILE @@ -558,59 +633,57 @@ void AssemblyWriter::printConstant(const Constant *CPV) { if (!CPV->hasName()) return; // Print out name... - Out << "\t%" << CPV->getName() << " ="; + Out << "\t" << getLLVMName(CPV->getName()) << " ="; // Write the value out now... writeOperand(CPV, true, false); - printInfoComment(CPV); + printInfoComment(*CPV); Out << "\n"; } // printFunction - Print all aspects of a function. // -void AssemblyWriter::printFunction(const Function *M) { +void AssemblyWriter::printFunction(const Function *F) { // Print out the return type and name... - Out << "\n" << (M->isExternal() ? "declare " : "") - << (M->hasInternalLinkage() ? "internal " : ""); - printType(M->getReturnType()) << " \"" << M->getName() << "\"("; - Table.incorporateFunction(M); + Out << "\n"; + + if (F->isExternal()) + Out << "declare "; + else + switch (F->getLinkage()) { + case GlobalValue::InternalLinkage: Out << "internal "; break; + case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break; + case GlobalValue::AppendingLinkage: Out << "appending "; break; + case GlobalValue::ExternalLinkage: break; + } + + printType(F->getReturnType()) << " " << getLLVMName(F->getName()) << "("; + Table.incorporateFunction(F); // Loop over the arguments, printing them... - const FunctionType *MT = M->getFunctionType(); + const FunctionType *FT = F->getFunctionType(); - if (!M->isExternal()) { - for_each(M->getArgumentList().begin(), M->getArgumentList().end(), - bind_obj(this, &AssemblyWriter::printArgument)); - } else { - // Loop over the arguments, printing them... - const FunctionType *MT = M->getFunctionType(); - for (FunctionType::ParamTypes::const_iterator I = MT->getParamTypes().begin(), - E = MT->getParamTypes().end(); I != E; ++I) { - if (I != MT->getParamTypes().begin()) Out << ", "; - printType(*I); - } - } + for(Function::const_aiterator I = F->abegin(), E = F->aend(); I != E; ++I) + printArgument(I); // Finish printing arguments... - if (MT->isVarArg()) { - if (MT->getParamTypes().size()) Out << ", "; + if (FT->isVarArg()) { + if (FT->getParamTypes().size()) Out << ", "; Out << "..."; // Output varargs portion of signature! } - Out << ")\n"; - - if (!M->isExternal()) { - // Loop over the symbol table, emitting all named constants... - if (M->hasSymbolTable()) - printSymbolTable(*M->getSymbolTable()); + Out << ")"; - Out << "begin"; + if (F->isExternal()) { + Out << "\n"; + } else { + Out << " {"; // Output all of its basic blocks... for the function - for_each(M->begin(), M->end(), - bind_obj(this, &AssemblyWriter::printBasicBlock)); + for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I) + printBasicBlock(I); - Out << "end\n"; + Out << "}\n"; } Table.purgeFunction(); @@ -621,14 +694,14 @@ void AssemblyWriter::printFunction(const Function *M) { // void AssemblyWriter::printArgument(const Argument *Arg) { // Insert commas as we go... the first arg doesn't get a comma - if (Arg != Arg->getParent()->getArgumentList().front()) Out << ", "; + if (Arg != &Arg->getParent()->afront()) Out << ", "; // Output type... printType(Arg->getType()); // Output name, if available... if (Arg->hasName()) - Out << " %" << Arg->getName(); + Out << " " << getLLVMName(Arg->getName()); else if (Table.getValSlot(Arg) < 0) Out << ""; } @@ -638,119 +711,150 @@ void AssemblyWriter::printArgument(const Argument *Arg) { void AssemblyWriter::printBasicBlock(const BasicBlock *BB) { if (BB->hasName()) { // Print out the label if it exists... Out << "\n" << BB->getName() << ":"; - } else { + } else if (!BB->use_empty()) { // Don't print block # of no uses... int Slot = Table.getValSlot(BB); Out << "\n;