X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FTarget%2FCBackend%2FCBackend.cpp;h=7af9bfe4fa6b6d566bc9f8b478d767d781850c95;hb=cac731ecbe6a80e0c607ece2833525a92601db99;hp=b1f8793d64d24849ed7955a0b4a79d92a5f22c72;hpb=4065ef99f91f929e4e0305cbd22b44873bbe66ab;p=oota-llvm.git diff --git a/lib/Target/CBackend/CBackend.cpp b/lib/Target/CBackend/CBackend.cpp index b1f8793d64d..7af9bfe4fa6 100644 --- a/lib/Target/CBackend/CBackend.cpp +++ b/lib/Target/CBackend/CBackend.cpp @@ -7,82 +7,120 @@ // //===----------------------------------------------------------------------===// // -// This library converts LLVM code to C code, compilable by GCC. +// This library converts LLVM code to C code, compilable by GCC and other C +// compilers. // //===----------------------------------------------------------------------===// -#include "llvm/Assembly/CWriter.h" +#include "CTargetMachine.h" #include "llvm/Constants.h" #include "llvm/DerivedTypes.h" #include "llvm/Module.h" #include "llvm/Instructions.h" #include "llvm/Pass.h" +#include "llvm/PassManager.h" #include "llvm/SymbolTable.h" #include "llvm/Intrinsics.h" -#include "llvm/Analysis/FindUsedTypes.h" #include "llvm/Analysis/ConstantsScanner.h" -#include "llvm/Support/InstVisitor.h" -#include "llvm/Support/InstIterator.h" +#include "llvm/Analysis/FindUsedTypes.h" +#include "llvm/Analysis/LoopInfo.h" +#include "llvm/CodeGen/IntrinsicLowering.h" +#include "llvm/Transforms/Scalar.h" +#include "llvm/Target/TargetMachineRegistry.h" #include "llvm/Support/CallSite.h" +#include "llvm/Support/CFG.h" +#include "llvm/Support/GetElementPtrTypeIterator.h" +#include "llvm/Support/InstVisitor.h" #include "llvm/Support/Mangler.h" -#include "Support/StringExtras.h" -#include "Support/STLExtras.h" -#include "Config/config.h" +#include "llvm/ADT/StringExtras.h" +#include "llvm/Support/MathExtras.h" +#include "llvm/Config/config.h" #include +#include #include +using namespace llvm; namespace { - class CWriter : public Pass, public InstVisitor { + // Register the target. + RegisterTarget X("c", " C backend"); + + /// NameAllUsedStructs - This pass inserts names for any unnamed structure + /// types that are used by the program. + /// + class CBackendNameAllUsedStructs : public ModulePass { + void getAnalysisUsage(AnalysisUsage &AU) const { + AU.addRequired(); + } + + virtual const char *getPassName() const { + return "C backend type canonicalizer"; + } + + virtual bool runOnModule(Module &M); + }; + + /// CWriter - This class is the main chunk of code that converts an LLVM + /// module to a C translation unit. + class CWriter : public FunctionPass, public InstVisitor { std::ostream &Out; + IntrinsicLowering &IL; Mangler *Mang; + LoopInfo *LI; const Module *TheModule; std::map TypeNames; - std::set MangledGlobals; - bool needsMalloc, emittedInvoke; std::map FPConstantMap; public: - CWriter(std::ostream &o) : Out(o) {} + CWriter(std::ostream &o, IntrinsicLowering &il) : Out(o), IL(il) {} + + virtual const char *getPassName() const { return "C backend"; } void getAnalysisUsage(AnalysisUsage &AU) const { + AU.addRequired(); AU.setPreservesAll(); - AU.addRequired(); } - virtual bool run(Module &M) { - // Initialize - TheModule = &M; + virtual bool doInitialization(Module &M); - // Ensure that all structure types have names... - bool Changed = nameAllUsedStructureTypes(M); - Mang = new Mangler(M); + bool runOnFunction(Function &F) { + LI = &getAnalysis(); - // Run... - printModule(&M); + // Output all floating point constants that cannot be printed accurately. + printFloatingPointConstants(F); + + lowerIntrinsics(F); + printFunction(F); + FPConstantMap.clear(); + return false; + } + virtual bool doFinalization(Module &M) { // Free memory... delete Mang; TypeNames.clear(); - MangledGlobals.clear(); return false; } std::ostream &printType(std::ostream &Out, const Type *Ty, const std::string &VariableName = "", - bool IgnoreName = false, bool namedContext = true); + bool IgnoreName = false); void writeOperand(Value *Operand); void writeOperandInternal(Value *Operand); private : + void lowerIntrinsics(Function &F); + bool nameAllUsedStructureTypes(Module &M); void printModule(Module *M); - void printFloatingPointConstants(Module &M); - void printSymbolTable(const SymbolTable &ST); + void printModuleTypes(const SymbolTable &ST); void printContainedStructs(const Type *Ty, std::set &); + void printFloatingPointConstants(Function &F); void printFunctionSignature(const Function *F, bool Prototype); - void printFunction(Function *); + void printFunction(Function &); + void printBasicBlock(BasicBlock *BB); + void printLoop(Loop *L); void printConstant(Constant *CPV); void printConstantArray(ConstantArray *CPA); @@ -93,6 +131,10 @@ namespace { // printed and an extra copy of the expr is not emitted. // static bool isInlinableInst(const Instruction &I) { + // Always inline setcc instructions, even if they are shared by multiple + // expressions. GCC generates horrible code if we don't. + if (isa(I)) return true; + // Must be an expression, must be used exactly once. If it is dead, we // emit it inline where it would go. if (I.getType() == Type::VoidTy || !I.hasOneUse() || @@ -125,13 +167,20 @@ namespace { void visitReturnInst(ReturnInst &I); void visitBranchInst(BranchInst &I); void visitSwitchInst(SwitchInst &I); - void visitInvokeInst(InvokeInst &I); - void visitUnwindInst(UnwindInst &I); + void visitInvokeInst(InvokeInst &I) { + assert(0 && "Lowerinvoke pass didn't work!"); + } + + void visitUnwindInst(UnwindInst &I) { + assert(0 && "Lowerinvoke pass didn't work!"); + } + void visitUnreachableInst(UnreachableInst &I); void visitPHINode(PHINode &I); void visitBinaryOperator(Instruction &I); void visitCastInst (CastInst &I); + void visitSelectInst(SelectInst &I); void visitCallInst (CallInst &I); void visitCallSite (CallSite CS); void visitShiftInst(ShiftInst &I) { visitBinaryOperator(I); } @@ -153,26 +202,68 @@ namespace { void outputLValue(Instruction *I) { Out << " " << Mang->getValueName(I) << " = "; } + + bool isGotoCodeNecessary(BasicBlock *From, BasicBlock *To); + void printPHICopiesForSuccessor(BasicBlock *CurBlock, + BasicBlock *Successor, unsigned Indent); + void printPHICopiesForSuccessors(BasicBlock *CurBlock, + unsigned Indent); void printBranchToBlock(BasicBlock *CurBlock, BasicBlock *SuccBlock, unsigned Indent); - void printIndexingExpression(Value *Ptr, User::op_iterator I, - User::op_iterator E); + void printIndexingExpression(Value *Ptr, gep_type_iterator I, + gep_type_iterator E); }; } -// A pointer type should not use parens around *'s alone, e.g., (**) -inline bool ptrTypeNameNeedsParens(const std::string &NameSoFar) { - return NameSoFar.find_last_not_of('*') != std::string::npos; +/// This method inserts names for any unnamed structure types that are used by +/// the program, and removes names from structure types that are not used by the +/// program. +/// +bool CBackendNameAllUsedStructs::runOnModule(Module &M) { + // Get a set of types that are used by the program... + std::set UT = getAnalysis().getTypes(); + + // Loop over the module symbol table, removing types from UT that are + // already named, and removing names for structure types that are not used. + // + SymbolTable &MST = M.getSymbolTable(); + for (SymbolTable::type_iterator TI = MST.type_begin(), TE = MST.type_end(); + TI != TE; ) { + SymbolTable::type_iterator I = TI++; + if (const StructType *STy = dyn_cast(I->second)) { + // If this is not used, remove it from the symbol table. + std::set::iterator UTI = UT.find(STy); + if (UTI == UT.end()) + MST.remove(I); + else + UT.erase(UTI); + } + } + + // UT now contains types that are not named. Loop over it, naming + // structure types. + // + bool Changed = false; + unsigned RenameCounter = 0; + for (std::set::const_iterator I = UT.begin(), E = UT.end(); + I != E; ++I) + if (const StructType *ST = dyn_cast(*I)) { + while (M.addTypeName("unnamed"+utostr(RenameCounter), ST)) + ++RenameCounter; + Changed = true; + } + return Changed; } + // Pass the Type* and the variable name and this prints out the variable // declaration. // std::ostream &CWriter::printType(std::ostream &Out, const Type *Ty, const std::string &NameSoFar, - bool IgnoreName, bool namedContext) { + bool IgnoreName) { if (Ty->isPrimitiveType()) - switch (Ty->getPrimitiveID()) { + switch (Ty->getTypeID()) { case Type::VoidTyID: return Out << "void " << NameSoFar; case Type::BoolTyID: return Out << "bool " << NameSoFar; case Type::UByteTyID: return Out << "unsigned char " << NameSoFar; @@ -186,7 +277,7 @@ std::ostream &CWriter::printType(std::ostream &Out, const Type *Ty, case Type::FloatTyID: return Out << "float " << NameSoFar; case Type::DoubleTyID: return Out << "double " << NameSoFar; default : - std::cerr << "Unknown primitive type: " << Ty << "\n"; + std::cerr << "Unknown primitive type: " << *Ty << "\n"; abort(); } @@ -196,22 +287,21 @@ std::ostream &CWriter::printType(std::ostream &Out, const Type *Ty, if (I != TypeNames.end()) return Out << I->second << " " << NameSoFar; } - switch (Ty->getPrimitiveID()) { + switch (Ty->getTypeID()) { case Type::FunctionTyID: { const FunctionType *MTy = cast(Ty); std::stringstream FunctionInnards; FunctionInnards << " (" << NameSoFar << ") ("; - for (FunctionType::ParamTypes::const_iterator - I = MTy->getParamTypes().begin(), - E = MTy->getParamTypes().end(); I != E; ++I) { - if (I != MTy->getParamTypes().begin()) + for (FunctionType::param_iterator I = MTy->param_begin(), + E = MTy->param_end(); I != E; ++I) { + if (I != MTy->param_begin()) FunctionInnards << ", "; printType(FunctionInnards, *I, ""); } if (MTy->isVarArg()) { - if (!MTy->getParamTypes().empty()) - FunctionInnards << ", ..."; - } else if (MTy->getParamTypes().empty()) { + if (MTy->getNumParams()) + FunctionInnards << ", ..."; + } else if (!MTy->getNumParams()) { FunctionInnards << "void"; } FunctionInnards << ")"; @@ -223,9 +313,8 @@ std::ostream &CWriter::printType(std::ostream &Out, const Type *Ty, const StructType *STy = cast(Ty); Out << NameSoFar + " {\n"; unsigned Idx = 0; - for (StructType::ElementTypes::const_iterator - I = STy->getElementTypes().begin(), - E = STy->getElementTypes().end(); I != E; ++I) { + for (StructType::element_iterator I = STy->element_begin(), + E = STy->element_end(); I != E; ++I) { Out << " "; printType(Out, *I, "field" + utostr(Idx++)); Out << ";\n"; @@ -237,12 +326,8 @@ std::ostream &CWriter::printType(std::ostream &Out, const Type *Ty, const PointerType *PTy = cast(Ty); std::string ptrName = "*" + NameSoFar; - // Do not need parens around "* NameSoFar" if NameSoFar consists only - // of zero or more '*' chars *and* this is not an unnamed pointer type - // such as the result type in a cast statement. Otherwise, enclose in ( ). - if (ptrTypeNameNeedsParens(NameSoFar) || !namedContext || - PTy->getElementType()->getPrimitiveID() == Type::ArrayTyID) - ptrName = "(" + ptrName + ")"; // + if (isa(PTy->getElementType())) + ptrName = "(" + ptrName + ")"; return printType(Out, PTy->getElementType(), ptrName); } @@ -386,10 +471,19 @@ void CWriter::printConstant(Constant *CPV) { case Instruction::GetElementPtr: Out << "(&("; - printIndexingExpression(CE->getOperand(0), - CPV->op_begin()+1, CPV->op_end()); + printIndexingExpression(CE->getOperand(0), gep_type_begin(CPV), + gep_type_end(CPV)); Out << "))"; return; + case Instruction::Select: + Out << "("; + printConstant(CE->getOperand(0)); + Out << "?"; + printConstant(CE->getOperand(1)); + Out << ":"; + printConstant(CE->getOperand(2)); + Out << ")"; + return; case Instruction::Add: case Instruction::Sub: case Instruction::Mul: @@ -401,6 +495,8 @@ void CWriter::printConstant(Constant *CPV) { case Instruction::SetLE: case Instruction::SetGT: case Instruction::SetGE: + case Instruction::Shl: + case Instruction::Shr: Out << "("; printConstant(CE->getOperand(0)); switch (CE->getOpcode()) { @@ -415,6 +511,8 @@ void CWriter::printConstant(Constant *CPV) { case Instruction::SetLE: Out << " <= "; break; case Instruction::SetGT: Out << " > "; break; case Instruction::SetGE: Out << " >= "; break; + case Instruction::Shl: Out << " << "; break; + case Instruction::Shr: Out << " >> "; break; default: assert(0 && "Illegal opcode here!"); } printConstant(CE->getOperand(1)); @@ -423,12 +521,17 @@ void CWriter::printConstant(Constant *CPV) { default: std::cerr << "CWriter Error: Unhandled constant expression: " - << CE << "\n"; + << *CE << "\n"; abort(); } + } else if (isa(CPV) && CPV->getType()->isFirstClassType()) { + Out << "(("; + printType(Out, CPV->getType()); + Out << ")/*UNDEF*/0)"; + return; } - switch (CPV->getType()->getPrimitiveID()) { + switch (CPV->getType()->getTypeID()) { case Type::BoolTyID: Out << (CPV == ConstantBool::False ? "0" : "1"); break; case Type::SByteTyID: @@ -462,35 +565,99 @@ void CWriter::printConstant(Constant *CPV) { Out << "(*(" << (FPC->getType() == Type::FloatTy ? "float" : "double") << "*)&FPConstant" << I->second << ")"; } else { + if (IsNAN(FPC->getValue())) { + // The value is NaN + + // The prefix for a quiet NaN is 0x7FF8. For a signalling NaN, + // it's 0x7ff4. + const unsigned long QuietNaN = 0x7ff8UL; + const unsigned long SignalNaN = 0x7ff4UL; + + // We need to grab the first part of the FP # + union { + double d; + uint64_t ll; + } DHex; + char Buffer[100]; + + DHex.d = FPC->getValue(); + sprintf(Buffer, "0x%llx", (unsigned long long)DHex.ll); + + std::string Num(&Buffer[0], &Buffer[6]); + unsigned long Val = strtoul(Num.c_str(), 0, 16); + + if (FPC->getType() == Type::FloatTy) + Out << "LLVM_NAN" << (Val == QuietNaN ? "" : "S") << "F(\"" + << Buffer << "\") /*nan*/ "; + else + Out << "LLVM_NAN" << (Val == QuietNaN ? "" : "S") << "(\"" + << Buffer << "\") /*nan*/ "; + } else if (IsInf(FPC->getValue())) { + // The value is Inf + if (FPC->getValue() < 0) Out << "-"; + Out << "LLVM_INF" << (FPC->getType() == Type::FloatTy ? "F" : "") + << " /*inf*/ "; + } else { + std::string Num; #if HAVE_PRINTF_A - // Print out the constant as a floating point number. - char Buffer[100]; - sprintf(Buffer, "%a", FPC->getValue()); - Out << Buffer << " /*" << FPC->getValue() << "*/ "; + // Print out the constant as a floating point number. + char Buffer[100]; + sprintf(Buffer, "%a", FPC->getValue()); + Num = Buffer; #else - Out << ftostr(FPC->getValue()); + Num = ftostr(FPC->getValue()); #endif + Out << Num; + } } break; } case Type::ArrayTyID: - printConstantArray(cast(CPV)); + if (isa(CPV) || isa(CPV)) { + const ArrayType *AT = cast(CPV->getType()); + Out << "{"; + if (AT->getNumElements()) { + Out << " "; + Constant *CZ = Constant::getNullValue(AT->getElementType()); + printConstant(CZ); + for (unsigned i = 1, e = AT->getNumElements(); i != e; ++i) { + Out << ", "; + printConstant(CZ); + } + } + Out << " }"; + } else { + printConstantArray(cast(CPV)); + } break; - case Type::StructTyID: { - Out << "{"; - if (CPV->getNumOperands()) { - Out << " "; - printConstant(cast(CPV->getOperand(0))); - for (unsigned i = 1, e = CPV->getNumOperands(); i != e; ++i) { - Out << ", "; - printConstant(cast(CPV->getOperand(i))); + case Type::StructTyID: + if (isa(CPV) || isa(CPV)) { + const StructType *ST = cast(CPV->getType()); + Out << "{"; + if (ST->getNumElements()) { + Out << " "; + printConstant(Constant::getNullValue(ST->getElementType(0))); + for (unsigned i = 1, e = ST->getNumElements(); i != e; ++i) { + Out << ", "; + printConstant(Constant::getNullValue(ST->getElementType(i))); + } + } + Out << " }"; + } else { + Out << "{"; + if (CPV->getNumOperands()) { + Out << " "; + printConstant(cast(CPV->getOperand(0))); + for (unsigned i = 1, e = CPV->getNumOperands(); i != e; ++i) { + Out << ", "; + printConstant(cast(CPV->getOperand(i))); + } } + Out << " }"; } - Out << " }"; break; - } case Type::PointerTyID: if (isa(CPV)) { @@ -498,13 +665,13 @@ void CWriter::printConstant(Constant *CPV) { printType(Out, CPV->getType()); Out << ")/*NULL*/0)"; break; - } else if (ConstantPointerRef *CPR = dyn_cast(CPV)) { - writeOperand(CPR->getValue()); + } else if (GlobalValue *GV = dyn_cast(CPV)) { + writeOperand(GV); break; } // FALL THROUGH default: - std::cerr << "Unknown constant type: " << CPV << "\n"; + std::cerr << "Unknown constant type: " << *CPV << "\n"; abort(); } } @@ -519,7 +686,8 @@ void CWriter::writeOperandInternal(Value *Operand) { return; } - if (Constant *CPV = dyn_cast(Operand)) { + Constant* CPV = dyn_cast(Operand); + if (CPV && !isa(CPV)) { printConstant(CPV); } else { Out << Mang->getValueName(Operand); @@ -536,84 +704,111 @@ void CWriter::writeOperand(Value *Operand) { Out << ")"; } -// nameAllUsedStructureTypes - If there are structure types in the module that -// are used but do not have names assigned to them in the symbol table yet then -// we assign them names now. -// -bool CWriter::nameAllUsedStructureTypes(Module &M) { - // Get a set of types that are used by the program... - std::set UT = getAnalysis().getTypes(); - - // Loop over the module symbol table, removing types from UT that are already - // named. - // - SymbolTable &MST = M.getSymbolTable(); - if (MST.find(Type::TypeTy) != MST.end()) - for (SymbolTable::type_iterator I = MST.type_begin(Type::TypeTy), - E = MST.type_end(Type::TypeTy); I != E; ++I) - UT.erase(cast(I->second)); - - // UT now contains types that are not named. Loop over it, naming structure - // types. - // - bool Changed = false; - for (std::set::const_iterator I = UT.begin(), E = UT.end(); - I != E; ++I) - if (const StructType *ST = dyn_cast(*I)) { - ((Value*)ST)->setName("unnamed", &MST); - Changed = true; - } - return Changed; -} - // generateCompilerSpecificCode - This is where we add conditional compilation // directives to cater to specific compilers as need be. // static void generateCompilerSpecificCode(std::ostream& Out) { // Alloca is hard to get, and we don't want to include stdlib.h here... Out << "/* get a declaration for alloca */\n" - << "#ifdef sun\n" + << "#if defined(sun) || defined(__CYGWIN__) || defined(__APPLE__)\n" << "extern void *__builtin_alloca(unsigned long);\n" << "#define alloca(x) __builtin_alloca(x)\n" + << "#elif defined(__FreeBSD__)\n" + << "#define alloca(x) __builtin_alloca(x)\n" << "#else\n" - << "#ifndef __FreeBSD__\n" << "#include \n" - << "#endif\n" << "#endif\n\n"; // We output GCC specific attributes to preserve 'linkonce'ness on globals. // If we aren't being compiled with GCC, just drop these attributes. Out << "#ifndef __GNUC__ /* Can only support \"linkonce\" vars with GCC */\n" << "#define __attribute__(X)\n" + << "#endif\n\n"; + +#if 0 + // At some point, we should support "external weak" vs. "weak" linkages. + // On Mac OS X, "external weak" is spelled "__attribute__((weak_import))". + Out << "#if defined(__GNUC__) && defined(__APPLE_CC__)\n" + << "#define __EXTERNAL_WEAK__ __attribute__((weak_import))\n" + << "#elif defined(__GNUC__)\n" + << "#define __EXTERNAL_WEAK__ __attribute__((weak))\n" + << "#else\n" + << "#define __EXTERNAL_WEAK__\n" + << "#endif\n\n"; +#endif + + // For now, turn off the weak linkage attribute on Mac OS X. (See above.) + Out << "#if defined(__GNUC__) && defined(__APPLE_CC__)\n" + << "#define __ATTRIBUTE_WEAK__\n" + << "#elif defined(__GNUC__)\n" + << "#define __ATTRIBUTE_WEAK__ __attribute__((weak))\n" + << "#else\n" + << "#define __ATTRIBUTE_WEAK__\n" + << "#endif\n\n"; + + // Define NaN and Inf as GCC builtins if using GCC, as 0 otherwise + // From the GCC documentation: + // + // double __builtin_nan (const char *str) + // + // This is an implementation of the ISO C99 function nan. + // + // Since ISO C99 defines this function in terms of strtod, which we do + // not implement, a description of the parsing is in order. The string is + // parsed as by strtol; that is, the base is recognized by leading 0 or + // 0x prefixes. The number parsed is placed in the significand such that + // the least significant bit of the number is at the least significant + // bit of the significand. The number is truncated to fit the significand + // field provided. The significand is forced to be a quiet NaN. + // + // This function, if given a string literal, is evaluated early enough + // that it is considered a compile-time constant. + // + // float __builtin_nanf (const char *str) + // + // Similar to __builtin_nan, except the return type is float. + // + // double __builtin_inf (void) + // + // Similar to __builtin_huge_val, except a warning is generated if the + // target floating-point format does not support infinities. This + // function is suitable for implementing the ISO C99 macro INFINITY. + // + // float __builtin_inff (void) + // + // Similar to __builtin_inf, except the return type is float. + Out << "#ifdef __GNUC__\n" + << "#define LLVM_NAN(NanStr) __builtin_nan(NanStr) /* Double */\n" + << "#define LLVM_NANF(NanStr) __builtin_nanf(NanStr) /* Float */\n" + << "#define LLVM_NANS(NanStr) __builtin_nans(NanStr) /* Double */\n" + << "#define LLVM_NANSF(NanStr) __builtin_nansf(NanStr) /* Float */\n" + << "#define LLVM_INF __builtin_inf() /* Double */\n" + << "#define LLVM_INFF __builtin_inff() /* Float */\n" + << "#else\n" + << "#define LLVM_NAN(NanStr) ((double)0.0) /* Double */\n" + << "#define LLVM_NANF(NanStr) 0.0F /* Float */\n" + << "#define LLVM_NANS(NanStr) ((double)0.0) /* Double */\n" + << "#define LLVM_NANSF(NanStr) 0.0F /* Float */\n" + << "#define LLVM_INF ((double)0.0) /* Double */\n" + << "#define LLVM_INFF 0.0F /* Float */\n" << "#endif\n"; } -void CWriter::printModule(Module *M) { - // Calculate which global values have names that will collide when we throw - // away type information. - { // Scope to delete the FoundNames set when we are done with it... - std::set FoundNames; - for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) - if (I->hasName()) // If the global has a name... - if (FoundNames.count(I->getName())) // And the name is already used - MangledGlobals.insert(I); // Mangle the name - else - FoundNames.insert(I->getName()); // Otherwise, keep track of name +bool CWriter::doInitialization(Module &M) { + // Initialize + TheModule = &M; - for (Module::giterator I = M->gbegin(), E = M->gend(); I != E; ++I) - if (I->hasName()) // If the global has a name... - if (FoundNames.count(I->getName())) // And the name is already used - MangledGlobals.insert(I); // Mangle the name - else - FoundNames.insert(I->getName()); // Otherwise, keep track of name - } + IL.AddPrototypes(M); + + // Ensure that all structure types have names... + Mang = new Mangler(M); // get declaration for alloca Out << "/* Provide Declarations */\n"; - Out << "#include \n"; - Out << "#include \n"; + Out << "#include \n"; // Varargs support + Out << "#include \n"; // Unwind support generateCompilerSpecificCode(Out); - + // Provide a definition for `bool' if not compiling with a C++ compiler. Out << "\n" << "#ifndef __cplusplus\ntypedef unsigned char bool;\n#endif\n" @@ -622,11 +817,6 @@ void CWriter::printModule(Module *M) { << "typedef unsigned long long ConstantDoubleTy;\n" << "typedef unsigned int ConstantFloatTy;\n" - << "\n\n/* Support for the invoke instruction */\n" - << "extern struct __llvm_jmpbuf_list_t {\n" - << " jmp_buf buf; struct __llvm_jmpbuf_list_t *next;\n" - << "} *__llvm_jmpbuf_list;\n" - << "\n\n/* Global Declarations */\n"; // First output all the declarations for the program, because C requires @@ -634,12 +824,12 @@ void CWriter::printModule(Module *M) { // // Loop over the symbol table, emitting all named constants... - printSymbolTable(M->getSymbolTable()); + printModuleTypes(M.getSymbolTable()); // Global variable declarations... - if (!M->gempty()) { + if (!M.gempty()) { Out << "\n/* External Global Variable Declarations */\n"; - for (Module::giterator I = M->gbegin(), E = M->gend(); I != E; ++I) { + for (Module::giterator I = M.gbegin(), E = M.gend(); I != E; ++I) { if (I->hasExternalLinkage()) { Out << "extern "; printType(Out, I->getType()->getElementType(), Mang->getValueName(I)); @@ -649,43 +839,40 @@ void CWriter::printModule(Module *M) { } // Function declarations - if (!M->empty()) { + if (!M.empty()) { Out << "\n/* Function Declarations */\n"; - needsMalloc = true; - for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) { - // If the function is external and the name collides don't print it. - // Sometimes the bytecode likes to have multiple "declarations" for - // external functions - if ((I->hasInternalLinkage() || !MangledGlobals.count(I)) && - !I->getIntrinsicID()) { + for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) { + // Don't print declarations for intrinsic functions. + if (!I->getIntrinsicID() && + I->getName() != "setjmp" && I->getName() != "longjmp") { printFunctionSignature(I, true); + if (I->hasWeakLinkage()) Out << " __ATTRIBUTE_WEAK__"; + if (I->hasLinkOnceLinkage()) Out << " __ATTRIBUTE_WEAK__"; Out << ";\n"; } } } - // Print Malloc prototype if needed - if (needsMalloc) { - Out << "\n/* Malloc to make sun happy */\n"; - Out << "extern void * malloc();\n\n"; - } - // Output the global variable declarations - if (!M->gempty()) { + if (!M.gempty()) { Out << "\n\n/* Global Variable Declarations */\n"; - for (Module::giterator I = M->gbegin(), E = M->gend(); I != E; ++I) + for (Module::giterator I = M.gbegin(), E = M.gend(); I != E; ++I) if (!I->isExternal()) { Out << "extern "; printType(Out, I->getType()->getElementType(), Mang->getValueName(I)); - + + if (I->hasLinkOnceLinkage()) + Out << " __attribute__((common))"; + else if (I->hasWeakLinkage()) + Out << " __ATTRIBUTE_WEAK__"; Out << ";\n"; } } // Output the global variable definitions and contents... - if (!M->gempty()) { + if (!M.gempty()) { Out << "\n\n/* Global Variable Definitions and Initialization */\n"; - for (Module::giterator I = M->gbegin(), E = M->gend(); I != E; ++I) + for (Module::giterator I = M.gbegin(), E = M.gend(); I != E; ++I) if (!I->isExternal()) { if (I->hasInternalLinkage()) Out << "static "; @@ -693,43 +880,44 @@ void CWriter::printModule(Module *M) { if (I->hasLinkOnceLinkage()) Out << " __attribute__((common))"; else if (I->hasWeakLinkage()) - Out << " __attribute__((weak))"; + Out << " __ATTRIBUTE_WEAK__"; + + // If the initializer is not null, emit the initializer. If it is null, + // we try to avoid emitting large amounts of zeros. The problem with + // this, however, occurs when the variable has weak linkage. In this + // case, the assembler will complain about the variable being both weak + // and common, so we disable this optimization. if (!I->getInitializer()->isNullValue()) { Out << " = " ; writeOperand(I->getInitializer()); + } else if (I->hasWeakLinkage()) { + // We have to specify an initializer, but it doesn't have to be + // complete. If the value is an aggregate, print out { 0 }, and let + // the compiler figure out the rest of the zeros. + Out << " = " ; + if (isa(I->getInitializer()->getType()) || + isa(I->getInitializer()->getType())) { + Out << "{ 0 }"; + } else { + // Just print it out normally. + writeOperand(I->getInitializer()); + } } Out << ";\n"; } } - // Output all floating point constants that cannot be printed accurately... - printFloatingPointConstants(*M); - - // Output all of the functions... - emittedInvoke = false; - if (!M->empty()) { + if (!M.empty()) Out << "\n\n/* Function Bodies */\n"; - for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) - printFunction(I); - } - - // If the program included an invoke instruction, we need to output the - // support code for it here! - if (emittedInvoke) { - Out << "\n/* More support for the invoke instruction */\n" - << "struct __llvm_jmpbuf_list_t *__llvm_jmpbuf_list " - << "__attribute__((common)) = 0;\n"; - } - - // Done with global FP constants - FPConstantMap.clear(); + return false; } + /// Output all floating point constants that cannot be printed accurately... -void CWriter::printFloatingPointConstants(Module &M) { +void CWriter::printFloatingPointConstants(Function &F) { union { double D; - unsigned long long U; + uint64_t U; } DBLUnion; union { @@ -742,46 +930,45 @@ void CWriter::printFloatingPointConstants(Module &M) { // the precision of the printed form, unless the printed form preserves // precision. // - unsigned FPCounter = 0; - for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) - for (constant_iterator I = constant_begin(F), E = constant_end(F); - I != E; ++I) - if (const ConstantFP *FPC = dyn_cast(*I)) - if (!isFPCSafeToPrint(FPC) && // Do not put in FPConstantMap if safe. - !FPConstantMap.count(FPC)) { - double Val = FPC->getValue(); - - FPConstantMap[FPC] = FPCounter; // Number the FP constants - - if (FPC->getType() == Type::DoubleTy) { - DBLUnion.D = Val; - Out << "const ConstantDoubleTy FPConstant" << FPCounter++ - << " = 0x" << std::hex << DBLUnion.U << std::dec - << "ULL; /* " << Val << " */\n"; - } else if (FPC->getType() == Type::FloatTy) { - FLTUnion.F = Val; - Out << "const ConstantFloatTy FPConstant" << FPCounter++ - << " = 0x" << std::hex << FLTUnion.U << std::dec - << "U; /* " << Val << " */\n"; - } else - assert(0 && "Unknown float type!"); - } + static unsigned FPCounter = 0; + for (constant_iterator I = constant_begin(&F), E = constant_end(&F); + I != E; ++I) + if (const ConstantFP *FPC = dyn_cast(*I)) + if (!isFPCSafeToPrint(FPC) && // Do not put in FPConstantMap if safe. + !FPConstantMap.count(FPC)) { + double Val = FPC->getValue(); + + FPConstantMap[FPC] = FPCounter; // Number the FP constants + + if (FPC->getType() == Type::DoubleTy) { + DBLUnion.D = Val; + Out << "static const ConstantDoubleTy FPConstant" << FPCounter++ + << " = 0x" << std::hex << DBLUnion.U << std::dec + << "ULL; /* " << Val << " */\n"; + } else if (FPC->getType() == Type::FloatTy) { + FLTUnion.F = Val; + Out << "static const ConstantFloatTy FPConstant" << FPCounter++ + << " = 0x" << std::hex << FLTUnion.U << std::dec + << "U; /* " << Val << " */\n"; + } else + assert(0 && "Unknown float type!"); + } Out << "\n"; - } +} /// printSymbolTable - Run through symbol table looking for type names. If a /// type name is found, emit it's declaration... /// -void CWriter::printSymbolTable(const SymbolTable &ST) { +void CWriter::printModuleTypes(const SymbolTable &ST) { // If there are no type names, exit early. - if (ST.find(Type::TypeTy) == ST.end()) + if ( ! ST.hasTypes() ) return; // We are only interested in the type plane of the symbol table... - SymbolTable::type_const_iterator I = ST.type_begin(Type::TypeTy); - SymbolTable::type_const_iterator End = ST.type_end(Type::TypeTy); + SymbolTable::type_const_iterator I = ST.type_begin(); + SymbolTable::type_const_iterator End = ST.type_end(); // Print out forward declarations for structure types before anything else! Out << "/* Structure forward decls */\n"; @@ -796,14 +983,14 @@ void CWriter::printSymbolTable(const SymbolTable &ST) { // Now we can print out typedefs... Out << "/* Typedefs */\n"; - for (I = ST.type_begin(Type::TypeTy); I != End; ++I) { + for (I = ST.type_begin(); I != End; ++I) { const Type *Ty = cast(I->second); std::string Name = "l_" + Mangler::makeNameProper(I->first); Out << "typedef "; printType(Out, Ty, Name); Out << ";\n"; } - + Out << "\n"; // Keep track of which structures have been printed so far... @@ -813,8 +1000,9 @@ void CWriter::printSymbolTable(const SymbolTable &ST) { // printed in the correct order. // Out << "/* Structure contents */\n"; - for (I = ST.type_begin(Type::TypeTy); I != End; ++I) + for (I = ST.type_begin(); I != End; ++I) if (const StructType *STy = dyn_cast(I->second)) + // Only print out used types! printContainedStructs(STy, StructPrinted); } @@ -826,9 +1014,8 @@ void CWriter::printContainedStructs(const Type *Ty, //Check to see if we have already printed this struct if (StructPrinted.count(STy) == 0) { // Print all contained types first... - for (StructType::ElementTypes::const_iterator - I = STy->getElementTypes().begin(), - E = STy->getElementTypes().end(); I != E; ++I) { + for (StructType::element_iterator I = STy->element_begin(), + E = STy->element_end(); I != E; ++I) { const Type *Ty1 = I->get(); if (isa(Ty1) || isa(Ty1)) printContainedStructs(*I, StructPrinted); @@ -851,13 +1038,7 @@ void CWriter::printContainedStructs(const Type *Ty, void CWriter::printFunctionSignature(const Function *F, bool Prototype) { - // If the program provides its own malloc prototype we don't need - // to include the general one. - if (Mang->getValueName(F) == "malloc") - needsMalloc = false; - if (F->hasInternalLinkage()) Out << "static "; - if (F->hasLinkOnceLinkage()) Out << "inline "; // Loop over the arguments, printing them... const FunctionType *FT = cast(F->getFunctionType()); @@ -885,10 +1066,9 @@ void CWriter::printFunctionSignature(const Function *F, bool Prototype) { } } else { // Loop over the arguments, printing them... - for (FunctionType::ParamTypes::const_iterator I = - FT->getParamTypes().begin(), - E = FT->getParamTypes().end(); I != E; ++I) { - if (I != FT->getParamTypes().begin()) FunctionInnards << ", "; + for (FunctionType::param_iterator I = FT->param_begin(), + E = FT->param_end(); I != E; ++I) { + if (I != FT->param_begin()) FunctionInnards << ", "; printType(FunctionInnards, *I); } } @@ -896,38 +1076,36 @@ void CWriter::printFunctionSignature(const Function *F, bool Prototype) { // Finish printing arguments... if this is a vararg function, print the ..., // unless there are no known types, in which case, we just emit (). // - if (FT->isVarArg() && !FT->getParamTypes().empty()) { - if (FT->getParamTypes().size()) FunctionInnards << ", "; + if (FT->isVarArg() && FT->getNumParams()) { + if (FT->getNumParams()) FunctionInnards << ", "; FunctionInnards << "..."; // Output varargs portion of signature! + } else if (!FT->isVarArg() && FT->getNumParams() == 0) { + FunctionInnards << "void"; // ret() -> ret(void) in C. } FunctionInnards << ")"; // Print out the return type and the entire signature for that matter printType(Out, F->getReturnType(), FunctionInnards.str()); - - if (F->hasWeakLinkage()) Out << " __attribute((weak))"; } -void CWriter::printFunction(Function *F) { - if (F->isExternal()) return; - - printFunctionSignature(F, false); +void CWriter::printFunction(Function &F) { + printFunctionSignature(&F, false); Out << " {\n"; // print local variable information for the function - for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I) - if (const AllocaInst *AI = isDirectAlloca(*I)) { + for (inst_iterator I = inst_begin(&F), E = inst_end(&F); I != E; ++I) + if (const AllocaInst *AI = isDirectAlloca(&*I)) { Out << " "; printType(Out, AI->getAllocatedType(), Mang->getValueName(AI)); Out << "; /* Address exposed local */\n"; - } else if ((*I)->getType() != Type::VoidTy && !isInlinableInst(**I)) { + } else if (I->getType() != Type::VoidTy && !isInlinableInst(*I)) { Out << " "; - printType(Out, (*I)->getType(), Mang->getValueName(*I)); + printType(Out, I->getType(), Mang->getValueName(&*I)); Out << ";\n"; if (isa(*I)) { // Print out PHI node temporaries as well... Out << " "; - printType(Out, (*I)->getType(), - Mang->getValueName(*I)+"__PHI_TEMPORARY"); + printType(Out, I->getType(), + Mang->getValueName(&*I)+"__PHI_TEMPORARY"); Out << ";\n"; } } @@ -935,46 +1113,67 @@ void CWriter::printFunction(Function *F) { Out << "\n"; // print the basic blocks - for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) { - BasicBlock *Prev = BB->getPrev(); + for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) { + if (Loop *L = LI->getLoopFor(BB)) { + if (L->getHeader() == BB && L->getParentLoop() == 0) + printLoop(L); + } else { + printBasicBlock(BB); + } + } + + Out << "}\n\n"; +} - // Don't print the label for the basic block if there are no uses, or if the - // only terminator use is the predecessor basic block's terminator. We have - // to scan the use list because PHI nodes use basic blocks too but do not - // require a label to be generated. - // - bool NeedsLabel = false; - for (Value::use_iterator UI = BB->use_begin(), UE = BB->use_end(); - UI != UE; ++UI) - if (TerminatorInst *TI = dyn_cast(*UI)) - if (TI != Prev->getTerminator() || - isa(Prev->getTerminator()) || - isa(Prev->getTerminator())) { - NeedsLabel = true; - break; - } +void CWriter::printLoop(Loop *L) { + Out << " do { /* Syntactic loop '" << L->getHeader()->getName() + << "' to make GCC happy */\n"; + for (unsigned i = 0, e = L->getBlocks().size(); i != e; ++i) { + BasicBlock *BB = L->getBlocks()[i]; + Loop *BBLoop = LI->getLoopFor(BB); + if (BBLoop == L) + printBasicBlock(BB); + else if (BB == BBLoop->getHeader() && BBLoop->getParentLoop() == L) + printLoop(BBLoop); + } + Out << " } while (1); /* end of syntactic loop '" + << L->getHeader()->getName() << "' */\n"; +} - if (NeedsLabel) Out << Mang->getValueName(BB) << ":\n"; +void CWriter::printBasicBlock(BasicBlock *BB) { - // Output all of the instructions in the basic block... - for (BasicBlock::iterator II = BB->begin(), E = --BB->end(); II != E; ++II){ - if (!isInlinableInst(*II) && !isDirectAlloca(II)) { - if (II->getType() != Type::VoidTy) - outputLValue(II); - else - Out << " "; - visit(*II); - Out << ";\n"; - } + // Don't print the label for the basic block if there are no uses, or if + // the only terminator use is the predecessor basic block's terminator. + // We have to scan the use list because PHI nodes use basic blocks too but + // do not require a label to be generated. + // + bool NeedsLabel = false; + for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) + if (isGotoCodeNecessary(*PI, BB)) { + NeedsLabel = true; + break; + } + + if (NeedsLabel) Out << Mang->getValueName(BB) << ":\n"; + + // Output all of the instructions in the basic block... + for (BasicBlock::iterator II = BB->begin(), E = --BB->end(); II != E; + ++II) { + if (!isInlinableInst(*II) && !isDirectAlloca(II)) { + if (II->getType() != Type::VoidTy) + outputLValue(II); + else + Out << " "; + visit(*II); + Out << ";\n"; } - - // Don't emit prefix or suffix for the terminator... - visit(*BB->getTerminator()); } - - Out << "}\n\n"; + + // Don't emit prefix or suffix for the terminator... + visit(*BB->getTerminator()); } + // Specific Instruction type classes... note that all of the casts are // necessary because we use the instruction classes as opaque types... // @@ -995,6 +1194,8 @@ void CWriter::visitReturnInst(ReturnInst &I) { } void CWriter::visitSwitchInst(SwitchInst &SI) { + printPHICopiesForSuccessors(SI.getParent(), 0); + Out << " switch ("; writeOperand(SI.getOperand(0)); Out << ") {\n default:\n"; @@ -1012,66 +1213,63 @@ void CWriter::visitSwitchInst(SwitchInst &SI) { Out << " }\n"; } -void CWriter::visitInvokeInst(InvokeInst &II) { - Out << " {\n" - << " struct __llvm_jmpbuf_list_t Entry;\n" - << " Entry.next = __llvm_jmpbuf_list;\n" - << " if (setjmp(Entry.buf)) {\n" - << " __llvm_jmpbuf_list = Entry.next;\n"; - printBranchToBlock(II.getParent(), II.getExceptionalDest(), 4); - Out << " }\n" - << " __llvm_jmpbuf_list = &Entry;\n" - << " "; - - if (II.getType() != Type::VoidTy) outputLValue(&II); - visitCallSite(&II); - Out << ";\n" - << " __llvm_jmpbuf_list = Entry.next;\n" - << " }\n"; - printBranchToBlock(II.getParent(), II.getNormalDest(), 0); - emittedInvoke = true; +void CWriter::visitUnreachableInst(UnreachableInst &I) { + Out << " /*UNREACHABLE*/;\n"; } +bool CWriter::isGotoCodeNecessary(BasicBlock *From, BasicBlock *To) { + /// FIXME: This should be reenabled, but loop reordering safe!! + return true; -void CWriter::visitUnwindInst(UnwindInst &I) { - // The unwind instructions causes a control flow transfer out of the current - // function, unwinding the stack until a caller who used the invoke - // instruction is found. In this context, we code generated the invoke - // instruction to add an entry to the top of the jmpbuf_list. Thus, here we - // just have to longjmp to the specified handler. - Out << " if (__llvm_jmpbuf_list == 0) { /* unwind */\n" - << " extern write();\n" - << " ((void (*)(int, void*, unsigned))write)(2,\n" - << " \"throw found with no handler!\\n\", 31); abort();\n" - << " }\n" - << " longjmp(__llvm_jmpbuf_list->buf, 1);\n"; - emittedInvoke = true; -} + if (From->getNext() != To) // Not the direct successor, we need a goto + return true; -static bool isGotoCodeNecessary(BasicBlock *From, BasicBlock *To) { - // If PHI nodes need copies, we need the copy code... - if (isa(To->front()) || - From->getNext() != To) // Not directly successor, need goto - return true; + //isa(From->getTerminator()) - // Otherwise we don't need the code. + + if (LI->getLoopFor(From) != LI->getLoopFor(To)) + return true; return false; } -void CWriter::printBranchToBlock(BasicBlock *CurBB, BasicBlock *Succ, - unsigned Indent) { - for (BasicBlock::iterator I = Succ->begin(); - PHINode *PN = dyn_cast(I); ++I) { - // now we have to do the printing - Out << std::string(Indent, ' '); - Out << " " << Mang->getValueName(I) << "__PHI_TEMPORARY = "; - writeOperand(PN->getIncomingValue(PN->getBasicBlockIndex(CurBB))); - Out << "; /* for PHI node */\n"; +void CWriter::printPHICopiesForSuccessor (BasicBlock *CurBlock, + BasicBlock *Successor, + unsigned Indent) { + for (BasicBlock::iterator I = Successor->begin(); isa(I); ++I) { + PHINode *PN = cast(I); + // Now we have to do the printing. + Value *IV = PN->getIncomingValueForBlock(CurBlock); + if (!isa(IV)) { + Out << std::string(Indent, ' '); + Out << " " << Mang->getValueName(I) << "__PHI_TEMPORARY = "; + writeOperand(IV); + Out << "; /* for PHI node */\n"; + } } +} + + +void CWriter::printPHICopiesForSuccessors(BasicBlock *CurBlock, + unsigned Indent) { + for (succ_iterator SI = succ_begin(CurBlock), E = succ_end(CurBlock); + SI != E; ++SI) + for (BasicBlock::iterator I = SI->begin(); isa(I); ++I) { + PHINode *PN = cast(I); + // Now we have to do the printing. + Value *IV = PN->getIncomingValueForBlock(CurBlock); + if (!isa(IV)) { + Out << std::string(Indent, ' '); + Out << " " << Mang->getValueName(I) << "__PHI_TEMPORARY = "; + writeOperand(IV); + Out << "; /* for PHI node */\n"; + } + } +} + - if (CurBB->getNext() != Succ || - isa(CurBB->getTerminator()) || - isa(CurBB->getTerminator())) { +void CWriter::printBranchToBlock(BasicBlock *CurBB, BasicBlock *Succ, + unsigned Indent) { + if (isGotoCodeNecessary(CurBB, Succ)) { Out << std::string(Indent, ' ') << " goto "; writeOperand(Succ); Out << ";\n"; @@ -1082,16 +1280,19 @@ void CWriter::printBranchToBlock(BasicBlock *CurBB, BasicBlock *Succ, // that immediately succeeds the current one. // void CWriter::visitBranchInst(BranchInst &I) { + if (I.isConditional()) { if (isGotoCodeNecessary(I.getParent(), I.getSuccessor(0))) { Out << " if ("; writeOperand(I.getCondition()); Out << ") {\n"; + printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(0), 2); printBranchToBlock(I.getParent(), I.getSuccessor(0), 2); if (isGotoCodeNecessary(I.getParent(), I.getSuccessor(1))) { Out << " } else {\n"; + printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(1), 2); printBranchToBlock(I.getParent(), I.getSuccessor(1), 2); } } else { @@ -1100,11 +1301,13 @@ void CWriter::visitBranchInst(BranchInst &I) { writeOperand(I.getCondition()); Out << ") {\n"; + printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(1), 2); printBranchToBlock(I.getParent(), I.getSuccessor(1), 2); } Out << " }\n"; } else { + printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(0), 0); printBranchToBlock(I.getParent(), I.getSuccessor(0), 0); } Out << "\n"; @@ -1130,7 +1333,7 @@ void CWriter::visitBinaryOperator(Instruction &I) { || (I.getType() == Type::FloatTy)) { needsCast = true; Out << "(("; - printType(Out, I.getType(), "", false, false); + printType(Out, I.getType()); Out << ")("; } @@ -1171,7 +1374,7 @@ void CWriter::visitCastInst(CastInst &I) { return; } Out << "("; - printType(Out, I.getType(), "", /*ignoreName*/false, /*namedContext*/false); + printType(Out, I.getType()); Out << ")"; if (isa(I.getType())&&I.getOperand(0)->getType()->isIntegral() || isa(I.getOperand(0)->getType())&&I.getType()->isIntegral()) { @@ -1182,13 +1385,54 @@ void CWriter::visitCastInst(CastInst &I) { writeOperand(I.getOperand(0)); } +void CWriter::visitSelectInst(SelectInst &I) { + Out << "(("; + writeOperand(I.getCondition()); + Out << ") ? ("; + writeOperand(I.getTrueValue()); + Out << ") : ("; + writeOperand(I.getFalseValue()); + Out << "))"; +} + + +void CWriter::lowerIntrinsics(Function &F) { + for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) + for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ) + if (CallInst *CI = dyn_cast(I++)) + if (Function *F = CI->getCalledFunction()) + switch (F->getIntrinsicID()) { + case Intrinsic::not_intrinsic: + case Intrinsic::vastart: + case Intrinsic::vacopy: + case Intrinsic::vaend: + case Intrinsic::returnaddress: + case Intrinsic::frameaddress: + case Intrinsic::setjmp: + case Intrinsic::longjmp: + // We directly implement these intrinsics + break; + default: + // All other intrinsic calls we must lower. + Instruction *Before = CI->getPrev(); + IL.LowerIntrinsicCall(CI); + if (Before) { // Move iterator to instruction after call + I = Before; ++I; + } else { + I = BB->begin(); + } + } +} + + + void CWriter::visitCallInst(CallInst &I) { // Handle intrinsic function calls first... if (Function *F = I.getCalledFunction()) - if (LLVMIntrinsic::ID ID = (LLVMIntrinsic::ID)F->getIntrinsicID()) { + if (Intrinsic::ID ID = (Intrinsic::ID)F->getIntrinsicID()) { switch (ID) { - default: assert(0 && "Unknown LLVM intrinsic!"); - case LLVMIntrinsic::va_start: + default: assert(0 && "Unknown LLVM intrinsic!"); + case Intrinsic::vastart: Out << "0; "; Out << "va_start(*(va_list*)&" << Mang->getValueName(&I) << ", "; @@ -1202,31 +1446,43 @@ void CWriter::visitCallInst(CallInst &I) { writeOperand(&I.getParent()->getParent()->aback()); Out << ")"; return; - case LLVMIntrinsic::va_end: - Out << "va_end(*(va_list*)&"; - writeOperand(I.getOperand(1)); - Out << ")"; + case Intrinsic::vaend: + if (!isa(I.getOperand(1))) { + Out << "va_end(*(va_list*)&"; + writeOperand(I.getOperand(1)); + Out << ")"; + } else { + Out << "va_end(*(va_list*)0)"; + } return; - case LLVMIntrinsic::va_copy: + case Intrinsic::vacopy: Out << "0;"; Out << "va_copy(*(va_list*)&" << Mang->getValueName(&I) << ", "; Out << "*(va_list*)&"; writeOperand(I.getOperand(1)); Out << ")"; return; - case LLVMIntrinsic::setjmp: - case LLVMIntrinsic::sigsetjmp: - // This intrinsic should never exist in the program, but until we get - // setjmp/longjmp transformations going on, we should codegen it to - // something reasonable. This will allow code that never calls longjmp - // to work. - Out << "0"; + case Intrinsic::returnaddress: + Out << "__builtin_return_address("; + writeOperand(I.getOperand(1)); + Out << ")"; + return; + case Intrinsic::frameaddress: + Out << "__builtin_frame_address("; + writeOperand(I.getOperand(1)); + Out << ")"; + return; + case Intrinsic::setjmp: + Out << "setjmp(*(jmp_buf*)"; + writeOperand(I.getOperand(1)); + Out << ")"; return; - case LLVMIntrinsic::longjmp: - case LLVMIntrinsic::siglongjmp: - // Longjmp is not implemented, and never will be. It would cause an - // exception throw. - Out << "abort()"; + case Intrinsic::longjmp: + Out << "longjmp(*(jmp_buf*)"; + writeOperand(I.getOperand(1)); + Out << ", "; + writeOperand(I.getOperand(2)); + Out << ")"; return; } } @@ -1254,17 +1510,7 @@ void CWriter::visitCallSite(CallSite CS) { } void CWriter::visitMallocInst(MallocInst &I) { - Out << "("; - printType(Out, I.getType()); - Out << ")malloc(sizeof("; - printType(Out, I.getType()->getElementType()); - Out << ")"; - - if (I.isArrayAllocation()) { - Out << " * " ; - writeOperand(I.getOperand(0)); - } - Out << ")"; + assert(0 && "lowerallocations pass didn't work!"); } void CWriter::visitAllocaInst(AllocaInst &I) { @@ -1281,20 +1527,15 @@ void CWriter::visitAllocaInst(AllocaInst &I) { } void CWriter::visitFreeInst(FreeInst &I) { - Out << "free((char*)"; - writeOperand(I.getOperand(0)); - Out << ")"; + assert(0 && "lowerallocations pass didn't work!"); } -void CWriter::printIndexingExpression(Value *Ptr, User::op_iterator I, - User::op_iterator E) { +void CWriter::printIndexingExpression(Value *Ptr, gep_type_iterator I, + gep_type_iterator E) { bool HasImplicitAddress = false; // If accessing a global value with no indexing, avoid *(&GV) syndrome if (GlobalValue *V = dyn_cast(Ptr)) { HasImplicitAddress = true; - } else if (ConstantPointerRef *CPR = dyn_cast(Ptr)) { - HasImplicitAddress = true; - Ptr = CPR->getValue(); // Get to the global... } else if (isDirectAlloca(Ptr)) { HasImplicitAddress = true; } @@ -1307,7 +1548,7 @@ void CWriter::printIndexingExpression(Value *Ptr, User::op_iterator I, return; } - const Constant *CI = dyn_cast(I); + const Constant *CI = dyn_cast(I.getOperand()); if (HasImplicitAddress && (!CI || !CI->isNullValue())) Out << "(&"; @@ -1323,22 +1564,24 @@ void CWriter::printIndexingExpression(Value *Ptr, User::op_iterator I, if (HasImplicitAddress) { ++I; - } else if (CI && CI->isNullValue() && I+1 != E) { + } else if (CI && CI->isNullValue()) { + gep_type_iterator TmpI = I; ++TmpI; + // Print out the -> operator if possible... - if ((*(I+1))->getType() == Type::UByteTy) { + if (TmpI != E && isa(*TmpI)) { Out << (HasImplicitAddress ? "." : "->"); - Out << "field" << cast(*(I+1))->getValue(); - I += 2; - } + Out << "field" << cast(TmpI.getOperand())->getValue(); + I = ++TmpI; + } } for (; I != E; ++I) - if ((*I)->getType() == Type::LongTy) { + if (isa(*I)) { + Out << ".field" << cast(I.getOperand())->getValue(); + } else { Out << "["; - writeOperand(*I); + writeOperand(I.getOperand()); Out << "]"; - } else { - Out << ".field" << cast(*I)->getValue(); } } @@ -1356,14 +1599,14 @@ void CWriter::visitStoreInst(StoreInst &I) { void CWriter::visitGetElementPtrInst(GetElementPtrInst &I) { Out << "&"; - printIndexingExpression(I.getPointerOperand(), I.idx_begin(), I.idx_end()); + printIndexingExpression(I.getPointerOperand(), gep_type_begin(I), + gep_type_end(I)); } void CWriter::visitVANextInst(VANextInst &I) { Out << Mang->getValueName(I.getOperand(0)); Out << "; va_arg(*(va_list*)&" << Mang->getValueName(&I) << ", "; - printType(Out, I.getArgType(), "", /*ignoreName*/false, - /*namedContext*/false); + printType(Out, I.getArgType()); Out << ")"; } @@ -1372,13 +1615,21 @@ void CWriter::visitVAArgInst(VAArgInst &I) { Out << "{ va_list Tmp; va_copy(Tmp, *(va_list*)&"; writeOperand(I.getOperand(0)); Out << ");\n " << Mang->getValueName(&I) << " = va_arg(Tmp, "; - printType(Out, I.getType(), "", /*ignoreName*/false, /*namedContext*/false); + printType(Out, I.getType()); Out << ");\n va_end(Tmp); }"; } - //===----------------------------------------------------------------------===// // External Interface declaration //===----------------------------------------------------------------------===// -Pass *createWriteToCPass(std::ostream &o) { return new CWriter(o); } +bool CTargetMachine::addPassesToEmitAssembly(PassManager &PM, std::ostream &o) { + PM.add(createLowerGCPass()); + PM.add(createLowerAllocationsPass()); + PM.add(createLowerInvokePass()); + PM.add(new CBackendNameAllUsedStructs()); + PM.add(new CWriter(o, getIntrinsicLowering())); + return false; +} + +// vim: sw=2