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/Constants.h"
  17 #include "llvm/DerivedTypes.h"
  18 #include "llvm/Module.h"
  19 #include "llvm/Instructions.h"
  20 #include "llvm/Pass.h"
  21 #include "llvm/PassManager.h"
  22 #include "llvm/SymbolTable.h"
  23 #include "llvm/Intrinsics.h"
  24 #include "llvm/Analysis/ConstantsScanner.h"
  25 #include "llvm/Analysis/FindUsedTypes.h"
  26 #include "llvm/Analysis/LoopInfo.h"
  27 #include "llvm/CodeGen/IntrinsicLowering.h"
  28 #include "llvm/Transforms/Scalar.h"
  29 #include "llvm/Target/TargetMachineRegistry.h"
  30 #include "llvm/Support/CallSite.h"
  31 #include "llvm/Support/CFG.h"
  32 #include "llvm/Support/GetElementPtrTypeIterator.h"
  33 #include "llvm/Support/InstVisitor.h"
  34 #include "llvm/Support/Mangler.h"
  35 #include "llvm/Support/MathExtras.h"
  36 #include "llvm/ADT/StringExtras.h"
  37 #include "llvm/ADT/STLExtras.h"
  38 #include "llvm/Support/MathExtras.h"
  39 #include "llvm/Config/config.h"
  40 #include <algorithm>
  41 #include <iostream>
  42 #include <ios>
  43 #include <sstream>
  44 using namespace llvm;
  45
  46 namespace {
  47   // Register the target.
  48   RegisterTarget<CTargetMachine> X("c", "  C backend");
  49
  50   /// NameAllUsedStructs - This pass inserts names for any unnamed structure
  51   /// types that are used by the program.
  52   ///
  53   class CBackendNameAllUsedStructs : public ModulePass {
  54     void getAnalysisUsage(AnalysisUsage &AU) const {
  55       AU.addRequired<FindUsedTypes>();
  56     }
  57
  58     virtual const char *getPassName() const {
  59       return "C backend type canonicalizer";
  60     }
  61
  62     virtual bool runOnModule(Module &M);
  63   };
  64
  65   /// CWriter - This class is the main chunk of code that converts an LLVM
  66   /// module to a C translation unit.
  67   class CWriter : public FunctionPass, public InstVisitor<CWriter> {
  68     std::ostream &Out;
  69     IntrinsicLowering &IL;
  70     Mangler *Mang;
  71     LoopInfo *LI;
  72     const Module *TheModule;
  73     std::map<const Type *, std::string> TypeNames;
  74
  75     std::map<const ConstantFP *, unsigned> FPConstantMap;
  76   public:
  77     CWriter(std::ostream &o, IntrinsicLowering &il) : Out(o), IL(il) {}
  78
  79     virtual const char *getPassName() const { return "C backend"; }
  80
  81     void getAnalysisUsage(AnalysisUsage &AU) const {
  82       AU.addRequired<LoopInfo>();
  83       AU.setPreservesAll();
  84     }
  85
  86     virtual bool doInitialization(Module &M);
  87
  88     bool runOnFunction(Function &F) {
  89       LI = &getAnalysis<LoopInfo>();
  90
  91       // Get rid of intrinsics we can't handle.
  92       lowerIntrinsics(F);
  93
  94       // Output all floating point constants that cannot be printed accurately.
  95       printFloatingPointConstants(F);
  96
  97       // Ensure that no local symbols conflict with global symbols.
  98       F.renameLocalSymbols();
  99
 100       printFunction(F);
 101       FPConstantMap.clear();
 102       return false;
 103     }
 104
 105     virtual bool doFinalization(Module &M) {
 106       // Free memory...
 107       delete Mang;
 108       TypeNames.clear();
 109       return false;
 110     }
 111
 112     std::ostream &printType(std::ostream &Out, const Type *Ty,
 113                             const std::string &VariableName = "",
 114                             bool IgnoreName = false);
 115
 116     void writeOperand(Value *Operand);
 117     void writeOperandInternal(Value *Operand);
 118
 119   private :
 120     void lowerIntrinsics(Function &F);
 121
 122     bool nameAllUsedStructureTypes(Module &M);
 123     void printModule(Module *M);
 124     void printModuleTypes(const SymbolTable &ST);
 125     void printContainedStructs(const Type *Ty, std::set<const StructType *> &);
 126     void printFloatingPointConstants(Function &F);
 127     void printFunctionSignature(const Function *F, bool Prototype);
 128
 129     void printFunction(Function &);
 130     void printBasicBlock(BasicBlock *BB);
 131     void printLoop(Loop *L);
 132
 133     void printConstant(Constant *CPV);
 134     void printConstantArray(ConstantArray *CPA);
 135
 136     // isInlinableInst - Attempt to inline instructions into their uses to build
 137     // trees as much as possible.  To do this, we have to consistently decide
 138     // what is acceptable to inline, so that variable declarations don't get
 139     // printed and an extra copy of the expr is not emitted.
 140     //
 141     static bool isInlinableInst(const Instruction &I) {
 142       // Always inline setcc instructions, even if they are shared by multiple
 143       // expressions.  GCC generates horrible code if we don't.
 144       if (isa<SetCondInst>(I)) return true;
 145
 146       // Must be an expression, must be used exactly once.  If it is dead, we
 147       // emit it inline where it would go.
 148       if (I.getType() == Type::VoidTy || !I.hasOneUse() ||
 149           isa<TerminatorInst>(I) || isa<CallInst>(I) || isa<PHINode>(I) ||
 150           isa<LoadInst>(I) || isa<VAArgInst>(I))
 151         // Don't inline a load across a store or other bad things!
 152         return false;
 153
 154       // Only inline instruction it it's use is in the same BB as the inst.
 155       return I.getParent() == cast<Instruction>(I.use_back())->getParent();
 156     }
 157
 158     // isDirectAlloca - Define fixed sized allocas in the entry block as direct
 159     // variables which are accessed with the & operator.  This causes GCC to
 160     // generate significantly better code than to emit alloca calls directly.
 161     //
 162     static const AllocaInst *isDirectAlloca(const Value *V) {
 163       const AllocaInst *AI = dyn_cast<AllocaInst>(V);
 164       if (!AI) return false;
 165       if (AI->isArrayAllocation())
 166         return 0;   // FIXME: we can also inline fixed size array allocas!
 167       if (AI->getParent() != &AI->getParent()->getParent()->getEntryBlock())
 168         return 0;
 169       return AI;
 170     }
 171
 172     // Instruction visitation functions
 173     friend class InstVisitor<CWriter>;
 174
 175     void visitReturnInst(ReturnInst &I);
 176     void visitBranchInst(BranchInst &I);
 177     void visitSwitchInst(SwitchInst &I);
 178     void visitInvokeInst(InvokeInst &I) {
 179       assert(0 && "Lowerinvoke pass didn't work!");
 180     }
 181
 182     void visitUnwindInst(UnwindInst &I) {
 183       assert(0 && "Lowerinvoke pass didn't work!");
 184     }
 185     void visitUnreachableInst(UnreachableInst &I);
 186
 187     void visitPHINode(PHINode &I);
 188     void visitBinaryOperator(Instruction &I);
 189
 190     void visitCastInst (CastInst &I);
 191     void visitSelectInst(SelectInst &I);
 192     void visitCallInst (CallInst &I);
 193     void visitShiftInst(ShiftInst &I) { visitBinaryOperator(I); }
 194
 195     void visitMallocInst(MallocInst &I);
 196     void visitAllocaInst(AllocaInst &I);
 197     void visitFreeInst  (FreeInst   &I);
 198     void visitLoadInst  (LoadInst   &I);
 199     void visitStoreInst (StoreInst  &I);
 200     void visitGetElementPtrInst(GetElementPtrInst &I);
 201     void visitVAArgInst (VAArgInst &I);
 202
 203     void visitInstruction(Instruction &I) {
 204       std::cerr << "C Writer does not know about " << I;
 205       abort();
 206     }
 207
 208     void outputLValue(Instruction *I) {
 209       Out << "  " << Mang->getValueName(I) << " = ";
 210     }
 211
 212     bool isGotoCodeNecessary(BasicBlock *From, BasicBlock *To);
 213     void printPHICopiesForSuccessor(BasicBlock *CurBlock,
 214                                     BasicBlock *Successor, unsigned Indent);
 215     void printBranchToBlock(BasicBlock *CurBlock, BasicBlock *SuccBlock,
 216                             unsigned Indent);
 217     void printIndexingExpression(Value *Ptr, gep_type_iterator I,
 218                                  gep_type_iterator E);
 219   };
 220 }
 221
 222 /// This method inserts names for any unnamed structure types that are used by
 223 /// the program, and removes names from structure types that are not used by the
 224 /// program.
 225 ///
 226 bool CBackendNameAllUsedStructs::runOnModule(Module &M) {
 227   // Get a set of types that are used by the program...
 228   std::set<const Type *> UT = getAnalysis<FindUsedTypes>().getTypes();
 229
 230   // Loop over the module symbol table, removing types from UT that are
 231   // already named, and removing names for types that are not used.
 232   //
 233   SymbolTable &MST = M.getSymbolTable();
 234   for (SymbolTable::type_iterator TI = MST.type_begin(), TE = MST.type_end();
 235        TI != TE; ) {
 236     SymbolTable::type_iterator I = TI++;
 237
 238     // If this is not used, remove it from the symbol table.
 239     std::set<const Type *>::iterator UTI = UT.find(I->second);
 240     if (UTI == UT.end())
 241       MST.remove(I);
 242     else
 243       UT.erase(UTI);    // Only keep one name for this type.
 244   }
 245
 246   // UT now contains types that are not named.  Loop over it, naming
 247   // structure types.
 248   //
 249   bool Changed = false;
 250   unsigned RenameCounter = 0;
 251   for (std::set<const Type *>::const_iterator I = UT.begin(), E = UT.end();
 252        I != E; ++I)
 253     if (const StructType *ST = dyn_cast<StructType>(*I)) {
 254       while (M.addTypeName("unnamed"+utostr(RenameCounter), ST))
 255         ++RenameCounter;
 256       Changed = true;
 257     }
 258   return Changed;
 259 }
 260
 261
 262 // Pass the Type* and the variable name and this prints out the variable
 263 // declaration.
 264 //
 265 std::ostream &CWriter::printType(std::ostream &Out, const Type *Ty,
 266                                  const std::string &NameSoFar,
 267                                  bool IgnoreName) {
 268   if (Ty->isPrimitiveType())
 269     switch (Ty->getTypeID()) {
 270     case Type::VoidTyID:   return Out << "void "               << NameSoFar;
 271     case Type::BoolTyID:   return Out << "bool "               << NameSoFar;
 272     case Type::UByteTyID:  return Out << "unsigned char "      << NameSoFar;
 273     case Type::SByteTyID:  return Out << "signed char "        << NameSoFar;
 274     case Type::UShortTyID: return Out << "unsigned short "     << NameSoFar;
 275     case Type::ShortTyID:  return Out << "short "              << NameSoFar;
 276     case Type::UIntTyID:   return Out << "unsigned "           << NameSoFar;
 277     case Type::IntTyID:    return Out << "int "                << NameSoFar;
 278     case Type::ULongTyID:  return Out << "unsigned long long " << NameSoFar;
 279     case Type::LongTyID:   return Out << "signed long long "   << NameSoFar;
 280     case Type::FloatTyID:  return Out << "float "              << NameSoFar;
 281     case Type::DoubleTyID: return Out << "double "             << NameSoFar;
 282     default :
 283       std::cerr << "Unknown primitive type: " << *Ty << "\n";
 284       abort();
 285     }
 286
 287   // Check to see if the type is named.
 288   if (!IgnoreName || isa<OpaqueType>(Ty)) {
 289     std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty);
 290     if (I != TypeNames.end()) return Out << I->second << ' ' << NameSoFar;
 291   }
 292
 293   switch (Ty->getTypeID()) {
 294   case Type::FunctionTyID: {
 295     const FunctionType *MTy = cast<FunctionType>(Ty);
 296     std::stringstream FunctionInnards;
 297     FunctionInnards << " (" << NameSoFar << ") (";
 298     for (FunctionType::param_iterator I = MTy->param_begin(),
 299            E = MTy->param_end(); I != E; ++I) {
 300       if (I != MTy->param_begin())
 301         FunctionInnards << ", ";
 302       printType(FunctionInnards, *I, "");
 303     }
 304     if (MTy->isVarArg()) {
 305       if (MTy->getNumParams())
 306         FunctionInnards << ", ...";
 307     } else if (!MTy->getNumParams()) {
 308       FunctionInnards << "void";
 309     }
 310     FunctionInnards << ')';
 311     std::string tstr = FunctionInnards.str();
 312     printType(Out, MTy->getReturnType(), tstr);
 313     return Out;
 314   }
 315   case Type::StructTyID: {
 316     const StructType *STy = cast<StructType>(Ty);
 317     Out << NameSoFar + " {\n";
 318     unsigned Idx = 0;
 319     for (StructType::element_iterator I = STy->element_begin(),
 320            E = STy->element_end(); I != E; ++I) {
 321       Out << "  ";
 322       printType(Out, *I, "field" + utostr(Idx++));
 323       Out << ";\n";
 324     }
 325     return Out << '}';
 326   }
 327
 328   case Type::PointerTyID: {
 329     const PointerType *PTy = cast<PointerType>(Ty);
 330     std::string ptrName = "*" + NameSoFar;
 331
 332     if (isa<ArrayType>(PTy->getElementType()))
 333       ptrName = "(" + ptrName + ")";
 334
 335     return printType(Out, PTy->getElementType(), ptrName);
 336   }
 337
 338   case Type::ArrayTyID: {
 339     const ArrayType *ATy = cast<ArrayType>(Ty);
 340     unsigned NumElements = ATy->getNumElements();
 341     if (NumElements == 0) NumElements = 1;
 342     return printType(Out, ATy->getElementType(),
 343                      NameSoFar + "[" + utostr(NumElements) + "]");
 344   }
 345
 346   case Type::OpaqueTyID: {
 347     static int Count = 0;
 348     std::string TyName = "struct opaque_" + itostr(Count++);
 349     assert(TypeNames.find(Ty) == TypeNames.end());
 350     TypeNames[Ty] = TyName;
 351     return Out << TyName << ' ' << NameSoFar;
 352   }
 353   default:
 354     assert(0 && "Unhandled case in getTypeProps!");
 355     abort();
 356   }
 357
 358   return Out;
 359 }
 360
 361 void CWriter::printConstantArray(ConstantArray *CPA) {
 362
 363   // As a special case, print the array as a string if it is an array of
 364   // ubytes or an array of sbytes with positive values.
 365   //
 366   const Type *ETy = CPA->getType()->getElementType();
 367   bool isString = (ETy == Type::SByteTy || ETy == Type::UByteTy);
 368
 369   // Make sure the last character is a null char, as automatically added by C
 370   if (isString && (CPA->getNumOperands() == 0 ||
 371                    !cast<Constant>(*(CPA->op_end()-1))->isNullValue()))
 372     isString = false;
 373
 374   if (isString) {
 375     Out << '\"';
 376     // Keep track of whether the last number was a hexadecimal escape
 377     bool LastWasHex = false;
 378
 379     // Do not include the last character, which we know is null
 380     for (unsigned i = 0, e = CPA->getNumOperands()-1; i != e; ++i) {
 381       unsigned char C = cast<ConstantInt>(CPA->getOperand(i))->getRawValue();
 382
 383       // Print it out literally if it is a printable character.  The only thing
 384       // to be careful about is when the last letter output was a hex escape
 385       // code, in which case we have to be careful not to print out hex digits
 386       // explicitly (the C compiler thinks it is a continuation of the previous
 387       // character, sheesh...)
 388       //
 389       if (isprint(C) && (!LastWasHex || !isxdigit(C))) {
 390         LastWasHex = false;
 391         if (C == '"' || C == '\\')
 392           Out << "\\" << C;
 393         else
 394           Out << C;
 395       } else {
 396         LastWasHex = false;
 397         switch (C) {
 398         case '\n': Out << "\\n"; break;
 399         case '\t': Out << "\\t"; break;
 400         case '\r': Out << "\\r"; break;
 401         case '\v': Out << "\\v"; break;
 402         case '\a': Out << "\\a"; break;
 403         case '\"': Out << "\\\""; break;
 404         case '\'': Out << "\\\'"; break;
 405         default:
 406           Out << "\\x";
 407           Out << (char)(( C/16  < 10) ? ( C/16 +'0') : ( C/16 -10+'A'));
 408           Out << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A'));
 409           LastWasHex = true;
 410           break;
 411         }
 412       }
 413     }
 414     Out << '\"';
 415   } else {
 416     Out << '{';
 417     if (CPA->getNumOperands()) {
 418       Out << ' ';
 419       printConstant(cast<Constant>(CPA->getOperand(0)));
 420       for (unsigned i = 1, e = CPA->getNumOperands(); i != e; ++i) {
 421         Out << ", ";
 422         printConstant(cast<Constant>(CPA->getOperand(i)));
 423       }
 424     }
 425     Out << " }";
 426   }
 427 }
 428
 429 // isFPCSafeToPrint - Returns true if we may assume that CFP may be written out
 430 // textually as a double (rather than as a reference to a stack-allocated
 431 // variable). We decide this by converting CFP to a string and back into a
 432 // double, and then checking whether the conversion results in a bit-equal
 433 // double to the original value of CFP. This depends on us and the target C
 434 // compiler agreeing on the conversion process (which is pretty likely since we
 435 // only deal in IEEE FP).
 436 //
 437 static bool isFPCSafeToPrint(const ConstantFP *CFP) {
 438 #if HAVE_PRINTF_A
 439   char Buffer[100];
 440   sprintf(Buffer, "%a", CFP->getValue());
 441
 442   if (!strncmp(Buffer, "0x", 2) ||
 443       !strncmp(Buffer, "-0x", 3) ||
 444       !strncmp(Buffer, "+0x", 3))
 445     return atof(Buffer) == CFP->getValue();
 446   return false;
 447 #else
 448   std::string StrVal = ftostr(CFP->getValue());
 449
 450   while (StrVal[0] == ' ')
 451     StrVal.erase(StrVal.begin());
 452
 453   // Check to make sure that the stringized number is not some string like "Inf"
 454   // or NaN.  Check that the string matches the "[-+]?[0-9]" regex.
 455   if ((StrVal[0] >= '0' && StrVal[0] <= '9') ||
 456       ((StrVal[0] == '-' || StrVal[0] == '+') &&
 457        (StrVal[1] >= '0' && StrVal[1] <= '9')))
 458     // Reparse stringized version!
 459     return atof(StrVal.c_str()) == CFP->getValue();
 460   return false;
 461 #endif
 462 }
 463
 464 // printConstant - The LLVM Constant to C Constant converter.
 465 void CWriter::printConstant(Constant *CPV) {
 466   if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CPV)) {
 467     switch (CE->getOpcode()) {
 468     case Instruction::Cast:
 469       Out << "((";
 470       printType(Out, CPV->getType());
 471       Out << ')';
 472       printConstant(CE->getOperand(0));
 473       Out << ')';
 474       return;
 475
 476     case Instruction::GetElementPtr:
 477       Out << "(&(";
 478       printIndexingExpression(CE->getOperand(0), gep_type_begin(CPV),
 479                               gep_type_end(CPV));
 480       Out << "))";
 481       return;
 482     case Instruction::Select:
 483       Out << '(';
 484       printConstant(CE->getOperand(0));
 485       Out << '?';
 486       printConstant(CE->getOperand(1));
 487       Out << ':';
 488       printConstant(CE->getOperand(2));
 489       Out << ')';
 490       return;
 491     case Instruction::Add:
 492     case Instruction::Sub:
 493     case Instruction::Mul:
 494     case Instruction::Div:
 495     case Instruction::Rem:
 496     case Instruction::And:
 497     case Instruction::Or:
 498     case Instruction::Xor:
 499     case Instruction::SetEQ:
 500     case Instruction::SetNE:
 501     case Instruction::SetLT:
 502     case Instruction::SetLE:
 503     case Instruction::SetGT:
 504     case Instruction::SetGE:
 505     case Instruction::Shl:
 506     case Instruction::Shr:
 507       Out << '(';
 508       printConstant(CE->getOperand(0));
 509       switch (CE->getOpcode()) {
 510       case Instruction::Add: Out << " + "; break;
 511       case Instruction::Sub: Out << " - "; break;
 512       case Instruction::Mul: Out << " * "; break;
 513       case Instruction::Div: Out << " / "; break;
 514       case Instruction::Rem: Out << " % "; break;
 515       case Instruction::And: Out << " & "; break;
 516       case Instruction::Or:  Out << " | "; break;
 517       case Instruction::Xor: Out << " ^ "; break;
 518       case Instruction::SetEQ: Out << " == "; break;
 519       case Instruction::SetNE: Out << " != "; break;
 520       case Instruction::SetLT: Out << " < "; break;
 521       case Instruction::SetLE: Out << " <= "; break;
 522       case Instruction::SetGT: Out << " > "; break;
 523       case Instruction::SetGE: Out << " >= "; break;
 524       case Instruction::Shl: Out << " << "; break;
 525       case Instruction::Shr: Out << " >> "; break;
 526       default: assert(0 && "Illegal opcode here!");
 527       }
 528       printConstant(CE->getOperand(1));
 529       Out << ')';
 530       return;
 531
 532     default:
 533       std::cerr << "CWriter Error: Unhandled constant expression: "
 534                 << *CE << "\n";
 535       abort();
 536     }
 537   } else if (isa<UndefValue>(CPV) && CPV->getType()->isFirstClassType()) {
 538     Out << "((";
 539     printType(Out, CPV->getType());
 540     Out << ")/*UNDEF*/0)";
 541     return;
 542   }
 543
 544   switch (CPV->getType()->getTypeID()) {
 545   case Type::BoolTyID:
 546     Out << (CPV == ConstantBool::False ? '0' : '1'); break;
 547   case Type::SByteTyID:
 548   case Type::ShortTyID:
 549     Out << cast<ConstantSInt>(CPV)->getValue(); break;
 550   case Type::IntTyID:
 551     if ((int)cast<ConstantSInt>(CPV)->getValue() == (int)0x80000000)
 552       Out << "((int)0x80000000U)";   // Handle MININT specially to avoid warning
 553     else
 554       Out << cast<ConstantSInt>(CPV)->getValue();
 555     break;
 556
 557   case Type::LongTyID:
 558     if (cast<ConstantSInt>(CPV)->isMinValue())
 559       Out << "(/*INT64_MIN*/(-9223372036854775807LL)-1)";
 560     else
 561       Out << cast<ConstantSInt>(CPV)->getValue() << "ll"; break;
 562
 563   case Type::UByteTyID:
 564   case Type::UShortTyID:
 565     Out << cast<ConstantUInt>(CPV)->getValue(); break;
 566   case Type::UIntTyID:
 567     Out << cast<ConstantUInt>(CPV)->getValue() << 'u'; break;
 568   case Type::ULongTyID:
 569     Out << cast<ConstantUInt>(CPV)->getValue() << "ull"; break;
 570
 571   case Type::FloatTyID:
 572   case Type::DoubleTyID: {
 573     ConstantFP *FPC = cast<ConstantFP>(CPV);
 574     std::map<const ConstantFP*, unsigned>::iterator I = FPConstantMap.find(FPC);
 575     if (I != FPConstantMap.end()) {
 576       // Because of FP precision problems we must load from a stack allocated
 577       // value that holds the value in hex.
 578       Out << "(*(" << (FPC->getType() == Type::FloatTy ? "float" : "double")
 579           << "*)&FPConstant" << I->second << ')';
 580     } else {
 581       if (IsNAN(FPC->getValue())) {
 582         // The value is NaN
 583
 584         // The prefix for a quiet NaN is 0x7FF8. For a signalling NaN,
 585         // it's 0x7ff4.
 586         const unsigned long QuietNaN = 0x7ff8UL;
 587         const unsigned long SignalNaN = 0x7ff4UL;
 588
 589         // We need to grab the first part of the FP #
 590         char Buffer[100];
 591
 592         uint64_t ll = DoubleToBits(FPC->getValue());
 593         sprintf(Buffer, "0x%llx", (unsigned long long)ll);
 594
 595         std::string Num(&Buffer[0], &Buffer[6]);
 596         unsigned long Val = strtoul(Num.c_str(), 0, 16);
 597
 598         if (FPC->getType() == Type::FloatTy)
 599           Out << "LLVM_NAN" << (Val == QuietNaN ? "" : "S") << "F(\""
 600               << Buffer << "\") /*nan*/ ";
 601         else
 602           Out << "LLVM_NAN" << (Val == QuietNaN ? "" : "S") << "(\""
 603               << Buffer << "\") /*nan*/ ";
 604       } else if (IsInf(FPC->getValue())) {
 605         // The value is Inf
 606         if (FPC->getValue() < 0) Out << '-';
 607         Out << "LLVM_INF" << (FPC->getType() == Type::FloatTy ? "F" : "")
 608             << " /*inf*/ ";
 609       } else {
 610         std::string Num;
 611 #if HAVE_PRINTF_A
 612         // Print out the constant as a floating point number.
 613         char Buffer[100];
 614         sprintf(Buffer, "%a", FPC->getValue());
 615         Num = Buffer;
 616 #else
 617         Num = ftostr(FPC->getValue());
 618 #endif
 619         Out << Num;
 620       }
 621     }
 622     break;
 623   }
 624
 625   case Type::ArrayTyID:
 626     if (isa<ConstantAggregateZero>(CPV) || isa<UndefValue>(CPV)) {
 627       const ArrayType *AT = cast<ArrayType>(CPV->getType());
 628       Out << '{';
 629       if (AT->getNumElements()) {
 630         Out << ' ';
 631         Constant *CZ = Constant::getNullValue(AT->getElementType());
 632         printConstant(CZ);
 633         for (unsigned i = 1, e = AT->getNumElements(); i != e; ++i) {
 634           Out << ", ";
 635           printConstant(CZ);
 636         }
 637       }
 638       Out << " }";
 639     } else {
 640       printConstantArray(cast<ConstantArray>(CPV));
 641     }
 642     break;
 643
 644   case Type::StructTyID:
 645     if (isa<ConstantAggregateZero>(CPV) || isa<UndefValue>(CPV)) {
 646       const StructType *ST = cast<StructType>(CPV->getType());
 647       Out << '{';
 648       if (ST->getNumElements()) {
 649         Out << ' ';
 650         printConstant(Constant::getNullValue(ST->getElementType(0)));
 651         for (unsigned i = 1, e = ST->getNumElements(); i != e; ++i) {
 652           Out << ", ";
 653           printConstant(Constant::getNullValue(ST->getElementType(i)));
 654         }
 655       }
 656       Out << " }";
 657     } else {
 658       Out << '{';
 659       if (CPV->getNumOperands()) {
 660         Out << ' ';
 661         printConstant(cast<Constant>(CPV->getOperand(0)));
 662         for (unsigned i = 1, e = CPV->getNumOperands(); i != e; ++i) {
 663           Out << ", ";
 664           printConstant(cast<Constant>(CPV->getOperand(i)));
 665         }
 666       }
 667       Out << " }";
 668     }
 669     break;
 670
 671   case Type::PointerTyID:
 672     if (isa<ConstantPointerNull>(CPV)) {
 673       Out << "((";
 674       printType(Out, CPV->getType());
 675       Out << ")/*NULL*/0)";
 676       break;
 677     } else if (GlobalValue *GV = dyn_cast<GlobalValue>(CPV)) {
 678       writeOperand(GV);
 679       break;
 680     }
 681     // FALL THROUGH
 682   default:
 683     std::cerr << "Unknown constant type: " << *CPV << "\n";
 684     abort();
 685   }
 686 }
 687
 688 void CWriter::writeOperandInternal(Value *Operand) {
 689   if (Instruction *I = dyn_cast<Instruction>(Operand))
 690     if (isInlinableInst(*I) && !isDirectAlloca(I)) {
 691       // Should we inline this instruction to build a tree?
 692       Out << '(';
 693       visit(*I);
 694       Out << ')';
 695       return;
 696     }
 697
 698   Constant* CPV = dyn_cast<Constant>(Operand);
 699   if (CPV && !isa<GlobalValue>(CPV)) {
 700     printConstant(CPV);
 701   } else {
 702     Out << Mang->getValueName(Operand);
 703   }
 704 }
 705
 706 void CWriter::writeOperand(Value *Operand) {
 707   if (isa<GlobalVariable>(Operand) || isDirectAlloca(Operand))
 708     Out << "(&";  // Global variables are references as their addresses by llvm
 709
 710   writeOperandInternal(Operand);
 711
 712   if (isa<GlobalVariable>(Operand) || isDirectAlloca(Operand))
 713     Out << ')';
 714 }
 715
 716 // generateCompilerSpecificCode - This is where we add conditional compilation
 717 // directives to cater to specific compilers as need be.
 718 //
 719 static void generateCompilerSpecificCode(std::ostream& Out) {
 720   // Alloca is hard to get, and we don't want to include stdlib.h here...
 721   Out << "/* get a declaration for alloca */\n"
 722       << "#if defined(__CYGWIN__)\n"
 723       << "extern void *_alloca(unsigned long);\n"
 724       << "#define alloca(x) _alloca(x)\n"
 725       << "#elif defined(__APPLE__)\n"
 726       << "extern void *__builtin_alloca(unsigned long);\n"
 727       << "#define alloca(x) __builtin_alloca(x)\n"
 728       << "#elif defined(__sun__)\n"
 729       << "#if defined(__sparcv9)\n"
 730       << "extern void *__builtin_alloca(unsigned long);\n"
 731       << "#else\n"
 732       << "extern void *__builtin_alloca(unsigned int);\n"
 733       << "#endif\n"
 734       << "#define alloca(x) __builtin_alloca(x)\n"
 735       << "#elif defined(__FreeBSD__)\n"
 736       << "#define alloca(x) __builtin_alloca(x)\n"
 737       << "#elif !defined(_MSC_VER)\n"
 738       << "#include <alloca.h>\n"
 739       << "#endif\n\n";
 740
 741   // We output GCC specific attributes to preserve 'linkonce'ness on globals.
 742   // If we aren't being compiled with GCC, just drop these attributes.
 743   Out << "#ifndef __GNUC__  /* Can only support \"linkonce\" vars with GCC */\n"
 744       << "#define __attribute__(X)\n"
 745       << "#endif\n\n";
 746
 747 #if 0
 748   // At some point, we should support "external weak" vs. "weak" linkages.
 749   // On Mac OS X, "external weak" is spelled "__attribute__((weak_import))".
 750   Out << "#if defined(__GNUC__) && defined(__APPLE_CC__)\n"
 751       << "#define __EXTERNAL_WEAK__ __attribute__((weak_import))\n"
 752       << "#elif defined(__GNUC__)\n"
 753       << "#define __EXTERNAL_WEAK__ __attribute__((weak))\n"
 754       << "#else\n"
 755       << "#define __EXTERNAL_WEAK__\n"
 756       << "#endif\n\n";
 757 #endif
 758
 759   // For now, turn off the weak linkage attribute on Mac OS X. (See above.)
 760   Out << "#if defined(__GNUC__) && defined(__APPLE_CC__)\n"
 761       << "#define __ATTRIBUTE_WEAK__\n"
 762       << "#elif defined(__GNUC__)\n"
 763       << "#define __ATTRIBUTE_WEAK__ __attribute__((weak))\n"
 764       << "#else\n"
 765       << "#define __ATTRIBUTE_WEAK__\n"
 766       << "#endif\n\n";
 767
 768   // Define NaN and Inf as GCC builtins if using GCC, as 0 otherwise
 769   // From the GCC documentation:
 770   //
 771   //   double __builtin_nan (const char *str)
 772   //
 773   // This is an implementation of the ISO C99 function nan.
 774   //
 775   // Since ISO C99 defines this function in terms of strtod, which we do
 776   // not implement, a description of the parsing is in order. The string is
 777   // parsed as by strtol; that is, the base is recognized by leading 0 or
 778   // 0x prefixes. The number parsed is placed in the significand such that
 779   // the least significant bit of the number is at the least significant
 780   // bit of the significand. The number is truncated to fit the significand
 781   // field provided. The significand is forced to be a quiet NaN.
 782   //
 783   // This function, if given a string literal, is evaluated early enough
 784   // that it is considered a compile-time constant.
 785   //
 786   //   float __builtin_nanf (const char *str)
 787   //
 788   // Similar to __builtin_nan, except the return type is float.
 789   //
 790   //   double __builtin_inf (void)
 791   //
 792   // Similar to __builtin_huge_val, except a warning is generated if the
 793   // target floating-point format does not support infinities. This
 794   // function is suitable for implementing the ISO C99 macro INFINITY.
 795   //
 796   //   float __builtin_inff (void)
 797   //
 798   // Similar to __builtin_inf, except the return type is float.
 799   Out << "#ifdef __GNUC__\n"
 800       << "#define LLVM_NAN(NanStr)   __builtin_nan(NanStr)   /* Double */\n"
 801       << "#define LLVM_NANF(NanStr)  __builtin_nanf(NanStr)  /* Float */\n"
 802       << "#define LLVM_NANS(NanStr)  __builtin_nans(NanStr)  /* Double */\n"
 803       << "#define LLVM_NANSF(NanStr) __builtin_nansf(NanStr) /* Float */\n"
 804       << "#define LLVM_INF           __builtin_inf()         /* Double */\n"
 805       << "#define LLVM_INFF          __builtin_inff()        /* Float */\n"
 806       << "#define LLVM_PREFETCH(addr,rw,locality)          __builtin_prefetch(addr,rw,locality)\n"
 807       << "#else\n"
 808       << "#define LLVM_NAN(NanStr)   ((double)0.0)           /* Double */\n"
 809       << "#define LLVM_NANF(NanStr)  0.0F                    /* Float */\n"
 810       << "#define LLVM_NANS(NanStr)  ((double)0.0)           /* Double */\n"
 811       << "#define LLVM_NANSF(NanStr) 0.0F                    /* Float */\n"
 812       << "#define LLVM_INF           ((double)0.0)           /* Double */\n"
 813       << "#define LLVM_INFF          0.0F                    /* Float */\n"
 814       << "#define LLVM_PREFETCH(addr,rw,locality)            /* PREFETCH */\n"
 815       << "#endif\n\n";
 816
 817   // Output target-specific code that should be inserted into main.
 818   Out << "#define CODE_FOR_MAIN() /* Any target-specific code for main()*/\n";
 819   // On X86, set the FP control word to 64-bits of precision instead of 80 bits.
 820   Out << "#if defined(__GNUC__) && !defined(__llvm__)\n"
 821       << "#if defined(i386) || defined(__i386__) || defined(__i386)\n"
 822       << "#undef CODE_FOR_MAIN\n"
 823       << "#define CODE_FOR_MAIN() \\\n"
 824       << "  {short F;__asm__ (\"fnstcw %0\" : \"=m\" (*&F)); \\\n"
 825       << "  F=(F&~0x300)|0x200;__asm__(\"fldcw %0\"::\"m\"(*&F));}\n"
 826       << "#endif\n#endif\n";
 827
 828 }
 829
 830 bool CWriter::doInitialization(Module &M) {
 831   // Initialize
 832   TheModule = &M;
 833
 834   IL.AddPrototypes(M);
 835
 836   // Ensure that all structure types have names...
 837   Mang = new Mangler(M);
 838   Mang->markCharUnacceptable('.');
 839
 840   // get declaration for alloca
 841   Out << "/* Provide Declarations */\n";
 842   Out << "#include <stdarg.h>\n";      // Varargs support
 843   Out << "#include <setjmp.h>\n";      // Unwind support
 844   generateCompilerSpecificCode(Out);
 845
 846   // Provide a definition for `bool' if not compiling with a C++ compiler.
 847   Out << "\n"
 848       << "#ifndef __cplusplus\ntypedef unsigned char bool;\n#endif\n"
 849
 850       << "\n\n/* Support for floating point constants */\n"
 851       << "typedef unsigned long long ConstantDoubleTy;\n"
 852       << "typedef unsigned int        ConstantFloatTy;\n"
 853
 854       << "\n\n/* Global Declarations */\n";
 855
 856   // First output all the declarations for the program, because C requires
 857   // Functions & globals to be declared before they are used.
 858   //
 859
 860   // Loop over the symbol table, emitting all named constants...
 861   printModuleTypes(M.getSymbolTable());
 862
 863   // Global variable declarations...
 864   if (!M.global_empty()) {
 865     Out << "\n/* External Global Variable Declarations */\n";
 866     for (Module::global_iterator I = M.global_begin(), E = M.global_end(); I != E; ++I) {
 867       if (I->hasExternalLinkage()) {
 868         Out << "extern ";
 869         printType(Out, I->getType()->getElementType(), Mang->getValueName(I));
 870         Out << ";\n";
 871       }
 872     }
 873   }
 874
 875   // Function declarations
 876   Out << "double fmod(double, double);\n";   // Support for FP rem
 877   Out << "float fmodf(float, float);\n";
 878
 879   if (!M.empty()) {
 880     Out << "\n/* Function Declarations */\n";
 881     for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
 882       // Don't print declarations for intrinsic functions.
 883       if (!I->getIntrinsicID() &&
 884           I->getName() != "setjmp" && I->getName() != "longjmp") {
 885         printFunctionSignature(I, true);
 886         if (I->hasWeakLinkage()) Out << " __ATTRIBUTE_WEAK__";
 887         if (I->hasLinkOnceLinkage()) Out << " __ATTRIBUTE_WEAK__";
 888         Out << ";\n";
 889       }
 890     }
 891   }
 892
 893   // Output the global variable declarations
 894   if (!M.global_empty()) {
 895     Out << "\n\n/* Global Variable Declarations */\n";
 896     for (Module::global_iterator I = M.global_begin(), E = M.global_end(); I != E; ++I)
 897       if (!I->isExternal()) {
 898         if (I->hasInternalLinkage())
 899           Out << "static ";
 900         else
 901           Out << "extern ";
 902         printType(Out, I->getType()->getElementType(), Mang->getValueName(I));
 903
 904         if (I->hasLinkOnceLinkage())
 905           Out << " __attribute__((common))";
 906         else if (I->hasWeakLinkage())
 907           Out << " __ATTRIBUTE_WEAK__";
 908         Out << ";\n";
 909       }
 910   }
 911
 912   // Output the global variable definitions and contents...
 913   if (!M.global_empty()) {
 914     Out << "\n\n/* Global Variable Definitions and Initialization */\n";
 915     for (Module::global_iterator I = M.global_begin(), E = M.global_end(); I != E; ++I)
 916       if (!I->isExternal()) {
 917         if (I->hasInternalLinkage())
 918           Out << "static ";
 919         printType(Out, I->getType()->getElementType(), Mang->getValueName(I));
 920         if (I->hasLinkOnceLinkage())
 921           Out << " __attribute__((common))";
 922         else if (I->hasWeakLinkage())
 923           Out << " __ATTRIBUTE_WEAK__";
 924
 925         // If the initializer is not null, emit the initializer.  If it is null,
 926         // we try to avoid emitting large amounts of zeros.  The problem with
 927         // this, however, occurs when the variable has weak linkage.  In this
 928         // case, the assembler will complain about the variable being both weak
 929         // and common, so we disable this optimization.
 930         if (!I->getInitializer()->isNullValue()) {
 931           Out << " = " ;
 932           writeOperand(I->getInitializer());
 933         } else if (I->hasWeakLinkage()) {
 934           // We have to specify an initializer, but it doesn't have to be
 935           // complete.  If the value is an aggregate, print out { 0 }, and let
 936           // the compiler figure out the rest of the zeros.
 937           Out << " = " ;
 938           if (isa<StructType>(I->getInitializer()->getType()) ||
 939               isa<ArrayType>(I->getInitializer()->getType())) {
 940             Out << "{ 0 }";
 941           } else {
 942             // Just print it out normally.
 943             writeOperand(I->getInitializer());
 944           }
 945         }
 946         Out << ";\n";
 947       }
 948   }
 949
 950   if (!M.empty())
 951     Out << "\n\n/* Function Bodies */\n";
 952   return false;
 953 }
 954
 955
 956 /// Output all floating point constants that cannot be printed accurately...
 957 void CWriter::printFloatingPointConstants(Function &F) {
 958   // Scan the module for floating point constants.  If any FP constant is used
 959   // in the function, we want to redirect it here so that we do not depend on
 960   // the precision of the printed form, unless the printed form preserves
 961   // precision.
 962   //
 963   static unsigned FPCounter = 0;
 964   for (constant_iterator I = constant_begin(&F), E = constant_end(&F);
 965        I != E; ++I)
 966     if (const ConstantFP *FPC = dyn_cast<ConstantFP>(*I))
 967       if (!isFPCSafeToPrint(FPC) && // Do not put in FPConstantMap if safe.
 968           !FPConstantMap.count(FPC)) {
 969         double Val = FPC->getValue();
 970
 971         FPConstantMap[FPC] = FPCounter;  // Number the FP constants
 972
 973         if (FPC->getType() == Type::DoubleTy) {
 974           Out << "static const ConstantDoubleTy FPConstant" << FPCounter++
 975               << " = 0x" << std::hex << DoubleToBits(Val) << std::dec
 976               << "ULL;    /* " << Val << " */\n";
 977         } else if (FPC->getType() == Type::FloatTy) {
 978           Out << "static const ConstantFloatTy FPConstant" << FPCounter++
 979               << " = 0x" << std::hex << FloatToBits(Val) << std::dec
 980               << "U;    /* " << Val << " */\n";
 981         } else
 982           assert(0 && "Unknown float type!");
 983       }
 984
 985   Out << '\n';
 986 }
 987
 988
 989 /// printSymbolTable - Run through symbol table looking for type names.  If a
 990 /// type name is found, emit it's declaration...
 991 ///
 992 void CWriter::printModuleTypes(const SymbolTable &ST) {
 993   // We are only interested in the type plane of the symbol table.
 994   SymbolTable::type_const_iterator I   = ST.type_begin();
 995   SymbolTable::type_const_iterator End = ST.type_end();
 996
 997   // If there are no type names, exit early.
 998   if (I == End) return;
 999
1000   // Print out forward declarations for structure types before anything else!
1001   Out << "/* Structure forward decls */\n";
1002   for (; I != End; ++I)
1003     if (const Type *STy = dyn_cast<StructType>(I->second)) {
1004       std::string Name = "struct l_" + Mang->makeNameProper(I->first);
1005       Out << Name << ";\n";
1006       TypeNames.insert(std::make_pair(STy, Name));
1007     }
1008
1009   Out << '\n';
1010
1011   // Now we can print out typedefs...
1012   Out << "/* Typedefs */\n";
1013   for (I = ST.type_begin(); I != End; ++I) {
1014     const Type *Ty = cast<Type>(I->second);
1015     std::string Name = "l_" + Mang->makeNameProper(I->first);
1016     Out << "typedef ";
1017     printType(Out, Ty, Name);
1018     Out << ";\n";
1019   }
1020
1021   Out << '\n';
1022
1023   // Keep track of which structures have been printed so far...
1024   std::set<const StructType *> StructPrinted;
1025
1026   // Loop over all structures then push them into the stack so they are
1027   // printed in the correct order.
1028   //
1029   Out << "/* Structure contents */\n";
1030   for (I = ST.type_begin(); I != End; ++I)
1031     if (const StructType *STy = dyn_cast<StructType>(I->second))
1032       // Only print out used types!
1033       printContainedStructs(STy, StructPrinted);
1034 }
1035
1036 // Push the struct onto the stack and recursively push all structs
1037 // this one depends on.
1038 void CWriter::printContainedStructs(const Type *Ty,
1039                                     std::set<const StructType*> &StructPrinted){
1040   // Don't walk through pointers.
1041   if (isa<PointerType>(Ty) || Ty->isPrimitiveType()) return;
1042
1043   // Print all contained types first.
1044   for (Type::subtype_iterator I = Ty->subtype_begin(),
1045        E = Ty->subtype_end(); I != E; ++I)
1046     printContainedStructs(*I, StructPrinted);
1047
1048   if (const StructType *STy = dyn_cast<StructType>(Ty)) {
1049     // Check to see if we have already printed this struct.
1050     if (StructPrinted.insert(STy).second) {
1051       // Print structure type out.
1052       std::string Name = TypeNames[STy];
1053       printType(Out, STy, Name, true);
1054       Out << ";\n\n";
1055     }
1056   }
1057 }
1058
1059
1060 void CWriter::printFunctionSignature(const Function *F, bool Prototype) {
1061   if (F->hasInternalLinkage()) Out << "static ";
1062
1063   // Loop over the arguments, printing them...
1064   const FunctionType *FT = cast<FunctionType>(F->getFunctionType());
1065
1066   std::stringstream FunctionInnards;
1067
1068   // Print out the name...
1069   FunctionInnards << Mang->getValueName(F) << '(';
1070
1071   if (!F->isExternal()) {
1072     if (!F->arg_empty()) {
1073       std::string ArgName;
1074       if (F->arg_begin()->hasName() || !Prototype)
1075         ArgName = Mang->getValueName(F->arg_begin());
1076       printType(FunctionInnards, F->arg_begin()->getType(), ArgName);
1077       for (Function::const_arg_iterator I = ++F->arg_begin(), E = F->arg_end();
1078            I != E; ++I) {
1079         FunctionInnards << ", ";
1080         if (I->hasName() || !Prototype)
1081           ArgName = Mang->getValueName(I);
1082         else
1083           ArgName = "";
1084         printType(FunctionInnards, I->getType(), ArgName);
1085       }
1086     }
1087   } else {
1088     // Loop over the arguments, printing them...
1089     for (FunctionType::param_iterator I = FT->param_begin(),
1090            E = FT->param_end(); I != E; ++I) {
1091       if (I != FT->param_begin()) FunctionInnards << ", ";
1092       printType(FunctionInnards, *I);
1093     }
1094   }
1095
1096   // Finish printing arguments... if this is a vararg function, print the ...,
1097   // unless there are no known types, in which case, we just emit ().
1098   //
1099   if (FT->isVarArg() && FT->getNumParams()) {
1100     if (FT->getNumParams()) FunctionInnards << ", ";
1101     FunctionInnards << "...";  // Output varargs portion of signature!
1102   } else if (!FT->isVarArg() && FT->getNumParams() == 0) {
1103     FunctionInnards << "void"; // ret() -> ret(void) in C.
1104   }
1105   FunctionInnards << ')';
1106   // Print out the return type and the entire signature for that matter
1107   printType(Out, F->getReturnType(), FunctionInnards.str());
1108 }
1109
1110 void CWriter::printFunction(Function &F) {
1111   printFunctionSignature(&F, false);
1112   Out << " {\n";
1113
1114   // print local variable information for the function
1115   for (inst_iterator I = inst_begin(&F), E = inst_end(&F); I != E; ++I)
1116     if (const AllocaInst *AI = isDirectAlloca(&*I)) {
1117       Out << "  ";
1118       printType(Out, AI->getAllocatedType(), Mang->getValueName(AI));
1119       Out << ";    /* Address-exposed local */\n";
1120     } else if (I->getType() != Type::VoidTy && !isInlinableInst(*I)) {
1121       Out << "  ";
1122       printType(Out, I->getType(), Mang->getValueName(&*I));
1123       Out << ";\n";
1124
1125       if (isa<PHINode>(*I)) {  // Print out PHI node temporaries as well...
1126         Out << "  ";
1127         printType(Out, I->getType(),
1128                   Mang->getValueName(&*I)+"__PHI_TEMPORARY");
1129         Out << ";\n";
1130       }
1131     }
1132
1133   Out << '\n';
1134
1135   if (F.hasExternalLinkage() && F.getName() == "main")
1136     Out << "  CODE_FOR_MAIN();\n";
1137
1138   // print the basic blocks
1139   for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
1140     if (Loop *L = LI->getLoopFor(BB)) {
1141       if (L->getHeader() == BB && L->getParentLoop() == 0)
1142         printLoop(L);
1143     } else {
1144       printBasicBlock(BB);
1145     }
1146   }
1147
1148   Out << "}\n\n";
1149 }
1150
1151 void CWriter::printLoop(Loop *L) {
1152   Out << "  do {     /* Syntactic loop '" << L->getHeader()->getName()
1153       << "' to make GCC happy */\n";
1154   for (unsigned i = 0, e = L->getBlocks().size(); i != e; ++i) {
1155     BasicBlock *BB = L->getBlocks()[i];
1156     Loop *BBLoop = LI->getLoopFor(BB);
1157     if (BBLoop == L)
1158       printBasicBlock(BB);
1159     else if (BB == BBLoop->getHeader() && BBLoop->getParentLoop() == L)
1160       printLoop(BBLoop);
1161   }
1162   Out << "  } while (1); /* end of syntactic loop '"
1163       << L->getHeader()->getName() << "' */\n";
1164 }
1165
1166 void CWriter::printBasicBlock(BasicBlock *BB) {
1167
1168   // Don't print the label for the basic block if there are no uses, or if
1169   // the only terminator use is the predecessor basic block's terminator.
1170   // We have to scan the use list because PHI nodes use basic blocks too but
1171   // do not require a label to be generated.
1172   //
1173   bool NeedsLabel = false;
1174   for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
1175     if (isGotoCodeNecessary(*PI, BB)) {
1176       NeedsLabel = true;
1177       break;
1178     }
1179
1180   if (NeedsLabel) Out << Mang->getValueName(BB) << ":\n";
1181
1182   // Output all of the instructions in the basic block...
1183   for (BasicBlock::iterator II = BB->begin(), E = --BB->end(); II != E;
1184        ++II) {
1185     if (!isInlinableInst(*II) && !isDirectAlloca(II)) {
1186       if (II->getType() != Type::VoidTy)
1187         outputLValue(II);
1188       else
1189         Out << "  ";
1190       visit(*II);
1191       Out << ";\n";
1192     }
1193   }
1194
1195   // Don't emit prefix or suffix for the terminator...
1196   visit(*BB->getTerminator());
1197 }
1198
1199
1200 // Specific Instruction type classes... note that all of the casts are
1201 // necessary because we use the instruction classes as opaque types...
1202 //
1203 void CWriter::visitReturnInst(ReturnInst &I) {
1204   // Don't output a void return if this is the last basic block in the function
1205   if (I.getNumOperands() == 0 &&
1206       &*--I.getParent()->getParent()->end() == I.getParent() &&
1207       !I.getParent()->size() == 1) {
1208     return;
1209   }
1210
1211   Out << "  return";
1212   if (I.getNumOperands()) {
1213     Out << ' ';
1214     writeOperand(I.getOperand(0));
1215   }
1216   Out << ";\n";
1217 }
1218
1219 void CWriter::visitSwitchInst(SwitchInst &SI) {
1220
1221   Out << "  switch (";
1222   writeOperand(SI.getOperand(0));
1223   Out << ") {\n  default:\n";
1224   printPHICopiesForSuccessor (SI.getParent(), SI.getDefaultDest(), 2);
1225   printBranchToBlock(SI.getParent(), SI.getDefaultDest(), 2);
1226   Out << ";\n";
1227   for (unsigned i = 2, e = SI.getNumOperands(); i != e; i += 2) {
1228     Out << "  case ";
1229     writeOperand(SI.getOperand(i));
1230     Out << ":\n";
1231     BasicBlock *Succ = cast<BasicBlock>(SI.getOperand(i+1));
1232     printPHICopiesForSuccessor (SI.getParent(), Succ, 2);
1233     printBranchToBlock(SI.getParent(), Succ, 2);
1234     if (Function::iterator(Succ) == next(Function::iterator(SI.getParent())))
1235       Out << "    break;\n";
1236   }
1237   Out << "  }\n";
1238 }
1239
1240 void CWriter::visitUnreachableInst(UnreachableInst &I) {
1241   Out << "  /*UNREACHABLE*/;\n";
1242 }
1243
1244 bool CWriter::isGotoCodeNecessary(BasicBlock *From, BasicBlock *To) {
1245   /// FIXME: This should be reenabled, but loop reordering safe!!
1246   return true;
1247
1248   if (next(Function::iterator(From)) != Function::iterator(To))
1249     return true;  // Not the direct successor, we need a goto.
1250
1251   //isa<SwitchInst>(From->getTerminator())
1252
1253   if (LI->getLoopFor(From) != LI->getLoopFor(To))
1254     return true;
1255   return false;
1256 }
1257
1258 void CWriter::printPHICopiesForSuccessor (BasicBlock *CurBlock,
1259                                           BasicBlock *Successor,
1260                                           unsigned Indent) {
1261   for (BasicBlock::iterator I = Successor->begin(); isa<PHINode>(I); ++I) {
1262     PHINode *PN = cast<PHINode>(I);
1263     // Now we have to do the printing.
1264     Value *IV = PN->getIncomingValueForBlock(CurBlock);
1265     if (!isa<UndefValue>(IV)) {
1266       Out << std::string(Indent, ' ');
1267       Out << "  " << Mang->getValueName(I) << "__PHI_TEMPORARY = ";
1268       writeOperand(IV);
1269       Out << ";   /* for PHI node */\n";
1270     }
1271   }
1272 }
1273
1274 void CWriter::printBranchToBlock(BasicBlock *CurBB, BasicBlock *Succ,
1275                                  unsigned Indent) {
1276   if (isGotoCodeNecessary(CurBB, Succ)) {
1277     Out << std::string(Indent, ' ') << "  goto ";
1278     writeOperand(Succ);
1279     Out << ";\n";
1280   }
1281 }
1282
1283 // Branch instruction printing - Avoid printing out a branch to a basic block
1284 // that immediately succeeds the current one.
1285 //
1286 void CWriter::visitBranchInst(BranchInst &I) {
1287
1288   if (I.isConditional()) {
1289     if (isGotoCodeNecessary(I.getParent(), I.getSuccessor(0))) {
1290       Out << "  if (";
1291       writeOperand(I.getCondition());
1292       Out << ") {\n";
1293
1294       printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(0), 2);
1295       printBranchToBlock(I.getParent(), I.getSuccessor(0), 2);
1296
1297       if (isGotoCodeNecessary(I.getParent(), I.getSuccessor(1))) {
1298         Out << "  } else {\n";
1299         printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(1), 2);
1300         printBranchToBlock(I.getParent(), I.getSuccessor(1), 2);
1301       }
1302     } else {
1303       // First goto not necessary, assume second one is...
1304       Out << "  if (!";
1305       writeOperand(I.getCondition());
1306       Out << ") {\n";
1307
1308       printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(1), 2);
1309       printBranchToBlock(I.getParent(), I.getSuccessor(1), 2);
1310     }
1311
1312     Out << "  }\n";
1313   } else {
1314     printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(0), 0);
1315     printBranchToBlock(I.getParent(), I.getSuccessor(0), 0);
1316   }
1317   Out << "\n";
1318 }
1319
1320 // PHI nodes get copied into temporary values at the end of predecessor basic
1321 // blocks.  We now need to copy these temporary values into the REAL value for
1322 // the PHI.
1323 void CWriter::visitPHINode(PHINode &I) {
1324   writeOperand(&I);
1325   Out << "__PHI_TEMPORARY";
1326 }
1327
1328
1329 void CWriter::visitBinaryOperator(Instruction &I) {
1330   // binary instructions, shift instructions, setCond instructions.
1331   assert(!isa<PointerType>(I.getType()));
1332
1333   // We must cast the results of binary operations which might be promoted.
1334   bool needsCast = false;
1335   if ((I.getType() == Type::UByteTy) || (I.getType() == Type::SByteTy)
1336       || (I.getType() == Type::UShortTy) || (I.getType() == Type::ShortTy)
1337       || (I.getType() == Type::FloatTy)) {
1338     needsCast = true;
1339     Out << "((";
1340     printType(Out, I.getType());
1341     Out << ")(";
1342   }
1343
1344   // If this is a negation operation, print it out as such.  For FP, we don't
1345   // want to print "-0.0 - X".
1346   if (BinaryOperator::isNeg(&I)) {
1347     Out << "-(";
1348     writeOperand(BinaryOperator::getNegArgument(cast<BinaryOperator>(&I)));
1349     Out << ")";
1350   } else if (I.getOpcode() == Instruction::Rem &&
1351              I.getType()->isFloatingPoint()) {
1352     // Output a call to fmod/fmodf instead of emitting a%b
1353     if (I.getType() == Type::FloatTy)
1354       Out << "fmodf(";
1355     else
1356       Out << "fmod(";
1357     writeOperand(I.getOperand(0));
1358     Out << ", ";
1359     writeOperand(I.getOperand(1));
1360     Out << ")";
1361   } else {
1362     writeOperand(I.getOperand(0));
1363
1364     switch (I.getOpcode()) {
1365     case Instruction::Add: Out << " + "; break;
1366     case Instruction::Sub: Out << " - "; break;
1367     case Instruction::Mul: Out << '*'; break;
1368     case Instruction::Div: Out << '/'; break;
1369     case Instruction::Rem: Out << '%'; break;
1370     case Instruction::And: Out << " & "; break;
1371     case Instruction::Or: Out << " | "; break;
1372     case Instruction::Xor: Out << " ^ "; break;
1373     case Instruction::SetEQ: Out << " == "; break;
1374     case Instruction::SetNE: Out << " != "; break;
1375     case Instruction::SetLE: Out << " <= "; break;
1376     case Instruction::SetGE: Out << " >= "; break;
1377     case Instruction::SetLT: Out << " < "; break;
1378     case Instruction::SetGT: Out << " > "; break;
1379     case Instruction::Shl : Out << " << "; break;
1380     case Instruction::Shr : Out << " >> "; break;
1381     default: std::cerr << "Invalid operator type!" << I; abort();
1382     }
1383
1384     writeOperand(I.getOperand(1));
1385   }
1386
1387   if (needsCast) {
1388     Out << "))";
1389   }
1390 }
1391
1392 void CWriter::visitCastInst(CastInst &I) {
1393   if (I.getType() == Type::BoolTy) {
1394     Out << '(';
1395     writeOperand(I.getOperand(0));
1396     Out << " != 0)";
1397     return;
1398   }
1399   Out << '(';
1400   printType(Out, I.getType());
1401   Out << ')';
1402   if (isa<PointerType>(I.getType())&&I.getOperand(0)->getType()->isIntegral() ||
1403       isa<PointerType>(I.getOperand(0)->getType())&&I.getType()->isIntegral()) {
1404     // Avoid "cast to pointer from integer of different size" warnings
1405     Out << "(long)";
1406   }
1407
1408   writeOperand(I.getOperand(0));
1409 }
1410
1411 void CWriter::visitSelectInst(SelectInst &I) {
1412   Out << "((";
1413   writeOperand(I.getCondition());
1414   Out << ") ? (";
1415   writeOperand(I.getTrueValue());
1416   Out << ") : (";
1417   writeOperand(I.getFalseValue());
1418   Out << "))";
1419 }
1420
1421
1422 void CWriter::lowerIntrinsics(Function &F) {
1423   for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
1424     for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; )
1425       if (CallInst *CI = dyn_cast<CallInst>(I++))
1426         if (Function *F = CI->getCalledFunction())
1427           switch (F->getIntrinsicID()) {
1428           case Intrinsic::not_intrinsic:
1429           case Intrinsic::vastart:
1430           case Intrinsic::vacopy:
1431           case Intrinsic::vaend:
1432           case Intrinsic::returnaddress:
1433           case Intrinsic::frameaddress:
1434           case Intrinsic::setjmp:
1435           case Intrinsic::longjmp:
1436           case Intrinsic::prefetch:
1437             // We directly implement these intrinsics
1438             break;
1439           default:
1440             // All other intrinsic calls we must lower.
1441             Instruction *Before = 0;
1442             if (CI != &BB->front())
1443               Before = prior(BasicBlock::iterator(CI));
1444
1445             IL.LowerIntrinsicCall(CI);
1446             if (Before) {        // Move iterator to instruction after call
1447               I = Before; ++I;
1448             } else {
1449               I = BB->begin();
1450             }
1451           }
1452 }
1453
1454
1455
1456 void CWriter::visitCallInst(CallInst &I) {
1457   // Handle intrinsic function calls first...
1458   if (Function *F = I.getCalledFunction())
1459     if (Intrinsic::ID ID = (Intrinsic::ID)F->getIntrinsicID()) {
1460       switch (ID) {
1461       default: assert(0 && "Unknown LLVM intrinsic!");
1462       case Intrinsic::vastart:
1463         Out << "0; ";
1464
1465         //        Out << "va_start(*(va_list*)&" << Mang->getValueName(&I) << ", ";
1466         Out << "va_start(*(va_list*)";
1467         writeOperand(I.getOperand(1));
1468         Out << ", ";
1469         // Output the last argument to the enclosing function...
1470         if (I.getParent()->getParent()->arg_empty()) {
1471           std::cerr << "The C backend does not currently support zero "
1472                     << "argument varargs functions, such as '"
1473                     << I.getParent()->getParent()->getName() << "'!\n";
1474           abort();
1475         }
1476         writeOperand(--I.getParent()->getParent()->arg_end());
1477         Out << ')';
1478         return;
1479       case Intrinsic::vaend:
1480         if (!isa<ConstantPointerNull>(I.getOperand(1))) {
1481           Out << "0; va_end(*(va_list*)";
1482           writeOperand(I.getOperand(1));
1483           Out << ')';
1484         } else {
1485           Out << "va_end(*(va_list*)0)";
1486         }
1487         return;
1488       case Intrinsic::vacopy:
1489         Out << "0; ";
1490         Out << "va_copy(*(va_list*)";
1491         writeOperand(I.getOperand(1));
1492         Out << ", *(va_list*)";
1493         writeOperand(I.getOperand(2));
1494         Out << ')';
1495         return;
1496       case Intrinsic::returnaddress:
1497         Out << "__builtin_return_address(";
1498         writeOperand(I.getOperand(1));
1499         Out << ')';
1500         return;
1501       case Intrinsic::frameaddress:
1502         Out << "__builtin_frame_address(";
1503         writeOperand(I.getOperand(1));
1504         Out << ')';
1505         return;
1506       case Intrinsic::setjmp:
1507         Out << "setjmp(*(jmp_buf*)";
1508         writeOperand(I.getOperand(1));
1509         Out << ')';
1510         return;
1511       case Intrinsic::longjmp:
1512         Out << "longjmp(*(jmp_buf*)";
1513         writeOperand(I.getOperand(1));
1514         Out << ", ";
1515         writeOperand(I.getOperand(2));
1516         Out << ')';
1517         return;
1518       case Intrinsic::prefetch:
1519         Out << "LLVM_PREFETCH((const void *)";
1520         writeOperand(I.getOperand(1));
1521         Out << ", ";
1522         writeOperand(I.getOperand(2));
1523         Out << ", ";
1524         writeOperand(I.getOperand(3));
1525         Out << ")";
1526         return;
1527       }
1528     }
1529
1530   Value *Callee = I.getCalledValue();
1531
1532   // GCC is really a PITA.  It does not permit codegening casts of functions to
1533   // function pointers if they are in a call (it generates a trap instruction
1534   // instead!).  We work around this by inserting a cast to void* in between the
1535   // function and the function pointer cast.  Unfortunately, we can't just form
1536   // the constant expression here, because the folder will immediately nuke it.
1537   //
1538   // Note finally, that this is completely unsafe.  ANSI C does not guarantee
1539   // that void* and function pointers have the same size. :( To deal with this
1540   // in the common case, we handle casts where the number of arguments passed
1541   // match exactly.
1542   //
1543   bool WroteCallee = false;
1544   if (I.isTailCall()) Out << " /*tail*/ ";
1545   if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Callee))
1546     if (CE->getOpcode() == Instruction::Cast)
1547       if (Function *RF = dyn_cast<Function>(CE->getOperand(0))) {
1548         const FunctionType *RFTy = RF->getFunctionType();
1549         if (RFTy->getNumParams() == I.getNumOperands()-1) {
1550           // If the call site expects a value, and the actual callee doesn't
1551           // provide one, return 0.
1552           if (I.getType() != Type::VoidTy &&
1553               RFTy->getReturnType() == Type::VoidTy)
1554             Out << "0 /*actual callee doesn't return value*/; ";
1555           Callee = RF;
1556         } else {
1557           // Ok, just cast the pointer type.
1558           Out << "((";
1559           printType(Out, CE->getType());
1560           Out << ")(void*)";
1561           printConstant(RF);
1562           Out << ')';
1563           WroteCallee = true;
1564         }
1565       }
1566
1567   const PointerType  *PTy   = cast<PointerType>(Callee->getType());
1568   const FunctionType *FTy   = cast<FunctionType>(PTy->getElementType());
1569   const Type         *RetTy = FTy->getReturnType();
1570
1571   if (!WroteCallee) writeOperand(Callee);
1572   Out << '(';
1573
1574   unsigned NumDeclaredParams = FTy->getNumParams();
1575
1576   if (I.getNumOperands() != 1) {
1577     CallSite::arg_iterator AI = I.op_begin()+1, AE = I.op_end();
1578     if (NumDeclaredParams && (*AI)->getType() != FTy->getParamType(0)) {
1579       Out << '(';
1580       printType(Out, FTy->getParamType(0));
1581       Out << ')';
1582     }
1583
1584     writeOperand(*AI);
1585
1586     unsigned ArgNo;
1587     for (ArgNo = 1, ++AI; AI != AE; ++AI, ++ArgNo) {
1588       Out << ", ";
1589       if (ArgNo < NumDeclaredParams &&
1590           (*AI)->getType() != FTy->getParamType(ArgNo)) {
1591         Out << '(';
1592         printType(Out, FTy->getParamType(ArgNo));
1593         Out << ')';
1594       }
1595       writeOperand(*AI);
1596     }
1597   }
1598   Out << ')';
1599 }
1600
1601 void CWriter::visitMallocInst(MallocInst &I) {
1602   assert(0 && "lowerallocations pass didn't work!");
1603 }
1604
1605 void CWriter::visitAllocaInst(AllocaInst &I) {
1606   Out << '(';
1607   printType(Out, I.getType());
1608   Out << ") alloca(sizeof(";
1609   printType(Out, I.getType()->getElementType());
1610   Out << ')';
1611   if (I.isArrayAllocation()) {
1612     Out << " * " ;
1613     writeOperand(I.getOperand(0));
1614   }
1615   Out << ')';
1616 }
1617
1618 void CWriter::visitFreeInst(FreeInst &I) {
1619   assert(0 && "lowerallocations pass didn't work!");
1620 }
1621
1622 void CWriter::printIndexingExpression(Value *Ptr, gep_type_iterator I,
1623                                       gep_type_iterator E) {
1624   bool HasImplicitAddress = false;
1625   // If accessing a global value with no indexing, avoid *(&GV) syndrome
1626   if (GlobalValue *V = dyn_cast<GlobalValue>(Ptr)) {
1627     HasImplicitAddress = true;
1628   } else if (isDirectAlloca(Ptr)) {
1629     HasImplicitAddress = true;
1630   }
1631
1632   if (I == E) {
1633     if (!HasImplicitAddress)
1634       Out << '*';  // Implicit zero first argument: '*x' is equivalent to 'x[0]'
1635
1636     writeOperandInternal(Ptr);
1637     return;
1638   }
1639
1640   const Constant *CI = dyn_cast<Constant>(I.getOperand());
1641   if (HasImplicitAddress && (!CI || !CI->isNullValue()))
1642     Out << "(&";
1643
1644   writeOperandInternal(Ptr);
1645
1646   if (HasImplicitAddress && (!CI || !CI->isNullValue())) {
1647     Out << ')';
1648     HasImplicitAddress = false;  // HIA is only true if we haven't addressed yet
1649   }
1650
1651   assert(!HasImplicitAddress || (CI && CI->isNullValue()) &&
1652          "Can only have implicit address with direct accessing");
1653
1654   if (HasImplicitAddress) {
1655     ++I;
1656   } else if (CI && CI->isNullValue()) {
1657     gep_type_iterator TmpI = I; ++TmpI;
1658
1659     // Print out the -> operator if possible...
1660     if (TmpI != E && isa<StructType>(*TmpI)) {
1661       Out << (HasImplicitAddress ? "." : "->");
1662       Out << "field" << cast<ConstantUInt>(TmpI.getOperand())->getValue();
1663       I = ++TmpI;
1664     }
1665   }
1666
1667   for (; I != E; ++I)
1668     if (isa<StructType>(*I)) {
1669       Out << ".field" << cast<ConstantUInt>(I.getOperand())->getValue();
1670     } else {
1671       Out << '[';
1672       writeOperand(I.getOperand());
1673       Out << ']';
1674     }
1675 }
1676
1677 void CWriter::visitLoadInst(LoadInst &I) {
1678   Out << '*';
1679   if (I.isVolatile()) {
1680     Out << "((";
1681     printType(Out, I.getType(), "volatile*");
1682     Out << ")";
1683   }
1684
1685   writeOperand(I.getOperand(0));
1686
1687   if (I.isVolatile())
1688     Out << ')';
1689 }
1690
1691 void CWriter::visitStoreInst(StoreInst &I) {
1692   Out << '*';
1693   if (I.isVolatile()) {
1694     Out << "((";
1695     printType(Out, I.getOperand(0)->getType(), " volatile*");
1696     Out << ")";
1697   }
1698   writeOperand(I.getPointerOperand());
1699   if (I.isVolatile()) Out << ')';
1700   Out << " = ";
1701   writeOperand(I.getOperand(0));
1702 }
1703
1704 void CWriter::visitGetElementPtrInst(GetElementPtrInst &I) {
1705   Out << '&';
1706   printIndexingExpression(I.getPointerOperand(), gep_type_begin(I),
1707                           gep_type_end(I));
1708 }
1709
1710 void CWriter::visitVAArgInst(VAArgInst &I) {
1711   Out << "va_arg(*(va_list*)";
1712   writeOperand(I.getOperand(0));
1713   Out << ", ";
1714   printType(Out, I.getType());
1715   Out << ");\n ";
1716 }
1717
1718 //===----------------------------------------------------------------------===//
1719 //                       External Interface declaration
1720 //===----------------------------------------------------------------------===//
1721
1722 bool CTargetMachine::addPassesToEmitFile(PassManager &PM, std::ostream &o,
1723                                          CodeGenFileType FileType, bool Fast) {
1724   if (FileType != TargetMachine::AssemblyFile) return true;
1725
1726   PM.add(createLowerGCPass());
1727   PM.add(createLowerAllocationsPass(true));
1728   PM.add(createLowerInvokePass());
1729   PM.add(createCFGSimplificationPass());   // clean up after lower invoke.
1730   PM.add(new CBackendNameAllUsedStructs());
1731   PM.add(new CWriter(o, getIntrinsicLowering()));
1732   return false;
1733 }