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