lib/Target/CBackend/CBackend.cpp

   1 //===-- Writer.cpp - Library for converting LLVM code to C ----------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source 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/SymbolTable.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/IntrinsicLowering.h"
  31 #include "llvm/Transforms/Scalar.h"
  32 #include "llvm/Target/TargetMachineRegistry.h"
  33 #include "llvm/Target/TargetAsmInfo.h"
  34 #include "llvm/Support/CallSite.h"
  35 #include "llvm/Support/CFG.h"
  36 #include "llvm/Support/GetElementPtrTypeIterator.h"
  37 #include "llvm/Support/InstVisitor.h"
  38 #include "llvm/Support/Mangler.h"
  39 #include "llvm/Support/MathExtras.h"
  40 #include "llvm/ADT/StringExtras.h"
  41 #include "llvm/ADT/STLExtras.h"
  42 #include "llvm/Support/MathExtras.h"
  43 #include "llvm/Config/config.h"
  44 #include <algorithm>
  45 #include <sstream>
  46 using namespace llvm;
  47
  48 namespace {
  49   // Register the target.
  50   RegisterTarget<CTargetMachine> X("c", "  C backend");
  51
  52   /// CBackendNameAllUsedStructsAndMergeFunctions - This pass inserts names for
  53   /// any unnamed structure types that are used by the program, and merges
  54   /// external functions with the same name.
  55   ///
  56   class CBackendNameAllUsedStructsAndMergeFunctions : public ModulePass {
  57     void getAnalysisUsage(AnalysisUsage &AU) const {
  58       AU.addRequired<FindUsedTypes>();
  59     }
  60
  61     virtual const char *getPassName() const {
  62       return "C backend type canonicalizer";
  63     }
  64
  65     virtual bool runOnModule(Module &M);
  66   };
  67
  68   /// CWriter - This class is the main chunk of code that converts an LLVM
  69   /// module to a C translation unit.
  70   class CWriter : public FunctionPass, public InstVisitor<CWriter> {
  71     std::ostream &Out;
  72     IntrinsicLowering IL;
  73     Mangler *Mang;
  74     LoopInfo *LI;
  75     const Module *TheModule;
  76     const TargetAsmInfo* TAsm;
  77     std::map<const Type *, std::string> TypeNames;
  78
  79     std::map<const ConstantFP *, unsigned> FPConstantMap;
  80   public:
  81     CWriter(std::ostream &o) : Out(o), TAsm(0) {}
  82
  83     virtual const char *getPassName() const { return "C backend"; }
  84
  85     void getAnalysisUsage(AnalysisUsage &AU) const {
  86       AU.addRequired<LoopInfo>();
  87       AU.setPreservesAll();
  88     }
  89
  90     virtual bool doInitialization(Module &M);
  91
  92     bool runOnFunction(Function &F) {
  93       LI = &getAnalysis<LoopInfo>();
  94
  95       // Get rid of intrinsics we can't handle.
  96       lowerIntrinsics(F);
  97
  98       // Output all floating point constants that cannot be printed accurately.
  99       printFloatingPointConstants(F);
 100
 101       // Ensure that no local symbols conflict with global symbols.
 102       F.renameLocalSymbols();
 103
 104       printFunction(F);
 105       FPConstantMap.clear();
 106       return false;
 107     }
 108
 109     virtual bool doFinalization(Module &M) {
 110       // Free memory...
 111       delete Mang;
 112       TypeNames.clear();
 113       return false;
 114     }
 115
 116     std::ostream &printType(std::ostream &Out, const Type *Ty,
 117                             const std::string &VariableName = "",
 118                             bool IgnoreName = false);
 119     std::ostream &printPrimitiveType(std::ostream &Out, const Type *Ty,
 120                                      bool isSigned,
 121                                      const std::string &NameSoFar = "");
 122
 123     void printStructReturnPointerFunctionType(std::ostream &Out,
 124                                               const PointerType *Ty);
 125
 126     void writeOperand(Value *Operand);
 127     void writeOperandRaw(Value *Operand);
 128     void writeOperandInternal(Value *Operand);
 129     void writeOperandWithCast(Value* Operand, unsigned Opcode);
 130     void writeOperandWithCast(Value* Operand, ICmpInst::Predicate predicate);
 131     bool writeInstructionCast(const Instruction &I);
 132
 133   private :
 134     std::string InterpretASMConstraint(InlineAsm::ConstraintInfo& c);
 135
 136     void lowerIntrinsics(Function &F);
 137
 138     void printModule(Module *M);
 139     void printModuleTypes(const SymbolTable &ST);
 140     void printContainedStructs(const Type *Ty, std::set<const StructType *> &);
 141     void printFloatingPointConstants(Function &F);
 142     void printFunctionSignature(const Function *F, bool Prototype);
 143
 144     void printFunction(Function &);
 145     void printBasicBlock(BasicBlock *BB);
 146     void printLoop(Loop *L);
 147
 148     void printCast(unsigned opcode, const Type *SrcTy, const Type *DstTy);
 149     void printConstant(Constant *CPV);
 150     void printConstantWithCast(Constant *CPV, unsigned Opcode);
 151     bool printConstExprCast(const ConstantExpr *CE);
 152     void printConstantArray(ConstantArray *CPA);
 153     void printConstantPacked(ConstantPacked *CP);
 154
 155     // isInlinableInst - Attempt to inline instructions into their uses to build
 156     // trees as much as possible.  To do this, we have to consistently decide
 157     // what is acceptable to inline, so that variable declarations don't get
 158     // printed and an extra copy of the expr is not emitted.
 159     //
 160     static bool isInlinableInst(const Instruction &I) {
 161       // Always inline cmp instructions, even if they are shared by multiple
 162       // expressions.  GCC generates horrible code if we don't.
 163       if (isa<CmpInst>(I))
 164         return true;
 165
 166       // Must be an expression, must be used exactly once.  If it is dead, we
 167       // emit it inline where it would go.
 168       if (I.getType() == Type::VoidTy || !I.hasOneUse() ||
 169           isa<TerminatorInst>(I) || isa<CallInst>(I) || isa<PHINode>(I) ||
 170           isa<LoadInst>(I) || isa<VAArgInst>(I))
 171         // Don't inline a load across a store or other bad things!
 172         return false;
 173
 174       // Must not be used in inline asm
 175       if (I.hasOneUse() && isInlineAsm(*I.use_back())) return false;
 176
 177       // Only inline instruction it if it's use is in the same BB as the inst.
 178       return I.getParent() == cast<Instruction>(I.use_back())->getParent();
 179     }
 180
 181     // isDirectAlloca - Define fixed sized allocas in the entry block as direct
 182     // variables which are accessed with the & operator.  This causes GCC to
 183     // generate significantly better code than to emit alloca calls directly.
 184     //
 185     static const AllocaInst *isDirectAlloca(const Value *V) {
 186       const AllocaInst *AI = dyn_cast<AllocaInst>(V);
 187       if (!AI) return false;
 188       if (AI->isArrayAllocation())
 189         return 0;   // FIXME: we can also inline fixed size array allocas!
 190       if (AI->getParent() != &AI->getParent()->getParent()->getEntryBlock())
 191         return 0;
 192       return AI;
 193     }
 194
 195     // isInlineAsm - Check if the instruction is a call to an inline asm chunk
 196     static bool isInlineAsm(const Instruction& I) {
 197       if (isa<CallInst>(&I) && isa<InlineAsm>(I.getOperand(0)))
 198         return true;
 199       return false;
 200     }
 201
 202     // Instruction visitation functions
 203     friend class InstVisitor<CWriter>;
 204
 205     void visitReturnInst(ReturnInst &I);
 206     void visitBranchInst(BranchInst &I);
 207     void visitSwitchInst(SwitchInst &I);
 208     void visitInvokeInst(InvokeInst &I) {
 209       assert(0 && "Lowerinvoke pass didn't work!");
 210     }
 211
 212     void visitUnwindInst(UnwindInst &I) {
 213       assert(0 && "Lowerinvoke pass didn't work!");
 214     }
 215     void visitUnreachableInst(UnreachableInst &I);
 216
 217     void visitPHINode(PHINode &I);
 218     void visitBinaryOperator(Instruction &I);
 219     void visitICmpInst(ICmpInst &I);
 220     void visitFCmpInst(FCmpInst &I);
 221
 222     void visitCastInst (CastInst &I);
 223     void visitSelectInst(SelectInst &I);
 224     void visitCallInst (CallInst &I);
 225     void visitInlineAsm(CallInst &I);
 226     void visitShiftInst(ShiftInst &I) { visitBinaryOperator(I); }
 227
 228     void visitMallocInst(MallocInst &I);
 229     void visitAllocaInst(AllocaInst &I);
 230     void visitFreeInst  (FreeInst   &I);
 231     void visitLoadInst  (LoadInst   &I);
 232     void visitStoreInst (StoreInst  &I);
 233     void visitGetElementPtrInst(GetElementPtrInst &I);
 234     void visitVAArgInst (VAArgInst &I);
 235
 236     void visitInstruction(Instruction &I) {
 237       cerr << "C Writer does not know about " << I;
 238       abort();
 239     }
 240
 241     void outputLValue(Instruction *I) {
 242       Out << "  " << Mang->getValueName(I) << " = ";
 243     }
 244
 245     bool isGotoCodeNecessary(BasicBlock *From, BasicBlock *To);
 246     void printPHICopiesForSuccessor(BasicBlock *CurBlock,
 247                                     BasicBlock *Successor, unsigned Indent);
 248     void printBranchToBlock(BasicBlock *CurBlock, BasicBlock *SuccBlock,
 249                             unsigned Indent);
 250     void printIndexingExpression(Value *Ptr, gep_type_iterator I,
 251                                  gep_type_iterator E);
 252   };
 253 }
 254
 255 /// This method inserts names for any unnamed structure types that are used by
 256 /// the program, and removes names from structure types that are not used by the
 257 /// program.
 258 ///
 259 bool CBackendNameAllUsedStructsAndMergeFunctions::runOnModule(Module &M) {
 260   // Get a set of types that are used by the program...
 261   std::set<const Type *> UT = getAnalysis<FindUsedTypes>().getTypes();
 262
 263   // Loop over the module symbol table, removing types from UT that are
 264   // already named, and removing names for types that are not used.
 265   //
 266   SymbolTable &MST = M.getSymbolTable();
 267   for (SymbolTable::type_iterator TI = MST.type_begin(), TE = MST.type_end();
 268        TI != TE; ) {
 269     SymbolTable::type_iterator I = TI++;
 270
 271     // If this is not used, remove it from the symbol table.
 272     std::set<const Type *>::iterator UTI = UT.find(I->second);
 273     if (UTI == UT.end())
 274       MST.remove(I);
 275     else
 276       UT.erase(UTI);    // Only keep one name for this type.
 277   }
 278
 279   // UT now contains types that are not named.  Loop over it, naming
 280   // structure types.
 281   //
 282   bool Changed = false;
 283   unsigned RenameCounter = 0;
 284   for (std::set<const Type *>::const_iterator I = UT.begin(), E = UT.end();
 285        I != E; ++I)
 286     if (const StructType *ST = dyn_cast<StructType>(*I)) {
 287       while (M.addTypeName("unnamed"+utostr(RenameCounter), ST))
 288         ++RenameCounter;
 289       Changed = true;
 290     }
 291
 292
 293   // Loop over all external functions and globals.  If we have two with
 294   // identical names, merge them.
 295   // FIXME: This code should disappear when we don't allow values with the same
 296   // names when they have different types!
 297   std::map<std::string, GlobalValue*> ExtSymbols;
 298   for (Module::iterator I = M.begin(), E = M.end(); I != E;) {
 299     Function *GV = I++;
 300     if (GV->isExternal() && GV->hasName()) {
 301       std::pair<std::map<std::string, GlobalValue*>::iterator, bool> X
 302         = ExtSymbols.insert(std::make_pair(GV->getName(), GV));
 303       if (!X.second) {
 304         // Found a conflict, replace this global with the previous one.
 305         GlobalValue *OldGV = X.first->second;
 306         GV->replaceAllUsesWith(ConstantExpr::getBitCast(OldGV, GV->getType()));
 307         GV->eraseFromParent();
 308         Changed = true;
 309       }
 310     }
 311   }
 312   // Do the same for globals.
 313   for (Module::global_iterator I = M.global_begin(), E = M.global_end();
 314        I != E;) {
 315     GlobalVariable *GV = I++;
 316     if (GV->isExternal() && GV->hasName()) {
 317       std::pair<std::map<std::string, GlobalValue*>::iterator, bool> X
 318         = ExtSymbols.insert(std::make_pair(GV->getName(), GV));
 319       if (!X.second) {
 320         // Found a conflict, replace this global with the previous one.
 321         GlobalValue *OldGV = X.first->second;
 322         GV->replaceAllUsesWith(ConstantExpr::getBitCast(OldGV, GV->getType()));
 323         GV->eraseFromParent();
 324         Changed = true;
 325       }
 326     }
 327   }
 328
 329   return Changed;
 330 }
 331
 332 /// printStructReturnPointerFunctionType - This is like printType for a struct
 333 /// return type, except, instead of printing the type as void (*)(Struct*, ...)
 334 /// print it as "Struct (*)(...)", for struct return functions.
 335 void CWriter::printStructReturnPointerFunctionType(std::ostream &Out,
 336                                                    const PointerType *TheTy) {
 337   const FunctionType *FTy = cast<FunctionType>(TheTy->getElementType());
 338   std::stringstream FunctionInnards;
 339   FunctionInnards << " (*) (";
 340   bool PrintedType = false;
 341
 342   FunctionType::param_iterator I = FTy->param_begin(), E = FTy->param_end();
 343   const Type *RetTy = cast<PointerType>(I->get())->getElementType();
 344   for (++I; I != E; ++I) {
 345     if (PrintedType)
 346       FunctionInnards << ", ";
 347     printType(FunctionInnards, *I, "");
 348     PrintedType = true;
 349   }
 350   if (FTy->isVarArg()) {
 351     if (PrintedType)
 352       FunctionInnards << ", ...";
 353   } else if (!PrintedType) {
 354     FunctionInnards << "void";
 355   }
 356   FunctionInnards << ')';
 357   std::string tstr = FunctionInnards.str();
 358   printType(Out, RetTy, tstr);
 359 }
 360
 361 std::ostream &
 362 CWriter::printPrimitiveType(std::ostream &Out, const Type *Ty, bool isSigned,
 363                             const std::string &NameSoFar) {
 364   assert(Ty->isPrimitiveType() && "Invalid type for printPrimitiveType");
 365   switch (Ty->getTypeID()) {
 366   case Type::VoidTyID:   return Out << "void "               << NameSoFar;
 367   case Type::BoolTyID:   return Out << "bool "               << NameSoFar;
 368   case Type::Int8TyID:
 369     return Out << (isSigned?"signed":"unsigned") << " char " << NameSoFar;
 370   case Type::Int16TyID:
 371     return Out << (isSigned?"signed":"unsigned") << " short " << NameSoFar;
 372   case Type::Int32TyID:
 373     return Out << (isSigned?"signed":"unsigned") << " int " << NameSoFar;
 374   case Type::Int64TyID:
 375     return Out << (isSigned?"signed":"unsigned") << " long long " << NameSoFar;
 376   case Type::FloatTyID:  return Out << "float "              << NameSoFar;
 377   case Type::DoubleTyID: return Out << "double "             << NameSoFar;
 378   default :
 379     cerr << "Unknown primitive type: " << *Ty << "\n";
 380     abort();
 381   }
 382 }
 383
 384 // Pass the Type* and the variable name and this prints out the variable
 385 // declaration.
 386 //
 387 std::ostream &CWriter::printType(std::ostream &Out, const Type *Ty,
 388                                  const std::string &NameSoFar,
 389                                  bool IgnoreName) {
 390   if (Ty->isPrimitiveType()) {
 391     // FIXME:Signedness. When integer types are signless, this should just
 392     // always pass "false" for the sign of the primitive type. The instructions
 393     // will figure out how the value is to be interpreted.
 394     printPrimitiveType(Out, Ty, true, NameSoFar);
 395     return Out;
 396   }
 397
 398   // Check to see if the type is named.
 399   if (!IgnoreName || isa<OpaqueType>(Ty)) {
 400     std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty);
 401     if (I != TypeNames.end()) return Out << I->second << ' ' << NameSoFar;
 402   }
 403
 404   switch (Ty->getTypeID()) {
 405   case Type::FunctionTyID: {
 406     const FunctionType *FTy = cast<FunctionType>(Ty);
 407     std::stringstream FunctionInnards;
 408     FunctionInnards << " (" << NameSoFar << ") (";
 409     for (FunctionType::param_iterator I = FTy->param_begin(),
 410            E = FTy->param_end(); I != E; ++I) {
 411       if (I != FTy->param_begin())
 412         FunctionInnards << ", ";
 413       printType(FunctionInnards, *I, "");
 414     }
 415     if (FTy->isVarArg()) {
 416       if (FTy->getNumParams())
 417         FunctionInnards << ", ...";
 418     } else if (!FTy->getNumParams()) {
 419       FunctionInnards << "void";
 420     }
 421     FunctionInnards << ')';
 422     std::string tstr = FunctionInnards.str();
 423     printType(Out, FTy->getReturnType(), tstr);
 424     return Out;
 425   }
 426   case Type::StructTyID: {
 427     const StructType *STy = cast<StructType>(Ty);
 428     Out << NameSoFar + " {\n";
 429     unsigned Idx = 0;
 430     for (StructType::element_iterator I = STy->element_begin(),
 431            E = STy->element_end(); I != E; ++I) {
 432       Out << "  ";
 433       printType(Out, *I, "field" + utostr(Idx++));
 434       Out << ";\n";
 435     }
 436     return Out << '}';
 437   }
 438
 439   case Type::PointerTyID: {
 440     const PointerType *PTy = cast<PointerType>(Ty);
 441     std::string ptrName = "*" + NameSoFar;
 442
 443     if (isa<ArrayType>(PTy->getElementType()) ||
 444         isa<PackedType>(PTy->getElementType()))
 445       ptrName = "(" + ptrName + ")";
 446
 447     return printType(Out, PTy->getElementType(), ptrName);
 448   }
 449
 450   case Type::ArrayTyID: {
 451     const ArrayType *ATy = cast<ArrayType>(Ty);
 452     unsigned NumElements = ATy->getNumElements();
 453     if (NumElements == 0) NumElements = 1;
 454     return printType(Out, ATy->getElementType(),
 455                      NameSoFar + "[" + utostr(NumElements) + "]");
 456   }
 457
 458   case Type::PackedTyID: {
 459     const PackedType *PTy = cast<PackedType>(Ty);
 460     unsigned NumElements = PTy->getNumElements();
 461     if (NumElements == 0) NumElements = 1;
 462     return printType(Out, PTy->getElementType(),
 463                      NameSoFar + "[" + utostr(NumElements) + "]");
 464   }
 465
 466   case Type::OpaqueTyID: {
 467     static int Count = 0;
 468     std::string TyName = "struct opaque_" + itostr(Count++);
 469     assert(TypeNames.find(Ty) == TypeNames.end());
 470     TypeNames[Ty] = TyName;
 471     return Out << TyName << ' ' << NameSoFar;
 472   }
 473   default:
 474     assert(0 && "Unhandled case in getTypeProps!");
 475     abort();
 476   }
 477
 478   return Out;
 479 }
 480
 481 void CWriter::printConstantArray(ConstantArray *CPA) {
 482
 483   // As a special case, print the array as a string if it is an array of
 484   // ubytes or an array of sbytes with positive values.
 485   //
 486   const Type *ETy = CPA->getType()->getElementType();
 487   bool isString = (ETy == Type::Int8Ty || ETy == Type::Int8Ty);
 488
 489   // Make sure the last character is a null char, as automatically added by C
 490   if (isString && (CPA->getNumOperands() == 0 ||
 491                    !cast<Constant>(*(CPA->op_end()-1))->isNullValue()))
 492     isString = false;
 493
 494   if (isString) {
 495     Out << '\"';
 496     // Keep track of whether the last number was a hexadecimal escape
 497     bool LastWasHex = false;
 498
 499     // Do not include the last character, which we know is null
 500     for (unsigned i = 0, e = CPA->getNumOperands()-1; i != e; ++i) {
 501       unsigned char C = cast<ConstantInt>(CPA->getOperand(i))->getZExtValue();
 502
 503       // Print it out literally if it is a printable character.  The only thing
 504       // to be careful about is when the last letter output was a hex escape
 505       // code, in which case we have to be careful not to print out hex digits
 506       // explicitly (the C compiler thinks it is a continuation of the previous
 507       // character, sheesh...)
 508       //
 509       if (isprint(C) && (!LastWasHex || !isxdigit(C))) {
 510         LastWasHex = false;
 511         if (C == '"' || C == '\\')
 512           Out << "\\" << C;
 513         else
 514           Out << C;
 515       } else {
 516         LastWasHex = false;
 517         switch (C) {
 518         case '\n': Out << "\\n"; break;
 519         case '\t': Out << "\\t"; break;
 520         case '\r': Out << "\\r"; break;
 521         case '\v': Out << "\\v"; break;
 522         case '\a': Out << "\\a"; break;
 523         case '\"': Out << "\\\""; break;
 524         case '\'': Out << "\\\'"; break;
 525         default:
 526           Out << "\\x";
 527           Out << (char)(( C/16  < 10) ? ( C/16 +'0') : ( C/16 -10+'A'));
 528           Out << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A'));
 529           LastWasHex = true;
 530           break;
 531         }
 532       }
 533     }
 534     Out << '\"';
 535   } else {
 536     Out << '{';
 537     if (CPA->getNumOperands()) {
 538       Out << ' ';
 539       printConstant(cast<Constant>(CPA->getOperand(0)));
 540       for (unsigned i = 1, e = CPA->getNumOperands(); i != e; ++i) {
 541         Out << ", ";
 542         printConstant(cast<Constant>(CPA->getOperand(i)));
 543       }
 544     }
 545     Out << " }";
 546   }
 547 }
 548
 549 void CWriter::printConstantPacked(ConstantPacked *CP) {
 550   Out << '{';
 551   if (CP->getNumOperands()) {
 552     Out << ' ';
 553     printConstant(cast<Constant>(CP->getOperand(0)));
 554     for (unsigned i = 1, e = CP->getNumOperands(); i != e; ++i) {
 555       Out << ", ";
 556       printConstant(cast<Constant>(CP->getOperand(i)));
 557     }
 558   }
 559   Out << " }";
 560 }
 561
 562 // isFPCSafeToPrint - Returns true if we may assume that CFP may be written out
 563 // textually as a double (rather than as a reference to a stack-allocated
 564 // variable). We decide this by converting CFP to a string and back into a
 565 // double, and then checking whether the conversion results in a bit-equal
 566 // double to the original value of CFP. This depends on us and the target C
 567 // compiler agreeing on the conversion process (which is pretty likely since we
 568 // only deal in IEEE FP).
 569 //
 570 static bool isFPCSafeToPrint(const ConstantFP *CFP) {
 571 #if HAVE_PRINTF_A && ENABLE_CBE_PRINTF_A
 572   char Buffer[100];
 573   sprintf(Buffer, "%a", CFP->getValue());
 574
 575   if (!strncmp(Buffer, "0x", 2) ||
 576       !strncmp(Buffer, "-0x", 3) ||
 577       !strncmp(Buffer, "+0x", 3))
 578     return atof(Buffer) == CFP->getValue();
 579   return false;
 580 #else
 581   std::string StrVal = ftostr(CFP->getValue());
 582
 583   while (StrVal[0] == ' ')
 584     StrVal.erase(StrVal.begin());
 585
 586   // Check to make sure that the stringized number is not some string like "Inf"
 587   // or NaN.  Check that the string matches the "[-+]?[0-9]" regex.
 588   if ((StrVal[0] >= '0' && StrVal[0] <= '9') ||
 589       ((StrVal[0] == '-' || StrVal[0] == '+') &&
 590        (StrVal[1] >= '0' && StrVal[1] <= '9')))
 591     // Reparse stringized version!
 592     return atof(StrVal.c_str()) == CFP->getValue();
 593   return false;
 594 #endif
 595 }
 596
 597 /// Print out the casting for a cast operation. This does the double casting
 598 /// necessary for conversion to the destination type, if necessary.
 599 /// @brief Print a cast
 600 void CWriter::printCast(unsigned opc, const Type *SrcTy, const Type *DstTy) {
 601   // Print the destination type cast
 602   switch (opc) {
 603     case Instruction::UIToFP:
 604     case Instruction::SIToFP:
 605     case Instruction::IntToPtr:
 606     case Instruction::Trunc:
 607     case Instruction::BitCast:
 608     case Instruction::FPExt:
 609     case Instruction::FPTrunc: // For these the DstTy sign doesn't matter
 610       Out << '(';
 611       printType(Out, DstTy);
 612       Out << ')';
 613       break;
 614     case Instruction::ZExt:
 615     case Instruction::PtrToInt:
 616     case Instruction::FPToUI: // For these, make sure we get an unsigned dest
 617       Out << '(';
 618       printPrimitiveType(Out, DstTy, false);
 619       Out << ')';
 620       break;
 621     case Instruction::SExt:
 622     case Instruction::FPToSI: // For these, make sure we get a signed dest
 623       Out << '(';
 624       printPrimitiveType(Out, DstTy, true);
 625       Out << ')';
 626       break;
 627     default:
 628       assert(0 && "Invalid cast opcode");
 629   }
 630
 631   // Print the source type cast
 632   switch (opc) {
 633     case Instruction::UIToFP:
 634     case Instruction::ZExt:
 635       Out << '(';
 636       printPrimitiveType(Out, SrcTy, false);
 637       Out << ')';
 638       break;
 639     case Instruction::SIToFP:
 640     case Instruction::SExt:
 641       Out << '(';
 642       printPrimitiveType(Out, SrcTy, true);
 643       Out << ')';
 644       break;
 645     case Instruction::IntToPtr:
 646     case Instruction::PtrToInt:
 647       // Avoid "cast to pointer from integer of different size" warnings
 648       Out << "(unsigned long)";
 649       break;
 650     case Instruction::Trunc:
 651     case Instruction::BitCast:
 652     case Instruction::FPExt:
 653     case Instruction::FPTrunc:
 654     case Instruction::FPToSI:
 655     case Instruction::FPToUI:
 656       break; // These don't need a source cast.
 657     default:
 658       assert(0 && "Invalid cast opcode");
 659       break;
 660   }
 661 }
 662
 663 // printConstant - The LLVM Constant to C Constant converter.
 664 void CWriter::printConstant(Constant *CPV) {
 665   if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CPV)) {
 666     switch (CE->getOpcode()) {
 667     case Instruction::Trunc:
 668     case Instruction::ZExt:
 669     case Instruction::SExt:
 670     case Instruction::FPTrunc:
 671     case Instruction::FPExt:
 672     case Instruction::UIToFP:
 673     case Instruction::SIToFP:
 674     case Instruction::FPToUI:
 675     case Instruction::FPToSI:
 676     case Instruction::PtrToInt:
 677     case Instruction::IntToPtr:
 678     case Instruction::BitCast:
 679       Out << "(";
 680       printCast(CE->getOpcode(), CE->getOperand(0)->getType(), CE->getType());
 681       if (CE->getOpcode() == Instruction::SExt &&
 682           CE->getOperand(0)->getType() == Type::BoolTy) {
 683         // Make sure we really sext from bool here by subtracting from 0
 684         Out << "0-";
 685       }
 686       printConstant(CE->getOperand(0));
 687       if (CE->getType() == Type::BoolTy &&
 688           (CE->getOpcode() == Instruction::Trunc ||
 689            CE->getOpcode() == Instruction::FPToUI ||
 690            CE->getOpcode() == Instruction::FPToSI ||
 691            CE->getOpcode() == Instruction::PtrToInt)) {
 692         // Make sure we really truncate to bool here by anding with 1
 693         Out << "&1u";
 694       }
 695       Out << ')';
 696       return;
 697
 698     case Instruction::GetElementPtr:
 699       Out << "(&(";
 700       printIndexingExpression(CE->getOperand(0), gep_type_begin(CPV),
 701                               gep_type_end(CPV));
 702       Out << "))";
 703       return;
 704     case Instruction::Select:
 705       Out << '(';
 706       printConstant(CE->getOperand(0));
 707       Out << '?';
 708       printConstant(CE->getOperand(1));
 709       Out << ':';
 710       printConstant(CE->getOperand(2));
 711       Out << ')';
 712       return;
 713     case Instruction::Add:
 714     case Instruction::Sub:
 715     case Instruction::Mul:
 716     case Instruction::SDiv:
 717     case Instruction::UDiv:
 718     case Instruction::FDiv:
 719     case Instruction::URem:
 720     case Instruction::SRem:
 721     case Instruction::FRem:
 722     case Instruction::And:
 723     case Instruction::Or:
 724     case Instruction::Xor:
 725     case Instruction::ICmp:
 726     case Instruction::FCmp:
 727     case Instruction::Shl:
 728     case Instruction::LShr:
 729     case Instruction::AShr:
 730     {
 731       Out << '(';
 732       bool NeedsClosingParens = printConstExprCast(CE);
 733       printConstantWithCast(CE->getOperand(0), CE->getOpcode());
 734       switch (CE->getOpcode()) {
 735       case Instruction::Add: Out << " + "; break;
 736       case Instruction::Sub: Out << " - "; break;
 737       case Instruction::Mul: Out << " * "; break;
 738       case Instruction::URem:
 739       case Instruction::SRem:
 740       case Instruction::FRem: Out << " % "; break;
 741       case Instruction::UDiv:
 742       case Instruction::SDiv:
 743       case Instruction::FDiv: Out << " / "; break;
 744       case Instruction::And: Out << " & "; break;
 745       case Instruction::Or:  Out << " | "; break;
 746       case Instruction::Xor: Out << " ^ "; break;
 747       case Instruction::Shl: Out << " << "; break;
 748       case Instruction::LShr:
 749       case Instruction::AShr: Out << " >> "; break;
 750       case Instruction::ICmp:
 751         switch (CE->getPredicate()) {
 752           case ICmpInst::ICMP_EQ: Out << " == "; break;
 753           case ICmpInst::ICMP_NE: Out << " != "; break;
 754           case ICmpInst::ICMP_SLT:
 755           case ICmpInst::ICMP_ULT: Out << " < "; break;
 756           case ICmpInst::ICMP_SLE:
 757           case ICmpInst::ICMP_ULE: Out << " <= "; break;
 758           case ICmpInst::ICMP_SGT:
 759           case ICmpInst::ICMP_UGT: Out << " > "; break;
 760           case ICmpInst::ICMP_SGE:
 761           case ICmpInst::ICMP_UGE: Out << " >= "; break;
 762           default: assert(0 && "Illegal ICmp predicate");
 763         }
 764         break;
 765       case Instruction::FCmp:
 766         switch (CE->getPredicate()) {
 767           case FCmpInst::FCMP_ORD:
 768           case FCmpInst::FCMP_UEQ:
 769           case FCmpInst::FCMP_OEQ: Out << " == "; break;
 770           case FCmpInst::FCMP_UNO:
 771           case FCmpInst::FCMP_UNE:
 772           case FCmpInst::FCMP_ONE: Out << " != "; break;
 773           case FCmpInst::FCMP_OLT:
 774           case FCmpInst::FCMP_ULT: Out << " < "; break;
 775           case FCmpInst::FCMP_OLE:
 776           case FCmpInst::FCMP_ULE: Out << " <= "; break;
 777           case FCmpInst::FCMP_OGT:
 778           case FCmpInst::FCMP_UGT: Out << " > "; break;
 779           case FCmpInst::FCMP_OGE:
 780           case FCmpInst::FCMP_UGE: Out << " >= "; break;
 781           default: assert(0 && "Illegal FCmp predicate");
 782         }
 783         break;
 784       default: assert(0 && "Illegal opcode here!");
 785       }
 786       printConstantWithCast(CE->getOperand(1), CE->getOpcode());
 787       if (NeedsClosingParens)
 788         Out << "))";
 789       Out << ')';
 790       return;
 791     }
 792
 793     default:
 794       cerr << "CWriter Error: Unhandled constant expression: "
 795            << *CE << "\n";
 796       abort();
 797     }
 798   } else if (isa<UndefValue>(CPV) && CPV->getType()->isFirstClassType()) {
 799     Out << "((";
 800     printType(Out, CPV->getType()); // sign doesn't matter
 801     Out << ")/*UNDEF*/0)";
 802     return;
 803   }
 804
 805   switch (CPV->getType()->getTypeID()) {
 806   case Type::BoolTyID:
 807     Out << (cast<ConstantBool>(CPV)->getValue() ? '1' : '0');
 808     break;
 809   case Type::Int8TyID:
 810     Out << "((char)" << cast<ConstantInt>(CPV)->getSExtValue() << ")";
 811     break;
 812   case Type::Int16TyID:
 813     Out << "((short)" << cast<ConstantInt>(CPV)->getSExtValue() << ")";
 814     break;
 815   case Type::Int32TyID:
 816     Out << "((int)" << cast<ConstantInt>(CPV)->getSExtValue() << ")";
 817     break;
 818   case Type::Int64TyID:
 819     Out << "((long long)" << cast<ConstantInt>(CPV)->getSExtValue() << "ll)";
 820     break;
 821
 822   case Type::FloatTyID:
 823   case Type::DoubleTyID: {
 824     ConstantFP *FPC = cast<ConstantFP>(CPV);
 825     std::map<const ConstantFP*, unsigned>::iterator I = FPConstantMap.find(FPC);
 826     if (I != FPConstantMap.end()) {
 827       // Because of FP precision problems we must load from a stack allocated
 828       // value that holds the value in hex.
 829       Out << "(*(" << (FPC->getType() == Type::FloatTy ? "float" : "double")
 830           << "*)&FPConstant" << I->second << ')';
 831     } else {
 832       if (IsNAN(FPC->getValue())) {
 833         // The value is NaN
 834
 835         // The prefix for a quiet NaN is 0x7FF8. For a signalling NaN,
 836         // it's 0x7ff4.
 837         const unsigned long QuietNaN = 0x7ff8UL;
 838         //const unsigned long SignalNaN = 0x7ff4UL;
 839
 840         // We need to grab the first part of the FP #
 841         char Buffer[100];
 842
 843         uint64_t ll = DoubleToBits(FPC->getValue());
 844         sprintf(Buffer, "0x%llx", static_cast<long long>(ll));
 845
 846         std::string Num(&Buffer[0], &Buffer[6]);
 847         unsigned long Val = strtoul(Num.c_str(), 0, 16);
 848
 849         if (FPC->getType() == Type::FloatTy)
 850           Out << "LLVM_NAN" << (Val == QuietNaN ? "" : "S") << "F(\""
 851               << Buffer << "\") /*nan*/ ";
 852         else
 853           Out << "LLVM_NAN" << (Val == QuietNaN ? "" : "S") << "(\""
 854               << Buffer << "\") /*nan*/ ";
 855       } else if (IsInf(FPC->getValue())) {
 856         // The value is Inf
 857         if (FPC->getValue() < 0) Out << '-';
 858         Out << "LLVM_INF" << (FPC->getType() == Type::FloatTy ? "F" : "")
 859             << " /*inf*/ ";
 860       } else {
 861         std::string Num;
 862 #if HAVE_PRINTF_A && ENABLE_CBE_PRINTF_A
 863         // Print out the constant as a floating point number.
 864         char Buffer[100];
 865         sprintf(Buffer, "%a", FPC->getValue());
 866         Num = Buffer;
 867 #else
 868         Num = ftostr(FPC->getValue());
 869 #endif
 870         Out << Num;
 871       }
 872     }
 873     break;
 874   }
 875
 876   case Type::ArrayTyID:
 877     if (isa<ConstantAggregateZero>(CPV) || isa<UndefValue>(CPV)) {
 878       const ArrayType *AT = cast<ArrayType>(CPV->getType());
 879       Out << '{';
 880       if (AT->getNumElements()) {
 881         Out << ' ';
 882         Constant *CZ = Constant::getNullValue(AT->getElementType());
 883         printConstant(CZ);
 884         for (unsigned i = 1, e = AT->getNumElements(); i != e; ++i) {
 885           Out << ", ";
 886           printConstant(CZ);
 887         }
 888       }
 889       Out << " }";
 890     } else {
 891       printConstantArray(cast<ConstantArray>(CPV));
 892     }
 893     break;
 894
 895   case Type::PackedTyID:
 896     if (isa<ConstantAggregateZero>(CPV) || isa<UndefValue>(CPV)) {
 897       const PackedType *AT = cast<PackedType>(CPV->getType());
 898       Out << '{';
 899       if (AT->getNumElements()) {
 900         Out << ' ';
 901         Constant *CZ = Constant::getNullValue(AT->getElementType());
 902         printConstant(CZ);
 903         for (unsigned i = 1, e = AT->getNumElements(); i != e; ++i) {
 904           Out << ", ";
 905           printConstant(CZ);
 906         }
 907       }
 908       Out << " }";
 909     } else {
 910       printConstantPacked(cast<ConstantPacked>(CPV));
 911     }
 912     break;
 913
 914   case Type::StructTyID:
 915     if (isa<ConstantAggregateZero>(CPV) || isa<UndefValue>(CPV)) {
 916       const StructType *ST = cast<StructType>(CPV->getType());
 917       Out << '{';
 918       if (ST->getNumElements()) {
 919         Out << ' ';
 920         printConstant(Constant::getNullValue(ST->getElementType(0)));
 921         for (unsigned i = 1, e = ST->getNumElements(); i != e; ++i) {
 922           Out << ", ";
 923           printConstant(Constant::getNullValue(ST->getElementType(i)));
 924         }
 925       }
 926       Out << " }";
 927     } else {
 928       Out << '{';
 929       if (CPV->getNumOperands()) {
 930         Out << ' ';
 931         printConstant(cast<Constant>(CPV->getOperand(0)));
 932         for (unsigned i = 1, e = CPV->getNumOperands(); i != e; ++i) {
 933           Out << ", ";
 934           printConstant(cast<Constant>(CPV->getOperand(i)));
 935         }
 936       }
 937       Out << " }";
 938     }
 939     break;
 940
 941   case Type::PointerTyID:
 942     if (isa<ConstantPointerNull>(CPV)) {
 943       Out << "((";
 944       printType(Out, CPV->getType()); // sign doesn't matter
 945       Out << ")/*NULL*/0)";
 946       break;
 947     } else if (GlobalValue *GV = dyn_cast<GlobalValue>(CPV)) {
 948       writeOperand(GV);
 949       break;
 950     }
 951     // FALL THROUGH
 952   default:
 953     cerr << "Unknown constant type: " << *CPV << "\n";
 954     abort();
 955   }
 956 }
 957
 958 // Some constant expressions need to be casted back to the original types
 959 // because their operands were casted to the expected type. This function takes
 960 // care of detecting that case and printing the cast for the ConstantExpr.
 961 bool CWriter::printConstExprCast(const ConstantExpr* CE) {
 962   bool NeedsExplicitCast = false;
 963   const Type *Ty = CE->getOperand(0)->getType();
 964   bool TypeIsSigned = false;
 965   switch (CE->getOpcode()) {
 966   case Instruction::LShr:
 967   case Instruction::URem:
 968   case Instruction::UDiv: NeedsExplicitCast = true; break;
 969   case Instruction::AShr:
 970   case Instruction::SRem:
 971   case Instruction::SDiv: NeedsExplicitCast = true; TypeIsSigned = true; break;
 972   case Instruction::SExt:
 973     Ty = CE->getType();
 974     NeedsExplicitCast = true;
 975     TypeIsSigned = true;
 976     break;
 977   case Instruction::ZExt:
 978   case Instruction::Trunc:
 979   case Instruction::FPTrunc:
 980   case Instruction::FPExt:
 981   case Instruction::UIToFP:
 982   case Instruction::SIToFP:
 983   case Instruction::FPToUI:
 984   case Instruction::FPToSI:
 985   case Instruction::PtrToInt:
 986   case Instruction::IntToPtr:
 987   case Instruction::BitCast:
 988     Ty = CE->getType();
 989     NeedsExplicitCast = true;
 990     break;
 991   default: break;
 992   }
 993   if (NeedsExplicitCast) {
 994     Out << "((";
 995     if (Ty->isPrimitiveType())
 996       printPrimitiveType(Out, Ty, TypeIsSigned);
 997     else
 998       printType(Out, Ty);
 999     Out << ")(";
1000   }
1001   return NeedsExplicitCast;
1002 }
1003
1004 //  Print a constant assuming that it is the operand for a given Opcode. The
1005 //  opcodes that care about sign need to cast their operands to the expected
1006 //  type before the operation proceeds. This function does the casting.
1007 void CWriter::printConstantWithCast(Constant* CPV, unsigned Opcode) {
1008
1009   // Extract the operand's type, we'll need it.
1010   const Type* OpTy = CPV->getType();
1011
1012   // Indicate whether to do the cast or not.
1013   bool shouldCast = false;
1014   bool typeIsSigned = false;
1015
1016   // Based on the Opcode for which this Constant is being written, determine
1017   // the new type to which the operand should be casted by setting the value
1018   // of OpTy. If we change OpTy, also set shouldCast to true so it gets
1019   // casted below.
1020   switch (Opcode) {
1021     default:
1022       // for most instructions, it doesn't matter
1023       break;
1024     case Instruction::LShr:
1025     case Instruction::UDiv:
1026     case Instruction::URem:
1027       shouldCast = true;
1028       break;
1029     case Instruction::AShr:
1030     case Instruction::SDiv:
1031     case Instruction::SRem:
1032       shouldCast = true;
1033       typeIsSigned = true;
1034       break;
1035   }
1036
1037   // Write out the casted constant if we should, otherwise just write the
1038   // operand.
1039   if (shouldCast) {
1040     Out << "((";
1041     printPrimitiveType(Out, OpTy, typeIsSigned);
1042     Out << ")";
1043     printConstant(CPV);
1044     Out << ")";
1045   } else
1046     printConstant(CPV);
1047 }
1048
1049 void CWriter::writeOperandInternal(Value *Operand) {
1050   if (Instruction *I = dyn_cast<Instruction>(Operand))
1051     if (isInlinableInst(*I) && !isDirectAlloca(I)) {
1052       // Should we inline this instruction to build a tree?
1053       Out << '(';
1054       visit(*I);
1055       Out << ')';
1056       return;
1057     }
1058
1059   Constant* CPV = dyn_cast<Constant>(Operand);
1060   if (CPV && !isa<GlobalValue>(CPV)) {
1061     printConstant(CPV);
1062   } else {
1063     Out << Mang->getValueName(Operand);
1064   }
1065 }
1066
1067 void CWriter::writeOperandRaw(Value *Operand) {
1068   Constant* CPV = dyn_cast<Constant>(Operand);
1069   if (CPV && !isa<GlobalValue>(CPV)) {
1070     printConstant(CPV);
1071   } else {
1072     Out << Mang->getValueName(Operand);
1073   }
1074 }
1075
1076 void CWriter::writeOperand(Value *Operand) {
1077   if (isa<GlobalVariable>(Operand) || isDirectAlloca(Operand))
1078     Out << "(&";  // Global variables are referenced as their addresses by llvm
1079
1080   writeOperandInternal(Operand);
1081
1082   if (isa<GlobalVariable>(Operand) || isDirectAlloca(Operand))
1083     Out << ')';
1084 }
1085
1086 // Some instructions need to have their result value casted back to the
1087 // original types because their operands were casted to the expected type.
1088 // This function takes care of detecting that case and printing the cast
1089 // for the Instruction.
1090 bool CWriter::writeInstructionCast(const Instruction &I) {
1091   const Type *Ty = I.getOperand(0)->getType();
1092   switch (I.getOpcode()) {
1093   case Instruction::LShr:
1094   case Instruction::URem:
1095   case Instruction::UDiv:
1096     Out << "((";
1097     printPrimitiveType(Out, Ty, false);
1098     Out << ")(";
1099     return true;
1100   case Instruction::AShr:
1101   case Instruction::SRem:
1102   case Instruction::SDiv:
1103     Out << "((";
1104     printPrimitiveType(Out, Ty, true);
1105     Out << ")(";
1106     return true;
1107   default: break;
1108   }
1109   return false;
1110 }
1111
1112 // Write the operand with a cast to another type based on the Opcode being used.
1113 // This will be used in cases where an instruction has specific type
1114 // requirements (usually signedness) for its operands.
1115 void CWriter::writeOperandWithCast(Value* Operand, unsigned Opcode) {
1116
1117   // Extract the operand's type, we'll need it.
1118   const Type* OpTy = Operand->getType();
1119
1120   // Indicate whether to do the cast or not.
1121   bool shouldCast = false;
1122
1123   // Indicate whether the cast should be to a signed type or not.
1124   bool castIsSigned = false;
1125
1126   // Based on the Opcode for which this Operand is being written, determine
1127   // the new type to which the operand should be casted by setting the value
1128   // of OpTy. If we change OpTy, also set shouldCast to true.
1129   switch (Opcode) {
1130     default:
1131       // for most instructions, it doesn't matter
1132       break;
1133     case Instruction::LShr:
1134     case Instruction::UDiv:
1135     case Instruction::URem: // Cast to unsigned first
1136       shouldCast = true;
1137       castIsSigned = false;
1138       break;
1139     case Instruction::AShr:
1140     case Instruction::SDiv:
1141     case Instruction::SRem: // Cast to signed first
1142       shouldCast = true;
1143       castIsSigned = true;
1144       break;
1145   }
1146
1147   // Write out the casted operand if we should, otherwise just write the
1148   // operand.
1149   if (shouldCast) {
1150     Out << "((";
1151     printPrimitiveType(Out, OpTy, castIsSigned);
1152     Out << ")";
1153     writeOperand(Operand);
1154     Out << ")";
1155   } else
1156     writeOperand(Operand);
1157 }
1158
1159 // Write the operand with a cast to another type based on the icmp predicate
1160 // being used.
1161 void CWriter::writeOperandWithCast(Value* Operand, ICmpInst::Predicate predicate) {
1162
1163   // Extract the operand's type, we'll need it.
1164   const Type* OpTy = Operand->getType();
1165
1166   // Indicate whether to do the cast or not.
1167   bool shouldCast = false;
1168
1169   // Indicate whether the cast should be to a signed type or not.
1170   bool castIsSigned = false;
1171
1172   // Based on the Opcode for which this Operand is being written, determine
1173   // the new type to which the operand should be casted by setting the value
1174   // of OpTy. If we change OpTy, also set shouldCast to true.
1175   switch (predicate) {
1176     default:
1177       // for eq and ne, it doesn't matter
1178       break;
1179     case ICmpInst::ICMP_UGT:
1180     case ICmpInst::ICMP_UGE:
1181     case ICmpInst::ICMP_ULT:
1182     case ICmpInst::ICMP_ULE:
1183       shouldCast = true;
1184       break;
1185     case ICmpInst::ICMP_SGT:
1186     case ICmpInst::ICMP_SGE:
1187     case ICmpInst::ICMP_SLT:
1188     case ICmpInst::ICMP_SLE:
1189       shouldCast = true;
1190       castIsSigned = true;
1191       break;
1192   }
1193
1194   // Write out the casted operand if we should, otherwise just write the
1195   // operand.
1196   if (shouldCast) {
1197     Out << "((";
1198     if (OpTy->isPrimitiveType())
1199       printPrimitiveType(Out, OpTy, castIsSigned);
1200     else
1201       printType(Out, OpTy);
1202     Out << ")";
1203     writeOperand(Operand);
1204     Out << ")";
1205   } else
1206     writeOperand(Operand);
1207 }
1208
1209 // generateCompilerSpecificCode - This is where we add conditional compilation
1210 // directives to cater to specific compilers as need be.
1211 //
1212 static void generateCompilerSpecificCode(std::ostream& Out) {
1213   // Alloca is hard to get, and we don't want to include stdlib.h here.
1214   Out << "/* get a declaration for alloca */\n"
1215       << "#if defined(__CYGWIN__) || defined(__MINGW32__)\n"
1216       << "extern void *_alloca(unsigned long);\n"
1217       << "#define alloca(x) _alloca(x)\n"
1218       << "#elif defined(__APPLE__)\n"
1219       << "extern void *__builtin_alloca(unsigned long);\n"
1220       << "#define alloca(x) __builtin_alloca(x)\n"
1221       << "#define longjmp _longjmp\n"
1222       << "#define setjmp _setjmp\n"
1223       << "#elif defined(__sun__)\n"
1224       << "#if defined(__sparcv9)\n"
1225       << "extern void *__builtin_alloca(unsigned long);\n"
1226       << "#else\n"
1227       << "extern void *__builtin_alloca(unsigned int);\n"
1228       << "#endif\n"
1229       << "#define alloca(x) __builtin_alloca(x)\n"
1230       << "#elif defined(__FreeBSD__) || defined(__OpenBSD__)\n"
1231       << "#define alloca(x) __builtin_alloca(x)\n"
1232       << "#elif !defined(_MSC_VER)\n"
1233       << "#include <alloca.h>\n"
1234       << "#endif\n\n";
1235
1236   // We output GCC specific attributes to preserve 'linkonce'ness on globals.
1237   // If we aren't being compiled with GCC, just drop these attributes.
1238   Out << "#ifndef __GNUC__  /* Can only support \"linkonce\" vars with GCC */\n"
1239       << "#define __attribute__(X)\n"
1240       << "#endif\n\n";
1241
1242   // On Mac OS X, "external weak" is spelled "__attribute__((weak_import))".
1243   Out << "#if defined(__GNUC__) && defined(__APPLE_CC__)\n"
1244       << "#define __EXTERNAL_WEAK__ __attribute__((weak_import))\n"
1245       << "#elif defined(__GNUC__)\n"
1246       << "#define __EXTERNAL_WEAK__ __attribute__((weak))\n"
1247       << "#else\n"
1248       << "#define __EXTERNAL_WEAK__\n"
1249       << "#endif\n\n";
1250
1251   // For now, turn off the weak linkage attribute on Mac OS X. (See above.)
1252   Out << "#if defined(__GNUC__) && defined(__APPLE_CC__)\n"
1253       << "#define __ATTRIBUTE_WEAK__\n"
1254       << "#elif defined(__GNUC__)\n"
1255       << "#define __ATTRIBUTE_WEAK__ __attribute__((weak))\n"
1256       << "#else\n"
1257       << "#define __ATTRIBUTE_WEAK__\n"
1258       << "#endif\n\n";
1259
1260   // Define NaN and Inf as GCC builtins if using GCC, as 0 otherwise
1261   // From the GCC documentation:
1262   //
1263   //   double __builtin_nan (const char *str)
1264   //
1265   // This is an implementation of the ISO C99 function nan.
1266   //
1267   // Since ISO C99 defines this function in terms of strtod, which we do
1268   // not implement, a description of the parsing is in order. The string is
1269   // parsed as by strtol; that is, the base is recognized by leading 0 or
1270   // 0x prefixes. The number parsed is placed in the significand such that
1271   // the least significant bit of the number is at the least significant
1272   // bit of the significand. The number is truncated to fit the significand
1273   // field provided. The significand is forced to be a quiet NaN.
1274   //
1275   // This function, if given a string literal, is evaluated early enough
1276   // that it is considered a compile-time constant.
1277   //
1278   //   float __builtin_nanf (const char *str)
1279   //
1280   // Similar to __builtin_nan, except the return type is float.
1281   //
1282   //   double __builtin_inf (void)
1283   //
1284   // Similar to __builtin_huge_val, except a warning is generated if the
1285   // target floating-point format does not support infinities. This
1286   // function is suitable for implementing the ISO C99 macro INFINITY.
1287   //
1288   //   float __builtin_inff (void)
1289   //
1290   // Similar to __builtin_inf, except the return type is float.
1291   Out << "#ifdef __GNUC__\n"
1292       << "#define LLVM_NAN(NanStr)   __builtin_nan(NanStr)   /* Double */\n"
1293       << "#define LLVM_NANF(NanStr)  __builtin_nanf(NanStr)  /* Float */\n"
1294       << "#define LLVM_NANS(NanStr)  __builtin_nans(NanStr)  /* Double */\n"
1295       << "#define LLVM_NANSF(NanStr) __builtin_nansf(NanStr) /* Float */\n"
1296       << "#define LLVM_INF           __builtin_inf()         /* Double */\n"
1297       << "#define LLVM_INFF          __builtin_inff()        /* Float */\n"
1298       << "#define LLVM_PREFETCH(addr,rw,locality) "
1299                               "__builtin_prefetch(addr,rw,locality)\n"
1300       << "#define __ATTRIBUTE_CTOR__ __attribute__((constructor))\n"
1301       << "#define __ATTRIBUTE_DTOR__ __attribute__((destructor))\n"
1302       << "#define LLVM_ASM           __asm__\n"
1303       << "#else\n"
1304       << "#define LLVM_NAN(NanStr)   ((double)0.0)           /* Double */\n"
1305       << "#define LLVM_NANF(NanStr)  0.0F                    /* Float */\n"
1306       << "#define LLVM_NANS(NanStr)  ((double)0.0)           /* Double */\n"
1307       << "#define LLVM_NANSF(NanStr) 0.0F                    /* Float */\n"
1308       << "#define LLVM_INF           ((double)0.0)           /* Double */\n"
1309       << "#define LLVM_INFF          0.0F                    /* Float */\n"
1310       << "#define LLVM_PREFETCH(addr,rw,locality)            /* PREFETCH */\n"
1311       << "#define __ATTRIBUTE_CTOR__\n"
1312       << "#define __ATTRIBUTE_DTOR__\n"
1313       << "#define LLVM_ASM(X)\n"
1314       << "#endif\n\n";
1315
1316   // Output target-specific code that should be inserted into main.
1317   Out << "#define CODE_FOR_MAIN() /* Any target-specific code for main()*/\n";
1318   // On X86, set the FP control word to 64-bits of precision instead of 80 bits.
1319   Out << "#if defined(__GNUC__) && !defined(__llvm__)\n"
1320       << "#if defined(i386) || defined(__i386__) || defined(__i386) || "
1321       << "defined(__x86_64__)\n"
1322       << "#undef CODE_FOR_MAIN\n"
1323       << "#define CODE_FOR_MAIN() \\\n"
1324       << "  {short F;__asm__ (\"fnstcw %0\" : \"=m\" (*&F)); \\\n"
1325       << "  F=(F&~0x300)|0x200;__asm__(\"fldcw %0\"::\"m\"(*&F));}\n"
1326       << "#endif\n#endif\n";
1327
1328 }
1329
1330 /// FindStaticTors - Given a static ctor/dtor list, unpack its contents into
1331 /// the StaticTors set.
1332 static void FindStaticTors(GlobalVariable *GV, std::set<Function*> &StaticTors){
1333   ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer());
1334   if (!InitList) return;
1335
1336   for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i)
1337     if (ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i))){
1338       if (CS->getNumOperands() != 2) return;  // Not array of 2-element structs.
1339
1340       if (CS->getOperand(1)->isNullValue())
1341         return;  // Found a null terminator, exit printing.
1342       Constant *FP = CS->getOperand(1);
1343       if (ConstantExpr *CE = dyn_cast<ConstantExpr>(FP))
1344         if (CE->isCast())
1345           FP = CE->getOperand(0);
1346       if (Function *F = dyn_cast<Function>(FP))
1347         StaticTors.insert(F);
1348     }
1349 }
1350
1351 enum SpecialGlobalClass {
1352   NotSpecial = 0,
1353   GlobalCtors, GlobalDtors,
1354   NotPrinted
1355 };
1356
1357 /// getGlobalVariableClass - If this is a global that is specially recognized
1358 /// by LLVM, return a code that indicates how we should handle it.
1359 static SpecialGlobalClass getGlobalVariableClass(const GlobalVariable *GV) {
1360   // If this is a global ctors/dtors list, handle it now.
1361   if (GV->hasAppendingLinkage() && GV->use_empty()) {
1362     if (GV->getName() == "llvm.global_ctors")
1363       return GlobalCtors;
1364     else if (GV->getName() == "llvm.global_dtors")
1365       return GlobalDtors;
1366   }
1367
1368   // Otherwise, it it is other metadata, don't print it.  This catches things
1369   // like debug information.
1370   if (GV->getSection() == "llvm.metadata")
1371     return NotPrinted;
1372
1373   return NotSpecial;
1374 }
1375
1376
1377 bool CWriter::doInitialization(Module &M) {
1378   // Initialize
1379   TheModule = &M;
1380
1381   IL.AddPrototypes(M);
1382
1383   // Ensure that all structure types have names...
1384   Mang = new Mangler(M);
1385   Mang->markCharUnacceptable('.');
1386
1387   // Keep track of which functions are static ctors/dtors so they can have
1388   // an attribute added to their prototypes.
1389   std::set<Function*> StaticCtors, StaticDtors;
1390   for (Module::global_iterator I = M.global_begin(), E = M.global_end();
1391        I != E; ++I) {
1392     switch (getGlobalVariableClass(I)) {
1393     default: break;
1394     case GlobalCtors:
1395       FindStaticTors(I, StaticCtors);
1396       break;
1397     case GlobalDtors:
1398       FindStaticTors(I, StaticDtors);
1399       break;
1400     }
1401   }
1402
1403   // get declaration for alloca
1404   Out << "/* Provide Declarations */\n";
1405   Out << "#include <stdarg.h>\n";      // Varargs support
1406   Out << "#include <setjmp.h>\n";      // Unwind support
1407   generateCompilerSpecificCode(Out);
1408
1409   // Provide a definition for `bool' if not compiling with a C++ compiler.
1410   Out << "\n"
1411       << "#ifndef __cplusplus\ntypedef unsigned char bool;\n#endif\n"
1412
1413       << "\n\n/* Support for floating point constants */\n"
1414       << "typedef unsigned long long ConstantDoubleTy;\n"
1415       << "typedef unsigned int        ConstantFloatTy;\n"
1416
1417       << "\n\n/* Global Declarations */\n";
1418
1419   // First output all the declarations for the program, because C requires
1420   // Functions & globals to be declared before they are used.
1421   //
1422
1423   // Loop over the symbol table, emitting all named constants...
1424   printModuleTypes(M.getSymbolTable());
1425
1426   // Global variable declarations...
1427   if (!M.global_empty()) {
1428     Out << "\n/* External Global Variable Declarations */\n";
1429     for (Module::global_iterator I = M.global_begin(), E = M.global_end();
1430          I != E; ++I) {
1431       if (I->hasExternalLinkage()) {
1432         Out << "extern ";
1433         printType(Out, I->getType()->getElementType(), Mang->getValueName(I));
1434         Out << ";\n";
1435       } else if (I->hasDLLImportLinkage()) {
1436         Out << "__declspec(dllimport) ";
1437         printType(Out, I->getType()->getElementType(), Mang->getValueName(I));
1438         Out << ";\n";
1439       } else if (I->hasExternalWeakLinkage()) {
1440         Out << "extern ";
1441         printType(Out, I->getType()->getElementType(), Mang->getValueName(I));
1442         Out << " __EXTERNAL_WEAK__ ;\n";
1443       }
1444     }
1445   }
1446
1447   // Function declarations
1448   Out << "\n/* Function Declarations */\n";
1449   Out << "double fmod(double, double);\n";   // Support for FP rem
1450   Out << "float fmodf(float, float);\n";
1451
1452   for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
1453     // Don't print declarations for intrinsic functions.
1454     if (!I->getIntrinsicID() && I->getName() != "setjmp" &&
1455         I->getName() != "longjmp" && I->getName() != "_setjmp") {
1456       if (I->hasExternalWeakLinkage())
1457         Out << "extern ";
1458       printFunctionSignature(I, true);
1459       if (I->hasWeakLinkage() || I->hasLinkOnceLinkage())
1460         Out << " __ATTRIBUTE_WEAK__";
1461       if (I->hasExternalWeakLinkage())
1462         Out << " __EXTERNAL_WEAK__";
1463       if (StaticCtors.count(I))
1464         Out << " __ATTRIBUTE_CTOR__";
1465       if (StaticDtors.count(I))
1466         Out << " __ATTRIBUTE_DTOR__";
1467
1468       if (I->hasName() && I->getName()[0] == 1)
1469         Out << " LLVM_ASM(\"" << I->getName().c_str()+1 << "\")";
1470
1471       Out << ";\n";
1472     }
1473   }
1474
1475   // Output the global variable declarations
1476   if (!M.global_empty()) {
1477     Out << "\n\n/* Global Variable Declarations */\n";
1478     for (Module::global_iterator I = M.global_begin(), E = M.global_end();
1479          I != E; ++I)
1480       if (!I->isExternal()) {
1481         // Ignore special globals, such as debug info.
1482         if (getGlobalVariableClass(I))
1483           continue;
1484
1485         if (I->hasInternalLinkage())
1486           Out << "static ";
1487         else
1488           Out << "extern ";
1489         printType(Out, I->getType()->getElementType(), Mang->getValueName(I));
1490
1491         if (I->hasLinkOnceLinkage())
1492           Out << " __attribute__((common))";
1493         else if (I->hasWeakLinkage())
1494           Out << " __ATTRIBUTE_WEAK__";
1495         else if (I->hasExternalWeakLinkage())
1496           Out << " __EXTERNAL_WEAK__";
1497         Out << ";\n";
1498       }
1499   }
1500
1501   // Output the global variable definitions and contents...
1502   if (!M.global_empty()) {
1503     Out << "\n\n/* Global Variable Definitions and Initialization */\n";
1504     for (Module::global_iterator I = M.global_begin(), E = M.global_end();
1505          I != E; ++I)
1506       if (!I->isExternal()) {
1507         // Ignore special globals, such as debug info.
1508         if (getGlobalVariableClass(I))
1509           continue;
1510
1511         if (I->hasInternalLinkage())
1512           Out << "static ";
1513         else if (I->hasDLLImportLinkage())
1514           Out << "__declspec(dllimport) ";
1515         else if (I->hasDLLExportLinkage())
1516           Out << "__declspec(dllexport) ";
1517
1518         printType(Out, I->getType()->getElementType(), Mang->getValueName(I));
1519         if (I->hasLinkOnceLinkage())
1520           Out << " __attribute__((common))";
1521         else if (I->hasWeakLinkage())
1522           Out << " __ATTRIBUTE_WEAK__";
1523
1524         // If the initializer is not null, emit the initializer.  If it is null,
1525         // we try to avoid emitting large amounts of zeros.  The problem with
1526         // this, however, occurs when the variable has weak linkage.  In this
1527         // case, the assembler will complain about the variable being both weak
1528         // and common, so we disable this optimization.
1529         if (!I->getInitializer()->isNullValue()) {
1530           Out << " = " ;
1531           writeOperand(I->getInitializer());
1532         } else if (I->hasWeakLinkage()) {
1533           // We have to specify an initializer, but it doesn't have to be
1534           // complete.  If the value is an aggregate, print out { 0 }, and let
1535           // the compiler figure out the rest of the zeros.
1536           Out << " = " ;
1537           if (isa<StructType>(I->getInitializer()->getType()) ||
1538               isa<ArrayType>(I->getInitializer()->getType()) ||
1539               isa<PackedType>(I->getInitializer()->getType())) {
1540             Out << "{ 0 }";
1541           } else {
1542             // Just print it out normally.
1543             writeOperand(I->getInitializer());
1544           }
1545         }
1546         Out << ";\n";
1547       }
1548   }
1549
1550   if (!M.empty())
1551     Out << "\n\n/* Function Bodies */\n";
1552   return false;
1553 }
1554
1555
1556 /// Output all floating point constants that cannot be printed accurately...
1557 void CWriter::printFloatingPointConstants(Function &F) {
1558   // Scan the module for floating point constants.  If any FP constant is used
1559   // in the function, we want to redirect it here so that we do not depend on
1560   // the precision of the printed form, unless the printed form preserves
1561   // precision.
1562   //
1563   static unsigned FPCounter = 0;
1564   for (constant_iterator I = constant_begin(&F), E = constant_end(&F);
1565        I != E; ++I)
1566     if (const ConstantFP *FPC = dyn_cast<ConstantFP>(*I))
1567       if (!isFPCSafeToPrint(FPC) && // Do not put in FPConstantMap if safe.
1568           !FPConstantMap.count(FPC)) {
1569         double Val = FPC->getValue();
1570
1571         FPConstantMap[FPC] = FPCounter;  // Number the FP constants
1572
1573         if (FPC->getType() == Type::DoubleTy) {
1574           Out << "static const ConstantDoubleTy FPConstant" << FPCounter++
1575               << " = 0x" << std::hex << DoubleToBits(Val) << std::dec
1576               << "ULL;    /* " << Val << " */\n";
1577         } else if (FPC->getType() == Type::FloatTy) {
1578           Out << "static const ConstantFloatTy FPConstant" << FPCounter++
1579               << " = 0x" << std::hex << FloatToBits(Val) << std::dec
1580               << "U;    /* " << Val << " */\n";
1581         } else
1582           assert(0 && "Unknown float type!");
1583       }
1584
1585   Out << '\n';
1586 }
1587
1588
1589 /// printSymbolTable - Run through symbol table looking for type names.  If a
1590 /// type name is found, emit its declaration...
1591 ///
1592 void CWriter::printModuleTypes(const SymbolTable &ST) {
1593   Out << "/* Helper union for bitcasts */\n";
1594   Out << "typedef union {\n";
1595   Out << "  unsigned int Int32;\n";
1596   Out << "  unsigned long long Int64;\n";
1597   Out << "  float Float;\n";
1598   Out << "  double Double;\n";
1599   Out << "} llvmBitCastUnion;\n";
1600
1601   // We are only interested in the type plane of the symbol table.
1602   SymbolTable::type_const_iterator I   = ST.type_begin();
1603   SymbolTable::type_const_iterator End = ST.type_end();
1604
1605   // If there are no type names, exit early.
1606   if (I == End) return;
1607
1608   // Print out forward declarations for structure types before anything else!
1609   Out << "/* Structure forward decls */\n";
1610   for (; I != End; ++I)
1611     if (const Type *STy = dyn_cast<StructType>(I->second)) {
1612       std::string Name = "struct l_" + Mang->makeNameProper(I->first);
1613       Out << Name << ";\n";
1614       TypeNames.insert(std::make_pair(STy, Name));
1615     }
1616
1617   Out << '\n';
1618
1619   // Now we can print out typedefs...
1620   Out << "/* Typedefs */\n";
1621   for (I = ST.type_begin(); I != End; ++I) {
1622     const Type *Ty = cast<Type>(I->second);
1623     std::string Name = "l_" + Mang->makeNameProper(I->first);
1624     Out << "typedef ";
1625     printType(Out, Ty, Name);
1626     Out << ";\n";
1627   }
1628
1629   Out << '\n';
1630
1631   // Keep track of which structures have been printed so far...
1632   std::set<const StructType *> StructPrinted;
1633
1634   // Loop over all structures then push them into the stack so they are
1635   // printed in the correct order.
1636   //
1637   Out << "/* Structure contents */\n";
1638   for (I = ST.type_begin(); I != End; ++I)
1639     if (const StructType *STy = dyn_cast<StructType>(I->second))
1640       // Only print out used types!
1641       printContainedStructs(STy, StructPrinted);
1642 }
1643
1644 // Push the struct onto the stack and recursively push all structs
1645 // this one depends on.
1646 //
1647 // TODO:  Make this work properly with packed types
1648 //
1649 void CWriter::printContainedStructs(const Type *Ty,
1650                                     std::set<const StructType*> &StructPrinted){
1651   // Don't walk through pointers.
1652   if (isa<PointerType>(Ty) || Ty->isPrimitiveType()) return;
1653
1654   // Print all contained types first.
1655   for (Type::subtype_iterator I = Ty->subtype_begin(),
1656        E = Ty->subtype_end(); I != E; ++I)
1657     printContainedStructs(*I, StructPrinted);
1658
1659   if (const StructType *STy = dyn_cast<StructType>(Ty)) {
1660     // Check to see if we have already printed this struct.
1661     if (StructPrinted.insert(STy).second) {
1662       // Print structure type out.
1663       std::string Name = TypeNames[STy];
1664       printType(Out, STy, Name, true);
1665       Out << ";\n\n";
1666     }
1667   }
1668 }
1669
1670 void CWriter::printFunctionSignature(const Function *F, bool Prototype) {
1671   /// isCStructReturn - Should this function actually return a struct by-value?
1672   bool isCStructReturn = F->getCallingConv() == CallingConv::CSRet;
1673
1674   if (F->hasInternalLinkage()) Out << "static ";
1675   if (F->hasDLLImportLinkage()) Out << "__declspec(dllimport) ";
1676   if (F->hasDLLExportLinkage()) Out << "__declspec(dllexport) ";
1677   switch (F->getCallingConv()) {
1678    case CallingConv::X86_StdCall:
1679     Out << "__stdcall ";
1680     break;
1681    case CallingConv::X86_FastCall:
1682     Out << "__fastcall ";
1683     break;
1684   }
1685
1686   // Loop over the arguments, printing them...
1687   const FunctionType *FT = cast<FunctionType>(F->getFunctionType());
1688
1689   std::stringstream FunctionInnards;
1690
1691   // Print out the name...
1692   FunctionInnards << Mang->getValueName(F) << '(';
1693
1694   bool PrintedArg = false;
1695   if (!F->isExternal()) {
1696     if (!F->arg_empty()) {
1697       Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();
1698
1699       // If this is a struct-return function, don't print the hidden
1700       // struct-return argument.
1701       if (isCStructReturn) {
1702         assert(I != E && "Invalid struct return function!");
1703         ++I;
1704       }
1705
1706       std::string ArgName;
1707       for (; I != E; ++I) {
1708         if (PrintedArg) FunctionInnards << ", ";
1709         if (I->hasName() || !Prototype)
1710           ArgName = Mang->getValueName(I);
1711         else
1712           ArgName = "";
1713         printType(FunctionInnards, I->getType(), ArgName);
1714         PrintedArg = true;
1715       }
1716     }
1717   } else {
1718     // Loop over the arguments, printing them.
1719     FunctionType::param_iterator I = FT->param_begin(), E = FT->param_end();
1720
1721     // If this is a struct-return function, don't print the hidden
1722     // struct-return argument.
1723     if (isCStructReturn) {
1724       assert(I != E && "Invalid struct return function!");
1725       ++I;
1726     }
1727
1728     for (; I != E; ++I) {
1729       if (PrintedArg) FunctionInnards << ", ";
1730       printType(FunctionInnards, *I);
1731       PrintedArg = true;
1732     }
1733   }
1734
1735   // Finish printing arguments... if this is a vararg function, print the ...,
1736   // unless there are no known types, in which case, we just emit ().
1737   //
1738   if (FT->isVarArg() && PrintedArg) {
1739     if (PrintedArg) FunctionInnards << ", ";
1740     FunctionInnards << "...";  // Output varargs portion of signature!
1741   } else if (!FT->isVarArg() && !PrintedArg) {
1742     FunctionInnards << "void"; // ret() -> ret(void) in C.
1743   }
1744   FunctionInnards << ')';
1745
1746   // Get the return tpe for the function.
1747   const Type *RetTy;
1748   if (!isCStructReturn)
1749     RetTy = F->getReturnType();
1750   else {
1751     // If this is a struct-return function, print the struct-return type.
1752     RetTy = cast<PointerType>(FT->getParamType(0))->getElementType();
1753   }
1754
1755   // Print out the return type and the signature built above.
1756   printType(Out, RetTy, FunctionInnards.str());
1757 }
1758
1759 static inline bool isFPIntBitCast(const Instruction &I) {
1760   if (!isa<BitCastInst>(I))
1761     return false;
1762   const Type *SrcTy = I.getOperand(0)->getType();
1763   const Type *DstTy = I.getType();
1764   return (SrcTy->isFloatingPoint() && DstTy->isInteger()) ||
1765          (DstTy->isFloatingPoint() && SrcTy->isInteger());
1766 }
1767
1768 void CWriter::printFunction(Function &F) {
1769   printFunctionSignature(&F, false);
1770   Out << " {\n";
1771
1772   // If this is a struct return function, handle the result with magic.
1773   if (F.getCallingConv() == CallingConv::CSRet) {
1774     const Type *StructTy =
1775       cast<PointerType>(F.arg_begin()->getType())->getElementType();
1776     Out << "  ";
1777     printType(Out, StructTy, "StructReturn");
1778     Out << ";  /* Struct return temporary */\n";
1779
1780     Out << "  ";
1781     printType(Out, F.arg_begin()->getType(), Mang->getValueName(F.arg_begin()));
1782     Out << " = &StructReturn;\n";
1783   }
1784
1785   bool PrintedVar = false;
1786
1787   // print local variable information for the function
1788   for (inst_iterator I = inst_begin(&F), E = inst_end(&F); I != E; ++I) {
1789     if (const AllocaInst *AI = isDirectAlloca(&*I)) {
1790       Out << "  ";
1791       printType(Out, AI->getAllocatedType(), Mang->getValueName(AI));
1792       Out << ";    /* Address-exposed local */\n";
1793       PrintedVar = true;
1794     } else if (I->getType() != Type::VoidTy && !isInlinableInst(*I)) {
1795       Out << "  ";
1796       printType(Out, I->getType(), Mang->getValueName(&*I));
1797       Out << ";\n";
1798
1799       if (isa<PHINode>(*I)) {  // Print out PHI node temporaries as well...
1800         Out << "  ";
1801         printType(Out, I->getType(),
1802                   Mang->getValueName(&*I)+"__PHI_TEMPORARY");
1803         Out << ";\n";
1804       }
1805       PrintedVar = true;
1806     }
1807     // We need a temporary for the BitCast to use so it can pluck a value out
1808     // of a union to do the BitCast. This is separate from the need for a
1809     // variable to hold the result of the BitCast.
1810     if (isFPIntBitCast(*I)) {
1811       Out << "  llvmBitCastUnion " << Mang->getValueName(&*I)
1812           << "__BITCAST_TEMPORARY;\n";
1813       PrintedVar = true;
1814     }
1815   }
1816
1817   if (PrintedVar)
1818     Out << '\n';
1819
1820   if (F.hasExternalLinkage() && F.getName() == "main")
1821     Out << "  CODE_FOR_MAIN();\n";
1822
1823   // print the basic blocks
1824   for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
1825     if (Loop *L = LI->getLoopFor(BB)) {
1826       if (L->getHeader() == BB && L->getParentLoop() == 0)
1827         printLoop(L);
1828     } else {
1829       printBasicBlock(BB);
1830     }
1831   }
1832
1833   Out << "}\n\n";
1834 }
1835
1836 void CWriter::printLoop(Loop *L) {
1837   Out << "  do {     /* Syntactic loop '" << L->getHeader()->getName()
1838       << "' to make GCC happy */\n";
1839   for (unsigned i = 0, e = L->getBlocks().size(); i != e; ++i) {
1840     BasicBlock *BB = L->getBlocks()[i];
1841     Loop *BBLoop = LI->getLoopFor(BB);
1842     if (BBLoop == L)
1843       printBasicBlock(BB);
1844     else if (BB == BBLoop->getHeader() && BBLoop->getParentLoop() == L)
1845       printLoop(BBLoop);
1846   }
1847   Out << "  } while (1); /* end of syntactic loop '"
1848       << L->getHeader()->getName() << "' */\n";
1849 }
1850
1851 void CWriter::printBasicBlock(BasicBlock *BB) {
1852
1853   // Don't print the label for the basic block if there are no uses, or if
1854   // the only terminator use is the predecessor basic block's terminator.
1855   // We have to scan the use list because PHI nodes use basic blocks too but
1856   // do not require a label to be generated.
1857   //
1858   bool NeedsLabel = false;
1859   for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
1860     if (isGotoCodeNecessary(*PI, BB)) {
1861       NeedsLabel = true;
1862       break;
1863     }
1864
1865   if (NeedsLabel) Out << Mang->getValueName(BB) << ":\n";
1866
1867   // Output all of the instructions in the basic block...
1868   for (BasicBlock::iterator II = BB->begin(), E = --BB->end(); II != E;
1869        ++II) {
1870     if (!isInlinableInst(*II) && !isDirectAlloca(II)) {
1871       if (II->getType() != Type::VoidTy && !isInlineAsm(*II))
1872         outputLValue(II);
1873       else
1874         Out << "  ";
1875       visit(*II);
1876       Out << ";\n";
1877     }
1878   }
1879
1880   // Don't emit prefix or suffix for the terminator...
1881   visit(*BB->getTerminator());
1882 }
1883
1884
1885 // Specific Instruction type classes... note that all of the casts are
1886 // necessary because we use the instruction classes as opaque types...
1887 //
1888 void CWriter::visitReturnInst(ReturnInst &I) {
1889   // If this is a struct return function, return the temporary struct.
1890   if (I.getParent()->getParent()->getCallingConv() == CallingConv::CSRet) {
1891     Out << "  return StructReturn;\n";
1892     return;
1893   }
1894
1895   // Don't output a void return if this is the last basic block in the function
1896   if (I.getNumOperands() == 0 &&
1897       &*--I.getParent()->getParent()->end() == I.getParent() &&
1898       !I.getParent()->size() == 1) {
1899     return;
1900   }
1901
1902   Out << "  return";
1903   if (I.getNumOperands()) {
1904     Out << ' ';
1905     writeOperand(I.getOperand(0));
1906   }
1907   Out << ";\n";
1908 }
1909
1910 void CWriter::visitSwitchInst(SwitchInst &SI) {
1911
1912   Out << "  switch (";
1913   writeOperand(SI.getOperand(0));
1914   Out << ") {\n  default:\n";
1915   printPHICopiesForSuccessor (SI.getParent(), SI.getDefaultDest(), 2);
1916   printBranchToBlock(SI.getParent(), SI.getDefaultDest(), 2);
1917   Out << ";\n";
1918   for (unsigned i = 2, e = SI.getNumOperands(); i != e; i += 2) {
1919     Out << "  case ";
1920     writeOperand(SI.getOperand(i));
1921     Out << ":\n";
1922     BasicBlock *Succ = cast<BasicBlock>(SI.getOperand(i+1));
1923     printPHICopiesForSuccessor (SI.getParent(), Succ, 2);
1924     printBranchToBlock(SI.getParent(), Succ, 2);
1925     if (Function::iterator(Succ) == next(Function::iterator(SI.getParent())))
1926       Out << "    break;\n";
1927   }
1928   Out << "  }\n";
1929 }
1930
1931 void CWriter::visitUnreachableInst(UnreachableInst &I) {
1932   Out << "  /*UNREACHABLE*/;\n";
1933 }
1934
1935 bool CWriter::isGotoCodeNecessary(BasicBlock *From, BasicBlock *To) {
1936   /// FIXME: This should be reenabled, but loop reordering safe!!
1937   return true;
1938
1939   if (next(Function::iterator(From)) != Function::iterator(To))
1940     return true;  // Not the direct successor, we need a goto.
1941
1942   //isa<SwitchInst>(From->getTerminator())
1943
1944   if (LI->getLoopFor(From) != LI->getLoopFor(To))
1945     return true;
1946   return false;
1947 }
1948
1949 void CWriter::printPHICopiesForSuccessor (BasicBlock *CurBlock,
1950                                           BasicBlock *Successor,
1951                                           unsigned Indent) {
1952   for (BasicBlock::iterator I = Successor->begin(); isa<PHINode>(I); ++I) {
1953     PHINode *PN = cast<PHINode>(I);
1954     // Now we have to do the printing.
1955     Value *IV = PN->getIncomingValueForBlock(CurBlock);
1956     if (!isa<UndefValue>(IV)) {
1957       Out << std::string(Indent, ' ');
1958       Out << "  " << Mang->getValueName(I) << "__PHI_TEMPORARY = ";
1959       writeOperand(IV);
1960       Out << ";   /* for PHI node */\n";
1961     }
1962   }
1963 }
1964
1965 void CWriter::printBranchToBlock(BasicBlock *CurBB, BasicBlock *Succ,
1966                                  unsigned Indent) {
1967   if (isGotoCodeNecessary(CurBB, Succ)) {
1968     Out << std::string(Indent, ' ') << "  goto ";
1969     writeOperand(Succ);
1970     Out << ";\n";
1971   }
1972 }
1973
1974 // Branch instruction printing - Avoid printing out a branch to a basic block
1975 // that immediately succeeds the current one.
1976 //
1977 void CWriter::visitBranchInst(BranchInst &I) {
1978
1979   if (I.isConditional()) {
1980     if (isGotoCodeNecessary(I.getParent(), I.getSuccessor(0))) {
1981       Out << "  if (";
1982       writeOperand(I.getCondition());
1983       Out << ") {\n";
1984
1985       printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(0), 2);
1986       printBranchToBlock(I.getParent(), I.getSuccessor(0), 2);
1987
1988       if (isGotoCodeNecessary(I.getParent(), I.getSuccessor(1))) {
1989         Out << "  } else {\n";
1990         printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(1), 2);
1991         printBranchToBlock(I.getParent(), I.getSuccessor(1), 2);
1992       }
1993     } else {
1994       // First goto not necessary, assume second one is...
1995       Out << "  if (!";
1996       writeOperand(I.getCondition());
1997       Out << ") {\n";
1998
1999       printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(1), 2);
2000       printBranchToBlock(I.getParent(), I.getSuccessor(1), 2);
2001     }
2002
2003     Out << "  }\n";
2004   } else {
2005     printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(0), 0);
2006     printBranchToBlock(I.getParent(), I.getSuccessor(0), 0);
2007   }
2008   Out << "\n";
2009 }
2010
2011 // PHI nodes get copied into temporary values at the end of predecessor basic
2012 // blocks.  We now need to copy these temporary values into the REAL value for
2013 // the PHI.
2014 void CWriter::visitPHINode(PHINode &I) {
2015   writeOperand(&I);
2016   Out << "__PHI_TEMPORARY";
2017 }
2018
2019
2020 void CWriter::visitBinaryOperator(Instruction &I) {
2021   // binary instructions, shift instructions, setCond instructions.
2022   assert(!isa<PointerType>(I.getType()));
2023
2024   // We must cast the results of binary operations which might be promoted.
2025   bool needsCast = false;
2026   if ((I.getType() == Type::Int8Ty) || (I.getType() == Type::Int16Ty)
2027       || (I.getType() == Type::FloatTy)) {
2028     needsCast = true;
2029     Out << "((";
2030     printType(Out, I.getType());
2031     Out << ")(";
2032   }
2033
2034   // If this is a negation operation, print it out as such.  For FP, we don't
2035   // want to print "-0.0 - X".
2036   if (BinaryOperator::isNeg(&I)) {
2037     Out << "-(";
2038     writeOperand(BinaryOperator::getNegArgument(cast<BinaryOperator>(&I)));
2039     Out << ")";
2040   } else if (I.getOpcode() == Instruction::FRem) {
2041     // Output a call to fmod/fmodf instead of emitting a%b
2042     if (I.getType() == Type::FloatTy)
2043       Out << "fmodf(";
2044     else
2045       Out << "fmod(";
2046     writeOperand(I.getOperand(0));
2047     Out << ", ";
2048     writeOperand(I.getOperand(1));
2049     Out << ")";
2050   } else {
2051
2052     // Write out the cast of the instruction's value back to the proper type
2053     // if necessary.
2054     bool NeedsClosingParens = writeInstructionCast(I);
2055
2056     // Certain instructions require the operand to be forced to a specific type
2057     // so we use writeOperandWithCast here instead of writeOperand. Similarly
2058     // below for operand 1
2059     writeOperandWithCast(I.getOperand(0), I.getOpcode());
2060
2061     switch (I.getOpcode()) {
2062     case Instruction::Add: Out << " + "; break;
2063     case Instruction::Sub: Out << " - "; break;
2064     case Instruction::Mul: Out << '*'; break;
2065     case Instruction::URem:
2066     case Instruction::SRem:
2067     case Instruction::FRem: Out << '%'; break;
2068     case Instruction::UDiv:
2069     case Instruction::SDiv:
2070     case Instruction::FDiv: Out << '/'; break;
2071     case Instruction::And: Out << " & "; break;
2072     case Instruction::Or: Out << " | "; break;
2073     case Instruction::Xor: Out << " ^ "; break;
2074     case Instruction::Shl : Out << " << "; break;
2075     case Instruction::LShr:
2076     case Instruction::AShr: Out << " >> "; break;
2077     default: cerr << "Invalid operator type!" << I; abort();
2078     }
2079
2080     writeOperandWithCast(I.getOperand(1), I.getOpcode());
2081     if (NeedsClosingParens)
2082       Out << "))";
2083   }
2084
2085   if (needsCast) {
2086     Out << "))";
2087   }
2088 }
2089
2090 void CWriter::visitICmpInst(ICmpInst &I) {
2091   // We must cast the results of icmp which might be promoted.
2092   bool needsCast = false;
2093
2094   // Write out the cast of the instruction's value back to the proper type
2095   // if necessary.
2096   bool NeedsClosingParens = writeInstructionCast(I);
2097
2098   // Certain icmp predicate require the operand to be forced to a specific type
2099   // so we use writeOperandWithCast here instead of writeOperand. Similarly
2100   // below for operand 1
2101   writeOperandWithCast(I.getOperand(0), I.getPredicate());
2102
2103   switch (I.getPredicate()) {
2104   case ICmpInst::ICMP_EQ:  Out << " == "; break;
2105   case ICmpInst::ICMP_NE:  Out << " != "; break;
2106   case ICmpInst::ICMP_ULE:
2107   case ICmpInst::ICMP_SLE: Out << " <= "; break;
2108   case ICmpInst::ICMP_UGE:
2109   case ICmpInst::ICMP_SGE: Out << " >= "; break;
2110   case ICmpInst::ICMP_ULT:
2111   case ICmpInst::ICMP_SLT: Out << " < "; break;
2112   case ICmpInst::ICMP_UGT:
2113   case ICmpInst::ICMP_SGT: Out << " > "; break;
2114   default: cerr << "Invalid icmp predicate!" << I; abort();
2115   }
2116
2117   writeOperandWithCast(I.getOperand(1), I.getPredicate());
2118   if (NeedsClosingParens)
2119     Out << "))";
2120
2121   if (needsCast) {
2122     Out << "))";
2123   }
2124 }
2125
2126 void CWriter::visitFCmpInst(FCmpInst &I) {
2127   // Write the first operand
2128   writeOperand(I.getOperand(0));
2129
2130   // Write the predicate
2131   switch (I.getPredicate()) {
2132   case FCmpInst::FCMP_FALSE: Out << " 0 "; break;
2133   case FCmpInst::FCMP_ORD:
2134   case FCmpInst::FCMP_OEQ:
2135   case FCmpInst::FCMP_UEQ:   Out << " == "; break;
2136   case FCmpInst::FCMP_UNO:
2137   case FCmpInst::FCMP_ONE:
2138   case FCmpInst::FCMP_UNE:   Out << " != "; break;
2139   case FCmpInst::FCMP_ULE:
2140   case FCmpInst::FCMP_OLE:   Out << " <= "; break;
2141   case FCmpInst::FCMP_UGE:
2142   case FCmpInst::FCMP_OGE:   Out << " >= "; break;
2143   case FCmpInst::FCMP_ULT:
2144   case FCmpInst::FCMP_OLT:   Out << " < "; break;
2145   case FCmpInst::FCMP_UGT:
2146   case FCmpInst::FCMP_OGT:   Out << " > "; break;
2147   case FCmpInst::FCMP_TRUE:  Out << " 1 "; break;
2148   default: cerr << "Invalid fcmp predicate!" << I; abort();
2149   }
2150   // Write the second operand
2151   writeOperand(I.getOperand(1));
2152 }
2153
2154 static const char * getFloatBitCastField(const Type *Ty) {
2155   switch (Ty->getTypeID()) {
2156     default: assert(0 && "Invalid Type");
2157     case Type::FloatTyID:  return "Float";
2158     case Type::Int32TyID:  return "Int32";
2159     case Type::DoubleTyID: return "Double";
2160     case Type::Int64TyID:  return "Int64";
2161   }
2162 }
2163
2164 void CWriter::visitCastInst(CastInst &I) {
2165   const Type *DstTy = I.getType();
2166   const Type *SrcTy = I.getOperand(0)->getType();
2167   Out << '(';
2168   if (isFPIntBitCast(I)) {
2169     // These int<->float and long<->double casts need to be handled specially
2170     Out << Mang->getValueName(&I) << "__BITCAST_TEMPORARY."
2171         << getFloatBitCastField(I.getOperand(0)->getType()) << " = ";
2172     writeOperand(I.getOperand(0));
2173     Out << ", " << Mang->getValueName(&I) << "__BITCAST_TEMPORARY."
2174         << getFloatBitCastField(I.getType());
2175   } else {
2176     printCast(I.getOpcode(), SrcTy, DstTy);
2177     if (I.getOpcode() == Instruction::SExt && SrcTy == Type::BoolTy) {
2178       // Make sure we really get a sext from bool by subtracing the bool from 0
2179       Out << "0-";
2180     }
2181     writeOperand(I.getOperand(0));
2182     if (DstTy == Type::BoolTy &&
2183         (I.getOpcode() == Instruction::Trunc ||
2184          I.getOpcode() == Instruction::FPToUI ||
2185          I.getOpcode() == Instruction::FPToSI ||
2186          I.getOpcode() == Instruction::PtrToInt)) {
2187       // Make sure we really get a trunc to bool by anding the operand with 1
2188       Out << "&1u";
2189     }
2190   }
2191   Out << ')';
2192 }
2193
2194 void CWriter::visitSelectInst(SelectInst &I) {
2195   Out << "((";
2196   writeOperand(I.getCondition());
2197   Out << ") ? (";
2198   writeOperand(I.getTrueValue());
2199   Out << ") : (";
2200   writeOperand(I.getFalseValue());
2201   Out << "))";
2202 }
2203
2204
2205 void CWriter::lowerIntrinsics(Function &F) {
2206   for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
2207     for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; )
2208       if (CallInst *CI = dyn_cast<CallInst>(I++))
2209         if (Function *F = CI->getCalledFunction())
2210           switch (F->getIntrinsicID()) {
2211           case Intrinsic::not_intrinsic:
2212           case Intrinsic::vastart:
2213           case Intrinsic::vacopy:
2214           case Intrinsic::vaend:
2215           case Intrinsic::returnaddress:
2216           case Intrinsic::frameaddress:
2217           case Intrinsic::setjmp:
2218           case Intrinsic::longjmp:
2219           case Intrinsic::prefetch:
2220           case Intrinsic::dbg_stoppoint:
2221           case Intrinsic::powi_f32:
2222           case Intrinsic::powi_f64:
2223             // We directly implement these intrinsics
2224             break;
2225           default:
2226             // If this is an intrinsic that directly corresponds to a GCC
2227             // builtin, we handle it.
2228             const char *BuiltinName = "";
2229 #define GET_GCC_BUILTIN_NAME
2230 #include "llvm/Intrinsics.gen"
2231 #undef GET_GCC_BUILTIN_NAME
2232             // If we handle it, don't lower it.
2233             if (BuiltinName[0]) break;
2234
2235             // All other intrinsic calls we must lower.
2236             Instruction *Before = 0;
2237             if (CI != &BB->front())
2238               Before = prior(BasicBlock::iterator(CI));
2239
2240             IL.LowerIntrinsicCall(CI);
2241             if (Before) {        // Move iterator to instruction after call
2242               I = Before; ++I;
2243             } else {
2244               I = BB->begin();
2245             }
2246             break;
2247           }
2248 }
2249
2250
2251
2252 void CWriter::visitCallInst(CallInst &I) {
2253   //check if we have inline asm
2254   if (isInlineAsm(I)) {
2255     visitInlineAsm(I);
2256     return;
2257   }
2258
2259   bool WroteCallee = false;
2260
2261   // Handle intrinsic function calls first...
2262   if (Function *F = I.getCalledFunction())
2263     if (Intrinsic::ID ID = (Intrinsic::ID)F->getIntrinsicID()) {
2264       switch (ID) {
2265       default: {
2266         // If this is an intrinsic that directly corresponds to a GCC
2267         // builtin, we emit it here.
2268         const char *BuiltinName = "";
2269 #define GET_GCC_BUILTIN_NAME
2270 #include "llvm/Intrinsics.gen"
2271 #undef GET_GCC_BUILTIN_NAME
2272         assert(BuiltinName[0] && "Unknown LLVM intrinsic!");
2273
2274         Out << BuiltinName;
2275         WroteCallee = true;
2276         break;
2277       }
2278       case Intrinsic::vastart:
2279         Out << "0; ";
2280
2281         Out << "va_start(*(va_list*)";
2282         writeOperand(I.getOperand(1));
2283         Out << ", ";
2284         // Output the last argument to the enclosing function...
2285         if (I.getParent()->getParent()->arg_empty()) {
2286           cerr << "The C backend does not currently support zero "
2287                << "argument varargs functions, such as '"
2288                << I.getParent()->getParent()->getName() << "'!\n";
2289           abort();
2290         }
2291         writeOperand(--I.getParent()->getParent()->arg_end());
2292         Out << ')';
2293         return;
2294       case Intrinsic::vaend:
2295         if (!isa<ConstantPointerNull>(I.getOperand(1))) {
2296           Out << "0; va_end(*(va_list*)";
2297           writeOperand(I.getOperand(1));
2298           Out << ')';
2299         } else {
2300           Out << "va_end(*(va_list*)0)";
2301         }
2302         return;
2303       case Intrinsic::vacopy:
2304         Out << "0; ";
2305         Out << "va_copy(*(va_list*)";
2306         writeOperand(I.getOperand(1));
2307         Out << ", *(va_list*)";
2308         writeOperand(I.getOperand(2));
2309         Out << ')';
2310         return;
2311       case Intrinsic::returnaddress:
2312         Out << "__builtin_return_address(";
2313         writeOperand(I.getOperand(1));
2314         Out << ')';
2315         return;
2316       case Intrinsic::frameaddress:
2317         Out << "__builtin_frame_address(";
2318         writeOperand(I.getOperand(1));
2319         Out << ')';
2320         return;
2321       case Intrinsic::powi_f32:
2322       case Intrinsic::powi_f64:
2323         Out << "__builtin_powi(";
2324         writeOperand(I.getOperand(1));
2325         Out << ", ";
2326         writeOperand(I.getOperand(2));
2327         Out << ')';
2328         return;
2329       case Intrinsic::setjmp:
2330         Out << "setjmp(*(jmp_buf*)";
2331         writeOperand(I.getOperand(1));
2332         Out << ')';
2333         return;
2334       case Intrinsic::longjmp:
2335         Out << "longjmp(*(jmp_buf*)";
2336         writeOperand(I.getOperand(1));
2337         Out << ", ";
2338         writeOperand(I.getOperand(2));
2339         Out << ')';
2340         return;
2341       case Intrinsic::prefetch:
2342         Out << "LLVM_PREFETCH((const void *)";
2343         writeOperand(I.getOperand(1));
2344         Out << ", ";
2345         writeOperand(I.getOperand(2));
2346         Out << ", ";
2347         writeOperand(I.getOperand(3));
2348         Out << ")";
2349         return;
2350       case Intrinsic::dbg_stoppoint: {
2351         // If we use writeOperand directly we get a "u" suffix which is rejected
2352         // by gcc.
2353         DbgStopPointInst &SPI = cast<DbgStopPointInst>(I);
2354
2355         Out << "\n#line "
2356             << SPI.getLine()
2357             << " \"" << SPI.getDirectory()
2358             << SPI.getFileName() << "\"\n";
2359         return;
2360       }
2361       }
2362     }
2363
2364   Value *Callee = I.getCalledValue();
2365
2366   // If this is a call to a struct-return function, assign to the first
2367   // parameter instead of passing it to the call.
2368   bool isStructRet = I.getCallingConv() == CallingConv::CSRet;
2369   if (isStructRet) {
2370     Out << "*(";
2371     writeOperand(I.getOperand(1));
2372     Out << ") = ";
2373   }
2374
2375   if (I.isTailCall()) Out << " /*tail*/ ";
2376
2377   const PointerType  *PTy   = cast<PointerType>(Callee->getType());
2378   const FunctionType *FTy   = cast<FunctionType>(PTy->getElementType());
2379
2380   if (!WroteCallee) {
2381     // If this is an indirect call to a struct return function, we need to cast
2382     // the pointer.
2383     bool NeedsCast = isStructRet && !isa<Function>(Callee);
2384
2385     // GCC is a real PITA.  It does not permit codegening casts of functions to
2386     // function pointers if they are in a call (it generates a trap instruction
2387     // instead!).  We work around this by inserting a cast to void* in between
2388     // the function and the function pointer cast.  Unfortunately, we can't just
2389     // form the constant expression here, because the folder will immediately
2390     // nuke it.
2391     //
2392     // Note finally, that this is completely unsafe.  ANSI C does not guarantee
2393     // that void* and function pointers have the same size. :( To deal with this
2394     // in the common case, we handle casts where the number of arguments passed
2395     // match exactly.
2396     //
2397     if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Callee))
2398       if (CE->isCast())
2399         if (Function *RF = dyn_cast<Function>(CE->getOperand(0))) {
2400           NeedsCast = true;
2401           Callee = RF;
2402         }
2403
2404     if (NeedsCast) {
2405       // Ok, just cast the pointer type.
2406       Out << "((";
2407       if (!isStructRet)
2408         printType(Out, I.getCalledValue()->getType());
2409       else
2410         printStructReturnPointerFunctionType(Out,
2411                              cast<PointerType>(I.getCalledValue()->getType()));
2412       Out << ")(void*)";
2413     }
2414     writeOperand(Callee);
2415     if (NeedsCast) Out << ')';
2416   }
2417
2418   Out << '(';
2419
2420   unsigned NumDeclaredParams = FTy->getNumParams();
2421
2422   CallSite::arg_iterator AI = I.op_begin()+1, AE = I.op_end();
2423   unsigned ArgNo = 0;
2424   if (isStructRet) {   // Skip struct return argument.
2425     ++AI;
2426     ++ArgNo;
2427   }
2428
2429   bool PrintedArg = false;
2430   for (; AI != AE; ++AI, ++ArgNo) {
2431     if (PrintedArg) Out << ", ";
2432     if (ArgNo < NumDeclaredParams &&
2433         (*AI)->getType() != FTy->getParamType(ArgNo)) {
2434       Out << '(';
2435       printType(Out, FTy->getParamType(ArgNo));
2436       Out << ')';
2437     }
2438     writeOperand(*AI);
2439     PrintedArg = true;
2440   }
2441   Out << ')';
2442 }
2443
2444
2445 //This converts the llvm constraint string to something gcc is expecting.
2446 //TODO: work out platform independent constraints and factor those out
2447 //      of the per target tables
2448 //      handle multiple constraint codes
2449 std::string CWriter::InterpretASMConstraint(InlineAsm::ConstraintInfo& c) {
2450
2451   assert(c.Codes.size() == 1 && "Too many asm constraint codes to handle");
2452
2453   const char** table = 0;
2454
2455   //Grab the translation table from TargetAsmInfo if it exists
2456   if (!TAsm) {
2457     std::string E;
2458     const TargetMachineRegistry::Entry* Match =
2459       TargetMachineRegistry::getClosestStaticTargetForModule(*TheModule, E);
2460     if (Match) {
2461       //Per platform Target Machines don't exist, so create it
2462       // this must be done only once
2463       const TargetMachine* TM = Match->CtorFn(*TheModule, "");
2464       TAsm = TM->getTargetAsmInfo();
2465     }
2466   }
2467   if (TAsm)
2468     table = TAsm->getAsmCBE();
2469
2470   //Search the translation table if it exists
2471   for (int i = 0; table && table[i]; i += 2)
2472     if (c.Codes[0] == table[i])
2473       return table[i+1];
2474
2475   //default is identity
2476   return c.Codes[0];
2477 }
2478
2479 //TODO: import logic from AsmPrinter.cpp
2480 static std::string gccifyAsm(std::string asmstr) {
2481   for (std::string::size_type i = 0; i != asmstr.size(); ++i)
2482     if (asmstr[i] == '\n')
2483       asmstr.replace(i, 1, "\\n");
2484     else if (asmstr[i] == '\t')
2485       asmstr.replace(i, 1, "\\t");
2486     else if (asmstr[i] == '$') {
2487       if (asmstr[i + 1] == '{') {
2488         std::string::size_type a = asmstr.find_first_of(':', i + 1);
2489         std::string::size_type b = asmstr.find_first_of('}', i + 1);
2490         std::string n = "%" +
2491           asmstr.substr(a + 1, b - a - 1) +
2492           asmstr.substr(i + 2, a - i - 2);
2493         asmstr.replace(i, b - i + 1, n);
2494         i += n.size() - 1;
2495       } else
2496         asmstr.replace(i, 1, "%");
2497     }
2498     else if (asmstr[i] == '%')//grr
2499       { asmstr.replace(i, 1, "%%"); ++i;}
2500
2501   return asmstr;
2502 }
2503
2504 //TODO: assumptions about what consume arguments from the call are likely wrong
2505 //      handle communitivity
2506 void CWriter::visitInlineAsm(CallInst &CI) {
2507   InlineAsm* as = cast<InlineAsm>(CI.getOperand(0));
2508   std::vector<InlineAsm::ConstraintInfo> Constraints = as->ParseConstraints();
2509   std::vector<std::pair<std::string, Value*> > Input;
2510   std::vector<std::pair<std::string, Value*> > Output;
2511   std::string Clobber;
2512   int count = CI.getType() == Type::VoidTy ? 1 : 0;
2513   for (std::vector<InlineAsm::ConstraintInfo>::iterator I = Constraints.begin(),
2514          E = Constraints.end(); I != E; ++I) {
2515     assert(I->Codes.size() == 1 && "Too many asm constraint codes to handle");
2516     std::string c =
2517       InterpretASMConstraint(*I);
2518     switch(I->Type) {
2519     default:
2520       assert(0 && "Unknown asm constraint");
2521       break;
2522     case InlineAsm::isInput: {
2523       if (c.size()) {
2524         Input.push_back(std::make_pair(c, count ? CI.getOperand(count) : &CI));
2525         ++count; //consume arg
2526       }
2527       break;
2528     }
2529     case InlineAsm::isOutput: {
2530       if (c.size()) {
2531         Output.push_back(std::make_pair("="+((I->isEarlyClobber ? "&" : "")+c),
2532                                         count ? CI.getOperand(count) : &CI));
2533         ++count; //consume arg
2534       }
2535       break;
2536     }
2537     case InlineAsm::isClobber: {
2538       if (c.size())
2539         Clobber += ",\"" + c + "\"";
2540       break;
2541     }
2542     }
2543   }
2544
2545   //fix up the asm string for gcc
2546   std::string asmstr = gccifyAsm(as->getAsmString());
2547
2548   Out << "__asm__ volatile (\"" << asmstr << "\"\n";
2549   Out << "        :";
2550   for (std::vector<std::pair<std::string, Value*> >::iterator I = Output.begin(),
2551          E = Output.end(); I != E; ++I) {
2552     Out << "\"" << I->first << "\"(";
2553     writeOperandRaw(I->second);
2554     Out << ")";
2555     if (I + 1 != E)
2556       Out << ",";
2557   }
2558   Out << "\n        :";
2559   for (std::vector<std::pair<std::string, Value*> >::iterator I = Input.begin(),
2560          E = Input.end(); I != E; ++I) {
2561     Out << "\"" << I->first << "\"(";
2562     writeOperandRaw(I->second);
2563     Out << ")";
2564     if (I + 1 != E)
2565       Out << ",";
2566   }
2567   if (Clobber.size())
2568     Out << "\n        :" << Clobber.substr(1);
2569   Out << ")";
2570 }
2571
2572 void CWriter::visitMallocInst(MallocInst &I) {
2573   assert(0 && "lowerallocations pass didn't work!");
2574 }
2575
2576 void CWriter::visitAllocaInst(AllocaInst &I) {
2577   Out << '(';
2578   printType(Out, I.getType());
2579   Out << ") alloca(sizeof(";
2580   printType(Out, I.getType()->getElementType());
2581   Out << ')';
2582   if (I.isArrayAllocation()) {
2583     Out << " * " ;
2584     writeOperand(I.getOperand(0));
2585   }
2586   Out << ')';
2587 }
2588
2589 void CWriter::visitFreeInst(FreeInst &I) {
2590   assert(0 && "lowerallocations pass didn't work!");
2591 }
2592
2593 void CWriter::printIndexingExpression(Value *Ptr, gep_type_iterator I,
2594                                       gep_type_iterator E) {
2595   bool HasImplicitAddress = false;
2596   // If accessing a global value with no indexing, avoid *(&GV) syndrome
2597   if (isa<GlobalValue>(Ptr)) {
2598     HasImplicitAddress = true;
2599   } else if (isDirectAlloca(Ptr)) {
2600     HasImplicitAddress = true;
2601   }
2602
2603   if (I == E) {
2604     if (!HasImplicitAddress)
2605       Out << '*';  // Implicit zero first argument: '*x' is equivalent to 'x[0]'
2606
2607     writeOperandInternal(Ptr);
2608     return;
2609   }
2610
2611   const Constant *CI = dyn_cast<Constant>(I.getOperand());
2612   if (HasImplicitAddress && (!CI || !CI->isNullValue()))
2613     Out << "(&";
2614
2615   writeOperandInternal(Ptr);
2616
2617   if (HasImplicitAddress && (!CI || !CI->isNullValue())) {
2618     Out << ')';
2619     HasImplicitAddress = false;  // HIA is only true if we haven't addressed yet
2620   }
2621
2622   assert(!HasImplicitAddress || (CI && CI->isNullValue()) &&
2623          "Can only have implicit address with direct accessing");
2624
2625   if (HasImplicitAddress) {
2626     ++I;
2627   } else if (CI && CI->isNullValue()) {
2628     gep_type_iterator TmpI = I; ++TmpI;
2629
2630     // Print out the -> operator if possible...
2631     if (TmpI != E && isa<StructType>(*TmpI)) {
2632       Out << (HasImplicitAddress ? "." : "->");
2633       Out << "field" << cast<ConstantInt>(TmpI.getOperand())->getZExtValue();
2634       I = ++TmpI;
2635     }
2636   }
2637
2638   for (; I != E; ++I)
2639     if (isa<StructType>(*I)) {
2640       Out << ".field" << cast<ConstantInt>(I.getOperand())->getZExtValue();
2641     } else {
2642       Out << '[';
2643       writeOperand(I.getOperand());
2644       Out << ']';
2645     }
2646 }
2647
2648 void CWriter::visitLoadInst(LoadInst &I) {
2649   Out << '*';
2650   if (I.isVolatile()) {
2651     Out << "((";
2652     printType(Out, I.getType(), "volatile*");
2653     Out << ")";
2654   }
2655
2656   writeOperand(I.getOperand(0));
2657
2658   if (I.isVolatile())
2659     Out << ')';
2660 }
2661
2662 void CWriter::visitStoreInst(StoreInst &I) {
2663   Out << '*';
2664   if (I.isVolatile()) {
2665     Out << "((";
2666     printType(Out, I.getOperand(0)->getType(), " volatile*");
2667     Out << ")";
2668   }
2669   writeOperand(I.getPointerOperand());
2670   if (I.isVolatile()) Out << ')';
2671   Out << " = ";
2672   writeOperand(I.getOperand(0));
2673 }
2674
2675 void CWriter::visitGetElementPtrInst(GetElementPtrInst &I) {
2676   Out << '&';
2677   printIndexingExpression(I.getPointerOperand(), gep_type_begin(I),
2678                           gep_type_end(I));
2679 }
2680
2681 void CWriter::visitVAArgInst(VAArgInst &I) {
2682   Out << "va_arg(*(va_list*)";
2683   writeOperand(I.getOperand(0));
2684   Out << ", ";
2685   printType(Out, I.getType());
2686   Out << ");\n ";
2687 }
2688
2689 //===----------------------------------------------------------------------===//
2690 //                       External Interface declaration
2691 //===----------------------------------------------------------------------===//
2692
2693 bool CTargetMachine::addPassesToEmitWholeFile(PassManager &PM,
2694                                               std::ostream &o,
2695                                               CodeGenFileType FileType,
2696                                               bool Fast) {
2697   if (FileType != TargetMachine::AssemblyFile) return true;
2698
2699   PM.add(createLowerGCPass());
2700   PM.add(createLowerAllocationsPass(true));
2701   PM.add(createLowerInvokePass());
2702   PM.add(createCFGSimplificationPass());   // clean up after lower invoke.
2703   PM.add(new CBackendNameAllUsedStructsAndMergeFunctions());
2704   PM.add(new CWriter(o));
2705   return false;
2706 }