lib/Target/CBackend/CBackend.cpp

   1 //===-- CBackend.cpp - Library for converting LLVM code to C --------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This library converts LLVM code to C code, compilable by GCC and other C
  11 // compilers.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "CTargetMachine.h"
  16 #include "llvm/CallingConv.h"
  17 #include "llvm/Constants.h"
  18 #include "llvm/DerivedTypes.h"
  19 #include "llvm/Module.h"
  20 #include "llvm/Instructions.h"
  21 #include "llvm/Pass.h"
  22 #include "llvm/PassManager.h"
  23 #include "llvm/TypeSymbolTable.h"
  24 #include "llvm/Intrinsics.h"
  25 #include "llvm/IntrinsicInst.h"
  26 #include "llvm/InlineAsm.h"
  27 #include "llvm/ADT/StringExtras.h"
  28 #include "llvm/ADT/SmallString.h"
  29 #include "llvm/ADT/STLExtras.h"
  30 #include "llvm/Analysis/ConstantsScanner.h"
  31 #include "llvm/Analysis/FindUsedTypes.h"
  32 #include "llvm/Analysis/LoopInfo.h"
  33 #include "llvm/Analysis/ValueTracking.h"
  34 #include "llvm/CodeGen/Passes.h"
  35 #include "llvm/CodeGen/IntrinsicLowering.h"
  36 #include "llvm/Target/Mangler.h"
  37 #include "llvm/Transforms/Scalar.h"
  38 #include "llvm/MC/MCAsmInfo.h"
  39 #include "llvm/MC/MCContext.h"
  40 #include "llvm/MC/MCSymbol.h"
  41 #include "llvm/Target/TargetData.h"
  42 #include "llvm/Target/TargetRegistry.h"
  43 #include "llvm/Support/CallSite.h"
  44 #include "llvm/Support/CFG.h"
  45 #include "llvm/Support/ErrorHandling.h"
  46 #include "llvm/Support/FormattedStream.h"
  47 #include "llvm/Support/GetElementPtrTypeIterator.h"
  48 #include "llvm/Support/InstVisitor.h"
  49 #include "llvm/Support/MathExtras.h"
  50 #include "llvm/System/Host.h"
  51 #include "llvm/Config/config.h"
  52 #include <algorithm>
  53 using namespace llvm;
  54
  55 extern "C" void LLVMInitializeCBackendTarget() {
  56   // Register the target.
  57   RegisterTargetMachine<CTargetMachine> X(TheCBackendTarget);
  58 }
  59
  60 namespace {
  61   class CBEMCAsmInfo : public MCAsmInfo {
  62   public:
  63     CBEMCAsmInfo() {
  64       GlobalPrefix = "";
  65       PrivateGlobalPrefix = "";
  66     }
  67   };
  68   /// CBackendNameAllUsedStructsAndMergeFunctions - This pass inserts names for
  69   /// any unnamed structure types that are used by the program, and merges
  70   /// external functions with the same name.
  71   ///
  72   class CBackendNameAllUsedStructsAndMergeFunctions : public ModulePass {
  73   public:
  74     static char ID;
  75     CBackendNameAllUsedStructsAndMergeFunctions()
  76       : ModulePass(&ID) {}
  77     void getAnalysisUsage(AnalysisUsage &AU) const {
  78       AU.addRequired<FindUsedTypes>();
  79     }
  80
  81     virtual const char *getPassName() const {
  82       return "C backend type canonicalizer";
  83     }
  84
  85     virtual bool runOnModule(Module &M);
  86   };
  87
  88   char CBackendNameAllUsedStructsAndMergeFunctions::ID = 0;
  89
  90   /// CWriter - This class is the main chunk of code that converts an LLVM
  91   /// module to a C translation unit.
  92   class CWriter : public FunctionPass, public InstVisitor<CWriter> {
  93     formatted_raw_ostream &Out;
  94     IntrinsicLowering *IL;
  95     Mangler *Mang;
  96     LoopInfo *LI;
  97     const Module *TheModule;
  98     const MCAsmInfo* TAsm;
  99     MCContext *TCtx;
 100     const TargetData* TD;
 101     std::map<const Type *, std::string> TypeNames;
 102     std::map<const ConstantFP *, unsigned> FPConstantMap;
 103     std::set<Function*> intrinsicPrototypesAlreadyGenerated;
 104     std::set<const Argument*> ByValParams;
 105     unsigned FPCounter;
 106     unsigned OpaqueCounter;
 107     DenseMap<const Value*, unsigned> AnonValueNumbers;
 108     unsigned NextAnonValueNumber;
 109
 110   public:
 111     static char ID;
 112     explicit CWriter(formatted_raw_ostream &o)
 113       : FunctionPass(&ID), Out(o), IL(0), Mang(0), LI(0),
 114         TheModule(0), TAsm(0), TD(0), OpaqueCounter(0), NextAnonValueNumber(0) {
 115       FPCounter = 0;
 116     }
 117
 118     virtual const char *getPassName() const { return "C backend"; }
 119
 120     void getAnalysisUsage(AnalysisUsage &AU) const {
 121       AU.addRequired<LoopInfo>();
 122       AU.setPreservesAll();
 123     }
 124
 125     virtual bool doInitialization(Module &M);
 126
 127     bool runOnFunction(Function &F) {
 128      // Do not codegen any 'available_externally' functions at all, they have
 129      // definitions outside the translation unit.
 130      if (F.hasAvailableExternallyLinkage())
 131        return false;
 132
 133       LI = &getAnalysis<LoopInfo>();
 134
 135       // Get rid of intrinsics we can't handle.
 136       lowerIntrinsics(F);
 137
 138       // Output all floating point constants that cannot be printed accurately.
 139       printFloatingPointConstants(F);
 140
 141       printFunction(F);
 142       return false;
 143     }
 144
 145     virtual bool doFinalization(Module &M) {
 146       // Free memory...
 147       delete IL;
 148       delete TD;
 149       delete Mang;
 150       FPConstantMap.clear();
 151       TypeNames.clear();
 152       ByValParams.clear();
 153       intrinsicPrototypesAlreadyGenerated.clear();
 154       return false;
 155     }
 156
 157     raw_ostream &printType(raw_ostream &Out, const Type *Ty,
 158                            bool isSigned = false,
 159                            const std::string &VariableName = "",
 160                            bool IgnoreName = false,
 161                            const AttrListPtr &PAL = AttrListPtr());
 162     raw_ostream &printSimpleType(raw_ostream &Out, const Type *Ty,
 163                                  bool isSigned,
 164                                  const std::string &NameSoFar = "");
 165
 166     void printStructReturnPointerFunctionType(raw_ostream &Out,
 167                                               const AttrListPtr &PAL,
 168                                               const PointerType *Ty);
 169
 170     /// writeOperandDeref - Print the result of dereferencing the specified
 171     /// operand with '*'.  This is equivalent to printing '*' then using
 172     /// writeOperand, but avoids excess syntax in some cases.
 173     void writeOperandDeref(Value *Operand) {
 174       if (isAddressExposed(Operand)) {
 175         // Already something with an address exposed.
 176         writeOperandInternal(Operand);
 177       } else {
 178         Out << "*(";
 179         writeOperand(Operand);
 180         Out << ")";
 181       }
 182     }
 183
 184     void writeOperand(Value *Operand, bool Static = false);
 185     void writeInstComputationInline(Instruction &I);
 186     void writeOperandInternal(Value *Operand, bool Static = false);
 187     void writeOperandWithCast(Value* Operand, unsigned Opcode);
 188     void writeOperandWithCast(Value* Operand, const ICmpInst &I);
 189     bool writeInstructionCast(const Instruction &I);
 190
 191     void writeMemoryAccess(Value *Operand, const Type *OperandType,
 192                            bool IsVolatile, unsigned Alignment);
 193
 194   private :
 195     std::string InterpretASMConstraint(InlineAsm::ConstraintInfo& c);
 196
 197     void lowerIntrinsics(Function &F);
 198
 199     void printModule(Module *M);
 200     void printModuleTypes(const TypeSymbolTable &ST);
 201     void printContainedStructs(const Type *Ty, std::set<const Type *> &);
 202     void printFloatingPointConstants(Function &F);
 203     void printFloatingPointConstants(const Constant *C);
 204     void printFunctionSignature(const Function *F, bool Prototype);
 205
 206     void printFunction(Function &);
 207     void printBasicBlock(BasicBlock *BB);
 208     void printLoop(Loop *L);
 209
 210     void printCast(unsigned opcode, const Type *SrcTy, const Type *DstTy);
 211     void printConstant(Constant *CPV, bool Static);
 212     void printConstantWithCast(Constant *CPV, unsigned Opcode);
 213     bool printConstExprCast(const ConstantExpr *CE, bool Static);
 214     void printConstantArray(ConstantArray *CPA, bool Static);
 215     void printConstantVector(ConstantVector *CV, bool Static);
 216
 217     /// isAddressExposed - Return true if the specified value's name needs to
 218     /// have its address taken in order to get a C value of the correct type.
 219     /// This happens for global variables, byval parameters, and direct allocas.
 220     bool isAddressExposed(const Value *V) const {
 221       if (const Argument *A = dyn_cast<Argument>(V))
 222         return ByValParams.count(A);
 223       return isa<GlobalVariable>(V) || isDirectAlloca(V);
 224     }
 225
 226     // isInlinableInst - Attempt to inline instructions into their uses to build
 227     // trees as much as possible.  To do this, we have to consistently decide
 228     // what is acceptable to inline, so that variable declarations don't get
 229     // printed and an extra copy of the expr is not emitted.
 230     //
 231     static bool isInlinableInst(const Instruction &I) {
 232       // Always inline cmp instructions, even if they are shared by multiple
 233       // expressions.  GCC generates horrible code if we don't.
 234       if (isa<CmpInst>(I))
 235         return true;
 236
 237       // Must be an expression, must be used exactly once.  If it is dead, we
 238       // emit it inline where it would go.
 239       if (I.getType() == Type::getVoidTy(I.getContext()) || !I.hasOneUse() ||
 240           isa<TerminatorInst>(I) || isa<CallInst>(I) || isa<PHINode>(I) ||
 241           isa<LoadInst>(I) || isa<VAArgInst>(I) || isa<InsertElementInst>(I) ||
 242           isa<InsertValueInst>(I))
 243         // Don't inline a load across a store or other bad things!
 244         return false;
 245
 246       // Must not be used in inline asm, extractelement, or shufflevector.
 247       if (I.hasOneUse()) {
 248         const Instruction &User = cast<Instruction>(*I.use_back());
 249         if (isInlineAsm(User) || isa<ExtractElementInst>(User) ||
 250             isa<ShuffleVectorInst>(User))
 251           return false;
 252       }
 253
 254       // Only inline instruction it if it's use is in the same BB as the inst.
 255       return I.getParent() == cast<Instruction>(I.use_back())->getParent();
 256     }
 257
 258     // isDirectAlloca - Define fixed sized allocas in the entry block as direct
 259     // variables which are accessed with the & operator.  This causes GCC to
 260     // generate significantly better code than to emit alloca calls directly.
 261     //
 262     static const AllocaInst *isDirectAlloca(const Value *V) {
 263       const AllocaInst *AI = dyn_cast<AllocaInst>(V);
 264       if (!AI) return false;
 265       if (AI->isArrayAllocation())
 266         return 0;   // FIXME: we can also inline fixed size array allocas!
 267       if (AI->getParent() != &AI->getParent()->getParent()->getEntryBlock())
 268         return 0;
 269       return AI;
 270     }
 271
 272     // isInlineAsm - Check if the instruction is a call to an inline asm chunk
 273     static bool isInlineAsm(const Instruction& I) {
 274       if (isa<CallInst>(&I) && isa<InlineAsm>(I.getOperand(0)))
 275         return true;
 276       return false;
 277     }
 278
 279     // Instruction visitation functions
 280     friend class InstVisitor<CWriter>;
 281
 282     void visitReturnInst(ReturnInst &I);
 283     void visitBranchInst(BranchInst &I);
 284     void visitSwitchInst(SwitchInst &I);
 285     void visitIndirectBrInst(IndirectBrInst &I);
 286     void visitInvokeInst(InvokeInst &I) {
 287       llvm_unreachable("Lowerinvoke pass didn't work!");
 288     }
 289
 290     void visitUnwindInst(UnwindInst &I) {
 291       llvm_unreachable("Lowerinvoke pass didn't work!");
 292     }
 293     void visitUnreachableInst(UnreachableInst &I);
 294
 295     void visitPHINode(PHINode &I);
 296     void visitBinaryOperator(Instruction &I);
 297     void visitICmpInst(ICmpInst &I);
 298     void visitFCmpInst(FCmpInst &I);
 299
 300     void visitCastInst (CastInst &I);
 301     void visitSelectInst(SelectInst &I);
 302     void visitCallInst (CallInst &I);
 303     void visitInlineAsm(CallInst &I);
 304     bool visitBuiltinCall(CallInst &I, Intrinsic::ID ID, bool &WroteCallee);
 305
 306     void visitAllocaInst(AllocaInst &I);
 307     void visitLoadInst  (LoadInst   &I);
 308     void visitStoreInst (StoreInst  &I);
 309     void visitGetElementPtrInst(GetElementPtrInst &I);
 310     void visitVAArgInst (VAArgInst &I);
 311
 312     void visitInsertElementInst(InsertElementInst &I);
 313     void visitExtractElementInst(ExtractElementInst &I);
 314     void visitShuffleVectorInst(ShuffleVectorInst &SVI);
 315
 316     void visitInsertValueInst(InsertValueInst &I);
 317     void visitExtractValueInst(ExtractValueInst &I);
 318
 319     void visitInstruction(Instruction &I) {
 320 #ifndef NDEBUG
 321       errs() << "C Writer does not know about " << I;
 322 #endif
 323       llvm_unreachable(0);
 324     }
 325
 326     void outputLValue(Instruction *I) {
 327       Out << "  " << GetValueName(I) << " = ";
 328     }
 329
 330     bool isGotoCodeNecessary(BasicBlock *From, BasicBlock *To);
 331     void printPHICopiesForSuccessor(BasicBlock *CurBlock,
 332                                     BasicBlock *Successor, unsigned Indent);
 333     void printBranchToBlock(BasicBlock *CurBlock, BasicBlock *SuccBlock,
 334                             unsigned Indent);
 335     void printGEPExpression(Value *Ptr, gep_type_iterator I,
 336                             gep_type_iterator E, bool Static);
 337
 338     std::string GetValueName(const Value *Operand);
 339   };
 340 }
 341
 342 char CWriter::ID = 0;
 343
 344
 345 static std::string CBEMangle(const std::string &S) {
 346   std::string Result;
 347
 348   for (unsigned i = 0, e = S.size(); i != e; ++i)
 349     if (isalnum(S[i]) || S[i] == '_') {
 350       Result += S[i];
 351     } else {
 352       Result += '_';
 353       Result += 'A'+(S[i]&15);
 354       Result += 'A'+((S[i]>>4)&15);
 355       Result += '_';
 356     }
 357   return Result;
 358 }
 359
 360
 361 /// This method inserts names for any unnamed structure types that are used by
 362 /// the program, and removes names from structure types that are not used by the
 363 /// program.
 364 ///
 365 bool CBackendNameAllUsedStructsAndMergeFunctions::runOnModule(Module &M) {
 366   // Get a set of types that are used by the program...
 367   std::set<const Type *> UT = getAnalysis<FindUsedTypes>().getTypes();
 368
 369   // Loop over the module symbol table, removing types from UT that are
 370   // already named, and removing names for types that are not used.
 371   //
 372   TypeSymbolTable &TST = M.getTypeSymbolTable();
 373   for (TypeSymbolTable::iterator TI = TST.begin(), TE = TST.end();
 374        TI != TE; ) {
 375     TypeSymbolTable::iterator I = TI++;
 376
 377     // If this isn't a struct or array type, remove it from our set of types
 378     // to name. This simplifies emission later.
 379     if (!I->second->isStructTy() && !I->second->isOpaqueTy() &&
 380         !I->second->isArrayTy()) {
 381       TST.remove(I);
 382     } else {
 383       // If this is not used, remove it from the symbol table.
 384       std::set<const Type *>::iterator UTI = UT.find(I->second);
 385       if (UTI == UT.end())
 386         TST.remove(I);
 387       else
 388         UT.erase(UTI);    // Only keep one name for this type.
 389     }
 390   }
 391
 392   // UT now contains types that are not named.  Loop over it, naming
 393   // structure types.
 394   //
 395   bool Changed = false;
 396   unsigned RenameCounter = 0;
 397   for (std::set<const Type *>::const_iterator I = UT.begin(), E = UT.end();
 398        I != E; ++I)
 399     if ((*I)->isStructTy() || (*I)->isArrayTy()) {
 400       while (M.addTypeName("unnamed"+utostr(RenameCounter), *I))
 401         ++RenameCounter;
 402       Changed = true;
 403     }
 404
 405
 406   // Loop over all external functions and globals.  If we have two with
 407   // identical names, merge them.
 408   // FIXME: This code should disappear when we don't allow values with the same
 409   // names when they have different types!
 410   std::map<std::string, GlobalValue*> ExtSymbols;
 411   for (Module::iterator I = M.begin(), E = M.end(); I != E;) {
 412     Function *GV = I++;
 413     if (GV->isDeclaration() && GV->hasName()) {
 414       std::pair<std::map<std::string, GlobalValue*>::iterator, bool> X
 415         = ExtSymbols.insert(std::make_pair(GV->getName(), GV));
 416       if (!X.second) {
 417         // Found a conflict, replace this global with the previous one.
 418         GlobalValue *OldGV = X.first->second;
 419         GV->replaceAllUsesWith(ConstantExpr::getBitCast(OldGV, GV->getType()));
 420         GV->eraseFromParent();
 421         Changed = true;
 422       }
 423     }
 424   }
 425   // Do the same for globals.
 426   for (Module::global_iterator I = M.global_begin(), E = M.global_end();
 427        I != E;) {
 428     GlobalVariable *GV = I++;
 429     if (GV->isDeclaration() && GV->hasName()) {
 430       std::pair<std::map<std::string, GlobalValue*>::iterator, bool> X
 431         = ExtSymbols.insert(std::make_pair(GV->getName(), GV));
 432       if (!X.second) {
 433         // Found a conflict, replace this global with the previous one.
 434         GlobalValue *OldGV = X.first->second;
 435         GV->replaceAllUsesWith(ConstantExpr::getBitCast(OldGV, GV->getType()));
 436         GV->eraseFromParent();
 437         Changed = true;
 438       }
 439     }
 440   }
 441
 442   return Changed;
 443 }
 444
 445 /// printStructReturnPointerFunctionType - This is like printType for a struct
 446 /// return type, except, instead of printing the type as void (*)(Struct*, ...)
 447 /// print it as "Struct (*)(...)", for struct return functions.
 448 void CWriter::printStructReturnPointerFunctionType(raw_ostream &Out,
 449                                                    const AttrListPtr &PAL,
 450                                                    const PointerType *TheTy) {
 451   const FunctionType *FTy = cast<FunctionType>(TheTy->getElementType());
 452   std::string tstr;
 453   raw_string_ostream FunctionInnards(tstr);
 454   FunctionInnards << " (*) (";
 455   bool PrintedType = false;
 456
 457   FunctionType::param_iterator I = FTy->param_begin(), E = FTy->param_end();
 458   const Type *RetTy = cast<PointerType>(I->get())->getElementType();
 459   unsigned Idx = 1;
 460   for (++I, ++Idx; I != E; ++I, ++Idx) {
 461     if (PrintedType)
 462       FunctionInnards << ", ";
 463     const Type *ArgTy = *I;
 464     if (PAL.paramHasAttr(Idx, Attribute::ByVal)) {
 465       assert(ArgTy->isPointerTy());
 466       ArgTy = cast<PointerType>(ArgTy)->getElementType();
 467     }
 468     printType(FunctionInnards, ArgTy,
 469         /*isSigned=*/PAL.paramHasAttr(Idx, Attribute::SExt), "");
 470     PrintedType = true;
 471   }
 472   if (FTy->isVarArg()) {
 473     if (PrintedType)
 474       FunctionInnards << ", ...";
 475   } else if (!PrintedType) {
 476     FunctionInnards << "void";
 477   }
 478   FunctionInnards << ')';
 479   printType(Out, RetTy,
 480       /*isSigned=*/PAL.paramHasAttr(0, Attribute::SExt), FunctionInnards.str());
 481 }
 482
 483 raw_ostream &
 484 CWriter::printSimpleType(raw_ostream &Out, const Type *Ty, bool isSigned,
 485                          const std::string &NameSoFar) {
 486   assert((Ty->isPrimitiveType() || Ty->isIntegerTy() || Ty->isVectorTy()) &&
 487          "Invalid type for printSimpleType");
 488   switch (Ty->getTypeID()) {
 489   case Type::VoidTyID:   return Out << "void " << NameSoFar;
 490   case Type::IntegerTyID: {
 491     unsigned NumBits = cast<IntegerType>(Ty)->getBitWidth();
 492     if (NumBits == 1)
 493       return Out << "bool " << NameSoFar;
 494     else if (NumBits <= 8)
 495       return Out << (isSigned?"signed":"unsigned") << " char " << NameSoFar;
 496     else if (NumBits <= 16)
 497       return Out << (isSigned?"signed":"unsigned") << " short " << NameSoFar;
 498     else if (NumBits <= 32)
 499       return Out << (isSigned?"signed":"unsigned") << " int " << NameSoFar;
 500     else if (NumBits <= 64)
 501       return Out << (isSigned?"signed":"unsigned") << " long long "<< NameSoFar;
 502     else {
 503       assert(NumBits <= 128 && "Bit widths > 128 not implemented yet");
 504       return Out << (isSigned?"llvmInt128":"llvmUInt128") << " " << NameSoFar;
 505     }
 506   }
 507   case Type::FloatTyID:  return Out << "float "   << NameSoFar;
 508   case Type::DoubleTyID: return Out << "double "  << NameSoFar;
 509   // Lacking emulation of FP80 on PPC, etc., we assume whichever of these is
 510   // present matches host 'long double'.
 511   case Type::X86_FP80TyID:
 512   case Type::PPC_FP128TyID:
 513   case Type::FP128TyID:  return Out << "long double " << NameSoFar;
 514
 515   case Type::VectorTyID: {
 516     const VectorType *VTy = cast<VectorType>(Ty);
 517     return printSimpleType(Out, VTy->getElementType(), isSigned,
 518                      " __attribute__((vector_size(" +
 519                      utostr(TD->getTypeAllocSize(VTy)) + " ))) " + NameSoFar);
 520   }
 521
 522   default:
 523 #ifndef NDEBUG
 524     errs() << "Unknown primitive type: " << *Ty << "\n";
 525 #endif
 526     llvm_unreachable(0);
 527   }
 528 }
 529
 530 // Pass the Type* and the variable name and this prints out the variable
 531 // declaration.
 532 //
 533 raw_ostream &CWriter::printType(raw_ostream &Out, const Type *Ty,
 534                                 bool isSigned, const std::string &NameSoFar,
 535                                 bool IgnoreName, const AttrListPtr &PAL) {
 536   if (Ty->isPrimitiveType() || Ty->isIntegerTy() || Ty->isVectorTy()) {
 537     printSimpleType(Out, Ty, isSigned, NameSoFar);
 538     return Out;
 539   }
 540
 541   // Check to see if the type is named.
 542   if (!IgnoreName || Ty->isOpaqueTy()) {
 543     std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty);
 544     if (I != TypeNames.end()) return Out << I->second << ' ' << NameSoFar;
 545   }
 546
 547   switch (Ty->getTypeID()) {
 548   case Type::FunctionTyID: {
 549     const FunctionType *FTy = cast<FunctionType>(Ty);
 550     std::string tstr;
 551     raw_string_ostream FunctionInnards(tstr);
 552     FunctionInnards << " (" << NameSoFar << ") (";
 553     unsigned Idx = 1;
 554     for (FunctionType::param_iterator I = FTy->param_begin(),
 555            E = FTy->param_end(); I != E; ++I) {
 556       const Type *ArgTy = *I;
 557       if (PAL.paramHasAttr(Idx, Attribute::ByVal)) {
 558         assert(ArgTy->isPointerTy());
 559         ArgTy = cast<PointerType>(ArgTy)->getElementType();
 560       }
 561       if (I != FTy->param_begin())
 562         FunctionInnards << ", ";
 563       printType(FunctionInnards, ArgTy,
 564         /*isSigned=*/PAL.paramHasAttr(Idx, Attribute::SExt), "");
 565       ++Idx;
 566     }
 567     if (FTy->isVarArg()) {
 568       if (FTy->getNumParams())
 569         FunctionInnards << ", ...";
 570     } else if (!FTy->getNumParams()) {
 571       FunctionInnards << "void";
 572     }
 573     FunctionInnards << ')';
 574     printType(Out, FTy->getReturnType(),
 575       /*isSigned=*/PAL.paramHasAttr(0, Attribute::SExt), FunctionInnards.str());
 576     return Out;
 577   }
 578   case Type::StructTyID: {
 579     const StructType *STy = cast<StructType>(Ty);
 580     Out << NameSoFar + " {\n";
 581     unsigned Idx = 0;
 582     for (StructType::element_iterator I = STy->element_begin(),
 583            E = STy->element_end(); I != E; ++I) {
 584       Out << "  ";
 585       printType(Out, *I, false, "field" + utostr(Idx++));
 586       Out << ";\n";
 587     }
 588     Out << '}';
 589     if (STy->isPacked())
 590       Out << " __attribute__ ((packed))";
 591     return Out;
 592   }
 593
 594   case Type::PointerTyID: {
 595     const PointerType *PTy = cast<PointerType>(Ty);
 596     std::string ptrName = "*" + NameSoFar;
 597
 598     if (PTy->getElementType()->isArrayTy() ||
 599         PTy->getElementType()->isVectorTy())
 600       ptrName = "(" + ptrName + ")";
 601
 602     if (!PAL.isEmpty())
 603       // Must be a function ptr cast!
 604       return printType(Out, PTy->getElementType(), false, ptrName, true, PAL);
 605     return printType(Out, PTy->getElementType(), false, ptrName);
 606   }
 607
 608   case Type::ArrayTyID: {
 609     const ArrayType *ATy = cast<ArrayType>(Ty);
 610     unsigned NumElements = ATy->getNumElements();
 611     if (NumElements == 0) NumElements = 1;
 612     // Arrays are wrapped in structs to allow them to have normal
 613     // value semantics (avoiding the array "decay").
 614     Out << NameSoFar << " { ";
 615     printType(Out, ATy->getElementType(), false,
 616               "array[" + utostr(NumElements) + "]");
 617     return Out << "; }";
 618   }
 619
 620   case Type::OpaqueTyID: {
 621     std::string TyName = "struct opaque_" + itostr(OpaqueCounter++);
 622     assert(TypeNames.find(Ty) == TypeNames.end());
 623     TypeNames[Ty] = TyName;
 624     return Out << TyName << ' ' << NameSoFar;
 625   }
 626   default:
 627     llvm_unreachable("Unhandled case in getTypeProps!");
 628   }
 629
 630   return Out;
 631 }
 632
 633 void CWriter::printConstantArray(ConstantArray *CPA, bool Static) {
 634
 635   // As a special case, print the array as a string if it is an array of
 636   // ubytes or an array of sbytes with positive values.
 637   //
 638   const Type *ETy = CPA->getType()->getElementType();
 639   bool isString = (ETy == Type::getInt8Ty(CPA->getContext()) ||
 640                    ETy == Type::getInt8Ty(CPA->getContext()));
 641
 642   // Make sure the last character is a null char, as automatically added by C
 643   if (isString && (CPA->getNumOperands() == 0 ||
 644                    !cast<Constant>(*(CPA->op_end()-1))->isNullValue()))
 645     isString = false;
 646
 647   if (isString) {
 648     Out << '\"';
 649     // Keep track of whether the last number was a hexadecimal escape
 650     bool LastWasHex = false;
 651
 652     // Do not include the last character, which we know is null
 653     for (unsigned i = 0, e = CPA->getNumOperands()-1; i != e; ++i) {
 654       unsigned char C = cast<ConstantInt>(CPA->getOperand(i))->getZExtValue();
 655
 656       // Print it out literally if it is a printable character.  The only thing
 657       // to be careful about is when the last letter output was a hex escape
 658       // code, in which case we have to be careful not to print out hex digits
 659       // explicitly (the C compiler thinks it is a continuation of the previous
 660       // character, sheesh...)
 661       //
 662       if (isprint(C) && (!LastWasHex || !isxdigit(C))) {
 663         LastWasHex = false;
 664         if (C == '"' || C == '\\')
 665           Out << "\\" << (char)C;
 666         else
 667           Out << (char)C;
 668       } else {
 669         LastWasHex = false;
 670         switch (C) {
 671         case '\n': Out << "\\n"; break;
 672         case '\t': Out << "\\t"; break;
 673         case '\r': Out << "\\r"; break;
 674         case '\v': Out << "\\v"; break;
 675         case '\a': Out << "\\a"; break;
 676         case '\"': Out << "\\\""; break;
 677         case '\'': Out << "\\\'"; break;
 678         default:
 679           Out << "\\x";
 680           Out << (char)(( C/16  < 10) ? ( C/16 +'0') : ( C/16 -10+'A'));
 681           Out << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A'));
 682           LastWasHex = true;
 683           break;
 684         }
 685       }
 686     }
 687     Out << '\"';
 688   } else {
 689     Out << '{';
 690     if (CPA->getNumOperands()) {
 691       Out << ' ';
 692       printConstant(cast<Constant>(CPA->getOperand(0)), Static);
 693       for (unsigned i = 1, e = CPA->getNumOperands(); i != e; ++i) {
 694         Out << ", ";
 695         printConstant(cast<Constant>(CPA->getOperand(i)), Static);
 696       }
 697     }
 698     Out << " }";
 699   }
 700 }
 701
 702 void CWriter::printConstantVector(ConstantVector *CP, bool Static) {
 703   Out << '{';
 704   if (CP->getNumOperands()) {
 705     Out << ' ';
 706     printConstant(cast<Constant>(CP->getOperand(0)), Static);
 707     for (unsigned i = 1, e = CP->getNumOperands(); i != e; ++i) {
 708       Out << ", ";
 709       printConstant(cast<Constant>(CP->getOperand(i)), Static);
 710     }
 711   }
 712   Out << " }";
 713 }
 714
 715 // isFPCSafeToPrint - Returns true if we may assume that CFP may be written out
 716 // textually as a double (rather than as a reference to a stack-allocated
 717 // variable). We decide this by converting CFP to a string and back into a
 718 // double, and then checking whether the conversion results in a bit-equal
 719 // double to the original value of CFP. This depends on us and the target C
 720 // compiler agreeing on the conversion process (which is pretty likely since we
 721 // only deal in IEEE FP).
 722 //
 723 static bool isFPCSafeToPrint(const ConstantFP *CFP) {
 724   bool ignored;
 725   // Do long doubles in hex for now.
 726   if (CFP->getType() != Type::getFloatTy(CFP->getContext()) &&
 727       CFP->getType() != Type::getDoubleTy(CFP->getContext()))
 728     return false;
 729   APFloat APF = APFloat(CFP->getValueAPF());  // copy
 730   if (CFP->getType() == Type::getFloatTy(CFP->getContext()))
 731     APF.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &ignored);
 732 #if HAVE_PRINTF_A && ENABLE_CBE_PRINTF_A
 733   char Buffer[100];
 734   sprintf(Buffer, "%a", APF.convertToDouble());
 735   if (!strncmp(Buffer, "0x", 2) ||
 736       !strncmp(Buffer, "-0x", 3) ||
 737       !strncmp(Buffer, "+0x", 3))
 738     return APF.bitwiseIsEqual(APFloat(atof(Buffer)));
 739   return false;
 740 #else
 741   std::string StrVal = ftostr(APF);
 742
 743   while (StrVal[0] == ' ')
 744     StrVal.erase(StrVal.begin());
 745
 746   // Check to make sure that the stringized number is not some string like "Inf"
 747   // or NaN.  Check that the string matches the "[-+]?[0-9]" regex.
 748   if ((StrVal[0] >= '0' && StrVal[0] <= '9') ||
 749       ((StrVal[0] == '-' || StrVal[0] == '+') &&
 750        (StrVal[1] >= '0' && StrVal[1] <= '9')))
 751     // Reparse stringized version!
 752     return APF.bitwiseIsEqual(APFloat(atof(StrVal.c_str())));
 753   return false;
 754 #endif
 755 }
 756
 757 /// Print out the casting for a cast operation. This does the double casting
 758 /// necessary for conversion to the destination type, if necessary.
 759 /// @brief Print a cast
 760 void CWriter::printCast(unsigned opc, const Type *SrcTy, const Type *DstTy) {
 761   // Print the destination type cast
 762   switch (opc) {
 763     case Instruction::UIToFP:
 764     case Instruction::SIToFP:
 765     case Instruction::IntToPtr:
 766     case Instruction::Trunc:
 767     case Instruction::BitCast:
 768     case Instruction::FPExt:
 769     case Instruction::FPTrunc: // For these the DstTy sign doesn't matter
 770       Out << '(';
 771       printType(Out, DstTy);
 772       Out << ')';
 773       break;
 774     case Instruction::ZExt:
 775     case Instruction::PtrToInt:
 776     case Instruction::FPToUI: // For these, make sure we get an unsigned dest
 777       Out << '(';
 778       printSimpleType(Out, DstTy, false);
 779       Out << ')';
 780       break;
 781     case Instruction::SExt:
 782     case Instruction::FPToSI: // For these, make sure we get a signed dest
 783       Out << '(';
 784       printSimpleType(Out, DstTy, true);
 785       Out << ')';
 786       break;
 787     default:
 788       llvm_unreachable("Invalid cast opcode");
 789   }
 790
 791   // Print the source type cast
 792   switch (opc) {
 793     case Instruction::UIToFP:
 794     case Instruction::ZExt:
 795       Out << '(';
 796       printSimpleType(Out, SrcTy, false);
 797       Out << ')';
 798       break;
 799     case Instruction::SIToFP:
 800     case Instruction::SExt:
 801       Out << '(';
 802       printSimpleType(Out, SrcTy, true);
 803       Out << ')';
 804       break;
 805     case Instruction::IntToPtr:
 806     case Instruction::PtrToInt:
 807       // Avoid "cast to pointer from integer of different size" warnings
 808       Out << "(unsigned long)";
 809       break;
 810     case Instruction::Trunc:
 811     case Instruction::BitCast:
 812     case Instruction::FPExt:
 813     case Instruction::FPTrunc:
 814     case Instruction::FPToSI:
 815     case Instruction::FPToUI:
 816       break; // These don't need a source cast.
 817     default:
 818       llvm_unreachable("Invalid cast opcode");
 819       break;
 820   }
 821 }
 822
 823 // printConstant - The LLVM Constant to C Constant converter.
 824 void CWriter::printConstant(Constant *CPV, bool Static) {
 825   if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CPV)) {
 826     switch (CE->getOpcode()) {
 827     case Instruction::Trunc:
 828     case Instruction::ZExt:
 829     case Instruction::SExt:
 830     case Instruction::FPTrunc:
 831     case Instruction::FPExt:
 832     case Instruction::UIToFP:
 833     case Instruction::SIToFP:
 834     case Instruction::FPToUI:
 835     case Instruction::FPToSI:
 836     case Instruction::PtrToInt:
 837     case Instruction::IntToPtr:
 838     case Instruction::BitCast:
 839       Out << "(";
 840       printCast(CE->getOpcode(), CE->getOperand(0)->getType(), CE->getType());
 841       if (CE->getOpcode() == Instruction::SExt &&
 842           CE->getOperand(0)->getType() == Type::getInt1Ty(CPV->getContext())) {
 843         // Make sure we really sext from bool here by subtracting from 0
 844         Out << "0-";
 845       }
 846       printConstant(CE->getOperand(0), Static);
 847       if (CE->getType() == Type::getInt1Ty(CPV->getContext()) &&
 848           (CE->getOpcode() == Instruction::Trunc ||
 849            CE->getOpcode() == Instruction::FPToUI ||
 850            CE->getOpcode() == Instruction::FPToSI ||
 851            CE->getOpcode() == Instruction::PtrToInt)) {
 852         // Make sure we really truncate to bool here by anding with 1
 853         Out << "&1u";
 854       }
 855       Out << ')';
 856       return;
 857
 858     case Instruction::GetElementPtr:
 859       Out << "(";
 860       printGEPExpression(CE->getOperand(0), gep_type_begin(CPV),
 861                          gep_type_end(CPV), Static);
 862       Out << ")";
 863       return;
 864     case Instruction::Select:
 865       Out << '(';
 866       printConstant(CE->getOperand(0), Static);
 867       Out << '?';
 868       printConstant(CE->getOperand(1), Static);
 869       Out << ':';
 870       printConstant(CE->getOperand(2), Static);
 871       Out << ')';
 872       return;
 873     case Instruction::Add:
 874     case Instruction::FAdd:
 875     case Instruction::Sub:
 876     case Instruction::FSub:
 877     case Instruction::Mul:
 878     case Instruction::FMul:
 879     case Instruction::SDiv:
 880     case Instruction::UDiv:
 881     case Instruction::FDiv:
 882     case Instruction::URem:
 883     case Instruction::SRem:
 884     case Instruction::FRem:
 885     case Instruction::And:
 886     case Instruction::Or:
 887     case Instruction::Xor:
 888     case Instruction::ICmp:
 889     case Instruction::Shl:
 890     case Instruction::LShr:
 891     case Instruction::AShr:
 892     {
 893       Out << '(';
 894       bool NeedsClosingParens = printConstExprCast(CE, Static);
 895       printConstantWithCast(CE->getOperand(0), CE->getOpcode());
 896       switch (CE->getOpcode()) {
 897       case Instruction::Add:
 898       case Instruction::FAdd: Out << " + "; break;
 899       case Instruction::Sub:
 900       case Instruction::FSub: Out << " - "; break;
 901       case Instruction::Mul:
 902       case Instruction::FMul: Out << " * "; break;
 903       case Instruction::URem:
 904       case Instruction::SRem:
 905       case Instruction::FRem: Out << " % "; break;
 906       case Instruction::UDiv:
 907       case Instruction::SDiv:
 908       case Instruction::FDiv: Out << " / "; break;
 909       case Instruction::And: Out << " & "; break;
 910       case Instruction::Or:  Out << " | "; break;
 911       case Instruction::Xor: Out << " ^ "; break;
 912       case Instruction::Shl: Out << " << "; break;
 913       case Instruction::LShr:
 914       case Instruction::AShr: Out << " >> "; break;
 915       case Instruction::ICmp:
 916         switch (CE->getPredicate()) {
 917           case ICmpInst::ICMP_EQ: Out << " == "; break;
 918           case ICmpInst::ICMP_NE: Out << " != "; break;
 919           case ICmpInst::ICMP_SLT:
 920           case ICmpInst::ICMP_ULT: Out << " < "; break;
 921           case ICmpInst::ICMP_SLE:
 922           case ICmpInst::ICMP_ULE: Out << " <= "; break;
 923           case ICmpInst::ICMP_SGT:
 924           case ICmpInst::ICMP_UGT: Out << " > "; break;
 925           case ICmpInst::ICMP_SGE:
 926           case ICmpInst::ICMP_UGE: Out << " >= "; break;
 927           default: llvm_unreachable("Illegal ICmp predicate");
 928         }
 929         break;
 930       default: llvm_unreachable("Illegal opcode here!");
 931       }
 932       printConstantWithCast(CE->getOperand(1), CE->getOpcode());
 933       if (NeedsClosingParens)
 934         Out << "))";
 935       Out << ')';
 936       return;
 937     }
 938     case Instruction::FCmp: {
 939       Out << '(';
 940       bool NeedsClosingParens = printConstExprCast(CE, Static);
 941       if (CE->getPredicate() == FCmpInst::FCMP_FALSE)
 942         Out << "0";
 943       else if (CE->getPredicate() == FCmpInst::FCMP_TRUE)
 944         Out << "1";
 945       else {
 946         const char* op = 0;
 947         switch (CE->getPredicate()) {
 948         default: llvm_unreachable("Illegal FCmp predicate");
 949         case FCmpInst::FCMP_ORD: op = "ord"; break;
 950         case FCmpInst::FCMP_UNO: op = "uno"; break;
 951         case FCmpInst::FCMP_UEQ: op = "ueq"; break;
 952         case FCmpInst::FCMP_UNE: op = "une"; break;
 953         case FCmpInst::FCMP_ULT: op = "ult"; break;
 954         case FCmpInst::FCMP_ULE: op = "ule"; break;
 955         case FCmpInst::FCMP_UGT: op = "ugt"; break;
 956         case FCmpInst::FCMP_UGE: op = "uge"; break;
 957         case FCmpInst::FCMP_OEQ: op = "oeq"; break;
 958         case FCmpInst::FCMP_ONE: op = "one"; break;
 959         case FCmpInst::FCMP_OLT: op = "olt"; break;
 960         case FCmpInst::FCMP_OLE: op = "ole"; break;
 961         case FCmpInst::FCMP_OGT: op = "ogt"; break;
 962         case FCmpInst::FCMP_OGE: op = "oge"; break;
 963         }
 964         Out << "llvm_fcmp_" << op << "(";
 965         printConstantWithCast(CE->getOperand(0), CE->getOpcode());
 966         Out << ", ";
 967         printConstantWithCast(CE->getOperand(1), CE->getOpcode());
 968         Out << ")";
 969       }
 970       if (NeedsClosingParens)
 971         Out << "))";
 972       Out << ')';
 973       return;
 974     }
 975     default:
 976 #ifndef NDEBUG
 977       errs() << "CWriter Error: Unhandled constant expression: "
 978            << *CE << "\n";
 979 #endif
 980       llvm_unreachable(0);
 981     }
 982   } else if (isa<UndefValue>(CPV) && CPV->getType()->isSingleValueType()) {
 983     Out << "((";
 984     printType(Out, CPV->getType()); // sign doesn't matter
 985     Out << ")/*UNDEF*/";
 986     if (!CPV->getType()->isVectorTy()) {
 987       Out << "0)";
 988     } else {
 989       Out << "{})";
 990     }
 991     return;
 992   }
 993
 994   if (ConstantInt *CI = dyn_cast<ConstantInt>(CPV)) {
 995     const Type* Ty = CI->getType();
 996     if (Ty == Type::getInt1Ty(CPV->getContext()))
 997       Out << (CI->getZExtValue() ? '1' : '0');
 998     else if (Ty == Type::getInt32Ty(CPV->getContext()))
 999       Out << CI->getZExtValue() << 'u';
1000     else if (Ty->getPrimitiveSizeInBits() > 32)
1001       Out << CI->getZExtValue() << "ull";
1002     else {
1003       Out << "((";
1004       printSimpleType(Out, Ty, false) << ')';
1005       if (CI->isMinValue(true))
1006         Out << CI->getZExtValue() << 'u';
1007       else
1008         Out << CI->getSExtValue();
1009       Out << ')';
1010     }
1011     return;
1012   }
1013
1014   switch (CPV->getType()->getTypeID()) {
1015   case Type::FloatTyID:
1016   case Type::DoubleTyID:
1017   case Type::X86_FP80TyID:
1018   case Type::PPC_FP128TyID:
1019   case Type::FP128TyID: {
1020     ConstantFP *FPC = cast<ConstantFP>(CPV);
1021     std::map<const ConstantFP*, unsigned>::iterator I = FPConstantMap.find(FPC);
1022     if (I != FPConstantMap.end()) {
1023       // Because of FP precision problems we must load from a stack allocated
1024       // value that holds the value in hex.
1025       Out << "(*(" << (FPC->getType() == Type::getFloatTy(CPV->getContext()) ?
1026                        "float" :
1027                        FPC->getType() == Type::getDoubleTy(CPV->getContext()) ?
1028                        "double" :
1029                        "long double")
1030           << "*)&FPConstant" << I->second << ')';
1031     } else {
1032       double V;
1033       if (FPC->getType() == Type::getFloatTy(CPV->getContext()))
1034         V = FPC->getValueAPF().convertToFloat();
1035       else if (FPC->getType() == Type::getDoubleTy(CPV->getContext()))
1036         V = FPC->getValueAPF().convertToDouble();
1037       else {
1038         // Long double.  Convert the number to double, discarding precision.
1039         // This is not awesome, but it at least makes the CBE output somewhat
1040         // useful.
1041         APFloat Tmp = FPC->getValueAPF();
1042         bool LosesInfo;
1043         Tmp.convert(APFloat::IEEEdouble, APFloat::rmTowardZero, &LosesInfo);
1044         V = Tmp.convertToDouble();
1045       }
1046
1047       if (IsNAN(V)) {
1048         // The value is NaN
1049
1050         // FIXME the actual NaN bits should be emitted.
1051         // The prefix for a quiet NaN is 0x7FF8. For a signalling NaN,
1052         // it's 0x7ff4.
1053         const unsigned long QuietNaN = 0x7ff8UL;
1054         //const unsigned long SignalNaN = 0x7ff4UL;
1055
1056         // We need to grab the first part of the FP #
1057         char Buffer[100];
1058
1059         uint64_t ll = DoubleToBits(V);
1060         sprintf(Buffer, "0x%llx", static_cast<long long>(ll));
1061
1062         std::string Num(&Buffer[0], &Buffer[6]);
1063         unsigned long Val = strtoul(Num.c_str(), 0, 16);
1064
1065         if (FPC->getType() == Type::getFloatTy(FPC->getContext()))
1066           Out << "LLVM_NAN" << (Val == QuietNaN ? "" : "S") << "F(\""
1067               << Buffer << "\") /*nan*/ ";
1068         else
1069           Out << "LLVM_NAN" << (Val == QuietNaN ? "" : "S") << "(\""
1070               << Buffer << "\") /*nan*/ ";
1071       } else if (IsInf(V)) {
1072         // The value is Inf
1073         if (V < 0) Out << '-';
1074         Out << "LLVM_INF" <<
1075             (FPC->getType() == Type::getFloatTy(FPC->getContext()) ? "F" : "")
1076             << " /*inf*/ ";
1077       } else {
1078         std::string Num;
1079 #if HAVE_PRINTF_A && ENABLE_CBE_PRINTF_A
1080         // Print out the constant as a floating point number.
1081         char Buffer[100];
1082         sprintf(Buffer, "%a", V);
1083         Num = Buffer;
1084 #else
1085         Num = ftostr(FPC->getValueAPF());
1086 #endif
1087        Out << Num;
1088       }
1089     }
1090     break;
1091   }
1092
1093   case Type::ArrayTyID:
1094     // Use C99 compound expression literal initializer syntax.
1095     if (!Static) {
1096       Out << "(";
1097       printType(Out, CPV->getType());
1098       Out << ")";
1099     }
1100     Out << "{ "; // Arrays are wrapped in struct types.
1101     if (ConstantArray *CA = dyn_cast<ConstantArray>(CPV)) {
1102       printConstantArray(CA, Static);
1103     } else {
1104       assert(isa<ConstantAggregateZero>(CPV) || isa<UndefValue>(CPV));
1105       const ArrayType *AT = cast<ArrayType>(CPV->getType());
1106       Out << '{';
1107       if (AT->getNumElements()) {
1108         Out << ' ';
1109         Constant *CZ = Constant::getNullValue(AT->getElementType());
1110         printConstant(CZ, Static);
1111         for (unsigned i = 1, e = AT->getNumElements(); i != e; ++i) {
1112           Out << ", ";
1113           printConstant(CZ, Static);
1114         }
1115       }
1116       Out << " }";
1117     }
1118     Out << " }"; // Arrays are wrapped in struct types.
1119     break;
1120
1121   case Type::VectorTyID:
1122     // Use C99 compound expression literal initializer syntax.
1123     if (!Static) {
1124       Out << "(";
1125       printType(Out, CPV->getType());
1126       Out << ")";
1127     }
1128     if (ConstantVector *CV = dyn_cast<ConstantVector>(CPV)) {
1129       printConstantVector(CV, Static);
1130     } else {
1131       assert(isa<ConstantAggregateZero>(CPV) || isa<UndefValue>(CPV));
1132       const VectorType *VT = cast<VectorType>(CPV->getType());
1133       Out << "{ ";
1134       Constant *CZ = Constant::getNullValue(VT->getElementType());
1135       printConstant(CZ, Static);
1136       for (unsigned i = 1, e = VT->getNumElements(); i != e; ++i) {
1137         Out << ", ";
1138         printConstant(CZ, Static);
1139       }
1140       Out << " }";
1141     }
1142     break;
1143
1144   case Type::StructTyID:
1145     // Use C99 compound expression literal initializer syntax.
1146     if (!Static) {
1147       Out << "(";
1148       printType(Out, CPV->getType());
1149       Out << ")";
1150     }
1151     if (isa<ConstantAggregateZero>(CPV) || isa<UndefValue>(CPV)) {
1152       const StructType *ST = cast<StructType>(CPV->getType());
1153       Out << '{';
1154       if (ST->getNumElements()) {
1155         Out << ' ';
1156         printConstant(Constant::getNullValue(ST->getElementType(0)), Static);
1157         for (unsigned i = 1, e = ST->getNumElements(); i != e; ++i) {
1158           Out << ", ";
1159           printConstant(Constant::getNullValue(ST->getElementType(i)), Static);
1160         }
1161       }
1162       Out << " }";
1163     } else {
1164       Out << '{';
1165       if (CPV->getNumOperands()) {
1166         Out << ' ';
1167         printConstant(cast<Constant>(CPV->getOperand(0)), Static);
1168         for (unsigned i = 1, e = CPV->getNumOperands(); i != e; ++i) {
1169           Out << ", ";
1170           printConstant(cast<Constant>(CPV->getOperand(i)), Static);
1171         }
1172       }
1173       Out << " }";
1174     }
1175     break;
1176
1177   case Type::PointerTyID:
1178     if (isa<ConstantPointerNull>(CPV)) {
1179       Out << "((";
1180       printType(Out, CPV->getType()); // sign doesn't matter
1181       Out << ")/*NULL*/0)";
1182       break;
1183     } else if (GlobalValue *GV = dyn_cast<GlobalValue>(CPV)) {
1184       writeOperand(GV, Static);
1185       break;
1186     }
1187     // FALL THROUGH
1188   default:
1189 #ifndef NDEBUG
1190     errs() << "Unknown constant type: " << *CPV << "\n";
1191 #endif
1192     llvm_unreachable(0);
1193   }
1194 }
1195
1196 // Some constant expressions need to be casted back to the original types
1197 // because their operands were casted to the expected type. This function takes
1198 // care of detecting that case and printing the cast for the ConstantExpr.
1199 bool CWriter::printConstExprCast(const ConstantExpr* CE, bool Static) {
1200   bool NeedsExplicitCast = false;
1201   const Type *Ty = CE->getOperand(0)->getType();
1202   bool TypeIsSigned = false;
1203   switch (CE->getOpcode()) {
1204   case Instruction::Add:
1205   case Instruction::Sub:
1206   case Instruction::Mul:
1207     // We need to cast integer arithmetic so that it is always performed
1208     // as unsigned, to avoid undefined behavior on overflow.
1209   case Instruction::LShr:
1210   case Instruction::URem:
1211   case Instruction::UDiv: NeedsExplicitCast = true; break;
1212   case Instruction::AShr:
1213   case Instruction::SRem:
1214   case Instruction::SDiv: NeedsExplicitCast = true; TypeIsSigned = true; break;
1215   case Instruction::SExt:
1216     Ty = CE->getType();
1217     NeedsExplicitCast = true;
1218     TypeIsSigned = true;
1219     break;
1220   case Instruction::ZExt:
1221   case Instruction::Trunc:
1222   case Instruction::FPTrunc:
1223   case Instruction::FPExt:
1224   case Instruction::UIToFP:
1225   case Instruction::SIToFP:
1226   case Instruction::FPToUI:
1227   case Instruction::FPToSI:
1228   case Instruction::PtrToInt:
1229   case Instruction::IntToPtr:
1230   case Instruction::BitCast:
1231     Ty = CE->getType();
1232     NeedsExplicitCast = true;
1233     break;
1234   default: break;
1235   }
1236   if (NeedsExplicitCast) {
1237     Out << "((";
1238     if (Ty->isIntegerTy() && Ty != Type::getInt1Ty(Ty->getContext()))
1239       printSimpleType(Out, Ty, TypeIsSigned);
1240     else
1241       printType(Out, Ty); // not integer, sign doesn't matter
1242     Out << ")(";
1243   }
1244   return NeedsExplicitCast;
1245 }
1246
1247 //  Print a constant assuming that it is the operand for a given Opcode. The
1248 //  opcodes that care about sign need to cast their operands to the expected
1249 //  type before the operation proceeds. This function does the casting.
1250 void CWriter::printConstantWithCast(Constant* CPV, unsigned Opcode) {
1251
1252   // Extract the operand's type, we'll need it.
1253   const Type* OpTy = CPV->getType();
1254
1255   // Indicate whether to do the cast or not.
1256   bool shouldCast = false;
1257   bool typeIsSigned = false;
1258
1259   // Based on the Opcode for which this Constant is being written, determine
1260   // the new type to which the operand should be casted by setting the value
1261   // of OpTy. If we change OpTy, also set shouldCast to true so it gets
1262   // casted below.
1263   switch (Opcode) {
1264     default:
1265       // for most instructions, it doesn't matter
1266       break;
1267     case Instruction::Add:
1268     case Instruction::Sub:
1269     case Instruction::Mul:
1270       // We need to cast integer arithmetic so that it is always performed
1271       // as unsigned, to avoid undefined behavior on overflow.
1272     case Instruction::LShr:
1273     case Instruction::UDiv:
1274     case Instruction::URem:
1275       shouldCast = true;
1276       break;
1277     case Instruction::AShr:
1278     case Instruction::SDiv:
1279     case Instruction::SRem:
1280       shouldCast = true;
1281       typeIsSigned = true;
1282       break;
1283   }
1284
1285   // Write out the casted constant if we should, otherwise just write the
1286   // operand.
1287   if (shouldCast) {
1288     Out << "((";
1289     printSimpleType(Out, OpTy, typeIsSigned);
1290     Out << ")";
1291     printConstant(CPV, false);
1292     Out << ")";
1293   } else
1294     printConstant(CPV, false);
1295 }
1296
1297 std::string CWriter::GetValueName(const Value *Operand) {
1298   // Mangle globals with the standard mangler interface for LLC compatibility.
1299   if (const GlobalValue *GV = dyn_cast<GlobalValue>(Operand)) {
1300     SmallString<128> Str;
1301     Mang->getNameWithPrefix(Str, GV, false);
1302     return CBEMangle(Str.str().str());
1303   }
1304
1305   std::string Name = Operand->getName();
1306
1307   if (Name.empty()) { // Assign unique names to local temporaries.
1308     unsigned &No = AnonValueNumbers[Operand];
1309     if (No == 0)
1310       No = ++NextAnonValueNumber;
1311     Name = "tmp__" + utostr(No);
1312   }
1313
1314   std::string VarName;
1315   VarName.reserve(Name.capacity());
1316
1317   for (std::string::iterator I = Name.begin(), E = Name.end();
1318        I != E; ++I) {
1319     char ch = *I;
1320
1321     if (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
1322           (ch >= '0' && ch <= '9') || ch == '_')) {
1323       char buffer[5];
1324       sprintf(buffer, "_%x_", ch);
1325       VarName += buffer;
1326     } else
1327       VarName += ch;
1328   }
1329
1330   return "llvm_cbe_" + VarName;
1331 }
1332
1333 /// writeInstComputationInline - Emit the computation for the specified
1334 /// instruction inline, with no destination provided.
1335 void CWriter::writeInstComputationInline(Instruction &I) {
1336   // We can't currently support integer types other than 1, 8, 16, 32, 64.
1337   // Validate this.
1338   const Type *Ty = I.getType();
1339   if (Ty->isIntegerTy() && (Ty!=Type::getInt1Ty(I.getContext()) &&
1340         Ty!=Type::getInt8Ty(I.getContext()) &&
1341         Ty!=Type::getInt16Ty(I.getContext()) &&
1342         Ty!=Type::getInt32Ty(I.getContext()) &&
1343         Ty!=Type::getInt64Ty(I.getContext()))) {
1344       llvm_report_error("The C backend does not currently support integer "
1345                         "types of widths other than 1, 8, 16, 32, 64.\n"
1346                         "This is being tracked as PR 4158.");
1347   }
1348
1349   // If this is a non-trivial bool computation, make sure to truncate down to
1350   // a 1 bit value.  This is important because we want "add i1 x, y" to return
1351   // "0" when x and y are true, not "2" for example.
1352   bool NeedBoolTrunc = false;
1353   if (I.getType() == Type::getInt1Ty(I.getContext()) &&
1354       !isa<ICmpInst>(I) && !isa<FCmpInst>(I))
1355     NeedBoolTrunc = true;
1356
1357   if (NeedBoolTrunc)
1358     Out << "((";
1359
1360   visit(I);
1361
1362   if (NeedBoolTrunc)
1363     Out << ")&1)";
1364 }
1365
1366
1367 void CWriter::writeOperandInternal(Value *Operand, bool Static) {
1368   if (Instruction *I = dyn_cast<Instruction>(Operand))
1369     // Should we inline this instruction to build a tree?
1370     if (isInlinableInst(*I) && !isDirectAlloca(I)) {
1371       Out << '(';
1372       writeInstComputationInline(*I);
1373       Out << ')';
1374       return;
1375     }
1376
1377   Constant* CPV = dyn_cast<Constant>(Operand);
1378
1379   if (CPV && !isa<GlobalValue>(CPV))
1380     printConstant(CPV, Static);
1381   else
1382     Out << GetValueName(Operand);
1383 }
1384
1385 void CWriter::writeOperand(Value *Operand, bool Static) {
1386   bool isAddressImplicit = isAddressExposed(Operand);
1387   if (isAddressImplicit)
1388     Out << "(&";  // Global variables are referenced as their addresses by llvm
1389
1390   writeOperandInternal(Operand, Static);
1391
1392   if (isAddressImplicit)
1393     Out << ')';
1394 }
1395
1396 // Some instructions need to have their result value casted back to the
1397 // original types because their operands were casted to the expected type.
1398 // This function takes care of detecting that case and printing the cast
1399 // for the Instruction.
1400 bool CWriter::writeInstructionCast(const Instruction &I) {
1401   const Type *Ty = I.getOperand(0)->getType();
1402   switch (I.getOpcode()) {
1403   case Instruction::Add:
1404   case Instruction::Sub:
1405   case Instruction::Mul:
1406     // We need to cast integer arithmetic so that it is always performed
1407     // as unsigned, to avoid undefined behavior on overflow.
1408   case Instruction::LShr:
1409   case Instruction::URem:
1410   case Instruction::UDiv:
1411     Out << "((";
1412     printSimpleType(Out, Ty, false);
1413     Out << ")(";
1414     return true;
1415   case Instruction::AShr:
1416   case Instruction::SRem:
1417   case Instruction::SDiv:
1418     Out << "((";
1419     printSimpleType(Out, Ty, true);
1420     Out << ")(";
1421     return true;
1422   default: break;
1423   }
1424   return false;
1425 }
1426
1427 // Write the operand with a cast to another type based on the Opcode being used.
1428 // This will be used in cases where an instruction has specific type
1429 // requirements (usually signedness) for its operands.
1430 void CWriter::writeOperandWithCast(Value* Operand, unsigned Opcode) {
1431
1432   // Extract the operand's type, we'll need it.
1433   const Type* OpTy = Operand->getType();
1434
1435   // Indicate whether to do the cast or not.
1436   bool shouldCast = false;
1437
1438   // Indicate whether the cast should be to a signed type or not.
1439   bool castIsSigned = false;
1440
1441   // Based on the Opcode for which this Operand is being written, determine
1442   // the new type to which the operand should be casted by setting the value
1443   // of OpTy. If we change OpTy, also set shouldCast to true.
1444   switch (Opcode) {
1445     default:
1446       // for most instructions, it doesn't matter
1447       break;
1448     case Instruction::Add:
1449     case Instruction::Sub:
1450     case Instruction::Mul:
1451       // We need to cast integer arithmetic so that it is always performed
1452       // as unsigned, to avoid undefined behavior on overflow.
1453     case Instruction::LShr:
1454     case Instruction::UDiv:
1455     case Instruction::URem: // Cast to unsigned first
1456       shouldCast = true;
1457       castIsSigned = false;
1458       break;
1459     case Instruction::GetElementPtr:
1460     case Instruction::AShr:
1461     case Instruction::SDiv:
1462     case Instruction::SRem: // Cast to signed first
1463       shouldCast = true;
1464       castIsSigned = true;
1465       break;
1466   }
1467
1468   // Write out the casted operand if we should, otherwise just write the
1469   // operand.
1470   if (shouldCast) {
1471     Out << "((";
1472     printSimpleType(Out, OpTy, castIsSigned);
1473     Out << ")";
1474     writeOperand(Operand);
1475     Out << ")";
1476   } else
1477     writeOperand(Operand);
1478 }
1479
1480 // Write the operand with a cast to another type based on the icmp predicate
1481 // being used.
1482 void CWriter::writeOperandWithCast(Value* Operand, const ICmpInst &Cmp) {
1483   // This has to do a cast to ensure the operand has the right signedness.
1484   // Also, if the operand is a pointer, we make sure to cast to an integer when
1485   // doing the comparison both for signedness and so that the C compiler doesn't
1486   // optimize things like "p < NULL" to false (p may contain an integer value
1487   // f.e.).
1488   bool shouldCast = Cmp.isRelational();
1489
1490   // Write out the casted operand if we should, otherwise just write the
1491   // operand.
1492   if (!shouldCast) {
1493     writeOperand(Operand);
1494     return;
1495   }
1496
1497   // Should this be a signed comparison?  If so, convert to signed.
1498   bool castIsSigned = Cmp.isSigned();
1499
1500   // If the operand was a pointer, convert to a large integer type.
1501   const Type* OpTy = Operand->getType();
1502   if (OpTy->isPointerTy())
1503     OpTy = TD->getIntPtrType(Operand->getContext());
1504
1505   Out << "((";
1506   printSimpleType(Out, OpTy, castIsSigned);
1507   Out << ")";
1508   writeOperand(Operand);
1509   Out << ")";
1510 }
1511
1512 // generateCompilerSpecificCode - This is where we add conditional compilation
1513 // directives to cater to specific compilers as need be.
1514 //
1515 static void generateCompilerSpecificCode(formatted_raw_ostream& Out,
1516                                          const TargetData *TD) {
1517   // Alloca is hard to get, and we don't want to include stdlib.h here.
1518   Out << "/* get a declaration for alloca */\n"
1519       << "#if defined(__CYGWIN__) || defined(__MINGW32__)\n"
1520       << "#define  alloca(x) __builtin_alloca((x))\n"
1521       << "#define _alloca(x) __builtin_alloca((x))\n"
1522       << "#elif defined(__APPLE__)\n"
1523       << "extern void *__builtin_alloca(unsigned long);\n"
1524       << "#define alloca(x) __builtin_alloca(x)\n"
1525       << "#define longjmp _longjmp\n"
1526       << "#define setjmp _setjmp\n"
1527       << "#elif defined(__sun__)\n"
1528       << "#if defined(__sparcv9)\n"
1529       << "extern void *__builtin_alloca(unsigned long);\n"
1530       << "#else\n"
1531       << "extern void *__builtin_alloca(unsigned int);\n"
1532       << "#endif\n"
1533       << "#define alloca(x) __builtin_alloca(x)\n"
1534       << "#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__arm__)\n"
1535       << "#define alloca(x) __builtin_alloca(x)\n"
1536       << "#elif defined(_MSC_VER)\n"
1537       << "#define inline _inline\n"
1538       << "#define alloca(x) _alloca(x)\n"
1539       << "#else\n"
1540       << "#include <alloca.h>\n"
1541       << "#endif\n\n";
1542
1543   // We output GCC specific attributes to preserve 'linkonce'ness on globals.
1544   // If we aren't being compiled with GCC, just drop these attributes.
1545   Out << "#ifndef __GNUC__  /* Can only support \"linkonce\" vars with GCC */\n"
1546       << "#define __attribute__(X)\n"
1547       << "#endif\n\n";
1548
1549   // On Mac OS X, "external weak" is spelled "__attribute__((weak_import))".
1550   Out << "#if defined(__GNUC__) && defined(__APPLE_CC__)\n"
1551       << "#define __EXTERNAL_WEAK__ __attribute__((weak_import))\n"
1552       << "#elif defined(__GNUC__)\n"
1553       << "#define __EXTERNAL_WEAK__ __attribute__((weak))\n"
1554       << "#else\n"
1555       << "#define __EXTERNAL_WEAK__\n"
1556       << "#endif\n\n";
1557
1558   // For now, turn off the weak linkage attribute on Mac OS X. (See above.)
1559   Out << "#if defined(__GNUC__) && defined(__APPLE_CC__)\n"
1560       << "#define __ATTRIBUTE_WEAK__\n"
1561       << "#elif defined(__GNUC__)\n"
1562       << "#define __ATTRIBUTE_WEAK__ __attribute__((weak))\n"
1563       << "#else\n"
1564       << "#define __ATTRIBUTE_WEAK__\n"
1565       << "#endif\n\n";
1566
1567   // Add hidden visibility support. FIXME: APPLE_CC?
1568   Out << "#if defined(__GNUC__)\n"
1569       << "#define __HIDDEN__ __attribute__((visibility(\"hidden\")))\n"
1570       << "#endif\n\n";
1571
1572   // Define NaN and Inf as GCC builtins if using GCC, as 0 otherwise
1573   // From the GCC documentation:
1574   //
1575   //   double __builtin_nan (const char *str)
1576   //
1577   // This is an implementation of the ISO C99 function nan.
1578   //
1579   // Since ISO C99 defines this function in terms of strtod, which we do
1580   // not implement, a description of the parsing is in order. The string is
1581   // parsed as by strtol; that is, the base is recognized by leading 0 or
1582   // 0x prefixes. The number parsed is placed in the significand such that
1583   // the least significant bit of the number is at the least significant
1584   // bit of the significand. The number is truncated to fit the significand
1585   // field provided. The significand is forced to be a quiet NaN.
1586   //
1587   // This function, if given a string literal, is evaluated early enough
1588   // that it is considered a compile-time constant.
1589   //
1590   //   float __builtin_nanf (const char *str)
1591   //
1592   // Similar to __builtin_nan, except the return type is float.
1593   //
1594   //   double __builtin_inf (void)
1595   //
1596   // Similar to __builtin_huge_val, except a warning is generated if the
1597   // target floating-point format does not support infinities. This
1598   // function is suitable for implementing the ISO C99 macro INFINITY.
1599   //
1600   //   float __builtin_inff (void)
1601   //
1602   // Similar to __builtin_inf, except the return type is float.
1603   Out << "#ifdef __GNUC__\n"
1604       << "#define LLVM_NAN(NanStr)   __builtin_nan(NanStr)   /* Double */\n"
1605       << "#define LLVM_NANF(NanStr)  __builtin_nanf(NanStr)  /* Float */\n"
1606       << "#define LLVM_NANS(NanStr)  __builtin_nans(NanStr)  /* Double */\n"
1607       << "#define LLVM_NANSF(NanStr) __builtin_nansf(NanStr) /* Float */\n"
1608       << "#define LLVM_INF           __builtin_inf()         /* Double */\n"
1609       << "#define LLVM_INFF          __builtin_inff()        /* Float */\n"
1610       << "#define LLVM_PREFETCH(addr,rw,locality) "
1611                               "__builtin_prefetch(addr,rw,locality)\n"
1612       << "#define __ATTRIBUTE_CTOR__ __attribute__((constructor))\n"
1613       << "#define __ATTRIBUTE_DTOR__ __attribute__((destructor))\n"
1614       << "#define LLVM_ASM           __asm__\n"
1615       << "#else\n"
1616       << "#define LLVM_NAN(NanStr)   ((double)0.0)           /* Double */\n"
1617       << "#define LLVM_NANF(NanStr)  0.0F                    /* Float */\n"
1618       << "#define LLVM_NANS(NanStr)  ((double)0.0)           /* Double */\n"
1619       << "#define LLVM_NANSF(NanStr) 0.0F                    /* Float */\n"
1620       << "#define LLVM_INF           ((double)0.0)           /* Double */\n"
1621       << "#define LLVM_INFF          0.0F                    /* Float */\n"
1622       << "#define LLVM_PREFETCH(addr,rw,locality)            /* PREFETCH */\n"
1623       << "#define __ATTRIBUTE_CTOR__\n"
1624       << "#define __ATTRIBUTE_DTOR__\n"
1625       << "#define LLVM_ASM(X)\n"
1626       << "#endif\n\n";
1627
1628   Out << "#if __GNUC__ < 4 /* Old GCC's, or compilers not GCC */ \n"
1629       << "#define __builtin_stack_save() 0   /* not implemented */\n"
1630       << "#define __builtin_stack_restore(X) /* noop */\n"
1631       << "#endif\n\n";
1632
1633   // Output typedefs for 128-bit integers. If these are needed with a
1634   // 32-bit target or with a C compiler that doesn't support mode(TI),
1635   // more drastic measures will be needed.
1636   Out << "#if __GNUC__ && __LP64__ /* 128-bit integer types */\n"
1637       << "typedef int __attribute__((mode(TI))) llvmInt128;\n"
1638       << "typedef unsigned __attribute__((mode(TI))) llvmUInt128;\n"
1639       << "#endif\n\n";
1640
1641   // Output target-specific code that should be inserted into main.
1642   Out << "#define CODE_FOR_MAIN() /* Any target-specific code for main()*/\n";
1643 }
1644
1645 /// FindStaticTors - Given a static ctor/dtor list, unpack its contents into
1646 /// the StaticTors set.
1647 static void FindStaticTors(GlobalVariable *GV, std::set<Function*> &StaticTors){
1648   ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer());
1649   if (!InitList) return;
1650
1651   for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i)
1652     if (ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i))){
1653       if (CS->getNumOperands() != 2) return;  // Not array of 2-element structs.
1654
1655       if (CS->getOperand(1)->isNullValue())
1656         return;  // Found a null terminator, exit printing.
1657       Constant *FP = CS->getOperand(1);
1658       if (ConstantExpr *CE = dyn_cast<ConstantExpr>(FP))
1659         if (CE->isCast())
1660           FP = CE->getOperand(0);
1661       if (Function *F = dyn_cast<Function>(FP))
1662         StaticTors.insert(F);
1663     }
1664 }
1665
1666 enum SpecialGlobalClass {
1667   NotSpecial = 0,
1668   GlobalCtors, GlobalDtors,
1669   NotPrinted
1670 };
1671
1672 /// getGlobalVariableClass - If this is a global that is specially recognized
1673 /// by LLVM, return a code that indicates how we should handle it.
1674 static SpecialGlobalClass getGlobalVariableClass(const GlobalVariable *GV) {
1675   // If this is a global ctors/dtors list, handle it now.
1676   if (GV->hasAppendingLinkage() && GV->use_empty()) {
1677     if (GV->getName() == "llvm.global_ctors")
1678       return GlobalCtors;
1679     else if (GV->getName() == "llvm.global_dtors")
1680       return GlobalDtors;
1681   }
1682
1683   // Otherwise, if it is other metadata, don't print it.  This catches things
1684   // like debug information.
1685   if (GV->getSection() == "llvm.metadata")
1686     return NotPrinted;
1687
1688   return NotSpecial;
1689 }
1690
1691 // PrintEscapedString - Print each character of the specified string, escaping
1692 // it if it is not printable or if it is an escape char.
1693 static void PrintEscapedString(const char *Str, unsigned Length,
1694                                raw_ostream &Out) {
1695   for (unsigned i = 0; i != Length; ++i) {
1696     unsigned char C = Str[i];
1697     if (isprint(C) && C != '\\' && C != '"')
1698       Out << C;
1699     else if (C == '\\')
1700       Out << "\\\\";
1701     else if (C == '\"')
1702       Out << "\\\"";
1703     else if (C == '\t')
1704       Out << "\\t";
1705     else
1706       Out << "\\x" << hexdigit(C >> 4) << hexdigit(C & 0x0F);
1707   }
1708 }
1709
1710 // PrintEscapedString - Print each character of the specified string, escaping
1711 // it if it is not printable or if it is an escape char.
1712 static void PrintEscapedString(const std::string &Str, raw_ostream &Out) {
1713   PrintEscapedString(Str.c_str(), Str.size(), Out);
1714 }
1715
1716 bool CWriter::doInitialization(Module &M) {
1717   FunctionPass::doInitialization(M);
1718
1719   // Initialize
1720   TheModule = &M;
1721
1722   TD = new TargetData(&M);
1723   IL = new IntrinsicLowering(*TD);
1724   IL->AddPrototypes(M);
1725
1726 #if 0
1727   std::string Triple = TheModule->getTargetTriple();
1728   if (Triple.empty())
1729     Triple = llvm::sys::getHostTriple();
1730
1731   std::string E;
1732   if (const Target *Match = TargetRegistry::lookupTarget(Triple, E))
1733     TAsm = Match->createAsmInfo(Triple);
1734 #endif
1735   TAsm = new CBEMCAsmInfo();
1736   TCtx = new MCContext(*TAsm);
1737   Mang = new Mangler(*TCtx);
1738
1739   // Keep track of which functions are static ctors/dtors so they can have
1740   // an attribute added to their prototypes.
1741   std::set<Function*> StaticCtors, StaticDtors;
1742   for (Module::global_iterator I = M.global_begin(), E = M.global_end();
1743        I != E; ++I) {
1744     switch (getGlobalVariableClass(I)) {
1745     default: break;
1746     case GlobalCtors:
1747       FindStaticTors(I, StaticCtors);
1748       break;
1749     case GlobalDtors:
1750       FindStaticTors(I, StaticDtors);
1751       break;
1752     }
1753   }
1754
1755   // get declaration for alloca
1756   Out << "/* Provide Declarations */\n";
1757   Out << "#include <stdarg.h>\n";      // Varargs support
1758   Out << "#include <setjmp.h>\n";      // Unwind support
1759   generateCompilerSpecificCode(Out, TD);
1760
1761   // Provide a definition for `bool' if not compiling with a C++ compiler.
1762   Out << "\n"
1763       << "#ifndef __cplusplus\ntypedef unsigned char bool;\n#endif\n"
1764
1765       << "\n\n/* Support for floating point constants */\n"
1766       << "typedef unsigned long long ConstantDoubleTy;\n"
1767       << "typedef unsigned int        ConstantFloatTy;\n"
1768       << "typedef struct { unsigned long long f1; unsigned short f2; "
1769          "unsigned short pad[3]; } ConstantFP80Ty;\n"
1770       // This is used for both kinds of 128-bit long double; meaning differs.
1771       << "typedef struct { unsigned long long f1; unsigned long long f2; }"
1772          " ConstantFP128Ty;\n"
1773       << "\n\n/* Global Declarations */\n";
1774
1775   // First output all the declarations for the program, because C requires
1776   // Functions & globals to be declared before they are used.
1777   //
1778   if (!M.getModuleInlineAsm().empty()) {
1779     Out << "/* Module asm statements */\n"
1780         << "asm(";
1781
1782     // Split the string into lines, to make it easier to read the .ll file.
1783     std::string Asm = M.getModuleInlineAsm();
1784     size_t CurPos = 0;
1785     size_t NewLine = Asm.find_first_of('\n', CurPos);
1786     while (NewLine != std::string::npos) {
1787       // We found a newline, print the portion of the asm string from the
1788       // last newline up to this newline.
1789       Out << "\"";
1790       PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.begin()+NewLine),
1791                          Out);
1792       Out << "\\n\"\n";
1793       CurPos = NewLine+1;
1794       NewLine = Asm.find_first_of('\n', CurPos);
1795     }
1796     Out << "\"";
1797     PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.end()), Out);
1798     Out << "\");\n"
1799         << "/* End Module asm statements */\n";
1800   }
1801
1802   // Loop over the symbol table, emitting all named constants...
1803   printModuleTypes(M.getTypeSymbolTable());
1804
1805   // Global variable declarations...
1806   if (!M.global_empty()) {
1807     Out << "\n/* External Global Variable Declarations */\n";
1808     for (Module::global_iterator I = M.global_begin(), E = M.global_end();
1809          I != E; ++I) {
1810
1811       if (I->hasExternalLinkage() || I->hasExternalWeakLinkage() ||
1812           I->hasCommonLinkage())
1813         Out << "extern ";
1814       else if (I->hasDLLImportLinkage())
1815         Out << "__declspec(dllimport) ";
1816       else
1817         continue; // Internal Global
1818
1819       // Thread Local Storage
1820       if (I->isThreadLocal())
1821         Out << "__thread ";
1822
1823       printType(Out, I->getType()->getElementType(), false, GetValueName(I));
1824
1825       if (I->hasExternalWeakLinkage())
1826          Out << " __EXTERNAL_WEAK__";
1827       Out << ";\n";
1828     }
1829   }
1830
1831   // Function declarations
1832   Out << "\n/* Function Declarations */\n";
1833   Out << "double fmod(double, double);\n";   // Support for FP rem
1834   Out << "float fmodf(float, float);\n";
1835   Out << "long double fmodl(long double, long double);\n";
1836
1837   for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
1838     // Don't print declarations for intrinsic functions.
1839     if (!I->isIntrinsic() && I->getName() != "setjmp" &&
1840         I->getName() != "longjmp" && I->getName() != "_setjmp") {
1841       if (I->hasExternalWeakLinkage())
1842         Out << "extern ";
1843       printFunctionSignature(I, true);
1844       if (I->hasWeakLinkage() || I->hasLinkOnceLinkage())
1845         Out << " __ATTRIBUTE_WEAK__";
1846       if (I->hasExternalWeakLinkage())
1847         Out << " __EXTERNAL_WEAK__";
1848       if (StaticCtors.count(I))
1849         Out << " __ATTRIBUTE_CTOR__";
1850       if (StaticDtors.count(I))
1851         Out << " __ATTRIBUTE_DTOR__";
1852       if (I->hasHiddenVisibility())
1853         Out << " __HIDDEN__";
1854
1855       if (I->hasName() && I->getName()[0] == 1)
1856         Out << " LLVM_ASM(\"" << I->getName().substr(1) << "\")";
1857
1858       Out << ";\n";
1859     }
1860   }
1861
1862   // Output the global variable declarations
1863   if (!M.global_empty()) {
1864     Out << "\n\n/* Global Variable Declarations */\n";
1865     for (Module::global_iterator I = M.global_begin(), E = M.global_end();
1866          I != E; ++I)
1867       if (!I->isDeclaration()) {
1868         // Ignore special globals, such as debug info.
1869         if (getGlobalVariableClass(I))
1870           continue;
1871
1872         if (I->hasLocalLinkage())
1873           Out << "static ";
1874         else
1875           Out << "extern ";
1876
1877         // Thread Local Storage
1878         if (I->isThreadLocal())
1879           Out << "__thread ";
1880
1881         printType(Out, I->getType()->getElementType(), false,
1882                   GetValueName(I));
1883
1884         if (I->hasLinkOnceLinkage())
1885           Out << " __attribute__((common))";
1886         else if (I->hasCommonLinkage())     // FIXME is this right?
1887           Out << " __ATTRIBUTE_WEAK__";
1888         else if (I->hasWeakLinkage())
1889           Out << " __ATTRIBUTE_WEAK__";
1890         else if (I->hasExternalWeakLinkage())
1891           Out << " __EXTERNAL_WEAK__";
1892         if (I->hasHiddenVisibility())
1893           Out << " __HIDDEN__";
1894         Out << ";\n";
1895       }
1896   }
1897
1898   // Output the global variable definitions and contents...
1899   if (!M.global_empty()) {
1900     Out << "\n\n/* Global Variable Definitions and Initialization */\n";
1901     for (Module::global_iterator I = M.global_begin(), E = M.global_end();
1902          I != E; ++I)
1903       if (!I->isDeclaration()) {
1904         // Ignore special globals, such as debug info.
1905         if (getGlobalVariableClass(I))
1906           continue;
1907
1908         if (I->hasLocalLinkage())
1909           Out << "static ";
1910         else if (I->hasDLLImportLinkage())
1911           Out << "__declspec(dllimport) ";
1912         else if (I->hasDLLExportLinkage())
1913           Out << "__declspec(dllexport) ";
1914
1915         // Thread Local Storage
1916         if (I->isThreadLocal())
1917           Out << "__thread ";
1918
1919         printType(Out, I->getType()->getElementType(), false,
1920                   GetValueName(I));
1921         if (I->hasLinkOnceLinkage())
1922           Out << " __attribute__((common))";
1923         else if (I->hasWeakLinkage())
1924           Out << " __ATTRIBUTE_WEAK__";
1925         else if (I->hasCommonLinkage())
1926           Out << " __ATTRIBUTE_WEAK__";
1927
1928         if (I->hasHiddenVisibility())
1929           Out << " __HIDDEN__";
1930
1931         // If the initializer is not null, emit the initializer.  If it is null,
1932         // we try to avoid emitting large amounts of zeros.  The problem with
1933         // this, however, occurs when the variable has weak linkage.  In this
1934         // case, the assembler will complain about the variable being both weak
1935         // and common, so we disable this optimization.
1936         // FIXME common linkage should avoid this problem.
1937         if (!I->getInitializer()->isNullValue()) {
1938           Out << " = " ;
1939           writeOperand(I->getInitializer(), true);
1940         } else if (I->hasWeakLinkage()) {
1941           // We have to specify an initializer, but it doesn't have to be
1942           // complete.  If the value is an aggregate, print out { 0 }, and let
1943           // the compiler figure out the rest of the zeros.
1944           Out << " = " ;
1945           if (I->getInitializer()->getType()->isStructTy() ||
1946               I->getInitializer()->getType()->isVectorTy()) {
1947             Out << "{ 0 }";
1948           } else if (I->getInitializer()->getType()->isArrayTy()) {
1949             // As with structs and vectors, but with an extra set of braces
1950             // because arrays are wrapped in structs.
1951             Out << "{ { 0 } }";
1952           } else {
1953             // Just print it out normally.
1954             writeOperand(I->getInitializer(), true);
1955           }
1956         }
1957         Out << ";\n";
1958       }
1959   }
1960
1961   if (!M.empty())
1962     Out << "\n\n/* Function Bodies */\n";
1963
1964   // Emit some helper functions for dealing with FCMP instruction's
1965   // predicates
1966   Out << "static inline int llvm_fcmp_ord(double X, double Y) { ";
1967   Out << "return X == X && Y == Y; }\n";
1968   Out << "static inline int llvm_fcmp_uno(double X, double Y) { ";
1969   Out << "return X != X || Y != Y; }\n";
1970   Out << "static inline int llvm_fcmp_ueq(double X, double Y) { ";
1971   Out << "return X == Y || llvm_fcmp_uno(X, Y); }\n";
1972   Out << "static inline int llvm_fcmp_une(double X, double Y) { ";
1973   Out << "return X != Y; }\n";
1974   Out << "static inline int llvm_fcmp_ult(double X, double Y) { ";
1975   Out << "return X <  Y || llvm_fcmp_uno(X, Y); }\n";
1976   Out << "static inline int llvm_fcmp_ugt(double X, double Y) { ";
1977   Out << "return X >  Y || llvm_fcmp_uno(X, Y); }\n";
1978   Out << "static inline int llvm_fcmp_ule(double X, double Y) { ";
1979   Out << "return X <= Y || llvm_fcmp_uno(X, Y); }\n";
1980   Out << "static inline int llvm_fcmp_uge(double X, double Y) { ";
1981   Out << "return X >= Y || llvm_fcmp_uno(X, Y); }\n";
1982   Out << "static inline int llvm_fcmp_oeq(double X, double Y) { ";
1983   Out << "return X == Y ; }\n";
1984   Out << "static inline int llvm_fcmp_one(double X, double Y) { ";
1985   Out << "return X != Y && llvm_fcmp_ord(X, Y); }\n";
1986   Out << "static inline int llvm_fcmp_olt(double X, double Y) { ";
1987   Out << "return X <  Y ; }\n";
1988   Out << "static inline int llvm_fcmp_ogt(double X, double Y) { ";
1989   Out << "return X >  Y ; }\n";
1990   Out << "static inline int llvm_fcmp_ole(double X, double Y) { ";
1991   Out << "return X <= Y ; }\n";
1992   Out << "static inline int llvm_fcmp_oge(double X, double Y) { ";
1993   Out << "return X >= Y ; }\n";
1994   return false;
1995 }
1996
1997
1998 /// Output all floating point constants that cannot be printed accurately...
1999 void CWriter::printFloatingPointConstants(Function &F) {
2000   // Scan the module for floating point constants.  If any FP constant is used
2001   // in the function, we want to redirect it here so that we do not depend on
2002   // the precision of the printed form, unless the printed form preserves
2003   // precision.
2004   //
2005   for (constant_iterator I = constant_begin(&F), E = constant_end(&F);
2006        I != E; ++I)
2007     printFloatingPointConstants(*I);
2008
2009   Out << '\n';
2010 }
2011
2012 void CWriter::printFloatingPointConstants(const Constant *C) {
2013   // If this is a constant expression, recursively check for constant fp values.
2014   if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
2015     for (unsigned i = 0, e = CE->getNumOperands(); i != e; ++i)
2016       printFloatingPointConstants(CE->getOperand(i));
2017     return;
2018   }
2019
2020   // Otherwise, check for a FP constant that we need to print.
2021   const ConstantFP *FPC = dyn_cast<ConstantFP>(C);
2022   if (FPC == 0 ||
2023       // Do not put in FPConstantMap if safe.
2024       isFPCSafeToPrint(FPC) ||
2025       // Already printed this constant?
2026       FPConstantMap.count(FPC))
2027     return;
2028
2029   FPConstantMap[FPC] = FPCounter;  // Number the FP constants
2030
2031   if (FPC->getType() == Type::getDoubleTy(FPC->getContext())) {
2032     double Val = FPC->getValueAPF().convertToDouble();
2033     uint64_t i = FPC->getValueAPF().bitcastToAPInt().getZExtValue();
2034     Out << "static const ConstantDoubleTy FPConstant" << FPCounter++
2035     << " = 0x" << utohexstr(i)
2036     << "ULL;    /* " << Val << " */\n";
2037   } else if (FPC->getType() == Type::getFloatTy(FPC->getContext())) {
2038     float Val = FPC->getValueAPF().convertToFloat();
2039     uint32_t i = (uint32_t)FPC->getValueAPF().bitcastToAPInt().
2040     getZExtValue();
2041     Out << "static const ConstantFloatTy FPConstant" << FPCounter++
2042     << " = 0x" << utohexstr(i)
2043     << "U;    /* " << Val << " */\n";
2044   } else if (FPC->getType() == Type::getX86_FP80Ty(FPC->getContext())) {
2045     // api needed to prevent premature destruction
2046     APInt api = FPC->getValueAPF().bitcastToAPInt();
2047     const uint64_t *p = api.getRawData();
2048     Out << "static const ConstantFP80Ty FPConstant" << FPCounter++
2049     << " = { 0x" << utohexstr(p[0])
2050     << "ULL, 0x" << utohexstr((uint16_t)p[1]) << ",{0,0,0}"
2051     << "}; /* Long double constant */\n";
2052   } else if (FPC->getType() == Type::getPPC_FP128Ty(FPC->getContext()) ||
2053              FPC->getType() == Type::getFP128Ty(FPC->getContext())) {
2054     APInt api = FPC->getValueAPF().bitcastToAPInt();
2055     const uint64_t *p = api.getRawData();
2056     Out << "static const ConstantFP128Ty FPConstant" << FPCounter++
2057     << " = { 0x"
2058     << utohexstr(p[0]) << ", 0x" << utohexstr(p[1])
2059     << "}; /* Long double constant */\n";
2060
2061   } else {
2062     llvm_unreachable("Unknown float type!");
2063   }
2064 }
2065
2066
2067
2068 /// printSymbolTable - Run through symbol table looking for type names.  If a
2069 /// type name is found, emit its declaration...
2070 ///
2071 void CWriter::printModuleTypes(const TypeSymbolTable &TST) {
2072   Out << "/* Helper union for bitcasts */\n";
2073   Out << "typedef union {\n";
2074   Out << "  unsigned int Int32;\n";
2075   Out << "  unsigned long long Int64;\n";
2076   Out << "  float Float;\n";
2077   Out << "  double Double;\n";
2078   Out << "} llvmBitCastUnion;\n";
2079
2080   // We are only interested in the type plane of the symbol table.
2081   TypeSymbolTable::const_iterator I   = TST.begin();
2082   TypeSymbolTable::const_iterator End = TST.end();
2083
2084   // If there are no type names, exit early.
2085   if (I == End) return;
2086
2087   // Print out forward declarations for structure types before anything else!
2088   Out << "/* Structure forward decls */\n";
2089   for (; I != End; ++I) {
2090     std::string Name = "struct " + CBEMangle("l_"+I->first);
2091     Out << Name << ";\n";
2092     TypeNames.insert(std::make_pair(I->second, Name));
2093   }
2094
2095   Out << '\n';
2096
2097   // Now we can print out typedefs.  Above, we guaranteed that this can only be
2098   // for struct or opaque types.
2099   Out << "/* Typedefs */\n";
2100   for (I = TST.begin(); I != End; ++I) {
2101     std::string Name = CBEMangle("l_"+I->first);
2102     Out << "typedef ";
2103     printType(Out, I->second, false, Name);
2104     Out << ";\n";
2105   }
2106
2107   Out << '\n';
2108
2109   // Keep track of which structures have been printed so far...
2110   std::set<const Type *> StructPrinted;
2111
2112   // Loop over all structures then push them into the stack so they are
2113   // printed in the correct order.
2114   //
2115   Out << "/* Structure contents */\n";
2116   for (I = TST.begin(); I != End; ++I)
2117     if (I->second->isStructTy() || I->second->isArrayTy())
2118       // Only print out used types!
2119       printContainedStructs(I->second, StructPrinted);
2120 }
2121
2122 // Push the struct onto the stack and recursively push all structs
2123 // this one depends on.
2124 //
2125 // TODO:  Make this work properly with vector types
2126 //
2127 void CWriter::printContainedStructs(const Type *Ty,
2128                                     std::set<const Type*> &StructPrinted) {
2129   // Don't walk through pointers.
2130   if (Ty->isPointerTy() || Ty->isPrimitiveType() || Ty->isIntegerTy())
2131     return;
2132
2133   // Print all contained types first.
2134   for (Type::subtype_iterator I = Ty->subtype_begin(),
2135        E = Ty->subtype_end(); I != E; ++I)
2136     printContainedStructs(*I, StructPrinted);
2137
2138   if (Ty->isStructTy() || Ty->isArrayTy()) {
2139     // Check to see if we have already printed this struct.
2140     if (StructPrinted.insert(Ty).second) {
2141       // Print structure type out.
2142       std::string Name = TypeNames[Ty];
2143       printType(Out, Ty, false, Name, true);
2144       Out << ";\n\n";
2145     }
2146   }
2147 }
2148
2149 void CWriter::printFunctionSignature(const Function *F, bool Prototype) {
2150   /// isStructReturn - Should this function actually return a struct by-value?
2151   bool isStructReturn = F->hasStructRetAttr();
2152
2153   if (F->hasLocalLinkage()) Out << "static ";
2154   if (F->hasDLLImportLinkage()) Out << "__declspec(dllimport) ";
2155   if (F->hasDLLExportLinkage()) Out << "__declspec(dllexport) ";
2156   switch (F->getCallingConv()) {
2157    case CallingConv::X86_StdCall:
2158     Out << "__attribute__((stdcall)) ";
2159     break;
2160    case CallingConv::X86_FastCall:
2161     Out << "__attribute__((fastcall)) ";
2162     break;
2163    default:
2164     break;
2165   }
2166
2167   // Loop over the arguments, printing them...
2168   const FunctionType *FT = cast<FunctionType>(F->getFunctionType());
2169   const AttrListPtr &PAL = F->getAttributes();
2170
2171   std::string tstr;
2172   raw_string_ostream FunctionInnards(tstr);
2173
2174   // Print out the name...
2175   FunctionInnards << GetValueName(F) << '(';
2176
2177   bool PrintedArg = false;
2178   if (!F->isDeclaration()) {
2179     if (!F->arg_empty()) {
2180       Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();
2181       unsigned Idx = 1;
2182
2183       // If this is a struct-return function, don't print the hidden
2184       // struct-return argument.
2185       if (isStructReturn) {
2186         assert(I != E && "Invalid struct return function!");
2187         ++I;
2188         ++Idx;
2189       }
2190
2191       std::string ArgName;
2192       for (; I != E; ++I) {
2193         if (PrintedArg) FunctionInnards << ", ";
2194         if (I->hasName() || !Prototype)
2195           ArgName = GetValueName(I);
2196         else
2197           ArgName = "";
2198         const Type *ArgTy = I->getType();
2199         if (PAL.paramHasAttr(Idx, Attribute::ByVal)) {
2200           ArgTy = cast<PointerType>(ArgTy)->getElementType();
2201           ByValParams.insert(I);
2202         }
2203         printType(FunctionInnards, ArgTy,
2204             /*isSigned=*/PAL.paramHasAttr(Idx, Attribute::SExt),
2205             ArgName);
2206         PrintedArg = true;
2207         ++Idx;
2208       }
2209     }
2210   } else {
2211     // Loop over the arguments, printing them.
2212     FunctionType::param_iterator I = FT->param_begin(), E = FT->param_end();
2213     unsigned Idx = 1;
2214
2215     // If this is a struct-return function, don't print the hidden
2216     // struct-return argument.
2217     if (isStructReturn) {
2218       assert(I != E && "Invalid struct return function!");
2219       ++I;
2220       ++Idx;
2221     }
2222
2223     for (; I != E; ++I) {
2224       if (PrintedArg) FunctionInnards << ", ";
2225       const Type *ArgTy = *I;
2226       if (PAL.paramHasAttr(Idx, Attribute::ByVal)) {
2227         assert(ArgTy->isPointerTy());
2228         ArgTy = cast<PointerType>(ArgTy)->getElementType();
2229       }
2230       printType(FunctionInnards, ArgTy,
2231              /*isSigned=*/PAL.paramHasAttr(Idx, Attribute::SExt));
2232       PrintedArg = true;
2233       ++Idx;
2234     }
2235   }
2236
2237   // Finish printing arguments... if this is a vararg function, print the ...,
2238   // unless there are no known types, in which case, we just emit ().
2239   //
2240   if (FT->isVarArg() && PrintedArg) {
2241     if (PrintedArg) FunctionInnards << ", ";
2242     FunctionInnards << "...";  // Output varargs portion of signature!
2243   } else if (!FT->isVarArg() && !PrintedArg) {
2244     FunctionInnards << "void"; // ret() -> ret(void) in C.
2245   }
2246   FunctionInnards << ')';
2247
2248   // Get the return tpe for the function.
2249   const Type *RetTy;
2250   if (!isStructReturn)
2251     RetTy = F->getReturnType();
2252   else {
2253     // If this is a struct-return function, print the struct-return type.
2254     RetTy = cast<PointerType>(FT->getParamType(0))->getElementType();
2255   }
2256
2257   // Print out the return type and the signature built above.
2258   printType(Out, RetTy,
2259             /*isSigned=*/PAL.paramHasAttr(0, Attribute::SExt),
2260             FunctionInnards.str());
2261 }
2262
2263 static inline bool isFPIntBitCast(const Instruction &I) {
2264   if (!isa<BitCastInst>(I))
2265     return false;
2266   const Type *SrcTy = I.getOperand(0)->getType();
2267   const Type *DstTy = I.getType();
2268   return (SrcTy->isFloatingPointTy() && DstTy->isIntegerTy()) ||
2269          (DstTy->isFloatingPointTy() && SrcTy->isIntegerTy());
2270 }
2271
2272 void CWriter::printFunction(Function &F) {
2273   /// isStructReturn - Should this function actually return a struct by-value?
2274   bool isStructReturn = F.hasStructRetAttr();
2275
2276   printFunctionSignature(&F, false);
2277   Out << " {\n";
2278
2279   // If this is a struct return function, handle the result with magic.
2280   if (isStructReturn) {
2281     const Type *StructTy =
2282       cast<PointerType>(F.arg_begin()->getType())->getElementType();
2283     Out << "  ";
2284     printType(Out, StructTy, false, "StructReturn");
2285     Out << ";  /* Struct return temporary */\n";
2286
2287     Out << "  ";
2288     printType(Out, F.arg_begin()->getType(), false,
2289               GetValueName(F.arg_begin()));
2290     Out << " = &StructReturn;\n";
2291   }
2292
2293   bool PrintedVar = false;
2294
2295   // print local variable information for the function
2296   for (inst_iterator I = inst_begin(&F), E = inst_end(&F); I != E; ++I) {
2297     if (const AllocaInst *AI = isDirectAlloca(&*I)) {
2298       Out << "  ";
2299       printType(Out, AI->getAllocatedType(), false, GetValueName(AI));
2300       Out << ";    /* Address-exposed local */\n";
2301       PrintedVar = true;
2302     } else if (I->getType() != Type::getVoidTy(F.getContext()) &&
2303                !isInlinableInst(*I)) {
2304       Out << "  ";
2305       printType(Out, I->getType(), false, GetValueName(&*I));
2306       Out << ";\n";
2307
2308       if (isa<PHINode>(*I)) {  // Print out PHI node temporaries as well...
2309         Out << "  ";
2310         printType(Out, I->getType(), false,
2311                   GetValueName(&*I)+"__PHI_TEMPORARY");
2312         Out << ";\n";
2313       }
2314       PrintedVar = true;
2315     }
2316     // We need a temporary for the BitCast to use so it can pluck a value out
2317     // of a union to do the BitCast. This is separate from the need for a
2318     // variable to hold the result of the BitCast.
2319     if (isFPIntBitCast(*I)) {
2320       Out << "  llvmBitCastUnion " << GetValueName(&*I)
2321           << "__BITCAST_TEMPORARY;\n";
2322       PrintedVar = true;
2323     }
2324   }
2325
2326   if (PrintedVar)
2327     Out << '\n';
2328
2329   if (F.hasExternalLinkage() && F.getName() == "main")
2330     Out << "  CODE_FOR_MAIN();\n";
2331
2332   // print the basic blocks
2333   for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
2334     if (Loop *L = LI->getLoopFor(BB)) {
2335       if (L->getHeader() == BB && L->getParentLoop() == 0)
2336         printLoop(L);
2337     } else {
2338       printBasicBlock(BB);
2339     }
2340   }
2341
2342   Out << "}\n\n";
2343 }
2344
2345 void CWriter::printLoop(Loop *L) {
2346   Out << "  do {     /* Syntactic loop '" << L->getHeader()->getName()
2347       << "' to make GCC happy */\n";
2348   for (unsigned i = 0, e = L->getBlocks().size(); i != e; ++i) {
2349     BasicBlock *BB = L->getBlocks()[i];
2350     Loop *BBLoop = LI->getLoopFor(BB);
2351     if (BBLoop == L)
2352       printBasicBlock(BB);
2353     else if (BB == BBLoop->getHeader() && BBLoop->getParentLoop() == L)
2354       printLoop(BBLoop);
2355   }
2356   Out << "  } while (1); /* end of syntactic loop '"
2357       << L->getHeader()->getName() << "' */\n";
2358 }
2359
2360 void CWriter::printBasicBlock(BasicBlock *BB) {
2361
2362   // Don't print the label for the basic block if there are no uses, or if
2363   // the only terminator use is the predecessor basic block's terminator.
2364   // We have to scan the use list because PHI nodes use basic blocks too but
2365   // do not require a label to be generated.
2366   //
2367   bool NeedsLabel = false;
2368   for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
2369     if (isGotoCodeNecessary(*PI, BB)) {
2370       NeedsLabel = true;
2371       break;
2372     }
2373
2374   if (NeedsLabel) Out << GetValueName(BB) << ":\n";
2375
2376   // Output all of the instructions in the basic block...
2377   for (BasicBlock::iterator II = BB->begin(), E = --BB->end(); II != E;
2378        ++II) {
2379     if (!isInlinableInst(*II) && !isDirectAlloca(II)) {
2380       if (II->getType() != Type::getVoidTy(BB->getContext()) &&
2381           !isInlineAsm(*II))
2382         outputLValue(II);
2383       else
2384         Out << "  ";
2385       writeInstComputationInline(*II);
2386       Out << ";\n";
2387     }
2388   }
2389
2390   // Don't emit prefix or suffix for the terminator.
2391   visit(*BB->getTerminator());
2392 }
2393
2394
2395 // Specific Instruction type classes... note that all of the casts are
2396 // necessary because we use the instruction classes as opaque types...
2397 //
2398 void CWriter::visitReturnInst(ReturnInst &I) {
2399   // If this is a struct return function, return the temporary struct.
2400   bool isStructReturn = I.getParent()->getParent()->hasStructRetAttr();
2401
2402   if (isStructReturn) {
2403     Out << "  return StructReturn;\n";
2404     return;
2405   }
2406
2407   // Don't output a void return if this is the last basic block in the function
2408   if (I.getNumOperands() == 0 &&
2409       &*--I.getParent()->getParent()->end() == I.getParent() &&
2410       !I.getParent()->size() == 1) {
2411     return;
2412   }
2413
2414   if (I.getNumOperands() > 1) {
2415     Out << "  {\n";
2416     Out << "    ";
2417     printType(Out, I.getParent()->getParent()->getReturnType());
2418     Out << "   llvm_cbe_mrv_temp = {\n";
2419     for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) {
2420       Out << "      ";
2421       writeOperand(I.getOperand(i));
2422       if (i != e - 1)
2423         Out << ",";
2424       Out << "\n";
2425     }
2426     Out << "    };\n";
2427     Out << "    return llvm_cbe_mrv_temp;\n";
2428     Out << "  }\n";
2429     return;
2430   }
2431
2432   Out << "  return";
2433   if (I.getNumOperands()) {
2434     Out << ' ';
2435     writeOperand(I.getOperand(0));
2436   }
2437   Out << ";\n";
2438 }
2439
2440 void CWriter::visitSwitchInst(SwitchInst &SI) {
2441
2442   Out << "  switch (";
2443   writeOperand(SI.getOperand(0));
2444   Out << ") {\n  default:\n";
2445   printPHICopiesForSuccessor (SI.getParent(), SI.getDefaultDest(), 2);
2446   printBranchToBlock(SI.getParent(), SI.getDefaultDest(), 2);
2447   Out << ";\n";
2448   for (unsigned i = 2, e = SI.getNumOperands(); i != e; i += 2) {
2449     Out << "  case ";
2450     writeOperand(SI.getOperand(i));
2451     Out << ":\n";
2452     BasicBlock *Succ = cast<BasicBlock>(SI.getOperand(i+1));
2453     printPHICopiesForSuccessor (SI.getParent(), Succ, 2);
2454     printBranchToBlock(SI.getParent(), Succ, 2);
2455     if (Function::iterator(Succ) == llvm::next(Function::iterator(SI.getParent())))
2456       Out << "    break;\n";
2457   }
2458   Out << "  }\n";
2459 }
2460
2461 void CWriter::visitIndirectBrInst(IndirectBrInst &IBI) {
2462   Out << "  goto *(void*)(";
2463   writeOperand(IBI.getOperand(0));
2464   Out << ");\n";
2465 }
2466
2467 void CWriter::visitUnreachableInst(UnreachableInst &I) {
2468   Out << "  /*UNREACHABLE*/;\n";
2469 }
2470
2471 bool CWriter::isGotoCodeNecessary(BasicBlock *From, BasicBlock *To) {
2472   /// FIXME: This should be reenabled, but loop reordering safe!!
2473   return true;
2474
2475   if (llvm::next(Function::iterator(From)) != Function::iterator(To))
2476     return true;  // Not the direct successor, we need a goto.
2477
2478   //isa<SwitchInst>(From->getTerminator())
2479
2480   if (LI->getLoopFor(From) != LI->getLoopFor(To))
2481     return true;
2482   return false;
2483 }
2484
2485 void CWriter::printPHICopiesForSuccessor (BasicBlock *CurBlock,
2486                                           BasicBlock *Successor,
2487                                           unsigned Indent) {
2488   for (BasicBlock::iterator I = Successor->begin(); isa<PHINode>(I); ++I) {
2489     PHINode *PN = cast<PHINode>(I);
2490     // Now we have to do the printing.
2491     Value *IV = PN->getIncomingValueForBlock(CurBlock);
2492     if (!isa<UndefValue>(IV)) {
2493       Out << std::string(Indent, ' ');
2494       Out << "  " << GetValueName(I) << "__PHI_TEMPORARY = ";
2495       writeOperand(IV);
2496       Out << ";   /* for PHI node */\n";
2497     }
2498   }
2499 }
2500
2501 void CWriter::printBranchToBlock(BasicBlock *CurBB, BasicBlock *Succ,
2502                                  unsigned Indent) {
2503   if (isGotoCodeNecessary(CurBB, Succ)) {
2504     Out << std::string(Indent, ' ') << "  goto ";
2505     writeOperand(Succ);
2506     Out << ";\n";
2507   }
2508 }
2509
2510 // Branch instruction printing - Avoid printing out a branch to a basic block
2511 // that immediately succeeds the current one.
2512 //
2513 void CWriter::visitBranchInst(BranchInst &I) {
2514
2515   if (I.isConditional()) {
2516     if (isGotoCodeNecessary(I.getParent(), I.getSuccessor(0))) {
2517       Out << "  if (";
2518       writeOperand(I.getCondition());
2519       Out << ") {\n";
2520
2521       printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(0), 2);
2522       printBranchToBlock(I.getParent(), I.getSuccessor(0), 2);
2523
2524       if (isGotoCodeNecessary(I.getParent(), I.getSuccessor(1))) {
2525         Out << "  } else {\n";
2526         printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(1), 2);
2527         printBranchToBlock(I.getParent(), I.getSuccessor(1), 2);
2528       }
2529     } else {
2530       // First goto not necessary, assume second one is...
2531       Out << "  if (!";
2532       writeOperand(I.getCondition());
2533       Out << ") {\n";
2534
2535       printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(1), 2);
2536       printBranchToBlock(I.getParent(), I.getSuccessor(1), 2);
2537     }
2538
2539     Out << "  }\n";
2540   } else {
2541     printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(0), 0);
2542     printBranchToBlock(I.getParent(), I.getSuccessor(0), 0);
2543   }
2544   Out << "\n";
2545 }
2546
2547 // PHI nodes get copied into temporary values at the end of predecessor basic
2548 // blocks.  We now need to copy these temporary values into the REAL value for
2549 // the PHI.
2550 void CWriter::visitPHINode(PHINode &I) {
2551   writeOperand(&I);
2552   Out << "__PHI_TEMPORARY";
2553 }
2554
2555
2556 void CWriter::visitBinaryOperator(Instruction &I) {
2557   // binary instructions, shift instructions, setCond instructions.
2558   assert(!I.getType()->isPointerTy());
2559
2560   // We must cast the results of binary operations which might be promoted.
2561   bool needsCast = false;
2562   if ((I.getType() == Type::getInt8Ty(I.getContext())) ||
2563       (I.getType() == Type::getInt16Ty(I.getContext()))
2564       || (I.getType() == Type::getFloatTy(I.getContext()))) {
2565     needsCast = true;
2566     Out << "((";
2567     printType(Out, I.getType(), false);
2568     Out << ")(";
2569   }
2570
2571   // If this is a negation operation, print it out as such.  For FP, we don't
2572   // want to print "-0.0 - X".
2573   if (BinaryOperator::isNeg(&I)) {
2574     Out << "-(";
2575     writeOperand(BinaryOperator::getNegArgument(cast<BinaryOperator>(&I)));
2576     Out << ")";
2577   } else if (BinaryOperator::isFNeg(&I)) {
2578     Out << "-(";
2579     writeOperand(BinaryOperator::getFNegArgument(cast<BinaryOperator>(&I)));
2580     Out << ")";
2581   } else if (I.getOpcode() == Instruction::FRem) {
2582     // Output a call to fmod/fmodf instead of emitting a%b
2583     if (I.getType() == Type::getFloatTy(I.getContext()))
2584       Out << "fmodf(";
2585     else if (I.getType() == Type::getDoubleTy(I.getContext()))
2586       Out << "fmod(";
2587     else  // all 3 flavors of long double
2588       Out << "fmodl(";
2589     writeOperand(I.getOperand(0));
2590     Out << ", ";
2591     writeOperand(I.getOperand(1));
2592     Out << ")";
2593   } else {
2594
2595     // Write out the cast of the instruction's value back to the proper type
2596     // if necessary.
2597     bool NeedsClosingParens = writeInstructionCast(I);
2598
2599     // Certain instructions require the operand to be forced to a specific type
2600     // so we use writeOperandWithCast here instead of writeOperand. Similarly
2601     // below for operand 1
2602     writeOperandWithCast(I.getOperand(0), I.getOpcode());
2603
2604     switch (I.getOpcode()) {
2605     case Instruction::Add:
2606     case Instruction::FAdd: Out << " + "; break;
2607     case Instruction::Sub:
2608     case Instruction::FSub: Out << " - "; break;
2609     case Instruction::Mul:
2610     case Instruction::FMul: Out << " * "; break;
2611     case Instruction::URem:
2612     case Instruction::SRem:
2613     case Instruction::FRem: Out << " % "; break;
2614     case Instruction::UDiv:
2615     case Instruction::SDiv:
2616     case Instruction::FDiv: Out << " / "; break;
2617     case Instruction::And:  Out << " & "; break;
2618     case Instruction::Or:   Out << " | "; break;
2619     case Instruction::Xor:  Out << " ^ "; break;
2620     case Instruction::Shl : Out << " << "; break;
2621     case Instruction::LShr:
2622     case Instruction::AShr: Out << " >> "; break;
2623     default:
2624 #ifndef NDEBUG
2625        errs() << "Invalid operator type!" << I;
2626 #endif
2627        llvm_unreachable(0);
2628     }
2629
2630     writeOperandWithCast(I.getOperand(1), I.getOpcode());
2631     if (NeedsClosingParens)
2632       Out << "))";
2633   }
2634
2635   if (needsCast) {
2636     Out << "))";
2637   }
2638 }
2639
2640 void CWriter::visitICmpInst(ICmpInst &I) {
2641   // We must cast the results of icmp which might be promoted.
2642   bool needsCast = false;
2643
2644   // Write out the cast of the instruction's value back to the proper type
2645   // if necessary.
2646   bool NeedsClosingParens = writeInstructionCast(I);
2647
2648   // Certain icmp predicate require the operand to be forced to a specific type
2649   // so we use writeOperandWithCast here instead of writeOperand. Similarly
2650   // below for operand 1
2651   writeOperandWithCast(I.getOperand(0), I);
2652
2653   switch (I.getPredicate()) {
2654   case ICmpInst::ICMP_EQ:  Out << " == "; break;
2655   case ICmpInst::ICMP_NE:  Out << " != "; break;
2656   case ICmpInst::ICMP_ULE:
2657   case ICmpInst::ICMP_SLE: Out << " <= "; break;
2658   case ICmpInst::ICMP_UGE:
2659   case ICmpInst::ICMP_SGE: Out << " >= "; break;
2660   case ICmpInst::ICMP_ULT:
2661   case ICmpInst::ICMP_SLT: Out << " < "; break;
2662   case ICmpInst::ICMP_UGT:
2663   case ICmpInst::ICMP_SGT: Out << " > "; break;
2664   default:
2665 #ifndef NDEBUG
2666     errs() << "Invalid icmp predicate!" << I;
2667 #endif
2668     llvm_unreachable(0);
2669   }
2670
2671   writeOperandWithCast(I.getOperand(1), I);
2672   if (NeedsClosingParens)
2673     Out << "))";
2674
2675   if (needsCast) {
2676     Out << "))";
2677   }
2678 }
2679
2680 void CWriter::visitFCmpInst(FCmpInst &I) {
2681   if (I.getPredicate() == FCmpInst::FCMP_FALSE) {
2682     Out << "0";
2683     return;
2684   }
2685   if (I.getPredicate() == FCmpInst::FCMP_TRUE) {
2686     Out << "1";
2687     return;
2688   }
2689
2690   const char* op = 0;
2691   switch (I.getPredicate()) {
2692   default: llvm_unreachable("Illegal FCmp predicate");
2693   case FCmpInst::FCMP_ORD: op = "ord"; break;
2694   case FCmpInst::FCMP_UNO: op = "uno"; break;
2695   case FCmpInst::FCMP_UEQ: op = "ueq"; break;
2696   case FCmpInst::FCMP_UNE: op = "une"; break;
2697   case FCmpInst::FCMP_ULT: op = "ult"; break;
2698   case FCmpInst::FCMP_ULE: op = "ule"; break;
2699   case FCmpInst::FCMP_UGT: op = "ugt"; break;
2700   case FCmpInst::FCMP_UGE: op = "uge"; break;
2701   case FCmpInst::FCMP_OEQ: op = "oeq"; break;
2702   case FCmpInst::FCMP_ONE: op = "one"; break;
2703   case FCmpInst::FCMP_OLT: op = "olt"; break;
2704   case FCmpInst::FCMP_OLE: op = "ole"; break;
2705   case FCmpInst::FCMP_OGT: op = "ogt"; break;
2706   case FCmpInst::FCMP_OGE: op = "oge"; break;
2707   }
2708
2709   Out << "llvm_fcmp_" << op << "(";
2710   // Write the first operand
2711   writeOperand(I.getOperand(0));
2712   Out << ", ";
2713   // Write the second operand
2714   writeOperand(I.getOperand(1));
2715   Out << ")";
2716 }
2717
2718 static const char * getFloatBitCastField(const Type *Ty) {
2719   switch (Ty->getTypeID()) {
2720     default: llvm_unreachable("Invalid Type");
2721     case Type::FloatTyID:  return "Float";
2722     case Type::DoubleTyID: return "Double";
2723     case Type::IntegerTyID: {
2724       unsigned NumBits = cast<IntegerType>(Ty)->getBitWidth();
2725       if (NumBits <= 32)
2726         return "Int32";
2727       else
2728         return "Int64";
2729     }
2730   }
2731 }
2732
2733 void CWriter::visitCastInst(CastInst &I) {
2734   const Type *DstTy = I.getType();
2735   const Type *SrcTy = I.getOperand(0)->getType();
2736   if (isFPIntBitCast(I)) {
2737     Out << '(';
2738     // These int<->float and long<->double casts need to be handled specially
2739     Out << GetValueName(&I) << "__BITCAST_TEMPORARY."
2740         << getFloatBitCastField(I.getOperand(0)->getType()) << " = ";
2741     writeOperand(I.getOperand(0));
2742     Out << ", " << GetValueName(&I) << "__BITCAST_TEMPORARY."
2743         << getFloatBitCastField(I.getType());
2744     Out << ')';
2745     return;
2746   }
2747
2748   Out << '(';
2749   printCast(I.getOpcode(), SrcTy, DstTy);
2750
2751   // Make a sext from i1 work by subtracting the i1 from 0 (an int).
2752   if (SrcTy == Type::getInt1Ty(I.getContext()) &&
2753       I.getOpcode() == Instruction::SExt)
2754     Out << "0-";
2755
2756   writeOperand(I.getOperand(0));
2757
2758   if (DstTy == Type::getInt1Ty(I.getContext()) &&
2759       (I.getOpcode() == Instruction::Trunc ||
2760        I.getOpcode() == Instruction::FPToUI ||
2761        I.getOpcode() == Instruction::FPToSI ||
2762        I.getOpcode() == Instruction::PtrToInt)) {
2763     // Make sure we really get a trunc to bool by anding the operand with 1
2764     Out << "&1u";
2765   }
2766   Out << ')';
2767 }
2768
2769 void CWriter::visitSelectInst(SelectInst &I) {
2770   Out << "((";
2771   writeOperand(I.getCondition());
2772   Out << ") ? (";
2773   writeOperand(I.getTrueValue());
2774   Out << ") : (";
2775   writeOperand(I.getFalseValue());
2776   Out << "))";
2777 }
2778
2779
2780 void CWriter::lowerIntrinsics(Function &F) {
2781   // This is used to keep track of intrinsics that get generated to a lowered
2782   // function. We must generate the prototypes before the function body which
2783   // will only be expanded on first use (by the loop below).
2784   std::vector<Function*> prototypesToGen;
2785
2786   // Examine all the instructions in this function to find the intrinsics that
2787   // need to be lowered.
2788   for (Function::iterator BB = F.begin(), EE = F.end(); BB != EE; ++BB)
2789     for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; )
2790       if (CallInst *CI = dyn_cast<CallInst>(I++))
2791         if (Function *F = CI->getCalledFunction())
2792           switch (F->getIntrinsicID()) {
2793           case Intrinsic::not_intrinsic:
2794           case Intrinsic::memory_barrier:
2795           case Intrinsic::vastart:
2796           case Intrinsic::vacopy:
2797           case Intrinsic::vaend:
2798           case Intrinsic::returnaddress:
2799           case Intrinsic::frameaddress:
2800           case Intrinsic::setjmp:
2801           case Intrinsic::longjmp:
2802           case Intrinsic::prefetch:
2803           case Intrinsic::powi:
2804           case Intrinsic::x86_sse_cmp_ss:
2805           case Intrinsic::x86_sse_cmp_ps:
2806           case Intrinsic::x86_sse2_cmp_sd:
2807           case Intrinsic::x86_sse2_cmp_pd:
2808           case Intrinsic::ppc_altivec_lvsl:
2809               // We directly implement these intrinsics
2810             break;
2811           default:
2812             // If this is an intrinsic that directly corresponds to a GCC
2813             // builtin, we handle it.
2814             const char *BuiltinName = "";
2815 #define GET_GCC_BUILTIN_NAME
2816 #include "llvm/Intrinsics.gen"
2817 #undef GET_GCC_BUILTIN_NAME
2818             // If we handle it, don't lower it.
2819             if (BuiltinName[0]) break;
2820
2821             // All other intrinsic calls we must lower.
2822             Instruction *Before = 0;
2823             if (CI != &BB->front())
2824               Before = prior(BasicBlock::iterator(CI));
2825
2826             IL->LowerIntrinsicCall(CI);
2827             if (Before) {        // Move iterator to instruction after call
2828               I = Before; ++I;
2829             } else {
2830               I = BB->begin();
2831             }
2832             // If the intrinsic got lowered to another call, and that call has
2833             // a definition then we need to make sure its prototype is emitted
2834             // before any calls to it.
2835             if (CallInst *Call = dyn_cast<CallInst>(I))
2836               if (Function *NewF = Call->getCalledFunction())
2837                 if (!NewF->isDeclaration())
2838                   prototypesToGen.push_back(NewF);
2839
2840             break;
2841           }
2842
2843   // We may have collected some prototypes to emit in the loop above.
2844   // Emit them now, before the function that uses them is emitted. But,
2845   // be careful not to emit them twice.
2846   std::vector<Function*>::iterator I = prototypesToGen.begin();
2847   std::vector<Function*>::iterator E = prototypesToGen.end();
2848   for ( ; I != E; ++I) {
2849     if (intrinsicPrototypesAlreadyGenerated.insert(*I).second) {
2850       Out << '\n';
2851       printFunctionSignature(*I, true);
2852       Out << ";\n";
2853     }
2854   }
2855 }
2856
2857 void CWriter::visitCallInst(CallInst &I) {
2858   if (isa<InlineAsm>(I.getOperand(0)))
2859     return visitInlineAsm(I);
2860
2861   bool WroteCallee = false;
2862
2863   // Handle intrinsic function calls first...
2864   if (Function *F = I.getCalledFunction())
2865     if (Intrinsic::ID ID = (Intrinsic::ID)F->getIntrinsicID())
2866       if (visitBuiltinCall(I, ID, WroteCallee))
2867         return;
2868
2869   Value *Callee = I.getCalledValue();
2870
2871   const PointerType  *PTy   = cast<PointerType>(Callee->getType());
2872   const FunctionType *FTy   = cast<FunctionType>(PTy->getElementType());
2873
2874   // If this is a call to a struct-return function, assign to the first
2875   // parameter instead of passing it to the call.
2876   const AttrListPtr &PAL = I.getAttributes();
2877   bool hasByVal = I.hasByValArgument();
2878   bool isStructRet = I.hasStructRetAttr();
2879   if (isStructRet) {
2880     writeOperandDeref(I.getOperand(1));
2881     Out << " = ";
2882   }
2883
2884   if (I.isTailCall()) Out << " /*tail*/ ";
2885
2886   if (!WroteCallee) {
2887     // If this is an indirect call to a struct return function, we need to cast
2888     // the pointer. Ditto for indirect calls with byval arguments.
2889     bool NeedsCast = (hasByVal || isStructRet) && !isa<Function>(Callee);
2890
2891     // GCC is a real PITA.  It does not permit codegening casts of functions to
2892     // function pointers if they are in a call (it generates a trap instruction
2893     // instead!).  We work around this by inserting a cast to void* in between
2894     // the function and the function pointer cast.  Unfortunately, we can't just
2895     // form the constant expression here, because the folder will immediately
2896     // nuke it.
2897     //
2898     // Note finally, that this is completely unsafe.  ANSI C does not guarantee
2899     // that void* and function pointers have the same size. :( To deal with this
2900     // in the common case, we handle casts where the number of arguments passed
2901     // match exactly.
2902     //
2903     if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Callee))
2904       if (CE->isCast())
2905         if (Function *RF = dyn_cast<Function>(CE->getOperand(0))) {
2906           NeedsCast = true;
2907           Callee = RF;
2908         }
2909
2910     if (NeedsCast) {
2911       // Ok, just cast the pointer type.
2912       Out << "((";
2913       if (isStructRet)
2914         printStructReturnPointerFunctionType(Out, PAL,
2915                              cast<PointerType>(I.getCalledValue()->getType()));
2916       else if (hasByVal)
2917         printType(Out, I.getCalledValue()->getType(), false, "", true, PAL);
2918       else
2919         printType(Out, I.getCalledValue()->getType());
2920       Out << ")(void*)";
2921     }
2922     writeOperand(Callee);
2923     if (NeedsCast) Out << ')';
2924   }
2925
2926   Out << '(';
2927
2928   unsigned NumDeclaredParams = FTy->getNumParams();
2929
2930   CallSite::arg_iterator AI = I.op_begin()+1, AE = I.op_end();
2931   unsigned ArgNo = 0;
2932   if (isStructRet) {   // Skip struct return argument.
2933     ++AI;
2934     ++ArgNo;
2935   }
2936
2937   bool PrintedArg = false;
2938   for (; AI != AE; ++AI, ++ArgNo) {
2939     if (PrintedArg) Out << ", ";
2940     if (ArgNo < NumDeclaredParams &&
2941         (*AI)->getType() != FTy->getParamType(ArgNo)) {
2942       Out << '(';
2943       printType(Out, FTy->getParamType(ArgNo),
2944             /*isSigned=*/PAL.paramHasAttr(ArgNo+1, Attribute::SExt));
2945       Out << ')';
2946     }
2947     // Check if the argument is expected to be passed by value.
2948     if (I.paramHasAttr(ArgNo+1, Attribute::ByVal))
2949       writeOperandDeref(*AI);
2950     else
2951       writeOperand(*AI);
2952     PrintedArg = true;
2953   }
2954   Out << ')';
2955 }
2956
2957 /// visitBuiltinCall - Handle the call to the specified builtin.  Returns true
2958 /// if the entire call is handled, return false if it wasn't handled, and
2959 /// optionally set 'WroteCallee' if the callee has already been printed out.
2960 bool CWriter::visitBuiltinCall(CallInst &I, Intrinsic::ID ID,
2961                                bool &WroteCallee) {
2962   switch (ID) {
2963   default: {
2964     // If this is an intrinsic that directly corresponds to a GCC
2965     // builtin, we emit it here.
2966     const char *BuiltinName = "";
2967     Function *F = I.getCalledFunction();
2968 #define GET_GCC_BUILTIN_NAME
2969 #include "llvm/Intrinsics.gen"
2970 #undef GET_GCC_BUILTIN_NAME
2971     assert(BuiltinName[0] && "Unknown LLVM intrinsic!");
2972
2973     Out << BuiltinName;
2974     WroteCallee = true;
2975     return false;
2976   }
2977   case Intrinsic::memory_barrier:
2978     Out << "__sync_synchronize()";
2979     return true;
2980   case Intrinsic::vastart:
2981     Out << "0; ";
2982
2983     Out << "va_start(*(va_list*)";
2984     writeOperand(I.getOperand(1));
2985     Out << ", ";
2986     // Output the last argument to the enclosing function.
2987     if (I.getParent()->getParent()->arg_empty()) {
2988       std::string msg;
2989       raw_string_ostream Msg(msg);
2990       Msg << "The C backend does not currently support zero "
2991            << "argument varargs functions, such as '"
2992            << I.getParent()->getParent()->getName() << "'!";
2993       llvm_report_error(Msg.str());
2994     }
2995     writeOperand(--I.getParent()->getParent()->arg_end());
2996     Out << ')';
2997     return true;
2998   case Intrinsic::vaend:
2999     if (!isa<ConstantPointerNull>(I.getOperand(1))) {
3000       Out << "0; va_end(*(va_list*)";
3001       writeOperand(I.getOperand(1));
3002       Out << ')';
3003     } else {
3004       Out << "va_end(*(va_list*)0)";
3005     }
3006     return true;
3007   case Intrinsic::vacopy:
3008     Out << "0; ";
3009     Out << "va_copy(*(va_list*)";
3010     writeOperand(I.getOperand(1));
3011     Out << ", *(va_list*)";
3012     writeOperand(I.getOperand(2));
3013     Out << ')';
3014     return true;
3015   case Intrinsic::returnaddress:
3016     Out << "__builtin_return_address(";
3017     writeOperand(I.getOperand(1));
3018     Out << ')';
3019     return true;
3020   case Intrinsic::frameaddress:
3021     Out << "__builtin_frame_address(";
3022     writeOperand(I.getOperand(1));
3023     Out << ')';
3024     return true;
3025   case Intrinsic::powi:
3026     Out << "__builtin_powi(";
3027     writeOperand(I.getOperand(1));
3028     Out << ", ";
3029     writeOperand(I.getOperand(2));
3030     Out << ')';
3031     return true;
3032   case Intrinsic::setjmp:
3033     Out << "setjmp(*(jmp_buf*)";
3034     writeOperand(I.getOperand(1));
3035     Out << ')';
3036     return true;
3037   case Intrinsic::longjmp:
3038     Out << "longjmp(*(jmp_buf*)";
3039     writeOperand(I.getOperand(1));
3040     Out << ", ";
3041     writeOperand(I.getOperand(2));
3042     Out << ')';
3043     return true;
3044   case Intrinsic::prefetch:
3045     Out << "LLVM_PREFETCH((const void *)";
3046     writeOperand(I.getOperand(1));
3047     Out << ", ";
3048     writeOperand(I.getOperand(2));
3049     Out << ", ";
3050     writeOperand(I.getOperand(3));
3051     Out << ")";
3052     return true;
3053   case Intrinsic::stacksave:
3054     // Emit this as: Val = 0; *((void**)&Val) = __builtin_stack_save()
3055     // to work around GCC bugs (see PR1809).
3056     Out << "0; *((void**)&" << GetValueName(&I)
3057         << ") = __builtin_stack_save()";
3058     return true;
3059   case Intrinsic::x86_sse_cmp_ss:
3060   case Intrinsic::x86_sse_cmp_ps:
3061   case Intrinsic::x86_sse2_cmp_sd:
3062   case Intrinsic::x86_sse2_cmp_pd:
3063     Out << '(';
3064     printType(Out, I.getType());
3065     Out << ')';
3066     // Multiple GCC builtins multiplex onto this intrinsic.
3067     switch (cast<ConstantInt>(I.getOperand(3))->getZExtValue()) {
3068     default: llvm_unreachable("Invalid llvm.x86.sse.cmp!");
3069     case 0: Out << "__builtin_ia32_cmpeq"; break;
3070     case 1: Out << "__builtin_ia32_cmplt"; break;
3071     case 2: Out << "__builtin_ia32_cmple"; break;
3072     case 3: Out << "__builtin_ia32_cmpunord"; break;
3073     case 4: Out << "__builtin_ia32_cmpneq"; break;
3074     case 5: Out << "__builtin_ia32_cmpnlt"; break;
3075     case 6: Out << "__builtin_ia32_cmpnle"; break;
3076     case 7: Out << "__builtin_ia32_cmpord"; break;
3077     }
3078     if (ID == Intrinsic::x86_sse_cmp_ps || ID == Intrinsic::x86_sse2_cmp_pd)
3079       Out << 'p';
3080     else
3081       Out << 's';
3082     if (ID == Intrinsic::x86_sse_cmp_ss || ID == Intrinsic::x86_sse_cmp_ps)
3083       Out << 's';
3084     else
3085       Out << 'd';
3086
3087     Out << "(";
3088     writeOperand(I.getOperand(1));
3089     Out << ", ";
3090     writeOperand(I.getOperand(2));
3091     Out << ")";
3092     return true;
3093   case Intrinsic::ppc_altivec_lvsl:
3094     Out << '(';
3095     printType(Out, I.getType());
3096     Out << ')';
3097     Out << "__builtin_altivec_lvsl(0, (void*)";
3098     writeOperand(I.getOperand(1));
3099     Out << ")";
3100     return true;
3101   }
3102 }
3103
3104 //This converts the llvm constraint string to something gcc is expecting.
3105 //TODO: work out platform independent constraints and factor those out
3106 //      of the per target tables
3107 //      handle multiple constraint codes
3108 std::string CWriter::InterpretASMConstraint(InlineAsm::ConstraintInfo& c) {
3109   assert(c.Codes.size() == 1 && "Too many asm constraint codes to handle");
3110
3111   // Grab the translation table from MCAsmInfo if it exists.
3112   const MCAsmInfo *TargetAsm;
3113   std::string Triple = TheModule->getTargetTriple();
3114   if (Triple.empty())
3115     Triple = llvm::sys::getHostTriple();
3116
3117   std::string E;
3118   if (const Target *Match = TargetRegistry::lookupTarget(Triple, E))
3119     TargetAsm = Match->createAsmInfo(Triple);
3120   else
3121     return c.Codes[0];
3122
3123   const char *const *table = TargetAsm->getAsmCBE();
3124
3125   // Search the translation table if it exists.
3126   for (int i = 0; table && table[i]; i += 2)
3127     if (c.Codes[0] == table[i]) {
3128       delete TargetAsm;
3129       return table[i+1];
3130     }
3131
3132   // Default is identity.
3133   delete TargetAsm;
3134   return c.Codes[0];
3135 }
3136
3137 //TODO: import logic from AsmPrinter.cpp
3138 static std::string gccifyAsm(std::string asmstr) {
3139   for (std::string::size_type i = 0; i != asmstr.size(); ++i)
3140     if (asmstr[i] == '\n')
3141       asmstr.replace(i, 1, "\\n");
3142     else if (asmstr[i] == '\t')
3143       asmstr.replace(i, 1, "\\t");
3144     else if (asmstr[i] == '$') {
3145       if (asmstr[i + 1] == '{') {
3146         std::string::size_type a = asmstr.find_first_of(':', i + 1);
3147         std::string::size_type b = asmstr.find_first_of('}', i + 1);
3148         std::string n = "%" +
3149           asmstr.substr(a + 1, b - a - 1) +
3150           asmstr.substr(i + 2, a - i - 2);
3151         asmstr.replace(i, b - i + 1, n);
3152         i += n.size() - 1;
3153       } else
3154         asmstr.replace(i, 1, "%");
3155     }
3156     else if (asmstr[i] == '%')//grr
3157       { asmstr.replace(i, 1, "%%"); ++i;}
3158
3159   return asmstr;
3160 }
3161
3162 //TODO: assumptions about what consume arguments from the call are likely wrong
3163 //      handle communitivity
3164 void CWriter::visitInlineAsm(CallInst &CI) {
3165   InlineAsm* as = cast<InlineAsm>(CI.getOperand(0));
3166   std::vector<InlineAsm::ConstraintInfo> Constraints = as->ParseConstraints();
3167
3168   std::vector<std::pair<Value*, int> > ResultVals;
3169   if (CI.getType() == Type::getVoidTy(CI.getContext()))
3170     ;
3171   else if (const StructType *ST = dyn_cast<StructType>(CI.getType())) {
3172     for (unsigned i = 0, e = ST->getNumElements(); i != e; ++i)
3173       ResultVals.push_back(std::make_pair(&CI, (int)i));
3174   } else {
3175     ResultVals.push_back(std::make_pair(&CI, -1));
3176   }
3177
3178   // Fix up the asm string for gcc and emit it.
3179   Out << "__asm__ volatile (\"" << gccifyAsm(as->getAsmString()) << "\"\n";
3180   Out << "        :";
3181
3182   unsigned ValueCount = 0;
3183   bool IsFirst = true;
3184
3185   // Convert over all the output constraints.
3186   for (std::vector<InlineAsm::ConstraintInfo>::iterator I = Constraints.begin(),
3187        E = Constraints.end(); I != E; ++I) {
3188
3189     if (I->Type != InlineAsm::isOutput) {
3190       ++ValueCount;
3191       continue;  // Ignore non-output constraints.
3192     }
3193
3194     assert(I->Codes.size() == 1 && "Too many asm constraint codes to handle");
3195     std::string C = InterpretASMConstraint(*I);
3196     if (C.empty()) continue;
3197
3198     if (!IsFirst) {
3199       Out << ", ";
3200       IsFirst = false;
3201     }
3202
3203     // Unpack the dest.
3204     Value *DestVal;
3205     int DestValNo = -1;
3206
3207     if (ValueCount < ResultVals.size()) {
3208       DestVal = ResultVals[ValueCount].first;
3209       DestValNo = ResultVals[ValueCount].second;
3210     } else
3211       DestVal = CI.getOperand(ValueCount-ResultVals.size()+1);
3212
3213     if (I->isEarlyClobber)
3214       C = "&"+C;
3215
3216     Out << "\"=" << C << "\"(" << GetValueName(DestVal);
3217     if (DestValNo != -1)
3218       Out << ".field" << DestValNo; // Multiple retvals.
3219     Out << ")";
3220     ++ValueCount;
3221   }
3222
3223
3224   // Convert over all the input constraints.
3225   Out << "\n        :";
3226   IsFirst = true;
3227   ValueCount = 0;
3228   for (std::vector<InlineAsm::ConstraintInfo>::iterator I = Constraints.begin(),
3229        E = Constraints.end(); I != E; ++I) {
3230     if (I->Type != InlineAsm::isInput) {
3231       ++ValueCount;
3232       continue;  // Ignore non-input constraints.
3233     }
3234
3235     assert(I->Codes.size() == 1 && "Too many asm constraint codes to handle");
3236     std::string C = InterpretASMConstraint(*I);
3237     if (C.empty()) continue;
3238
3239     if (!IsFirst) {
3240       Out << ", ";
3241       IsFirst = false;
3242     }
3243
3244     assert(ValueCount >= ResultVals.size() && "Input can't refer to result");
3245     Value *SrcVal = CI.getOperand(ValueCount-ResultVals.size()+1);
3246
3247     Out << "\"" << C << "\"(";
3248     if (!I->isIndirect)
3249       writeOperand(SrcVal);
3250     else
3251       writeOperandDeref(SrcVal);
3252     Out << ")";
3253   }
3254
3255   // Convert over the clobber constraints.
3256   IsFirst = true;
3257   for (std::vector<InlineAsm::ConstraintInfo>::iterator I = Constraints.begin(),
3258        E = Constraints.end(); I != E; ++I) {
3259     if (I->Type != InlineAsm::isClobber)
3260       continue;  // Ignore non-input constraints.
3261
3262     assert(I->Codes.size() == 1 && "Too many asm constraint codes to handle");
3263     std::string C = InterpretASMConstraint(*I);
3264     if (C.empty()) continue;
3265
3266     if (!IsFirst) {
3267       Out << ", ";
3268       IsFirst = false;
3269     }
3270
3271     Out << '\"' << C << '"';
3272   }
3273
3274   Out << ")";
3275 }
3276
3277 void CWriter::visitAllocaInst(AllocaInst &I) {
3278   Out << '(';
3279   printType(Out, I.getType());
3280   Out << ") alloca(sizeof(";
3281   printType(Out, I.getType()->getElementType());
3282   Out << ')';
3283   if (I.isArrayAllocation()) {
3284     Out << " * " ;
3285     writeOperand(I.getOperand(0));
3286   }
3287   Out << ')';
3288 }
3289
3290 void CWriter::printGEPExpression(Value *Ptr, gep_type_iterator I,
3291                                  gep_type_iterator E, bool Static) {
3292
3293   // If there are no indices, just print out the pointer.
3294   if (I == E) {
3295     writeOperand(Ptr);
3296     return;
3297   }
3298
3299   // Find out if the last index is into a vector.  If so, we have to print this
3300   // specially.  Since vectors can't have elements of indexable type, only the
3301   // last index could possibly be of a vector element.
3302   const VectorType *LastIndexIsVector = 0;
3303   {
3304     for (gep_type_iterator TmpI = I; TmpI != E; ++TmpI)
3305       LastIndexIsVector = dyn_cast<VectorType>(*TmpI);
3306   }
3307
3308   Out << "(";
3309
3310   // If the last index is into a vector, we can't print it as &a[i][j] because
3311   // we can't index into a vector with j in GCC.  Instead, emit this as
3312   // (((float*)&a[i])+j)
3313   if (LastIndexIsVector) {
3314     Out << "((";
3315     printType(Out, PointerType::getUnqual(LastIndexIsVector->getElementType()));
3316     Out << ")(";
3317   }
3318
3319   Out << '&';
3320
3321   // If the first index is 0 (very typical) we can do a number of
3322   // simplifications to clean up the code.
3323   Value *FirstOp = I.getOperand();
3324   if (!isa<Constant>(FirstOp) || !cast<Constant>(FirstOp)->isNullValue()) {
3325     // First index isn't simple, print it the hard way.
3326     writeOperand(Ptr);
3327   } else {
3328     ++I;  // Skip the zero index.
3329
3330     // Okay, emit the first operand. If Ptr is something that is already address
3331     // exposed, like a global, avoid emitting (&foo)[0], just emit foo instead.
3332     if (isAddressExposed(Ptr)) {
3333       writeOperandInternal(Ptr, Static);
3334     } else if (I != E && (*I)->isStructTy()) {
3335       // If we didn't already emit the first operand, see if we can print it as
3336       // P->f instead of "P[0].f"
3337       writeOperand(Ptr);
3338       Out << "->field" << cast<ConstantInt>(I.getOperand())->getZExtValue();
3339       ++I;  // eat the struct index as well.
3340     } else {
3341       // Instead of emitting P[0][1], emit (*P)[1], which is more idiomatic.
3342       Out << "(*";
3343       writeOperand(Ptr);
3344       Out << ")";
3345     }
3346   }
3347
3348   for (; I != E; ++I) {
3349     if ((*I)->isStructTy()) {
3350       Out << ".field" << cast<ConstantInt>(I.getOperand())->getZExtValue();
3351     } else if ((*I)->isArrayTy()) {
3352       Out << ".array[";
3353       writeOperandWithCast(I.getOperand(), Instruction::GetElementPtr);
3354       Out << ']';
3355     } else if (!(*I)->isVectorTy()) {
3356       Out << '[';
3357       writeOperandWithCast(I.getOperand(), Instruction::GetElementPtr);
3358       Out << ']';
3359     } else {
3360       // If the last index is into a vector, then print it out as "+j)".  This
3361       // works with the 'LastIndexIsVector' code above.
3362       if (isa<Constant>(I.getOperand()) &&
3363           cast<Constant>(I.getOperand())->isNullValue()) {
3364         Out << "))";  // avoid "+0".
3365       } else {
3366         Out << ")+(";
3367         writeOperandWithCast(I.getOperand(), Instruction::GetElementPtr);
3368         Out << "))";
3369       }
3370     }
3371   }
3372   Out << ")";
3373 }
3374
3375 void CWriter::writeMemoryAccess(Value *Operand, const Type *OperandType,
3376                                 bool IsVolatile, unsigned Alignment) {
3377
3378   bool IsUnaligned = Alignment &&
3379     Alignment < TD->getABITypeAlignment(OperandType);
3380
3381   if (!IsUnaligned)
3382     Out << '*';
3383   if (IsVolatile || IsUnaligned) {
3384     Out << "((";
3385     if (IsUnaligned)
3386       Out << "struct __attribute__ ((packed, aligned(" << Alignment << "))) {";
3387     printType(Out, OperandType, false, IsUnaligned ? "data" : "volatile*");
3388     if (IsUnaligned) {
3389       Out << "; } ";
3390       if (IsVolatile) Out << "volatile ";
3391       Out << "*";
3392     }
3393     Out << ")";
3394   }
3395
3396   writeOperand(Operand);
3397
3398   if (IsVolatile || IsUnaligned) {
3399     Out << ')';
3400     if (IsUnaligned)
3401       Out << "->data";
3402   }
3403 }
3404
3405 void CWriter::visitLoadInst(LoadInst &I) {
3406   writeMemoryAccess(I.getOperand(0), I.getType(), I.isVolatile(),
3407                     I.getAlignment());
3408
3409 }
3410
3411 void CWriter::visitStoreInst(StoreInst &I) {
3412   writeMemoryAccess(I.getPointerOperand(), I.getOperand(0)->getType(),
3413                     I.isVolatile(), I.getAlignment());
3414   Out << " = ";
3415   Value *Operand = I.getOperand(0);
3416   Constant *BitMask = 0;
3417   if (const IntegerType* ITy = dyn_cast<IntegerType>(Operand->getType()))
3418     if (!ITy->isPowerOf2ByteWidth())
3419       // We have a bit width that doesn't match an even power-of-2 byte
3420       // size. Consequently we must & the value with the type's bit mask
3421       BitMask = ConstantInt::get(ITy, ITy->getBitMask());
3422   if (BitMask)
3423     Out << "((";
3424   writeOperand(Operand);
3425   if (BitMask) {
3426     Out << ") & ";
3427     printConstant(BitMask, false);
3428     Out << ")";
3429   }
3430 }
3431
3432 void CWriter::visitGetElementPtrInst(GetElementPtrInst &I) {
3433   printGEPExpression(I.getPointerOperand(), gep_type_begin(I),
3434                      gep_type_end(I), false);
3435 }
3436
3437 void CWriter::visitVAArgInst(VAArgInst &I) {
3438   Out << "va_arg(*(va_list*)";
3439   writeOperand(I.getOperand(0));
3440   Out << ", ";
3441   printType(Out, I.getType());
3442   Out << ");\n ";
3443 }
3444
3445 void CWriter::visitInsertElementInst(InsertElementInst &I) {
3446   const Type *EltTy = I.getType()->getElementType();
3447   writeOperand(I.getOperand(0));
3448   Out << ";\n  ";
3449   Out << "((";
3450   printType(Out, PointerType::getUnqual(EltTy));
3451   Out << ")(&" << GetValueName(&I) << "))[";
3452   writeOperand(I.getOperand(2));
3453   Out << "] = (";
3454   writeOperand(I.getOperand(1));
3455   Out << ")";
3456 }
3457
3458 void CWriter::visitExtractElementInst(ExtractElementInst &I) {
3459   // We know that our operand is not inlined.
3460   Out << "((";
3461   const Type *EltTy =
3462     cast<VectorType>(I.getOperand(0)->getType())->getElementType();
3463   printType(Out, PointerType::getUnqual(EltTy));
3464   Out << ")(&" << GetValueName(I.getOperand(0)) << "))[";
3465   writeOperand(I.getOperand(1));
3466   Out << "]";
3467 }
3468
3469 void CWriter::visitShuffleVectorInst(ShuffleVectorInst &SVI) {
3470   Out << "(";
3471   printType(Out, SVI.getType());
3472   Out << "){ ";
3473   const VectorType *VT = SVI.getType();
3474   unsigned NumElts = VT->getNumElements();
3475   const Type *EltTy = VT->getElementType();
3476
3477   for (unsigned i = 0; i != NumElts; ++i) {
3478     if (i) Out << ", ";
3479     int SrcVal = SVI.getMaskValue(i);
3480     if ((unsigned)SrcVal >= NumElts*2) {
3481       Out << " 0/*undef*/ ";
3482     } else {
3483       Value *Op = SVI.getOperand((unsigned)SrcVal >= NumElts);
3484       if (isa<Instruction>(Op)) {
3485         // Do an extractelement of this value from the appropriate input.
3486         Out << "((";
3487         printType(Out, PointerType::getUnqual(EltTy));
3488         Out << ")(&" << GetValueName(Op)
3489             << "))[" << (SrcVal & (NumElts-1)) << "]";
3490       } else if (isa<ConstantAggregateZero>(Op) || isa<UndefValue>(Op)) {
3491         Out << "0";
3492       } else {
3493         printConstant(cast<ConstantVector>(Op)->getOperand(SrcVal &
3494                                                            (NumElts-1)),
3495                       false);
3496       }
3497     }
3498   }
3499   Out << "}";
3500 }
3501
3502 void CWriter::visitInsertValueInst(InsertValueInst &IVI) {
3503   // Start by copying the entire aggregate value into the result variable.
3504   writeOperand(IVI.getOperand(0));
3505   Out << ";\n  ";
3506
3507   // Then do the insert to update the field.
3508   Out << GetValueName(&IVI);
3509   for (const unsigned *b = IVI.idx_begin(), *i = b, *e = IVI.idx_end();
3510        i != e; ++i) {
3511     const Type *IndexedTy =
3512       ExtractValueInst::getIndexedType(IVI.getOperand(0)->getType(), b, i+1);
3513     if (IndexedTy->isArrayTy())
3514       Out << ".array[" << *i << "]";
3515     else
3516       Out << ".field" << *i;
3517   }
3518   Out << " = ";
3519   writeOperand(IVI.getOperand(1));
3520 }
3521
3522 void CWriter::visitExtractValueInst(ExtractValueInst &EVI) {
3523   Out << "(";
3524   if (isa<UndefValue>(EVI.getOperand(0))) {
3525     Out << "(";
3526     printType(Out, EVI.getType());
3527     Out << ") 0/*UNDEF*/";
3528   } else {
3529     Out << GetValueName(EVI.getOperand(0));
3530     for (const unsigned *b = EVI.idx_begin(), *i = b, *e = EVI.idx_end();
3531          i != e; ++i) {
3532       const Type *IndexedTy =
3533         ExtractValueInst::getIndexedType(EVI.getOperand(0)->getType(), b, i+1);
3534       if (IndexedTy->isArrayTy())
3535         Out << ".array[" << *i << "]";
3536       else
3537         Out << ".field" << *i;
3538     }
3539   }
3540   Out << ")";
3541 }
3542
3543 //===----------------------------------------------------------------------===//
3544 //                       External Interface declaration
3545 //===----------------------------------------------------------------------===//
3546
3547 bool CTargetMachine::addPassesToEmitWholeFile(PassManager &PM,
3548                                               formatted_raw_ostream &o,
3549                                               CodeGenFileType FileType,
3550                                               CodeGenOpt::Level OptLevel,
3551                                               bool DisableVerify) {
3552   if (FileType != TargetMachine::CGFT_AssemblyFile) return true;
3553
3554   PM.add(createGCLoweringPass());
3555   PM.add(createLowerInvokePass());
3556   PM.add(createCFGSimplificationPass());   // clean up after lower invoke.
3557   PM.add(new CBackendNameAllUsedStructsAndMergeFunctions());
3558   PM.add(new CWriter(o));
3559   PM.add(createGCInfoDeleter());
3560   return false;
3561 }