X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FTarget%2FCBackend%2FCBackend.cpp;h=c1c1d808e9a9c77197f74310086bd27d389b77fb;hb=b0bc6c361da9009e8414efde317d9bbff755f6c0;hp=6829218aad2828ce88c90c052212df5dd610d45c;hpb=3e3aa86b68053a9793ccd0c3541a054a41b76be8;p=oota-llvm.git diff --git a/lib/Target/CBackend/CBackend.cpp b/lib/Target/CBackend/CBackend.cpp index 6829218aad2..c1c1d808e9a 100644 --- a/lib/Target/CBackend/CBackend.cpp +++ b/lib/Target/CBackend/CBackend.cpp @@ -24,33 +24,47 @@ #include "llvm/Intrinsics.h" #include "llvm/IntrinsicInst.h" #include "llvm/InlineAsm.h" +#include "llvm/ADT/StringExtras.h" +#include "llvm/ADT/SmallString.h" +#include "llvm/ADT/STLExtras.h" #include "llvm/Analysis/ConstantsScanner.h" #include "llvm/Analysis/FindUsedTypes.h" #include "llvm/Analysis/LoopInfo.h" +#include "llvm/Analysis/ValueTracking.h" #include "llvm/CodeGen/Passes.h" #include "llvm/CodeGen/IntrinsicLowering.h" +#include "llvm/Target/Mangler.h" #include "llvm/Transforms/Scalar.h" -#include "llvm/Target/TargetMachineRegistry.h" -#include "llvm/Target/TargetAsmInfo.h" +#include "llvm/MC/MCAsmInfo.h" +#include "llvm/MC/MCSymbol.h" #include "llvm/Target/TargetData.h" +#include "llvm/Target/TargetRegistry.h" #include "llvm/Support/CallSite.h" #include "llvm/Support/CFG.h" +#include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/FormattedStream.h" #include "llvm/Support/GetElementPtrTypeIterator.h" #include "llvm/Support/InstVisitor.h" -#include "llvm/Support/Mangler.h" -#include "llvm/Support/MathExtras.h" -#include "llvm/ADT/StringExtras.h" -#include "llvm/ADT/STLExtras.h" #include "llvm/Support/MathExtras.h" +#include "llvm/System/Host.h" #include "llvm/Config/config.h" #include #include using namespace llvm; -// Register the target. -static RegisterTarget X("c", " C backend"); +extern "C" void LLVMInitializeCBackendTarget() { + // Register the target. + RegisterTargetMachine X(TheCBackendTarget); +} namespace { + class CBEMCAsmInfo : public MCAsmInfo { + public: + CBEMCAsmInfo() { + GlobalPrefix = ""; + PrivateGlobalPrefix = ""; + } + }; /// CBackendNameAllUsedStructsAndMergeFunctions - This pass inserts names for /// any unnamed structure types that are used by the program, and merges /// external functions with the same name. @@ -59,7 +73,7 @@ namespace { public: static char ID; CBackendNameAllUsedStructsAndMergeFunctions() - : ModulePass((intptr_t)&ID) {} + : ModulePass(&ID) {} void getAnalysisUsage(AnalysisUsage &AU) const { AU.addRequired(); } @@ -76,23 +90,29 @@ namespace { /// 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; + formatted_raw_ostream &Out; IntrinsicLowering *IL; Mangler *Mang; LoopInfo *LI; const Module *TheModule; - const TargetAsmInfo* TAsm; + const MCAsmInfo* TAsm; const TargetData* TD; std::map TypeNames; std::map FPConstantMap; std::set intrinsicPrototypesAlreadyGenerated; std::set ByValParams; + unsigned FPCounter; + unsigned OpaqueCounter; + DenseMap AnonValueNumbers; + unsigned NextAnonValueNumber; public: static char ID; - explicit CWriter(std::ostream &o) - : FunctionPass((intptr_t)&ID), Out(o), IL(0), Mang(0), LI(0), - TheModule(0), TAsm(0), TD(0) {} + explicit CWriter(formatted_raw_ostream &o) + : FunctionPass(&ID), Out(o), IL(0), Mang(0), LI(0), + TheModule(0), TAsm(0), TD(0), OpaqueCounter(0), NextAnonValueNumber(0) { + FPCounter = 0; + } virtual const char *getPassName() const { return "C backend"; } @@ -104,6 +124,11 @@ namespace { virtual bool doInitialization(Module &M); bool runOnFunction(Function &F) { + // Do not codegen any 'available_externally' functions at all, they have + // definitions outside the translation unit. + if (F.hasAvailableExternallyLinkage()) + return false; + LI = &getAnalysis(); // Get rid of intrinsics we can't handle. @@ -118,6 +143,8 @@ namespace { virtual bool doFinalization(Module &M) { // Free memory... + delete IL; + delete TD; delete Mang; FPConstantMap.clear(); TypeNames.clear(); @@ -126,17 +153,27 @@ namespace { return false; } + raw_ostream &printType(formatted_raw_ostream &Out, + const Type *Ty, + bool isSigned = false, + const std::string &VariableName = "", + bool IgnoreName = false, + const AttrListPtr &PAL = AttrListPtr()); std::ostream &printType(std::ostream &Out, const Type *Ty, - bool isSigned = false, - const std::string &VariableName = "", - bool IgnoreName = false, - const PAListPtr &PAL = PAListPtr()); + bool isSigned = false, + const std::string &VariableName = "", + bool IgnoreName = false, + const AttrListPtr &PAL = AttrListPtr()); + raw_ostream &printSimpleType(formatted_raw_ostream &Out, + const Type *Ty, + bool isSigned, + const std::string &NameSoFar = ""); std::ostream &printSimpleType(std::ostream &Out, const Type *Ty, - bool isSigned, - const std::string &NameSoFar = ""); + bool isSigned, + const std::string &NameSoFar = ""); - void printStructReturnPointerFunctionType(std::ostream &Out, - const PAListPtr &PAL, + void printStructReturnPointerFunctionType(formatted_raw_ostream &Out, + const AttrListPtr &PAL, const PointerType *Ty); /// writeOperandDeref - Print the result of dereferencing the specified @@ -153,10 +190,9 @@ namespace { } } - void writeOperand(Value *Operand); - void writeOperandRaw(Value *Operand); + void writeOperand(Value *Operand, bool Static = false); void writeInstComputationInline(Instruction &I); - void writeOperandInternal(Value *Operand); + void writeOperandInternal(Value *Operand, bool Static = false); void writeOperandWithCast(Value* Operand, unsigned Opcode); void writeOperandWithCast(Value* Operand, const ICmpInst &I); bool writeInstructionCast(const Instruction &I); @@ -173,6 +209,7 @@ namespace { void printModuleTypes(const TypeSymbolTable &ST); void printContainedStructs(const Type *Ty, std::set &); void printFloatingPointConstants(Function &F); + void printFloatingPointConstants(const Constant *C); void printFunctionSignature(const Function *F, bool Prototype); void printFunction(Function &); @@ -180,11 +217,11 @@ namespace { void printLoop(Loop *L); void printCast(unsigned opcode, const Type *SrcTy, const Type *DstTy); - void printConstant(Constant *CPV); + void printConstant(Constant *CPV, bool Static); void printConstantWithCast(Constant *CPV, unsigned Opcode); - bool printConstExprCast(const ConstantExpr *CE); - void printConstantArray(ConstantArray *CPA); - void printConstantVector(ConstantVector *CV); + bool printConstExprCast(const ConstantExpr *CE, bool Static); + void printConstantArray(ConstantArray *CPA, bool Static); + void printConstantVector(ConstantVector *CV, bool Static); /// isAddressExposed - Return true if the specified value's name needs to /// have its address taken in order to get a C value of the correct type. @@ -208,7 +245,7 @@ namespace { // 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() || + if (I.getType() == Type::getVoidTy(I.getContext()) || !I.hasOneUse() || isa(I) || isa(I) || isa(I) || isa(I) || isa(I) || isa(I) || isa(I)) @@ -254,12 +291,13 @@ namespace { void visitReturnInst(ReturnInst &I); void visitBranchInst(BranchInst &I); void visitSwitchInst(SwitchInst &I); + void visitIndirectBrInst(IndirectBrInst &I); void visitInvokeInst(InvokeInst &I) { - assert(0 && "Lowerinvoke pass didn't work!"); + llvm_unreachable("Lowerinvoke pass didn't work!"); } void visitUnwindInst(UnwindInst &I) { - assert(0 && "Lowerinvoke pass didn't work!"); + llvm_unreachable("Lowerinvoke pass didn't work!"); } void visitUnreachableInst(UnreachableInst &I); @@ -274,9 +312,7 @@ namespace { void visitInlineAsm(CallInst &I); bool visitBuiltinCall(CallInst &I, Intrinsic::ID ID, bool &WroteCallee); - void visitMallocInst(MallocInst &I); void visitAllocaInst(AllocaInst &I); - void visitFreeInst (FreeInst &I); void visitLoadInst (LoadInst &I); void visitStoreInst (StoreInst &I); void visitGetElementPtrInst(GetElementPtrInst &I); @@ -285,14 +321,15 @@ namespace { void visitInsertElementInst(InsertElementInst &I); void visitExtractElementInst(ExtractElementInst &I); void visitShuffleVectorInst(ShuffleVectorInst &SVI); - void visitGetResultInst(GetResultInst &GRI); void visitInsertValueInst(InsertValueInst &I); void visitExtractValueInst(ExtractValueInst &I); void visitInstruction(Instruction &I) { - cerr << "C Writer does not know about " << I; - abort(); +#ifndef NDEBUG + errs() << "C Writer does not know about " << I; +#endif + llvm_unreachable(0); } void outputLValue(Instruction *I) { @@ -305,7 +342,7 @@ namespace { void printBranchToBlock(BasicBlock *CurBlock, BasicBlock *SuccBlock, unsigned Indent); void printGEPExpression(Value *Ptr, gep_type_iterator I, - gep_type_iterator E); + gep_type_iterator E, bool Static); std::string GetValueName(const Value *Operand); }; @@ -313,6 +350,23 @@ namespace { char CWriter::ID = 0; + +static std::string CBEMangle(const std::string &S) { + std::string Result; + + for (unsigned i = 0, e = S.size(); i != e; ++i) + if (isalnum(S[i]) || S[i] == '_') { + Result += S[i]; + } else { + Result += '_'; + Result += 'A'+(S[i]&15); + Result += 'A'+((S[i]>>4)&15); + Result += '_'; + } + return Result; +} + + /// 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. @@ -400,8 +454,8 @@ bool CBackendNameAllUsedStructsAndMergeFunctions::runOnModule(Module &M) { /// printStructReturnPointerFunctionType - This is like printType for a struct /// return type, except, instead of printing the type as void (*)(Struct*, ...) /// print it as "Struct (*)(...)", for struct return functions. -void CWriter::printStructReturnPointerFunctionType(std::ostream &Out, - const PAListPtr &PAL, +void CWriter::printStructReturnPointerFunctionType(formatted_raw_ostream &Out, + const AttrListPtr &PAL, const PointerType *TheTy) { const FunctionType *FTy = cast(TheTy->getElementType()); std::stringstream FunctionInnards; @@ -415,12 +469,12 @@ void CWriter::printStructReturnPointerFunctionType(std::ostream &Out, if (PrintedType) FunctionInnards << ", "; const Type *ArgTy = *I; - if (PAL.paramHasAttr(Idx, ParamAttr::ByVal)) { + if (PAL.paramHasAttr(Idx, Attribute::ByVal)) { assert(isa(ArgTy)); ArgTy = cast(ArgTy)->getElementType(); } printType(FunctionInnards, ArgTy, - /*isSigned=*/PAL.paramHasAttr(Idx, ParamAttr::SExt), ""); + /*isSigned=*/PAL.paramHasAttr(Idx, Attribute::SExt), ""); PrintedType = true; } if (FTy->isVarArg()) { @@ -432,13 +486,61 @@ void CWriter::printStructReturnPointerFunctionType(std::ostream &Out, FunctionInnards << ')'; std::string tstr = FunctionInnards.str(); printType(Out, RetTy, - /*isSigned=*/PAL.paramHasAttr(0, ParamAttr::SExt), tstr); + /*isSigned=*/PAL.paramHasAttr(0, Attribute::SExt), tstr); +} + +raw_ostream & +CWriter::printSimpleType(formatted_raw_ostream &Out, const Type *Ty, + bool isSigned, + const std::string &NameSoFar) { + assert((Ty->isPrimitiveType() || Ty->isIntegerTy() || isa(Ty)) && + "Invalid type for printSimpleType"); + switch (Ty->getTypeID()) { + case Type::VoidTyID: return Out << "void " << NameSoFar; + case Type::IntegerTyID: { + unsigned NumBits = cast(Ty)->getBitWidth(); + if (NumBits == 1) + return Out << "bool " << NameSoFar; + else if (NumBits <= 8) + return Out << (isSigned?"signed":"unsigned") << " char " << NameSoFar; + else if (NumBits <= 16) + return Out << (isSigned?"signed":"unsigned") << " short " << NameSoFar; + else if (NumBits <= 32) + return Out << (isSigned?"signed":"unsigned") << " int " << NameSoFar; + else if (NumBits <= 64) + return Out << (isSigned?"signed":"unsigned") << " long long "<< NameSoFar; + else { + assert(NumBits <= 128 && "Bit widths > 128 not implemented yet"); + return Out << (isSigned?"llvmInt128":"llvmUInt128") << " " << NameSoFar; + } + } + case Type::FloatTyID: return Out << "float " << NameSoFar; + case Type::DoubleTyID: return Out << "double " << NameSoFar; + // Lacking emulation of FP80 on PPC, etc., we assume whichever of these is + // present matches host 'long double'. + case Type::X86_FP80TyID: + case Type::PPC_FP128TyID: + case Type::FP128TyID: return Out << "long double " << NameSoFar; + + case Type::VectorTyID: { + const VectorType *VTy = cast(Ty); + return printSimpleType(Out, VTy->getElementType(), isSigned, + " __attribute__((vector_size(" + + utostr(TD->getTypeAllocSize(VTy)) + " ))) " + NameSoFar); + } + + default: +#ifndef NDEBUG + errs() << "Unknown primitive type: " << *Ty << "\n"; +#endif + llvm_unreachable(0); + } } std::ostream & CWriter::printSimpleType(std::ostream &Out, const Type *Ty, bool isSigned, const std::string &NameSoFar) { - assert((Ty->isPrimitiveType() || Ty->isInteger() || isa(Ty)) && + assert((Ty->isPrimitiveType() || Ty->isIntegerTy() || isa(Ty)) && "Invalid type for printSimpleType"); switch (Ty->getTypeID()) { case Type::VoidTyID: return Out << "void " << NameSoFar; @@ -471,13 +573,119 @@ CWriter::printSimpleType(std::ostream &Out, const Type *Ty, bool isSigned, const VectorType *VTy = cast(Ty); return printSimpleType(Out, VTy->getElementType(), isSigned, " __attribute__((vector_size(" + - utostr(TD->getABITypeSize(VTy)) + " ))) " + NameSoFar); + utostr(TD->getTypeAllocSize(VTy)) + " ))) " + NameSoFar); } default: - cerr << "Unknown primitive type: " << *Ty << "\n"; - abort(); +#ifndef NDEBUG + errs() << "Unknown primitive type: " << *Ty << "\n"; +#endif + llvm_unreachable(0); + } +} + +// Pass the Type* and the variable name and this prints out the variable +// declaration. +// +raw_ostream &CWriter::printType(formatted_raw_ostream &Out, + const Type *Ty, + bool isSigned, const std::string &NameSoFar, + bool IgnoreName, const AttrListPtr &PAL) { + if (Ty->isPrimitiveType() || Ty->isIntegerTy() || isa(Ty)) { + printSimpleType(Out, Ty, isSigned, NameSoFar); + return Out; + } + + // Check to see if the type is named. + if (!IgnoreName || isa(Ty)) { + std::map::iterator I = TypeNames.find(Ty); + if (I != TypeNames.end()) return Out << I->second << ' ' << NameSoFar; + } + + switch (Ty->getTypeID()) { + case Type::FunctionTyID: { + const FunctionType *FTy = cast(Ty); + std::stringstream FunctionInnards; + FunctionInnards << " (" << NameSoFar << ") ("; + unsigned Idx = 1; + for (FunctionType::param_iterator I = FTy->param_begin(), + E = FTy->param_end(); I != E; ++I) { + const Type *ArgTy = *I; + if (PAL.paramHasAttr(Idx, Attribute::ByVal)) { + assert(isa(ArgTy)); + ArgTy = cast(ArgTy)->getElementType(); + } + if (I != FTy->param_begin()) + FunctionInnards << ", "; + printType(FunctionInnards, ArgTy, + /*isSigned=*/PAL.paramHasAttr(Idx, Attribute::SExt), ""); + ++Idx; + } + if (FTy->isVarArg()) { + if (FTy->getNumParams()) + FunctionInnards << ", ..."; + } else if (!FTy->getNumParams()) { + FunctionInnards << "void"; + } + FunctionInnards << ')'; + std::string tstr = FunctionInnards.str(); + printType(Out, FTy->getReturnType(), + /*isSigned=*/PAL.paramHasAttr(0, Attribute::SExt), tstr); + return Out; + } + case Type::StructTyID: { + const StructType *STy = cast(Ty); + Out << NameSoFar + " {\n"; + unsigned Idx = 0; + for (StructType::element_iterator I = STy->element_begin(), + E = STy->element_end(); I != E; ++I) { + Out << " "; + printType(Out, *I, false, "field" + utostr(Idx++)); + Out << ";\n"; + } + Out << '}'; + if (STy->isPacked()) + Out << " __attribute__ ((packed))"; + return Out; + } + + case Type::PointerTyID: { + const PointerType *PTy = cast(Ty); + std::string ptrName = "*" + NameSoFar; + + if (isa(PTy->getElementType()) || + isa(PTy->getElementType())) + ptrName = "(" + ptrName + ")"; + + if (!PAL.isEmpty()) + // Must be a function ptr cast! + return printType(Out, PTy->getElementType(), false, ptrName, true, PAL); + return printType(Out, PTy->getElementType(), false, ptrName); + } + + case Type::ArrayTyID: { + const ArrayType *ATy = cast(Ty); + unsigned NumElements = ATy->getNumElements(); + if (NumElements == 0) NumElements = 1; + // Arrays are wrapped in structs to allow them to have normal + // value semantics (avoiding the array "decay"). + Out << NameSoFar << " { "; + printType(Out, ATy->getElementType(), false, + "array[" + utostr(NumElements) + "]"); + return Out << "; }"; + } + + case Type::OpaqueTyID: { + std::string TyName = "struct opaque_" + itostr(OpaqueCounter++); + assert(TypeNames.find(Ty) == TypeNames.end()); + TypeNames[Ty] = TyName; + return Out << TyName << ' ' << NameSoFar; + } + default: + llvm_unreachable("Unhandled case in getTypeProps!"); } + + return Out; } // Pass the Type* and the variable name and this prints out the variable @@ -485,8 +693,8 @@ CWriter::printSimpleType(std::ostream &Out, const Type *Ty, bool isSigned, // std::ostream &CWriter::printType(std::ostream &Out, const Type *Ty, bool isSigned, const std::string &NameSoFar, - bool IgnoreName, const PAListPtr &PAL) { - if (Ty->isPrimitiveType() || Ty->isInteger() || isa(Ty)) { + bool IgnoreName, const AttrListPtr &PAL) { + if (Ty->isPrimitiveType() || Ty->isIntegerTy() || isa(Ty)) { printSimpleType(Out, Ty, isSigned, NameSoFar); return Out; } @@ -506,14 +714,14 @@ std::ostream &CWriter::printType(std::ostream &Out, const Type *Ty, for (FunctionType::param_iterator I = FTy->param_begin(), E = FTy->param_end(); I != E; ++I) { const Type *ArgTy = *I; - if (PAL.paramHasAttr(Idx, ParamAttr::ByVal)) { + if (PAL.paramHasAttr(Idx, Attribute::ByVal)) { assert(isa(ArgTy)); ArgTy = cast(ArgTy)->getElementType(); } if (I != FTy->param_begin()) FunctionInnards << ", "; printType(FunctionInnards, ArgTy, - /*isSigned=*/PAL.paramHasAttr(Idx, ParamAttr::SExt), ""); + /*isSigned=*/PAL.paramHasAttr(Idx, Attribute::SExt), ""); ++Idx; } if (FTy->isVarArg()) { @@ -525,7 +733,7 @@ std::ostream &CWriter::printType(std::ostream &Out, const Type *Ty, FunctionInnards << ')'; std::string tstr = FunctionInnards.str(); printType(Out, FTy->getReturnType(), - /*isSigned=*/PAL.paramHasAttr(0, ParamAttr::SExt), tstr); + /*isSigned=*/PAL.paramHasAttr(0, Attribute::SExt), tstr); return Out; } case Type::StructTyID: { @@ -571,27 +779,26 @@ std::ostream &CWriter::printType(std::ostream &Out, const Type *Ty, } case Type::OpaqueTyID: { - static int Count = 0; - std::string TyName = "struct opaque_" + itostr(Count++); + std::string TyName = "struct opaque_" + itostr(OpaqueCounter++); assert(TypeNames.find(Ty) == TypeNames.end()); TypeNames[Ty] = TyName; return Out << TyName << ' ' << NameSoFar; } default: - assert(0 && "Unhandled case in getTypeProps!"); - abort(); + llvm_unreachable("Unhandled case in getTypeProps!"); } return Out; } -void CWriter::printConstantArray(ConstantArray *CPA) { +void CWriter::printConstantArray(ConstantArray *CPA, bool Static) { // 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 = CPA->getType()->getElementType(); - bool isString = (ETy == Type::Int8Ty || ETy == Type::Int8Ty); + bool isString = (ETy == Type::getInt8Ty(CPA->getContext()) || + ETy == Type::getInt8Ty(CPA->getContext())); // Make sure the last character is a null char, as automatically added by C if (isString && (CPA->getNumOperands() == 0 || @@ -616,9 +823,9 @@ void CWriter::printConstantArray(ConstantArray *CPA) { if (isprint(C) && (!LastWasHex || !isxdigit(C))) { LastWasHex = false; if (C == '"' || C == '\\') - Out << "\\" << C; + Out << "\\" << (char)C; else - Out << C; + Out << (char)C; } else { LastWasHex = false; switch (C) { @@ -643,24 +850,24 @@ void CWriter::printConstantArray(ConstantArray *CPA) { Out << '{'; if (CPA->getNumOperands()) { Out << ' '; - printConstant(cast(CPA->getOperand(0))); + printConstant(cast(CPA->getOperand(0)), Static); for (unsigned i = 1, e = CPA->getNumOperands(); i != e; ++i) { Out << ", "; - printConstant(cast(CPA->getOperand(i))); + printConstant(cast(CPA->getOperand(i)), Static); } } Out << " }"; } } -void CWriter::printConstantVector(ConstantVector *CP) { +void CWriter::printConstantVector(ConstantVector *CP, bool Static) { Out << '{'; if (CP->getNumOperands()) { Out << ' '; - printConstant(cast(CP->getOperand(0))); + printConstant(cast(CP->getOperand(0)), Static); for (unsigned i = 1, e = CP->getNumOperands(); i != e; ++i) { Out << ", "; - printConstant(cast(CP->getOperand(i))); + printConstant(cast(CP->getOperand(i)), Static); } } Out << " }"; @@ -675,12 +882,14 @@ void CWriter::printConstantVector(ConstantVector *CP) { // only deal in IEEE FP). // static bool isFPCSafeToPrint(const ConstantFP *CFP) { + bool ignored; // Do long doubles in hex for now. - if (CFP->getType()!=Type::FloatTy && CFP->getType()!=Type::DoubleTy) + if (CFP->getType() != Type::getFloatTy(CFP->getContext()) && + CFP->getType() != Type::getDoubleTy(CFP->getContext())) return false; APFloat APF = APFloat(CFP->getValueAPF()); // copy - if (CFP->getType()==Type::FloatTy) - APF.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven); + if (CFP->getType() == Type::getFloatTy(CFP->getContext())) + APF.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &ignored); #if HAVE_PRINTF_A && ENABLE_CBE_PRINTF_A char Buffer[100]; sprintf(Buffer, "%a", APF.convertToDouble()); @@ -737,7 +946,7 @@ void CWriter::printCast(unsigned opc, const Type *SrcTy, const Type *DstTy) { Out << ')'; break; default: - assert(0 && "Invalid cast opcode"); + llvm_unreachable("Invalid cast opcode"); } // Print the source type cast @@ -767,13 +976,13 @@ void CWriter::printCast(unsigned opc, const Type *SrcTy, const Type *DstTy) { case Instruction::FPToUI: break; // These don't need a source cast. default: - assert(0 && "Invalid cast opcode"); + llvm_unreachable("Invalid cast opcode"); break; } } // printConstant - The LLVM Constant to C Constant converter. -void CWriter::printConstant(Constant *CPV) { +void CWriter::printConstant(Constant *CPV, bool Static) { if (const ConstantExpr *CE = dyn_cast(CPV)) { switch (CE->getOpcode()) { case Instruction::Trunc: @@ -791,12 +1000,12 @@ void CWriter::printConstant(Constant *CPV) { Out << "("; printCast(CE->getOpcode(), CE->getOperand(0)->getType(), CE->getType()); if (CE->getOpcode() == Instruction::SExt && - CE->getOperand(0)->getType() == Type::Int1Ty) { + CE->getOperand(0)->getType() == Type::getInt1Ty(CPV->getContext())) { // Make sure we really sext from bool here by subtracting from 0 Out << "0-"; } - printConstant(CE->getOperand(0)); - if (CE->getType() == Type::Int1Ty && + printConstant(CE->getOperand(0), Static); + if (CE->getType() == Type::getInt1Ty(CPV->getContext()) && (CE->getOpcode() == Instruction::Trunc || CE->getOpcode() == Instruction::FPToUI || CE->getOpcode() == Instruction::FPToSI || @@ -810,21 +1019,24 @@ void CWriter::printConstant(Constant *CPV) { case Instruction::GetElementPtr: Out << "("; printGEPExpression(CE->getOperand(0), gep_type_begin(CPV), - gep_type_end(CPV)); + gep_type_end(CPV), Static); Out << ")"; return; case Instruction::Select: Out << '('; - printConstant(CE->getOperand(0)); + printConstant(CE->getOperand(0), Static); Out << '?'; - printConstant(CE->getOperand(1)); + printConstant(CE->getOperand(1), Static); Out << ':'; - printConstant(CE->getOperand(2)); + printConstant(CE->getOperand(2), Static); Out << ')'; return; case Instruction::Add: + case Instruction::FAdd: case Instruction::Sub: + case Instruction::FSub: case Instruction::Mul: + case Instruction::FMul: case Instruction::SDiv: case Instruction::UDiv: case Instruction::FDiv: @@ -840,12 +1052,15 @@ void CWriter::printConstant(Constant *CPV) { case Instruction::AShr: { Out << '('; - bool NeedsClosingParens = printConstExprCast(CE); + bool NeedsClosingParens = printConstExprCast(CE, Static); printConstantWithCast(CE->getOperand(0), CE->getOpcode()); switch (CE->getOpcode()) { - case Instruction::Add: Out << " + "; break; - case Instruction::Sub: Out << " - "; break; - case Instruction::Mul: Out << " * "; break; + case Instruction::Add: + case Instruction::FAdd: Out << " + "; break; + case Instruction::Sub: + case Instruction::FSub: Out << " - "; break; + case Instruction::Mul: + case Instruction::FMul: Out << " * "; break; case Instruction::URem: case Instruction::SRem: case Instruction::FRem: Out << " % "; break; @@ -870,10 +1085,10 @@ void CWriter::printConstant(Constant *CPV) { case ICmpInst::ICMP_UGT: Out << " > "; break; case ICmpInst::ICMP_SGE: case ICmpInst::ICMP_UGE: Out << " >= "; break; - default: assert(0 && "Illegal ICmp predicate"); + default: llvm_unreachable("Illegal ICmp predicate"); } break; - default: assert(0 && "Illegal opcode here!"); + default: llvm_unreachable("Illegal opcode here!"); } printConstantWithCast(CE->getOperand(1), CE->getOpcode()); if (NeedsClosingParens) @@ -883,7 +1098,7 @@ void CWriter::printConstant(Constant *CPV) { } case Instruction::FCmp: { Out << '('; - bool NeedsClosingParens = printConstExprCast(CE); + bool NeedsClosingParens = printConstExprCast(CE, Static); if (CE->getPredicate() == FCmpInst::FCMP_FALSE) Out << "0"; else if (CE->getPredicate() == FCmpInst::FCMP_TRUE) @@ -891,7 +1106,7 @@ void CWriter::printConstant(Constant *CPV) { else { const char* op = 0; switch (CE->getPredicate()) { - default: assert(0 && "Illegal FCmp predicate"); + default: llvm_unreachable("Illegal FCmp predicate"); case FCmpInst::FCMP_ORD: op = "ord"; break; case FCmpInst::FCMP_UNO: op = "uno"; break; case FCmpInst::FCMP_UEQ: op = "ueq"; break; @@ -919,9 +1134,11 @@ void CWriter::printConstant(Constant *CPV) { return; } default: - cerr << "CWriter Error: Unhandled constant expression: " +#ifndef NDEBUG + errs() << "CWriter Error: Unhandled constant expression: " << *CE << "\n"; - abort(); +#endif + llvm_unreachable(0); } } else if (isa(CPV) && CPV->getType()->isSingleValueType()) { Out << "(("; @@ -937,9 +1154,9 @@ void CWriter::printConstant(Constant *CPV) { if (ConstantInt *CI = dyn_cast(CPV)) { const Type* Ty = CI->getType(); - if (Ty == Type::Int1Ty) + if (Ty == Type::getInt1Ty(CPV->getContext())) Out << (CI->getZExtValue() ? '1' : '0'); - else if (Ty == Type::Int32Ty) + else if (Ty == Type::getInt32Ty(CPV->getContext())) Out << CI->getZExtValue() << 'u'; else if (Ty->getPrimitiveSizeInBits() > 32) Out << CI->getZExtValue() << "ull"; @@ -950,7 +1167,7 @@ void CWriter::printConstant(Constant *CPV) { Out << CI->getZExtValue() << 'u'; else Out << CI->getSExtValue(); - Out << ')'; + Out << ')'; } return; } @@ -966,16 +1183,28 @@ void CWriter::printConstant(Constant *CPV) { if (I != FPConstantMap.end()) { // Because of FP precision problems we must load from a stack allocated // value that holds the value in hex. - Out << "(*(" << (FPC->getType() == Type::FloatTy ? "float" : - FPC->getType() == Type::DoubleTy ? "double" : + Out << "(*(" << (FPC->getType() == Type::getFloatTy(CPV->getContext()) ? + "float" : + FPC->getType() == Type::getDoubleTy(CPV->getContext()) ? + "double" : "long double") << "*)&FPConstant" << I->second << ')'; } else { - assert(FPC->getType() == Type::FloatTy || - FPC->getType() == Type::DoubleTy); - double V = FPC->getType() == Type::FloatTy ? - FPC->getValueAPF().convertToFloat() : - FPC->getValueAPF().convertToDouble(); + double V; + if (FPC->getType() == Type::getFloatTy(CPV->getContext())) + V = FPC->getValueAPF().convertToFloat(); + else if (FPC->getType() == Type::getDoubleTy(CPV->getContext())) + V = FPC->getValueAPF().convertToDouble(); + else { + // Long double. Convert the number to double, discarding precision. + // This is not awesome, but it at least makes the CBE output somewhat + // useful. + APFloat Tmp = FPC->getValueAPF(); + bool LosesInfo; + Tmp.convert(APFloat::IEEEdouble, APFloat::rmTowardZero, &LosesInfo); + V = Tmp.convertToDouble(); + } + if (IsNAN(V)) { // The value is NaN @@ -994,7 +1223,7 @@ void CWriter::printConstant(Constant *CPV) { std::string Num(&Buffer[0], &Buffer[6]); unsigned long Val = strtoul(Num.c_str(), 0, 16); - if (FPC->getType() == Type::FloatTy) + if (FPC->getType() == Type::getFloatTy(FPC->getContext())) Out << "LLVM_NAN" << (Val == QuietNaN ? "" : "S") << "F(\"" << Buffer << "\") /*nan*/ "; else @@ -1003,7 +1232,8 @@ void CWriter::printConstant(Constant *CPV) { } else if (IsInf(V)) { // The value is Inf if (V < 0) Out << '-'; - Out << "LLVM_INF" << (FPC->getType() == Type::FloatTy ? "F" : "") + Out << "LLVM_INF" << + (FPC->getType() == Type::getFloatTy(FPC->getContext()) ? "F" : "") << " /*inf*/ "; } else { std::string Num; @@ -1022,9 +1252,15 @@ void CWriter::printConstant(Constant *CPV) { } case Type::ArrayTyID: + // Use C99 compound expression literal initializer syntax. + if (!Static) { + Out << "("; + printType(Out, CPV->getType()); + Out << ")"; + } Out << "{ "; // Arrays are wrapped in struct types. if (ConstantArray *CA = dyn_cast(CPV)) { - printConstantArray(CA); + printConstantArray(CA, Static); } else { assert(isa(CPV) || isa(CPV)); const ArrayType *AT = cast(CPV->getType()); @@ -1032,10 +1268,10 @@ void CWriter::printConstant(Constant *CPV) { if (AT->getNumElements()) { Out << ' '; Constant *CZ = Constant::getNullValue(AT->getElementType()); - printConstant(CZ); + printConstant(CZ, Static); for (unsigned i = 1, e = AT->getNumElements(); i != e; ++i) { Out << ", "; - printConstant(CZ); + printConstant(CZ, Static); } } Out << " }"; @@ -1045,35 +1281,43 @@ void CWriter::printConstant(Constant *CPV) { case Type::VectorTyID: // Use C99 compound expression literal initializer syntax. - Out << "("; - printType(Out, CPV->getType()); - Out << ")"; + if (!Static) { + Out << "("; + printType(Out, CPV->getType()); + Out << ")"; + } if (ConstantVector *CV = dyn_cast(CPV)) { - printConstantVector(CV); + printConstantVector(CV, Static); } else { assert(isa(CPV) || isa(CPV)); const VectorType *VT = cast(CPV->getType()); Out << "{ "; Constant *CZ = Constant::getNullValue(VT->getElementType()); - printConstant(CZ); + printConstant(CZ, Static); for (unsigned i = 1, e = VT->getNumElements(); i != e; ++i) { Out << ", "; - printConstant(CZ); + printConstant(CZ, Static); } Out << " }"; } break; case Type::StructTyID: + // Use C99 compound expression literal initializer syntax. + if (!Static) { + Out << "("; + printType(Out, CPV->getType()); + Out << ")"; + } if (isa(CPV) || isa(CPV)) { const StructType *ST = cast(CPV->getType()); Out << '{'; if (ST->getNumElements()) { Out << ' '; - printConstant(Constant::getNullValue(ST->getElementType(0))); + printConstant(Constant::getNullValue(ST->getElementType(0)), Static); for (unsigned i = 1, e = ST->getNumElements(); i != e; ++i) { Out << ", "; - printConstant(Constant::getNullValue(ST->getElementType(i))); + printConstant(Constant::getNullValue(ST->getElementType(i)), Static); } } Out << " }"; @@ -1081,10 +1325,10 @@ void CWriter::printConstant(Constant *CPV) { Out << '{'; if (CPV->getNumOperands()) { Out << ' '; - printConstant(cast(CPV->getOperand(0))); + printConstant(cast(CPV->getOperand(0)), Static); for (unsigned i = 1, e = CPV->getNumOperands(); i != e; ++i) { Out << ", "; - printConstant(cast(CPV->getOperand(i))); + printConstant(cast(CPV->getOperand(i)), Static); } } Out << " }"; @@ -1098,24 +1342,31 @@ void CWriter::printConstant(Constant *CPV) { Out << ")/*NULL*/0)"; break; } else if (GlobalValue *GV = dyn_cast(CPV)) { - writeOperand(GV); + writeOperand(GV, Static); break; } // FALL THROUGH default: - cerr << "Unknown constant type: " << *CPV << "\n"; - abort(); +#ifndef NDEBUG + errs() << "Unknown constant type: " << *CPV << "\n"; +#endif + llvm_unreachable(0); } } // Some constant expressions need to be casted back to the original types // because their operands were casted to the expected type. This function takes // care of detecting that case and printing the cast for the ConstantExpr. -bool CWriter::printConstExprCast(const ConstantExpr* CE) { +bool CWriter::printConstExprCast(const ConstantExpr* CE, bool Static) { bool NeedsExplicitCast = false; const Type *Ty = CE->getOperand(0)->getType(); bool TypeIsSigned = false; switch (CE->getOpcode()) { + case Instruction::Add: + case Instruction::Sub: + case Instruction::Mul: + // We need to cast integer arithmetic so that it is always performed + // as unsigned, to avoid undefined behavior on overflow. case Instruction::LShr: case Instruction::URem: case Instruction::UDiv: NeedsExplicitCast = true; break; @@ -1145,7 +1396,7 @@ bool CWriter::printConstExprCast(const ConstantExpr* CE) { } if (NeedsExplicitCast) { Out << "(("; - if (Ty->isInteger() && Ty != Type::Int1Ty) + if (Ty->isIntegerTy() && Ty != Type::getInt1Ty(Ty->getContext())) printSimpleType(Out, Ty, TypeIsSigned); else printType(Out, Ty); // not integer, sign doesn't matter @@ -1174,6 +1425,11 @@ void CWriter::printConstantWithCast(Constant* CPV, unsigned Opcode) { default: // for most instructions, it doesn't matter break; + case Instruction::Add: + case Instruction::Sub: + case Instruction::Mul: + // We need to cast integer arithmetic so that it is always performed + // as unsigned, to avoid undefined behavior on overflow. case Instruction::LShr: case Instruction::UDiv: case Instruction::URem: @@ -1193,50 +1449,70 @@ void CWriter::printConstantWithCast(Constant* CPV, unsigned Opcode) { Out << "(("; printSimpleType(Out, OpTy, typeIsSigned); Out << ")"; - printConstant(CPV); + printConstant(CPV, false); Out << ")"; } else - printConstant(CPV); + printConstant(CPV, false); } std::string CWriter::GetValueName(const Value *Operand) { - std::string Name; - - if (!isa(Operand) && Operand->getName() != "") { - std::string VarName; - - Name = Operand->getName(); - VarName.reserve(Name.capacity()); - - for (std::string::iterator I = Name.begin(), E = Name.end(); - I != E; ++I) { - char ch = *I; + // Mangle globals with the standard mangler interface for LLC compatibility. + if (const GlobalValue *GV = dyn_cast(Operand)) { + SmallString<128> Str; + Mang->getNameWithPrefix(Str, GV, false); + return CBEMangle(Str.str().str()); + } + + std::string Name = Operand->getName(); + + if (Name.empty()) { // Assign unique names to local temporaries. + unsigned &No = AnonValueNumbers[Operand]; + if (No == 0) + No = ++NextAnonValueNumber; + Name = "tmp__" + utostr(No); + } + + std::string VarName; + VarName.reserve(Name.capacity()); - if (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || - (ch >= '0' && ch <= '9') || ch == '_')) { - char buffer[5]; - sprintf(buffer, "_%x_", ch); - VarName += buffer; - } else - VarName += ch; - } + for (std::string::iterator I = Name.begin(), E = Name.end(); + I != E; ++I) { + char ch = *I; - Name = "llvm_cbe_" + VarName; - } else { - Name = Mang->getValueName(Operand); + if (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || + (ch >= '0' && ch <= '9') || ch == '_')) { + char buffer[5]; + sprintf(buffer, "_%x_", ch); + VarName += buffer; + } else + VarName += ch; } - return Name; + return "llvm_cbe_" + VarName; } /// writeInstComputationInline - Emit the computation for the specified /// instruction inline, with no destination provided. void CWriter::writeInstComputationInline(Instruction &I) { + // We can't currently support integer types other than 1, 8, 16, 32, 64. + // Validate this. + const Type *Ty = I.getType(); + if (Ty->isIntegerTy() && (Ty!=Type::getInt1Ty(I.getContext()) && + Ty!=Type::getInt8Ty(I.getContext()) && + Ty!=Type::getInt16Ty(I.getContext()) && + Ty!=Type::getInt32Ty(I.getContext()) && + Ty!=Type::getInt64Ty(I.getContext()))) { + llvm_report_error("The C backend does not currently support integer " + "types of widths other than 1, 8, 16, 32, 64.\n" + "This is being tracked as PR 4158."); + } + // If this is a non-trivial bool computation, make sure to truncate down to // a 1 bit value. This is important because we want "add i1 x, y" to return // "0" when x and y are true, not "2" for example. bool NeedBoolTrunc = false; - if (I.getType() == Type::Int1Ty && !isa(I) && !isa(I)) + if (I.getType() == Type::getInt1Ty(I.getContext()) && + !isa(I) && !isa(I)) NeedBoolTrunc = true; if (NeedBoolTrunc) @@ -1249,7 +1525,7 @@ void CWriter::writeInstComputationInline(Instruction &I) { } -void CWriter::writeOperandInternal(Value *Operand) { +void CWriter::writeOperandInternal(Value *Operand, bool Static) { if (Instruction *I = dyn_cast(Operand)) // Should we inline this instruction to build a tree? if (isInlinableInst(*I) && !isDirectAlloca(I)) { @@ -1262,26 +1538,17 @@ void CWriter::writeOperandInternal(Value *Operand) { Constant* CPV = dyn_cast(Operand); if (CPV && !isa(CPV)) - printConstant(CPV); + printConstant(CPV, Static); else Out << GetValueName(Operand); } -void CWriter::writeOperandRaw(Value *Operand) { - Constant* CPV = dyn_cast(Operand); - if (CPV && !isa(CPV)) { - printConstant(CPV); - } else { - Out << GetValueName(Operand); - } -} - -void CWriter::writeOperand(Value *Operand) { +void CWriter::writeOperand(Value *Operand, bool Static) { bool isAddressImplicit = isAddressExposed(Operand); if (isAddressImplicit) Out << "(&"; // Global variables are referenced as their addresses by llvm - writeOperandInternal(Operand); + writeOperandInternal(Operand, Static); if (isAddressImplicit) Out << ')'; @@ -1294,6 +1561,11 @@ void CWriter::writeOperand(Value *Operand) { bool CWriter::writeInstructionCast(const Instruction &I) { const Type *Ty = I.getOperand(0)->getType(); switch (I.getOpcode()) { + case Instruction::Add: + case Instruction::Sub: + case Instruction::Mul: + // We need to cast integer arithmetic so that it is always performed + // as unsigned, to avoid undefined behavior on overflow. case Instruction::LShr: case Instruction::URem: case Instruction::UDiv: @@ -1334,6 +1606,11 @@ void CWriter::writeOperandWithCast(Value* Operand, unsigned Opcode) { default: // for most instructions, it doesn't matter break; + case Instruction::Add: + case Instruction::Sub: + case Instruction::Mul: + // We need to cast integer arithmetic so that it is always performed + // as unsigned, to avoid undefined behavior on overflow. case Instruction::LShr: case Instruction::UDiv: case Instruction::URem: // Cast to unsigned first @@ -1379,12 +1656,12 @@ void CWriter::writeOperandWithCast(Value* Operand, const ICmpInst &Cmp) { } // Should this be a signed comparison? If so, convert to signed. - bool castIsSigned = Cmp.isSignedPredicate(); + bool castIsSigned = Cmp.isSigned(); // If the operand was a pointer, convert to a large integer type. const Type* OpTy = Operand->getType(); if (isa(OpTy)) - OpTy = TD->getIntPtrType(); + OpTy = TD->getIntPtrType(Operand->getContext()); Out << "(("; printSimpleType(Out, OpTy, castIsSigned); @@ -1396,13 +1673,13 @@ void CWriter::writeOperandWithCast(Value* Operand, const ICmpInst &Cmp) { // generateCompilerSpecificCode - This is where we add conditional compilation // directives to cater to specific compilers as need be. // -static void generateCompilerSpecificCode(std::ostream& Out, +static void generateCompilerSpecificCode(formatted_raw_ostream& Out, const TargetData *TD) { // Alloca is hard to get, and we don't want to include stdlib.h here. Out << "/* get a declaration for alloca */\n" << "#if defined(__CYGWIN__) || defined(__MINGW32__)\n" << "#define alloca(x) __builtin_alloca((x))\n" - << "#define _alloca(x) __builtin_alloca((x))\n" + << "#define _alloca(x) __builtin_alloca((x))\n" << "#elif defined(__APPLE__)\n" << "extern void *__builtin_alloca(unsigned long);\n" << "#define alloca(x) __builtin_alloca(x)\n" @@ -1415,7 +1692,7 @@ static void generateCompilerSpecificCode(std::ostream& Out, << "extern void *__builtin_alloca(unsigned int);\n" << "#endif\n" << "#define alloca(x) __builtin_alloca(x)\n" - << "#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)\n" + << "#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__arm__)\n" << "#define alloca(x) __builtin_alloca(x)\n" << "#elif defined(_MSC_VER)\n" << "#define inline _inline\n" @@ -1517,12 +1794,10 @@ static void generateCompilerSpecificCode(std::ostream& Out, // Output typedefs for 128-bit integers. If these are needed with a // 32-bit target or with a C compiler that doesn't support mode(TI), // more drastic measures will be needed. - if (TD->getPointerSize() >= 8) { - Out << "#ifdef __GNUC__ /* 128-bit integer types */\n" - << "typedef int __attribute__((mode(TI))) llvmInt128;\n" - << "typedef unsigned __attribute__((mode(TI))) llvmUInt128;\n" - << "#endif\n\n"; - } + Out << "#if __GNUC__ && __LP64__ /* 128-bit integer types */\n" + << "typedef int __attribute__((mode(TI))) llvmInt128;\n" + << "typedef unsigned __attribute__((mode(TI))) llvmUInt128;\n" + << "#endif\n\n"; // Output target-specific code that should be inserted into main. Out << "#define CODE_FOR_MAIN() /* Any target-specific code for main()*/\n"; @@ -1566,7 +1841,7 @@ static SpecialGlobalClass getGlobalVariableClass(const GlobalVariable *GV) { return GlobalDtors; } - // Otherwise, it it is other metadata, don't print it. This catches things + // Otherwise, if it is other metadata, don't print it. This catches things // like debug information. if (GV->getSection() == "llvm.metadata") return NotPrinted; @@ -1574,8 +1849,34 @@ static SpecialGlobalClass getGlobalVariableClass(const GlobalVariable *GV) { return NotSpecial; } +// PrintEscapedString - Print each character of the specified string, escaping +// it if it is not printable or if it is an escape char. +static void PrintEscapedString(const char *Str, unsigned Length, + raw_ostream &Out) { + for (unsigned i = 0; i != Length; ++i) { + unsigned char C = Str[i]; + if (isprint(C) && C != '\\' && C != '"') + Out << C; + else if (C == '\\') + Out << "\\\\"; + else if (C == '\"') + Out << "\\\""; + else if (C == '\t') + Out << "\\t"; + else + Out << "\\x" << hexdigit(C >> 4) << hexdigit(C & 0x0F); + } +} + +// PrintEscapedString - Print each character of the specified string, escaping +// it if it is not printable or if it is an escape char. +static void PrintEscapedString(const std::string &Str, raw_ostream &Out) { + PrintEscapedString(Str.c_str(), Str.size(), Out); +} bool CWriter::doInitialization(Module &M) { + FunctionPass::doInitialization(M); + // Initialize TheModule = &M; @@ -1583,9 +1884,17 @@ bool CWriter::doInitialization(Module &M) { IL = new IntrinsicLowering(*TD); IL->AddPrototypes(M); - // Ensure that all structure types have names... - Mang = new Mangler(M); - Mang->markCharUnacceptable('.'); +#if 0 + std::string Triple = TheModule->getTargetTriple(); + if (Triple.empty()) + Triple = llvm::sys::getHostTriple(); + + std::string E; + if (const Target *Match = TargetRegistry::lookupTarget(Triple, E)) + TAsm = Match->createAsmInfo(Triple); +#endif + TAsm = new CBEMCAsmInfo(); + Mang = new Mangler(*TAsm); // Keep track of which functions are static ctors/dtors so they can have // an attribute added to their prototypes. @@ -1626,6 +1935,29 @@ bool CWriter::doInitialization(Module &M) { // First output all the declarations for the program, because C requires // Functions & globals to be declared before they are used. // + if (!M.getModuleInlineAsm().empty()) { + Out << "/* Module asm statements */\n" + << "asm("; + + // Split the string into lines, to make it easier to read the .ll file. + std::string Asm = M.getModuleInlineAsm(); + size_t CurPos = 0; + size_t NewLine = Asm.find_first_of('\n', CurPos); + while (NewLine != std::string::npos) { + // We found a newline, print the portion of the asm string from the + // last newline up to this newline. + Out << "\""; + PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.begin()+NewLine), + Out); + Out << "\\n\"\n"; + CurPos = NewLine+1; + NewLine = Asm.find_first_of('\n', CurPos); + } + Out << "\""; + PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.end()), Out); + Out << "\");\n" + << "/* End Module asm statements */\n"; + } // Loop over the symbol table, emitting all named constants... printModuleTypes(M.getTypeSymbolTable()); @@ -1681,7 +2013,7 @@ bool CWriter::doInitialization(Module &M) { Out << " __HIDDEN__"; if (I->hasName() && I->getName()[0] == 1) - Out << " LLVM_ASM(\"" << I->getName().c_str()+1 << "\")"; + Out << " LLVM_ASM(\"" << I->getName().substr(1) << "\")"; Out << ";\n"; } @@ -1697,7 +2029,7 @@ bool CWriter::doInitialization(Module &M) { if (getGlobalVariableClass(I)) continue; - if (I->hasInternalLinkage()) + if (I->hasLocalLinkage()) Out << "static "; else Out << "extern "; @@ -1733,7 +2065,7 @@ bool CWriter::doInitialization(Module &M) { if (getGlobalVariableClass(I)) continue; - if (I->hasInternalLinkage()) + if (I->hasLocalLinkage()) Out << "static "; else if (I->hasDLLImportLinkage()) Out << "__declspec(dllimport) "; @@ -1764,7 +2096,7 @@ bool CWriter::doInitialization(Module &M) { // FIXME common linkage should avoid this problem. if (!I->getInitializer()->isNullValue()) { Out << " = " ; - writeOperand(I->getInitializer()); + writeOperand(I->getInitializer(), true); } 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 @@ -1779,7 +2111,7 @@ bool CWriter::doInitialization(Module &M) { Out << "{ { 0 } }"; } else { // Just print it out normally. - writeOperand(I->getInitializer()); + writeOperand(I->getInitializer(), true); } } Out << ";\n"; @@ -1830,51 +2162,68 @@ void CWriter::printFloatingPointConstants(Function &F) { // the precision of the printed form, unless the printed form preserves // precision. // - 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)) { - FPConstantMap[FPC] = FPCounter; // Number the FP constants - - if (FPC->getType() == Type::DoubleTy) { - double Val = FPC->getValueAPF().convertToDouble(); - uint64_t i = FPC->getValueAPF().convertToAPInt().getZExtValue(); - Out << "static const ConstantDoubleTy FPConstant" << FPCounter++ - << " = 0x" << std::hex << i << std::dec - << "ULL; /* " << Val << " */\n"; - } else if (FPC->getType() == Type::FloatTy) { - float Val = FPC->getValueAPF().convertToFloat(); - uint32_t i = (uint32_t)FPC->getValueAPF().convertToAPInt(). - getZExtValue(); - Out << "static const ConstantFloatTy FPConstant" << FPCounter++ - << " = 0x" << std::hex << i << std::dec - << "U; /* " << Val << " */\n"; - } else if (FPC->getType() == Type::X86_FP80Ty) { - // api needed to prevent premature destruction - APInt api = FPC->getValueAPF().convertToAPInt(); - const uint64_t *p = api.getRawData(); - Out << "static const ConstantFP80Ty FPConstant" << FPCounter++ - << " = { 0x" << std::hex - << ((uint16_t)p[1] | (p[0] & 0xffffffffffffLL)<<16) - << "ULL, 0x" << (uint16_t)(p[0] >> 48) << ",{0,0,0}" - << "}; /* Long double constant */\n" << std::dec; - } else if (FPC->getType() == Type::PPC_FP128Ty) { - APInt api = FPC->getValueAPF().convertToAPInt(); - const uint64_t *p = api.getRawData(); - Out << "static const ConstantFP128Ty FPConstant" << FPCounter++ - << " = { 0x" << std::hex - << p[0] << ", 0x" << p[1] - << "}; /* Long double constant */\n" << std::dec; - - } else - assert(0 && "Unknown float type!"); - } + printFloatingPointConstants(*I); Out << '\n'; } +void CWriter::printFloatingPointConstants(const Constant *C) { + // If this is a constant expression, recursively check for constant fp values. + if (const ConstantExpr *CE = dyn_cast(C)) { + for (unsigned i = 0, e = CE->getNumOperands(); i != e; ++i) + printFloatingPointConstants(CE->getOperand(i)); + return; + } + + // Otherwise, check for a FP constant that we need to print. + const ConstantFP *FPC = dyn_cast(C); + if (FPC == 0 || + // Do not put in FPConstantMap if safe. + isFPCSafeToPrint(FPC) || + // Already printed this constant? + FPConstantMap.count(FPC)) + return; + + FPConstantMap[FPC] = FPCounter; // Number the FP constants + + if (FPC->getType() == Type::getDoubleTy(FPC->getContext())) { + double Val = FPC->getValueAPF().convertToDouble(); + uint64_t i = FPC->getValueAPF().bitcastToAPInt().getZExtValue(); + Out << "static const ConstantDoubleTy FPConstant" << FPCounter++ + << " = 0x" << utohexstr(i) + << "ULL; /* " << Val << " */\n"; + } else if (FPC->getType() == Type::getFloatTy(FPC->getContext())) { + float Val = FPC->getValueAPF().convertToFloat(); + uint32_t i = (uint32_t)FPC->getValueAPF().bitcastToAPInt(). + getZExtValue(); + Out << "static const ConstantFloatTy FPConstant" << FPCounter++ + << " = 0x" << utohexstr(i) + << "U; /* " << Val << " */\n"; + } else if (FPC->getType() == Type::getX86_FP80Ty(FPC->getContext())) { + // api needed to prevent premature destruction + APInt api = FPC->getValueAPF().bitcastToAPInt(); + const uint64_t *p = api.getRawData(); + Out << "static const ConstantFP80Ty FPConstant" << FPCounter++ + << " = { 0x" << utohexstr(p[0]) + << "ULL, 0x" << utohexstr((uint16_t)p[1]) << ",{0,0,0}" + << "}; /* Long double constant */\n"; + } else if (FPC->getType() == Type::getPPC_FP128Ty(FPC->getContext()) || + FPC->getType() == Type::getFP128Ty(FPC->getContext())) { + APInt api = FPC->getValueAPF().bitcastToAPInt(); + const uint64_t *p = api.getRawData(); + Out << "static const ConstantFP128Ty FPConstant" << FPCounter++ + << " = { 0x" + << utohexstr(p[0]) << ", 0x" << utohexstr(p[1]) + << "}; /* Long double constant */\n"; + + } else { + llvm_unreachable("Unknown float type!"); + } +} + + /// printSymbolTable - Run through symbol table looking for type names. If a /// type name is found, emit its declaration... @@ -1898,7 +2247,7 @@ void CWriter::printModuleTypes(const TypeSymbolTable &TST) { // Print out forward declarations for structure types before anything else! Out << "/* Structure forward decls */\n"; for (; I != End; ++I) { - std::string Name = "struct l_" + Mang->makeNameProper(I->first); + std::string Name = "struct " + CBEMangle("l_"+I->first); Out << Name << ";\n"; TypeNames.insert(std::make_pair(I->second, Name)); } @@ -1909,7 +2258,7 @@ void CWriter::printModuleTypes(const TypeSymbolTable &TST) { // for struct or opaque types. Out << "/* Typedefs */\n"; for (I = TST.begin(); I != End; ++I) { - std::string Name = "l_" + Mang->makeNameProper(I->first); + std::string Name = CBEMangle("l_"+I->first); Out << "typedef "; printType(Out, I->second, false, Name); Out << ";\n"; @@ -1938,7 +2287,8 @@ void CWriter::printModuleTypes(const TypeSymbolTable &TST) { void CWriter::printContainedStructs(const Type *Ty, std::set &StructPrinted) { // Don't walk through pointers. - if (isa(Ty) || Ty->isPrimitiveType() || Ty->isInteger()) return; + if (isa(Ty) || Ty->isPrimitiveType() || Ty->isIntegerTy()) + return; // Print all contained types first. for (Type::subtype_iterator I = Ty->subtype_begin(), @@ -1960,21 +2310,23 @@ void CWriter::printFunctionSignature(const Function *F, bool Prototype) { /// isStructReturn - Should this function actually return a struct by-value? bool isStructReturn = F->hasStructRetAttr(); - if (F->hasInternalLinkage()) Out << "static "; + if (F->hasLocalLinkage()) Out << "static "; if (F->hasDLLImportLinkage()) Out << "__declspec(dllimport) "; if (F->hasDLLExportLinkage()) Out << "__declspec(dllexport) "; switch (F->getCallingConv()) { case CallingConv::X86_StdCall: - Out << "__stdcall "; + Out << "__attribute__((stdcall)) "; break; case CallingConv::X86_FastCall: - Out << "__fastcall "; + Out << "__attribute__((fastcall)) "; + break; + default: break; } // Loop over the arguments, printing them... const FunctionType *FT = cast(F->getFunctionType()); - const PAListPtr &PAL = F->getParamAttrs(); + const AttrListPtr &PAL = F->getAttributes(); std::stringstream FunctionInnards; @@ -2003,12 +2355,12 @@ void CWriter::printFunctionSignature(const Function *F, bool Prototype) { else ArgName = ""; const Type *ArgTy = I->getType(); - if (PAL.paramHasAttr(Idx, ParamAttr::ByVal)) { + if (PAL.paramHasAttr(Idx, Attribute::ByVal)) { ArgTy = cast(ArgTy)->getElementType(); ByValParams.insert(I); } printType(FunctionInnards, ArgTy, - /*isSigned=*/PAL.paramHasAttr(Idx, ParamAttr::SExt), + /*isSigned=*/PAL.paramHasAttr(Idx, Attribute::SExt), ArgName); PrintedArg = true; ++Idx; @@ -2030,12 +2382,12 @@ void CWriter::printFunctionSignature(const Function *F, bool Prototype) { for (; I != E; ++I) { if (PrintedArg) FunctionInnards << ", "; const Type *ArgTy = *I; - if (PAL.paramHasAttr(Idx, ParamAttr::ByVal)) { + if (PAL.paramHasAttr(Idx, Attribute::ByVal)) { assert(isa(ArgTy)); ArgTy = cast(ArgTy)->getElementType(); } printType(FunctionInnards, ArgTy, - /*isSigned=*/PAL.paramHasAttr(Idx, ParamAttr::SExt)); + /*isSigned=*/PAL.paramHasAttr(Idx, Attribute::SExt)); PrintedArg = true; ++Idx; } @@ -2063,7 +2415,7 @@ void CWriter::printFunctionSignature(const Function *F, bool Prototype) { // Print out the return type and the signature built above. printType(Out, RetTy, - /*isSigned=*/PAL.paramHasAttr(0, ParamAttr::SExt), + /*isSigned=*/PAL.paramHasAttr(0, Attribute::SExt), FunctionInnards.str()); } @@ -2072,8 +2424,8 @@ static inline bool isFPIntBitCast(const Instruction &I) { return false; const Type *SrcTy = I.getOperand(0)->getType(); const Type *DstTy = I.getType(); - return (SrcTy->isFloatingPoint() && DstTy->isInteger()) || - (DstTy->isFloatingPoint() && SrcTy->isInteger()); + return (SrcTy->isFloatingPointTy() && DstTy->isIntegerTy()) || + (DstTy->isFloatingPointTy() && SrcTy->isIntegerTy()); } void CWriter::printFunction(Function &F) { @@ -2106,7 +2458,8 @@ void CWriter::printFunction(Function &F) { printType(Out, AI->getAllocatedType(), false, GetValueName(AI)); Out << "; /* Address-exposed local */\n"; PrintedVar = true; - } else if (I->getType() != Type::VoidTy && !isInlinableInst(*I)) { + } else if (I->getType() != Type::getVoidTy(F.getContext()) && + !isInlinableInst(*I)) { Out << " "; printType(Out, I->getType(), false, GetValueName(&*I)); Out << ";\n"; @@ -2183,7 +2536,8 @@ void CWriter::printBasicBlock(BasicBlock *BB) { for (BasicBlock::iterator II = BB->begin(), E = --BB->end(); II != E; ++II) { if (!isInlinableInst(*II) && !isDirectAlloca(II)) { - if (II->getType() != Type::VoidTy && !isInlineAsm(*II)) + if (II->getType() != Type::getVoidTy(BB->getContext()) && + !isInlineAsm(*II)) outputLValue(II); else Out << " "; @@ -2257,12 +2611,18 @@ void CWriter::visitSwitchInst(SwitchInst &SI) { BasicBlock *Succ = cast(SI.getOperand(i+1)); printPHICopiesForSuccessor (SI.getParent(), Succ, 2); printBranchToBlock(SI.getParent(), Succ, 2); - if (Function::iterator(Succ) == next(Function::iterator(SI.getParent()))) + if (Function::iterator(Succ) == llvm::next(Function::iterator(SI.getParent()))) Out << " break;\n"; } Out << " }\n"; } +void CWriter::visitIndirectBrInst(IndirectBrInst &IBI) { + Out << " goto *(void*)("; + writeOperand(IBI.getOperand(0)); + Out << ");\n"; +} + void CWriter::visitUnreachableInst(UnreachableInst &I) { Out << " /*UNREACHABLE*/;\n"; } @@ -2271,7 +2631,7 @@ bool CWriter::isGotoCodeNecessary(BasicBlock *From, BasicBlock *To) { /// FIXME: This should be reenabled, but loop reordering safe!! return true; - if (next(Function::iterator(From)) != Function::iterator(To)) + if (llvm::next(Function::iterator(From)) != Function::iterator(To)) return true; // Not the direct successor, we need a goto. //isa(From->getTerminator()) @@ -2358,8 +2718,9 @@ void CWriter::visitBinaryOperator(Instruction &I) { // We must cast the results of binary operations which might be promoted. bool needsCast = false; - if ((I.getType() == Type::Int8Ty) || (I.getType() == Type::Int16Ty) - || (I.getType() == Type::FloatTy)) { + if ((I.getType() == Type::getInt8Ty(I.getContext())) || + (I.getType() == Type::getInt16Ty(I.getContext())) + || (I.getType() == Type::getFloatTy(I.getContext()))) { needsCast = true; Out << "(("; printType(Out, I.getType(), false); @@ -2372,11 +2733,15 @@ void CWriter::visitBinaryOperator(Instruction &I) { Out << "-("; writeOperand(BinaryOperator::getNegArgument(cast(&I))); Out << ")"; + } else if (BinaryOperator::isFNeg(&I)) { + Out << "-("; + writeOperand(BinaryOperator::getFNegArgument(cast(&I))); + Out << ")"; } else if (I.getOpcode() == Instruction::FRem) { // Output a call to fmod/fmodf instead of emitting a%b - if (I.getType() == Type::FloatTy) + if (I.getType() == Type::getFloatTy(I.getContext())) Out << "fmodf("; - else if (I.getType() == Type::DoubleTy) + else if (I.getType() == Type::getDoubleTy(I.getContext())) Out << "fmod("; else // all 3 flavors of long double Out << "fmodl("; @@ -2396,9 +2761,12 @@ void CWriter::visitBinaryOperator(Instruction &I) { writeOperandWithCast(I.getOperand(0), I.getOpcode()); switch (I.getOpcode()) { - case Instruction::Add: Out << " + "; break; - case Instruction::Sub: Out << " - "; break; - case Instruction::Mul: Out << " * "; break; + case Instruction::Add: + case Instruction::FAdd: Out << " + "; break; + case Instruction::Sub: + case Instruction::FSub: Out << " - "; break; + case Instruction::Mul: + case Instruction::FMul: Out << " * "; break; case Instruction::URem: case Instruction::SRem: case Instruction::FRem: Out << " % "; break; @@ -2411,7 +2779,11 @@ void CWriter::visitBinaryOperator(Instruction &I) { case Instruction::Shl : Out << " << "; break; case Instruction::LShr: case Instruction::AShr: Out << " >> "; break; - default: cerr << "Invalid operator type!" << I; abort(); + default: +#ifndef NDEBUG + errs() << "Invalid operator type!" << I; +#endif + llvm_unreachable(0); } writeOperandWithCast(I.getOperand(1), I.getOpcode()); @@ -2448,7 +2820,11 @@ void CWriter::visitICmpInst(ICmpInst &I) { case ICmpInst::ICMP_SLT: Out << " < "; break; case ICmpInst::ICMP_UGT: case ICmpInst::ICMP_SGT: Out << " > "; break; - default: cerr << "Invalid icmp predicate!" << I; abort(); + default: +#ifndef NDEBUG + errs() << "Invalid icmp predicate!" << I; +#endif + llvm_unreachable(0); } writeOperandWithCast(I.getOperand(1), I); @@ -2472,7 +2848,7 @@ void CWriter::visitFCmpInst(FCmpInst &I) { const char* op = 0; switch (I.getPredicate()) { - default: assert(0 && "Illegal FCmp predicate"); + default: llvm_unreachable("Illegal FCmp predicate"); case FCmpInst::FCMP_ORD: op = "ord"; break; case FCmpInst::FCMP_UNO: op = "uno"; break; case FCmpInst::FCMP_UEQ: op = "ueq"; break; @@ -2500,7 +2876,7 @@ void CWriter::visitFCmpInst(FCmpInst &I) { static const char * getFloatBitCastField(const Type *Ty) { switch (Ty->getTypeID()) { - default: assert(0 && "Invalid Type"); + default: llvm_unreachable("Invalid Type"); case Type::FloatTyID: return "Float"; case Type::DoubleTyID: return "Double"; case Type::IntegerTyID: { @@ -2532,12 +2908,13 @@ void CWriter::visitCastInst(CastInst &I) { printCast(I.getOpcode(), SrcTy, DstTy); // Make a sext from i1 work by subtracting the i1 from 0 (an int). - if (SrcTy == Type::Int1Ty && I.getOpcode() == Instruction::SExt) + if (SrcTy == Type::getInt1Ty(I.getContext()) && + I.getOpcode() == Instruction::SExt) Out << "0-"; writeOperand(I.getOperand(0)); - if (DstTy == Type::Int1Ty && + if (DstTy == Type::getInt1Ty(I.getContext()) && (I.getOpcode() == Instruction::Trunc || I.getOpcode() == Instruction::FPToUI || I.getOpcode() == Instruction::FPToSI || @@ -2582,7 +2959,6 @@ void CWriter::lowerIntrinsics(Function &F) { case Intrinsic::setjmp: case Intrinsic::longjmp: case Intrinsic::prefetch: - case Intrinsic::dbg_stoppoint: case Intrinsic::powi: case Intrinsic::x86_sse_cmp_ss: case Intrinsic::x86_sse_cmp_ps: @@ -2656,7 +3032,7 @@ void CWriter::visitCallInst(CallInst &I) { // If this is a call to a struct-return function, assign to the first // parameter instead of passing it to the call. - const PAListPtr &PAL = I.getParamAttrs(); + const AttrListPtr &PAL = I.getAttributes(); bool hasByVal = I.hasByValArgument(); bool isStructRet = I.hasStructRetAttr(); if (isStructRet) { @@ -2724,11 +3100,11 @@ void CWriter::visitCallInst(CallInst &I) { (*AI)->getType() != FTy->getParamType(ArgNo)) { Out << '('; printType(Out, FTy->getParamType(ArgNo), - /*isSigned=*/PAL.paramHasAttr(ArgNo+1, ParamAttr::SExt)); + /*isSigned=*/PAL.paramHasAttr(ArgNo+1, Attribute::SExt)); Out << ')'; } // Check if the argument is expected to be passed by value. - if (I.paramHasAttr(ArgNo+1, ParamAttr::ByVal)) + if (I.paramHasAttr(ArgNo+1, Attribute::ByVal)) writeOperandDeref(*AI); else writeOperand(*AI); @@ -2738,7 +3114,7 @@ void CWriter::visitCallInst(CallInst &I) { } /// visitBuiltinCall - Handle the call to the specified builtin. Returns true -/// if the entire call is handled, return false it it wasn't handled, and +/// if the entire call is handled, return false if it wasn't handled, and /// optionally set 'WroteCallee' if the callee has already been printed out. bool CWriter::visitBuiltinCall(CallInst &I, Intrinsic::ID ID, bool &WroteCallee) { @@ -2768,10 +3144,12 @@ bool CWriter::visitBuiltinCall(CallInst &I, Intrinsic::ID ID, Out << ", "; // Output the last argument to the enclosing function. if (I.getParent()->getParent()->arg_empty()) { - cerr << "The C backend does not currently support zero " + std::string msg; + raw_string_ostream Msg(msg); + Msg << "The C backend does not currently support zero " << "argument varargs functions, such as '" - << I.getParent()->getParent()->getName() << "'!\n"; - abort(); + << I.getParent()->getParent()->getName() << "'!"; + llvm_report_error(Msg.str()); } writeOperand(--I.getParent()->getParent()->arg_end()); Out << ')'; @@ -2837,16 +3215,6 @@ bool CWriter::visitBuiltinCall(CallInst &I, Intrinsic::ID ID, Out << "0; *((void**)&" << GetValueName(&I) << ") = __builtin_stack_save()"; return true; - case Intrinsic::dbg_stoppoint: { - // If we use writeOperand directly we get a "u" suffix which is rejected - // by gcc. - DbgStopPointInst &SPI = cast(I); - Out << "\n#line " - << SPI.getLine() - << " \"" << SPI.getDirectory() - << SPI.getFileName() << "\"\n"; - return true; - } case Intrinsic::x86_sse_cmp_ss: case Intrinsic::x86_sse_cmp_ps: case Intrinsic::x86_sse2_cmp_sd: @@ -2856,7 +3224,7 @@ bool CWriter::visitBuiltinCall(CallInst &I, Intrinsic::ID ID, Out << ')'; // Multiple GCC builtins multiplex onto this intrinsic. switch (cast(I.getOperand(3))->getZExtValue()) { - default: assert(0 && "Invalid llvm.x86.sse.cmp!"); + default: llvm_unreachable("Invalid llvm.x86.sse.cmp!"); case 0: Out << "__builtin_ia32_cmpeq"; break; case 1: Out << "__builtin_ia32_cmplt"; break; case 2: Out << "__builtin_ia32_cmple"; break; @@ -2897,32 +3265,31 @@ bool CWriter::visitBuiltinCall(CallInst &I, Intrinsic::ID ID, // of the per target tables // handle multiple constraint codes std::string CWriter::InterpretASMConstraint(InlineAsm::ConstraintInfo& c) { - assert(c.Codes.size() == 1 && "Too many asm constraint codes to handle"); - const char *const *table = 0; + // Grab the translation table from MCAsmInfo if it exists. + const MCAsmInfo *TargetAsm; + std::string Triple = TheModule->getTargetTriple(); + if (Triple.empty()) + Triple = llvm::sys::getHostTriple(); + + std::string E; + if (const Target *Match = TargetRegistry::lookupTarget(Triple, E)) + TargetAsm = Match->createAsmInfo(Triple); + else + return c.Codes[0]; - //Grab the translation table from TargetAsmInfo if it exists - if (!TAsm) { - std::string E; - const TargetMachineRegistry::entry* Match = - TargetMachineRegistry::getClosestStaticTargetForModule(*TheModule, E); - if (Match) { - //Per platform Target Machines don't exist, so create it - // this must be done only once - const TargetMachine* TM = Match->CtorFn(*TheModule, ""); - TAsm = TM->getTargetAsmInfo(); - } - } - if (TAsm) - table = TAsm->getAsmCBE(); - - //Search the translation table if it exists + const char *const *table = TargetAsm->getAsmCBE(); + + // Search the translation table if it exists. for (int i = 0; table && table[i]; i += 2) - if (c.Codes[0] == table[i]) + if (c.Codes[0] == table[i]) { + delete TargetAsm; return table[i+1]; + } - //default is identity + // Default is identity. + delete TargetAsm; return c.Codes[0]; } @@ -2958,7 +3325,7 @@ void CWriter::visitInlineAsm(CallInst &CI) { std::vector Constraints = as->ParseConstraints(); std::vector > ResultVals; - if (CI.getType() == Type::VoidTy) + if (CI.getType() == Type::getVoidTy(CI.getContext())) ; else if (const StructType *ST = dyn_cast(CI.getType())) { for (unsigned i = 0, e = ST->getNumElements(); i != e; ++i) @@ -3046,7 +3413,6 @@ void CWriter::visitInlineAsm(CallInst &CI) { // Convert over the clobber constraints. IsFirst = true; - ValueCount = 0; for (std::vector::iterator I = Constraints.begin(), E = Constraints.end(); I != E; ++I) { if (I->Type != InlineAsm::isClobber) @@ -3067,10 +3433,6 @@ void CWriter::visitInlineAsm(CallInst &CI) { Out << ")"; } -void CWriter::visitMallocInst(MallocInst &I) { - assert(0 && "lowerallocations pass didn't work!"); -} - void CWriter::visitAllocaInst(AllocaInst &I) { Out << '('; printType(Out, I.getType()); @@ -3084,12 +3446,8 @@ void CWriter::visitAllocaInst(AllocaInst &I) { Out << ')'; } -void CWriter::visitFreeInst(FreeInst &I) { - assert(0 && "lowerallocations pass didn't work!"); -} - void CWriter::printGEPExpression(Value *Ptr, gep_type_iterator I, - gep_type_iterator E) { + gep_type_iterator E, bool Static) { // If there are no indices, just print out the pointer. if (I == E) { @@ -3131,7 +3489,7 @@ void CWriter::printGEPExpression(Value *Ptr, gep_type_iterator I, // Okay, emit the first operand. If Ptr is something that is already address // exposed, like a global, avoid emitting (&foo)[0], just emit foo instead. if (isAddressExposed(Ptr)) { - writeOperandInternal(Ptr); + writeOperandInternal(Ptr, Static); } else if (I != E && isa(*I)) { // If we didn't already emit the first operand, see if we can print it as // P->f instead of "P[0].f" @@ -3225,14 +3583,14 @@ void CWriter::visitStoreInst(StoreInst &I) { writeOperand(Operand); if (BitMask) { Out << ") & "; - printConstant(BitMask); + printConstant(BitMask, false); Out << ")"; } } void CWriter::visitGetElementPtrInst(GetElementPtrInst &I) { printGEPExpression(I.getPointerOperand(), gep_type_begin(I), - gep_type_end(I)); + gep_type_end(I), false); } void CWriter::visitVAArgInst(VAArgInst &I) { @@ -3292,25 +3650,14 @@ void CWriter::visitShuffleVectorInst(ShuffleVectorInst &SVI) { Out << "0"; } else { printConstant(cast(Op)->getOperand(SrcVal & - (NumElts-1))); + (NumElts-1)), + false); } } } Out << "}"; } -void CWriter::visitGetResultInst(GetResultInst &GRI) { - Out << "("; - if (isa(GRI.getOperand(0))) { - Out << "("; - printType(Out, GRI.getType()); - Out << ") 0/*UNDEF*/"; - } else { - Out << GetValueName(GRI.getOperand(0)) << ".field" << GRI.getIndex(); - } - Out << ")"; -} - void CWriter::visitInsertValueInst(InsertValueInst &IVI) { // Start by copying the entire aggregate value into the result variable. writeOperand(IVI.getOperand(0)); @@ -3357,17 +3704,16 @@ void CWriter::visitExtractValueInst(ExtractValueInst &EVI) { //===----------------------------------------------------------------------===// bool CTargetMachine::addPassesToEmitWholeFile(PassManager &PM, - std::ostream &o, + formatted_raw_ostream &o, CodeGenFileType FileType, - bool Fast) { - if (FileType != TargetMachine::AssemblyFile) return true; + CodeGenOpt::Level OptLevel) { + if (FileType != TargetMachine::CGFT_AssemblyFile) return true; PM.add(createGCLoweringPass()); - PM.add(createLowerAllocationsPass(true)); PM.add(createLowerInvokePass()); PM.add(createCFGSimplificationPass()); // clean up after lower invoke. PM.add(new CBackendNameAllUsedStructsAndMergeFunctions()); PM.add(new CWriter(o)); - PM.add(createCollectorMetadataDeleter()); + PM.add(createGCInfoDeleter()); return false; }