From c194e7e8432a5627b9954773544b16f0122c84a9 Mon Sep 17 00:00:00 2001 From: Reid Spencer Date: Mon, 29 May 2006 18:08:06 +0000 Subject: [PATCH] Next batch of implementation: 1. Get rid of old AsmWriter cruft that's not needed. 2. Implement several instructions. Enough to get by globalvars.ll and alignment.ll in the Feature test suite. 3. Handle constants properly (don't repeat definitions). 4. Make the output compatible with llvm-dis for diff purposes. llvm-svn: 28541 --- llvm/tools/llvm2cpp/CppWriter.cpp | 1445 ++++++----------------------- 1 file changed, 281 insertions(+), 1164 deletions(-) diff --git a/llvm/tools/llvm2cpp/CppWriter.cpp b/llvm/tools/llvm2cpp/CppWriter.cpp index 0f28e30e16a1..bd49a0793783 100644 --- a/llvm/tools/llvm2cpp/CppWriter.cpp +++ b/llvm/tools/llvm2cpp/CppWriter.cpp @@ -2,8 +2,8 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. +// This file was developed by Reid Spencer and is distributed under the +// University of Illinois Open Source License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -30,339 +30,53 @@ using namespace llvm; namespace { -/// This class provides computation of slot numbers for LLVM Assembly writing. -/// @brief LLVM Assembly Writing Slot Computation. -class SlotMachine { - -/// @name Types -/// @{ -public: - - /// @brief A mapping of Values to slot numbers - typedef std::map ValueMap; - typedef std::map TypeMap; - - /// @brief A plane with next slot number and ValueMap - struct ValuePlane { - unsigned next_slot; ///< The next slot number to use - ValueMap map; ///< The map of Value* -> unsigned - ValuePlane() { next_slot = 0; } ///< Make sure we start at 0 - }; - - struct TypePlane { - unsigned next_slot; - TypeMap map; - TypePlane() { next_slot = 0; } - void clear() { map.clear(); next_slot = 0; } - }; - - /// @brief The map of planes by Type - typedef std::map TypedPlanes; - -/// @} -/// @name Constructors -/// @{ -public: - /// @brief Construct from a module - SlotMachine(const Module *M ); - -/// @} -/// @name Accessors -/// @{ -public: - /// Return the slot number of the specified value in it's type - /// plane. Its an error to ask for something not in the SlotMachine. - /// Its an error to ask for a Type* - int getSlot(const Value *V); - int getSlot(const Type*Ty); - - /// Determine if a Value has a slot or not - bool hasSlot(const Value* V); - bool hasSlot(const Type* Ty); - -/// @} -/// @name Mutators -/// @{ -public: - /// If you'd like to deal with a function instead of just a module, use - /// this method to get its data into the SlotMachine. - void incorporateFunction(const Function *F) { - TheFunction = F; - FunctionProcessed = false; - } - - /// After calling incorporateFunction, use this method to remove the - /// most recently incorporated function from the SlotMachine. This - /// will reset the state of the machine back to just the module contents. - void purgeFunction(); - -/// @} -/// @name Implementation Details -/// @{ -private: - /// Values can be crammed into here at will. If they haven't - /// been inserted already, they get inserted, otherwise they are ignored. - /// Either way, the slot number for the Value* is returned. - unsigned createSlot(const Value *V); - unsigned createSlot(const Type* Ty); - - /// Insert a value into the value table. Return the slot number - /// that it now occupies. BadThings(TM) will happen if you insert a - /// Value that's already been inserted. - unsigned insertValue( const Value *V ); - unsigned insertValue( const Type* Ty); - - /// Add all of the module level global variables (and their initializers) - /// and function declarations, but not the contents of those functions. - void processModule(); - - /// Add all of the functions arguments, basic blocks, and instructions - void processFunction(); - - SlotMachine(const SlotMachine &); // DO NOT IMPLEMENT - void operator=(const SlotMachine &); // DO NOT IMPLEMENT - -/// @} -/// @name Data -/// @{ -public: - - /// @brief The module for which we are holding slot numbers - const Module* TheModule; - - /// @brief The function for which we are holding slot numbers - const Function* TheFunction; - bool FunctionProcessed; - - /// @brief The TypePlanes map for the module level data - TypedPlanes mMap; - TypePlane mTypes; - - /// @brief The TypePlanes map for the function level data - TypedPlanes fMap; - TypePlane fTypes; - -/// @} - -}; - typedef std::vector TypeList; typedef std::map TypeMap; typedef std::map ValueMap; -void WriteAsOperandInternal(std::ostream &Out, const Value *V, - bool PrintName, TypeMap &TypeTable, - SlotMachine *Machine); +class CppWriter { + std::ostream &Out; + const Module *TheModule; + unsigned long uniqueNum; + TypeMap TypeNames; + ValueMap ValueNames; + TypeMap UnresolvedTypes; + TypeList TypeStack; -void WriteAsOperandInternal(std::ostream &Out, const Type *T, - bool PrintName, TypeMap& TypeTable, - SlotMachine *Machine); +public: + inline CppWriter(std::ostream &o, const Module *M) + : Out(o), TheModule(M), uniqueNum(0), TypeNames(), + ValueNames(), UnresolvedTypes(), TypeStack() { } -const Module *getModuleFromVal(const Value *V) { - if (const Argument *MA = dyn_cast(V)) - return MA->getParent() ? MA->getParent()->getParent() : 0; - else if (const BasicBlock *BB = dyn_cast(V)) - return BB->getParent() ? BB->getParent()->getParent() : 0; - 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)) - return GV->getParent(); - return 0; -} + const Module* getModule() { return TheModule; } -// 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). -std::string getLLVMName(const std::string &Name, - bool prefixName = true) { - assert(!Name.empty() && "Cannot get empty name!"); + void printModule(const Module *M); - // First character cannot start with a number... - if (Name[0] >= '0' && Name[0] <= '9') - return "\"" + Name + "\""; +private: + void printTypes(const Module* M); + void printConstants(const Module* M); + void printConstant(const Constant *CPV); + void printGlobal(const GlobalVariable *GV); + void printFunction(const Function *F); + void printInstruction(const Instruction *I, const std::string& bbname); + void printSymbolTable(const SymbolTable &ST); + void printLinkageType(GlobalValue::LinkageTypes LT); + void printCallingConv(unsigned cc); - // 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 + "\""; - } + std::string getCppName(const Type* val); + std::string getCppName(const Value* val); + inline void printCppName(const Value* val); + inline void printCppName(const Type* val); + bool isOnStack(const Type*) const; + inline void printTypeDef(const Type* Ty); + bool printTypeDefInternal(const Type* Ty); + void printEscapedString(const std::string& str); +}; - // If we get here, then the identifier is legal to use as a "VarID". - if (prefixName) - return "%"+Name; - else - return Name; -} - - -/// fillTypeNameTable - If the module has a symbol table, take all global types -/// and stuff their names into the TypeNames map. -/// -void fillTypeNameTable(const Module *M, TypeMap& TypeNames) { - if (!M) return; - const SymbolTable &ST = M->getSymbolTable(); - SymbolTable::type_const_iterator TI = ST.type_begin(); - for (; TI != ST.type_end(); ++TI ) { - // 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(TI->second); - if (!isa(Ty) || - !cast(Ty)->getElementType()->isPrimitiveType() || - isa(cast(Ty)->getElementType())) - TypeNames.insert(std::make_pair(Ty, getLLVMName(TI->first))); - } -} - -void calcTypeName(const Type *Ty, - std::vector &TypeStack, - TypeMap& TypeNames, - std::string & Result){ - if (Ty->isPrimitiveType() && !isa(Ty)) { - Result += Ty->getDescription(); // Base case - return; - } - - // Check to see if the type is named. - TypeMap::iterator I = TypeNames.find(Ty); - if (I != TypeNames.end()) { - Result += I->second; - return; - } - - if (isa(Ty)) { - Result += "opaque"; - return; - } - - // Check to see if the Type is already on the stack... - unsigned Slot = 0, CurSize = TypeStack.size(); - while (Slot < CurSize && TypeStack[Slot] != Ty) ++Slot; // Scan for type - - // This is another base case for the recursion. In this case, we know - // that we have looped back to a type that we have previously visited. - // Generate the appropriate upreference to handle this. - if (Slot < CurSize) { - Result += "\\" + utostr(CurSize-Slot); // Here's the upreference - return; - } - - TypeStack.push_back(Ty); // Recursive case: Add us to the stack.. - - switch (Ty->getTypeID()) { - case Type::FunctionTyID: { - const FunctionType *FTy = cast(Ty); - calcTypeName(FTy->getReturnType(), TypeStack, TypeNames, Result); - Result += " ("; - for (FunctionType::param_iterator I = FTy->param_begin(), - E = FTy->param_end(); I != E; ++I) { - if (I != FTy->param_begin()) - Result += ", "; - calcTypeName(*I, TypeStack, TypeNames, Result); - } - if (FTy->isVarArg()) { - if (FTy->getNumParams()) Result += ", "; - Result += "..."; - } - Result += ")"; - break; - } - case Type::StructTyID: { - const StructType *STy = cast(Ty); - Result += "{ "; - for (StructType::element_iterator I = STy->element_begin(), - E = STy->element_end(); I != E; ++I) { - if (I != STy->element_begin()) - Result += ", "; - calcTypeName(*I, TypeStack, TypeNames, Result); - } - Result += " }"; - break; - } - case Type::PointerTyID: - calcTypeName(cast(Ty)->getElementType(), - TypeStack, TypeNames, Result); - Result += "*"; - break; - case Type::ArrayTyID: { - const ArrayType *ATy = cast(Ty); - Result += "[" + utostr(ATy->getNumElements()) + " x "; - calcTypeName(ATy->getElementType(), TypeStack, TypeNames, Result); - Result += "]"; - break; - } - case Type::PackedTyID: { - const PackedType *PTy = cast(Ty); - Result += "<" + utostr(PTy->getNumElements()) + " x "; - calcTypeName(PTy->getElementType(), TypeStack, TypeNames, Result); - Result += ">"; - break; - } - case Type::OpaqueTyID: - Result += "opaque"; - break; - default: - Result += ""; - } - - TypeStack.pop_back(); // Remove self from stack... - return; -} - - -/// printTypeInt - The internal guts of printing out a type that has a -/// potentially named portion. -/// -std::ostream &printTypeInt(std::ostream &Out, const Type *Ty,TypeMap&TypeNames){ - // Primitive types always print out their description, regardless of whether - // they have been named or not. - // - if (Ty->isPrimitiveType() && !isa(Ty)) - return Out << Ty->getDescription(); - - // Check to see if the type is named. - TypeMap::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. - // - std::vector TypeStack; - std::string TypeName; - calcTypeName(Ty, TypeStack, TypeNames, TypeName); - TypeNames.insert(std::make_pair(Ty, TypeName));//Cache type name for later use - return (Out << TypeName); -} - - -/// WriteTypeSymbolic - This attempts to write the specified type as a symbolic -/// 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 -/// -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) { - TypeMap TypeNames; - fillTypeNameTable(M, TypeNames); - - return printTypeInt(Out, Ty, TypeNames); - } else { - return Out << Ty->getDescription(); - } -} - -// PrintEscapedString - Print each character of the specified string, escaping +// printEscapedString - Print each character of the specified string, escaping // it if it is not printable or if it is an escape char. -void PrintEscapedString(const std::string &Str, std::ostream &Out) { +void +CppWriter::printEscapedString(const std::string &Str) { for (unsigned i = 0, e = Str.size(); i != e; ++i) { unsigned char C = Str[i]; if (isprint(C) && C != '"' && C != '\\') { @@ -375,301 +89,6 @@ void PrintEscapedString(const std::string &Str, std::ostream &Out) { } } -/// @brief Internal constant writer. -void WriteConstantInternal(std::ostream &Out, const Constant *CV, - bool PrintName, - TypeMap& TypeTable, - SlotMachine *Machine) { - const int IndentSize = 4; - static std::string Indent = "\n"; - if (const ConstantBool *CB = dyn_cast(CV)) { - Out << (CB == ConstantBool::True ? "true" : "false"); - } else if (const ConstantSInt *CI = dyn_cast(CV)) { - Out << CI->getValue(); - } else if (const ConstantUInt *CI = dyn_cast(CV)) { - Out << CI->getValue(); - } else if (const ConstantFP *CFP = dyn_cast(CV)) { - // We would like to output the FP constant value in exponential notation, - // but we cannot do this if doing so will lose precision. Check here to - // make sure that we only output it in exponential format if we can parse - // the value back and get the same value. - // - std::string StrVal = ftostr(CFP->getValue()); - - // Check to make sure that the stringized number is not some string like - // "Inf" or NaN, that atof will accept, but the lexer will not. Check that - // the string matches the "[-+]?[0-9]" regex. - // - if ((StrVal[0] >= '0' && StrVal[0] <= '9') || - ((StrVal[0] == '-' || StrVal[0] == '+') && - (StrVal[1] >= '0' && StrVal[1] <= '9'))) - // Reparse stringized version! - if (atof(StrVal.c_str()) == CFP->getValue()) { - Out << StrVal; - return; - } - - // Otherwise we could not reparse it to exactly the same value, so we must - // output the string in hexadecimal format! - assert(sizeof(double) == sizeof(uint64_t) && - "assuming that double is 64 bits!"); - Out << "0x" << utohexstr(DoubleToBits(CFP->getValue())); - - } else if (isa(CV)) { - Out << "zeroinitializer"; - } else if (const ConstantArray *CA = dyn_cast(CV)) { - // 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. - // - const Type *ETy = CA->getType()->getElementType(); - if (CA->isString()) { - Out << "c\""; - PrintEscapedString(CA->getAsString(), Out); - Out << "\""; - - } else { // Cannot output in string format... - Out << '['; - if (CA->getNumOperands()) { - Out << ' '; - printTypeInt(Out, ETy, TypeTable); - WriteAsOperandInternal(Out, CA->getOperand(0), - PrintName, TypeTable, Machine); - for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) { - Out << ", "; - printTypeInt(Out, ETy, TypeTable); - WriteAsOperandInternal(Out, CA->getOperand(i), PrintName, - TypeTable, Machine); - } - } - Out << " ]"; - } - } else if (const ConstantStruct *CS = dyn_cast(CV)) { - Out << '{'; - unsigned N = CS->getNumOperands(); - if (N) { - if (N > 2) { - Indent += std::string(IndentSize, ' '); - Out << Indent; - } else { - Out << ' '; - } - printTypeInt(Out, CS->getOperand(0)->getType(), TypeTable); - - WriteAsOperandInternal(Out, CS->getOperand(0), - PrintName, TypeTable, Machine); - - for (unsigned i = 1; i < N; i++) { - Out << ", "; - if (N > 2) Out << Indent; - printTypeInt(Out, CS->getOperand(i)->getType(), TypeTable); - - WriteAsOperandInternal(Out, CS->getOperand(i), - PrintName, TypeTable, Machine); - } - if (N > 2) Indent.resize(Indent.size() - IndentSize); - } - - Out << " }"; - } else if (const ConstantPacked *CP = dyn_cast(CV)) { - const Type *ETy = CP->getType()->getElementType(); - assert(CP->getNumOperands() > 0 && - "Number of operands for a PackedConst must be > 0"); - Out << '<'; - Out << ' '; - printTypeInt(Out, ETy, TypeTable); - WriteAsOperandInternal(Out, CP->getOperand(0), - PrintName, TypeTable, Machine); - for (unsigned i = 1, e = CP->getNumOperands(); i != e; ++i) { - Out << ", "; - printTypeInt(Out, ETy, TypeTable); - WriteAsOperandInternal(Out, CP->getOperand(i), PrintName, - TypeTable, Machine); - } - Out << " >"; - } else if (isa(CV)) { - Out << "null"; - - } else if (isa(CV)) { - Out << "undef"; - - } 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, Machine); - if (OI+1 != CE->op_end()) - Out << ", "; - } - - if (CE->getOpcode() == Instruction::Cast) { - Out << " to "; - printTypeInt(Out, CE->getType(), TypeTable); - } - Out << ')'; - - } else { - Out << ""; - } -} - - -/// WriteAsOperand - Write the name of the specified value out to the specified -/// ostream. This can be useful when you just want to print int %reg126, not -/// the whole instruction that generated it. -/// -void WriteAsOperandInternal(std::ostream &Out, const Value *V, - bool PrintName, TypeMap& TypeTable, - SlotMachine *Machine) { - Out << ' '; - if ((PrintName || isa(V)) && V->hasName()) - Out << getLLVMName(V->getName()); - else { - const Constant *CV = dyn_cast(V); - if (CV && !isa(CV)) { - WriteConstantInternal(Out, CV, PrintName, TypeTable, Machine); - } else if (const InlineAsm *IA = dyn_cast(V)) { - Out << "asm "; - if (IA->hasSideEffects()) - Out << "sideeffect "; - Out << '"'; - PrintEscapedString(IA->getAsmString(), Out); - Out << "\", \""; - PrintEscapedString(IA->getConstraintString(), Out); - Out << '"'; - } else { - int Slot = Machine->getSlot(V); - if (Slot != -1) - Out << '%' << Slot; - else - Out << ""; - } - } -} - -/// WriteAsOperand - Write the name of the specified value out to the specified -/// ostream. This can be useful when you just want to print int %reg126, not -/// the whole instruction that generated it. -/// -std::ostream &WriteAsOperand(std::ostream &Out, const Value *V, - bool PrintType, bool PrintName, - const Module *Context) { - TypeMap TypeNames; - if (Context == 0) Context = getModuleFromVal(V); - - if (Context) - fillTypeNameTable(Context, TypeNames); - - if (PrintType) - printTypeInt(Out, V->getType(), TypeNames); - - WriteAsOperandInternal(Out, V, PrintName, TypeNames, 0); - return Out; -} - -/// WriteAsOperandInternal - Write the name of the specified value out to -/// the specified ostream. This can be useful when you just want to print -/// int %reg126, not the whole instruction that generated it. -/// -void WriteAsOperandInternal(std::ostream &Out, const Type *T, - bool PrintName, TypeMap& TypeTable, - SlotMachine *Machine) { - Out << ' '; - int Slot = Machine->getSlot(T); - if (Slot != -1) - Out << '%' << Slot; - else - Out << ""; -} - -/// WriteAsOperand - Write the name of the specified value out to the specified -/// ostream. This can be useful when you just want to print int %reg126, not -/// the whole instruction that generated it. -/// -std::ostream &WriteAsOperand(std::ostream &Out, const Type *Ty, - bool PrintType, bool PrintName, - const Module *Context) { - TypeMap TypeNames; - assert(Context != 0 && "Can't write types as operand without module context"); - - fillTypeNameTable(Context, TypeNames); - - // if (PrintType) - // printTypeInt(Out, V->getType(), TypeNames); - - printTypeInt(Out, Ty, TypeNames); - - WriteAsOperandInternal(Out, Ty, PrintName, TypeNames, 0); - return Out; -} - -class CppWriter { - std::ostream &Out; - SlotMachine &Machine; - const Module *TheModule; - unsigned long uniqueNum; - TypeMap TypeNames; - ValueMap ValueNames; - TypeMap UnresolvedTypes; - TypeList TypeStack; - -public: - inline CppWriter(std::ostream &o, SlotMachine &Mac, const Module *M) - : Out(o), Machine(Mac), TheModule(M), uniqueNum(0), TypeNames(), - ValueNames(), UnresolvedTypes(), TypeStack() { } - - inline void write(const Module *M) { printModule(M); } - 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 Constant *CPV) { printConstant(CPV); } - inline void write(const Type *Ty) { printType(Ty); } - - void writeOperand(const Value *Op, bool PrintType, bool PrintName = true); - - const Module* getModule() { return TheModule; } - -private: - void printModule(const Module *M); - void printTypes(const Module* M); - void printConstants(const Module* M); - void printConstant(const Constant *CPV); - void printGlobal(const GlobalVariable *GV); - void printFunction(const Function *F); - void printArgument(const Argument *FA); - void printBasicBlock(const BasicBlock *BB); - void printInstruction(const Instruction &I); - void printSymbolTable(const SymbolTable &ST); - void printLinkageType(GlobalValue::LinkageTypes LT); - void printCallingConv(unsigned cc); - - - // printType - Go to extreme measures to attempt to print out a short, - // symbolic version of a type name. - // - 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. - // - std::ostream &printTypeAtLeastOneLevel(const Type *Ty); - - // printInfoComment - Print a little comment after the instruction indicating - // which slot it occupies. - void printInfoComment(const Value &V); - - std::string getCppName(const Type* val); - std::string getCppName(const Value* val); - inline void printCppName(const Value* val); - inline void printCppName(const Type* val); - bool isOnStack(const Type*) const; - inline void printTypeDef(const Type* Ty); - bool printTypeDefInternal(const Type* Ty); -}; - std::string CppWriter::getCppName(const Value* val) { std::string name; @@ -707,13 +126,13 @@ CppWriter::getCppName(const Value* val) { void CppWriter::printCppName(const Value* val) { - PrintEscapedString(getCppName(val),Out); + printEscapedString(getCppName(val)); } void CppWriter::printCppName(const Type* Ty) { - PrintEscapedString(getCppName(Ty),Out); + printEscapedString(getCppName(Ty)); } // Gets the C++ name for a type. Returns true if we already saw the type, @@ -785,67 +204,13 @@ CppWriter::getCppName(const Type* Ty) return TypeNames[Ty] = name; } -/// printTypeAtLeastOneLevel - Print out one level of the possibly complex type -/// without considering any symbolic types that we may have equal to it. -/// -std::ostream &CppWriter::printTypeAtLeastOneLevel(const Type *Ty) { - if (const FunctionType *FTy = dyn_cast(Ty)) { - printType(FTy->getReturnType()) << " ("; - for (FunctionType::param_iterator I = FTy->param_begin(), - E = FTy->param_end(); I != E; ++I) { - if (I != FTy->param_begin()) - Out << ", "; - printType(*I); - } - if (FTy->isVarArg()) { - if (FTy->getNumParams()) Out << ", "; - Out << "..."; - } - Out << ')'; - } else if (const StructType *STy = dyn_cast(Ty)) { - Out << "{ "; - for (StructType::element_iterator I = STy->element_begin(), - E = STy->element_end(); I != E; ++I) { - if (I != STy->element_begin()) - Out << ", "; - printType(*I); - } - Out << " }"; - } else if (const PointerType *PTy = dyn_cast(Ty)) { - printType(PTy->getElementType()) << '*'; - } else if (const ArrayType *ATy = dyn_cast(Ty)) { - Out << '[' << ATy->getNumElements() << " x "; - printType(ATy->getElementType()) << ']'; - } else if (const PackedType *PTy = dyn_cast(Ty)) { - Out << '<' << PTy->getNumElements() << " x "; - printType(PTy->getElementType()) << '>'; - } - else if (const OpaqueType *OTy = dyn_cast(Ty)) { - Out << "opaque"; - } else { - if (!Ty->isPrimitiveType()) - Out << ""; - printType(Ty); - } - return Out; -} - - -void CppWriter::writeOperand(const Value *Operand, bool PrintType, - bool PrintName) { - if (Operand != 0) { - if (PrintType) { Out << ' '; printType(Operand->getType()); } - WriteAsOperandInternal(Out, Operand, PrintName, TypeNames, &Machine); - } else { - Out << ""; - } -} - - void CppWriter::printModule(const Module *M) { Out << "\n// Module Construction\n"; Out << "Module* mod = new Module(\""; - PrintEscapedString(M->getModuleIdentifier(),Out); + if (M->getModuleIdentifier() == "-") + printEscapedString(""); + else + printEscapedString(M->getModuleIdentifier()); Out << "\");\n"; Out << "mod->setEndianness("; switch (M->getEndianness()) { @@ -864,7 +229,7 @@ void CppWriter::printModule(const Module *M) { if (!M->getModuleInlineAsm().empty()) { Out << "mod->setModuleInlineAsm(\""; - PrintEscapedString(M->getModuleInlineAsm(),Out); + printEscapedString(M->getModuleInlineAsm()); Out << "\");\n"; } @@ -945,13 +310,13 @@ void CppWriter::printGlobal(const GlobalVariable *GV) { Out << "0"; } Out << ",\n /*Name=*/\""; - PrintEscapedString(GV->getName(),Out); + printEscapedString(GV->getName()); Out << "\",\n mod);\n"; if (GV->hasSection()) { printCppName(GV); Out << "->setSection(\""; - PrintEscapedString(GV->getSection(),Out); + printEscapedString(GV->getSection()); Out << "\");\n"; } if (GV->getAlignment()) { @@ -993,10 +358,9 @@ CppWriter::printTypeDef(const Type* Ty) { case Type::OpaqueTyID: Out << "OpaqueType"; break; default: Out << "NoSuchDerivedType"; break; } - Out << ">(" << I->second << "_fwd.get());\n"; + Out << ">(" << I->second << "_fwd.get());\n\n"; UnresolvedTypes.erase(I); } - Out << "\n"; } bool @@ -1129,6 +493,7 @@ CppWriter::printTypeDefInternal(const Type* Ty) { // Pop us off the type stack TypeStack.pop_back(); + Out << "\n"; // We weren't a recursive type return false; @@ -1169,51 +534,37 @@ CppWriter::printTypes(const Module* M) { void CppWriter::printConstants(const Module* M) { - const SymbolTable& ST = M->getSymbolTable(); - - // Print the constants, in type plane order. - for (SymbolTable::plane_const_iterator PI = ST.plane_begin(); - PI != ST.plane_end(); ++PI ) { - SymbolTable::value_const_iterator VI = ST.value_begin(PI->first); - SymbolTable::value_const_iterator VE = ST.value_end(PI->first); - - for (; VI != VE; ++VI) { - const Value* V = VI->second; - const Constant *CPV = dyn_cast(V) ; - if (CPV && !isa(V)) { - printConstant(CPV); - } - } - } - // Add all of the global variables to the value table... for (Module::const_global_iterator I = TheModule->global_begin(), E = TheModule->global_end(); I != E; ++I) if (I->hasInitializer()) printConstant(I->getInitializer()); -} -// printSymbolTable - Run through symbol table looking for constants -// and types. Emit their declarations. -void CppWriter::printSymbolTable(const SymbolTable &ST) { - - // Print the types. - for (SymbolTable::type_const_iterator TI = ST.type_begin(); - TI != ST.type_end(); ++TI ) { - Out << "\t" << getLLVMName(TI->first) << " = type "; - - // Make sure we print out at least one level of the type structure, so - // that we do not get %FILE = type %FILE - // - printTypeAtLeastOneLevel(TI->second) << "\n"; + // Traverse the LLVM functions looking for constants + for (Module::const_iterator FI = TheModule->begin(), FE = TheModule->end(); + FI != FE; ++FI) { + // Add all of the basic blocks and instructions + for (Function::const_iterator BB = FI->begin(), + E = FI->end(); BB != E; ++BB) { + for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; + ++I) { + for (unsigned i = 0; i < I->getNumOperands(); ++i) { + if (Constant* C = dyn_cast(I->getOperand(i))) { + printConstant(C); + } + } + } + } } - } - -/// printConstant - Print out a constant pool entry... -/// +// printConstant - Print out a constant pool entry... void CppWriter::printConstant(const Constant *CV) { + // First, if the constant is in the constant list then we've printed it + // already and we shouldn't reprint it. + if (ValueNames.find(CV) != ValueNames.end()) + return; + const int IndentSize = 2; static std::string Indent = "\n"; std::string constName(getCppName(CV)); @@ -1223,6 +574,10 @@ void CppWriter::printConstant(const Constant *CV) { << typeName << ");\n"; return; } + if (isa(CV)) { + // Skip variables and functions, we emit them elsewhere + return; + } if (const ConstantBool *CB = dyn_cast(CV)) { Out << "Constant* " << constName << " = ConstantBool::get(" << (CB == ConstantBool::True ? "true" : "false") @@ -1267,9 +622,9 @@ void CppWriter::printConstant(const Constant *CV) { "assuming that double is 64 bits!"); Out << "0x" << utohexstr(DoubleToBits(CFP->getValue())) << ");"; } else if (const ConstantArray *CA = dyn_cast(CV)) { - if (CA->isString()) { + if (CA->isString() && CA->getType()->getElementType() == Type::SByteTy) { Out << "Constant* " << constName << " = ConstantArray::get(\""; - PrintEscapedString(CA->getAsString(),Out); + printEscapedString(CA->getAsString()); Out << "\");"; } else { Out << "std::vector " << constName << "_elems;\n"; @@ -1304,25 +659,55 @@ void CppWriter::printConstant(const Constant *CV) { << typeName << ", " << constName << "_elems);"; } else if (isa(CV)) { Out << "Constant* " << constName << " = UndefValue::get(" - << typeName << ");\n"; + << typeName << ");"; } 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, Machine); - if (OI+1 != CE->op_end()) - Out << ", "; + if (CE->getOpcode() == Instruction::GetElementPtr) { + Out << "std::vector " << constName << "_indices;\n"; + for (unsigned i = 1; i < CE->getNumOperands(); ++i ) { + Out << constName << "_indices.push_back(" + << getCppName(CE->getOperand(i)) << ");\n"; + } + Out << "Constant* " << constName << " = new GetElementPtrInst(" + << getCppName(CE->getOperand(0)) << ", " << constName << "_indices"; + } else if (CE->getOpcode() == Instruction::Cast) { + Out << "Constant* " << constName << " = ConstantExpr::getCast("; + Out << getCppName(CE->getOperand(0)) << ", " << getCppName(CE->getType()) + << ");"; + } else { + Out << "Constant* " << constName << " = ConstantExpr::"; + switch (CE->getOpcode()) { + case Instruction::Add: Out << "getAdd"; break; + case Instruction::Sub: Out << "getSub"; break; + case Instruction::Mul: Out << "getMul"; break; + case Instruction::Div: Out << "getDiv"; break; + case Instruction::Rem: Out << "getRem"; break; + case Instruction::And: Out << "getAnd"; break; + case Instruction::Or: Out << "getOr"; break; + case Instruction::Xor: Out << "getXor"; break; + case Instruction::SetEQ: Out << "getSetEQ"; break; + case Instruction::SetNE: Out << "getSetNE"; break; + case Instruction::SetLE: Out << "getSetLE"; break; + case Instruction::SetGE: Out << "getSetGE"; break; + case Instruction::SetLT: Out << "getSetLT"; break; + case Instruction::SetGT: Out << "getSetGT"; break; + case Instruction::Shl: Out << "getShl"; break; + case Instruction::Shr: Out << "getShr"; break; + case Instruction::Select: Out << "getSelect"; break; + case Instruction::ExtractElement: Out << "getExtractElement"; break; + case Instruction::InsertElement: Out << "getInsertElement"; break; + case Instruction::ShuffleVector: Out << "getShuffleVector"; break; + default: + assert(!"Invalid constant expression"); + break; + } + Out << getCppName(CE->getOperand(0)); + for (unsigned i = 1; i < CE->getNumOperands(); ++i) + Out << ", " << getCppName(CE->getOperand(i)); + Out << ");"; } - - if (CE->getOpcode() == Instruction::Cast) { - Out << " to "; - // printTypeInt(Out, CE->getType(), TypeTable); - } - Out << ')'; - } else { - Out << ""; + assert(!"Bad Constant"); + Out << "Constant* " << constName << " = 0; "; } Out << "\n"; } @@ -1336,7 +721,7 @@ void CppWriter::printFunction(const Function *F) { printCppName(F); Out << " = new Function(" << funcTypeName << ", " ; printLinkageType(F->getLinkage()); - Out << ", \"" << F->getName() << "\", mod);\n"; + Out << ",\n \"" << F->getName() << "\", mod);\n"; printCppName(F); Out << "->setCallingConv("; printCallingConv(F->getCallingConv()); @@ -1350,101 +735,170 @@ void CppWriter::printFunction(const Function *F) { Out << "->setAlignment(" << F->getAlignment() << ");\n"; } - Machine.incorporateFunction(F); - if (!F->isExternal()) { - Out << "{"; + Out << "{\n"; + // Create all the argument values + for (Function::const_arg_iterator AI = F->arg_begin(), AE = F->arg_end(); + AI != AE; ++AI) { + Out << " Argument* " << getCppName(AI) << " = new Argument(" + << getCppName(AI->getType()) << ", \""; + printEscapedString(AI->getName()); + Out << "\", " << getCppName(F) << ");\n"; + } + // Create all the basic blocks + for (Function::const_iterator BI = F->begin(), BE = F->end(); + BI != BE; ++BI) { + std::string bbname(getCppName(BI)); + Out << " BasicBlock* " << bbname << " = new BasicBlock(\""; + if (BI->hasName()) + printEscapedString(BI->getName()); + Out << "\"," << getCppName(BI->getParent()) << ",0);\n"; + } // Output all of its basic blocks... for the function - for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I) - printBasicBlock(I); + for (Function::const_iterator BI = F->begin(), BE = F->end(); + BI != BE; ++BI) { + // Output all of the instructions in the basic block... + Out << " {\n"; + for (BasicBlock::const_iterator I = BI->begin(), E = BI->end(); + I != E; ++I) { + std::string bbname(getCppName(BI)); + printInstruction(I,bbname); + } + Out << " }\n"; + } Out << "}\n"; } - - Machine.purgeFunction(); } -/// printArgument - This member is called for every argument that is passed into -/// the function. Simply print it out -/// -void CppWriter::printArgument(const Argument *Arg) { - // Insert commas as we go... the first arg doesn't get a comma - if (Arg != Arg->getParent()->arg_begin()) Out << ", "; +// printInstruction - This member is called for each Instruction in a function. +void +CppWriter::printInstruction(const Instruction *I, const std::string& bbname) +{ + std::string iName(getCppName(I)); - // Output type... - printType(Arg->getType()); - - // Output name, if available... - if (Arg->hasName()) - Out << ' ' << getLLVMName(Arg->getName()); -} - -/// printBasicBlock - This member is called for each basic block in a method. -/// -void CppWriter::printBasicBlock(const BasicBlock *BB) { - if (BB->hasName()) { // Print out the label if it exists... - Out << "\n" << getLLVMName(BB->getName(), false) << ':'; - } else if (!BB->use_empty()) { // Don't print block # of no uses... - Out << "\n;