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