Make sure to set stdout to binary when writing bitcode files via

[oota-llvm.git] / lib / Bitcode / Writer / BitcodeWriter.cpp

diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index 931e944a410d1dc13f9abe128a4b5b95771cfb2f..279e447873cab76fc90b4097f95d852e64366816 100644 (file)
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -24,6 +24,7 @@
 #include "llvm/ValueSymbolTable.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Streams.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/System/Program.h"
 using namespace llvm;
 
@@ -108,18 +109,18 @@ static void WriteStringRecord(unsigned Code, const std::string &Str,
 }
 
 // Emit information about parameter attributes.
-static void WriteParamAttrTable(const ValueEnumerator &VE, 
+static void WriteAttributeTable(const ValueEnumerator &VE, 
                                 BitstreamWriter &Stream) {
-  const std::vector<PAListPtr> &Attrs = VE.getParamAttrs();
+  const std::vector<AttrListPtr> &Attrs = VE.getAttributes();
   if (Attrs.empty()) return;
   
   Stream.EnterSubblock(bitc::PARAMATTR_BLOCK_ID, 3);
 
   SmallVector<uint64_t, 64> Record;
   for (unsigned i = 0, e = Attrs.size(); i != e; ++i) {
-    const PAListPtr &A = Attrs[i];
+    const AttrListPtr &A = Attrs[i];
     for (unsigned i = 0, e = A.getNumSlots(); i != e; ++i) {
-      const ParamAttrsWithIndex &PAWI = A.getSlot(i);
+      const AttributeWithIndex &PAWI = A.getSlot(i);
       Record.push_back(PAWI.Index);
       Record.push_back(PAWI.Attrs);
     }
@@ -407,7 +408,7 @@ static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE,
     Vals.push_back(F->getCallingConv());
     Vals.push_back(F->isDeclaration());
     Vals.push_back(getEncodedLinkage(F));
-    Vals.push_back(VE.getParamAttrID(F->getParamAttrs()));
+    Vals.push_back(VE.getAttributeID(F->getAttributes()));
     Vals.push_back(Log2_32(F->getAlignment())+1);
     Vals.push_back(F->hasSection() ? SectionMap[F->getSection()] : 0);
     Vals.push_back(getEncodedVisibility(F));
@@ -542,15 +543,15 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
       Code = bitc::CST_CODE_FLOAT;
       const Type *Ty = CFP->getType();
       if (Ty == Type::FloatTy || Ty == Type::DoubleTy) {
-        Record.push_back(CFP->getValueAPF().convertToAPInt().getZExtValue());
+        Record.push_back(CFP->getValueAPF().bitcastToAPInt().getZExtValue());
       } else if (Ty == Type::X86_FP80Ty) {
         // api needed to prevent premature destruction
-        APInt api = CFP->getValueAPF().convertToAPInt();
+        APInt api = CFP->getValueAPF().bitcastToAPInt();
         const uint64_t *p = api.getRawData();
         Record.push_back(p[0]);
         Record.push_back((uint16_t)p[1]);
       } else if (Ty == Type::FP128Ty || Ty == Type::PPC_FP128Ty) {
-        APInt api = CFP->getValueAPF().convertToAPInt();
+        APInt api = CFP->getValueAPF().bitcastToAPInt();
         const uint64_t *p = api.getRawData();
         Record.push_back(p[0]);
         Record.push_back(p[1]);
@@ -818,7 +819,7 @@ static void WriteInstruction(const Instruction &I, unsigned InstID,
     Code = bitc::FUNC_CODE_INST_INVOKE;
     
     const InvokeInst *II = cast<InvokeInst>(&I);
-    Vals.push_back(VE.getParamAttrID(II->getParamAttrs()));
+    Vals.push_back(VE.getAttributeID(II->getAttributes()));
     Vals.push_back(II->getCallingConv());
     Vals.push_back(VE.getValueID(I.getOperand(1)));      // normal dest
     Vals.push_back(VE.getValueID(I.getOperand(2)));      // unwind dest
@@ -892,7 +893,7 @@ static void WriteInstruction(const Instruction &I, unsigned InstID,
     Code = bitc::FUNC_CODE_INST_CALL;
     
     const CallInst *CI = cast<CallInst>(&I);
-    Vals.push_back(VE.getParamAttrID(CI->getParamAttrs()));
+    Vals.push_back(VE.getAttributeID(CI->getAttributes()));
     Vals.push_back((CI->getCallingConv() << 1) | unsigned(CI->isTailCall()));
     PushValueAndType(CI->getOperand(0), InstID, Vals, VE);  // Callee
     
@@ -1226,7 +1227,7 @@ static void WriteModule(const Module *M, BitstreamWriter &Stream) {
   WriteBlockInfo(VE, Stream);
   
   // Emit information about parameter attributes.
-  WriteParamAttrTable(VE, Stream);
+  WriteAttributeTable(VE, Stream);
   
   // Emit information describing all of the types in the module.
   WriteTypeTable(VE, Stream);
@@ -1330,6 +1331,16 @@ static void EmitDarwinBCTrailer(BitstreamWriter &Stream, unsigned BufferSize) {
 /// WriteBitcodeToFile - Write the specified module to the specified output
 /// stream.
 void llvm::WriteBitcodeToFile(const Module *M, std::ostream &Out) {
+  raw_os_ostream RawOut(Out);
+  // If writing to stdout, set binary mode.
+  if (llvm::cout == Out)
+    sys::Program::ChangeStdoutToBinary();
+  WriteBitcodeToFile(M, RawOut);
+}
+
+/// WriteBitcodeToFile - Write the specified module to the specified output
+/// stream.
+void llvm::WriteBitcodeToFile(const Module *M, raw_ostream &Out) {
   std::vector<unsigned char> Buffer;
   BitstreamWriter Stream(Buffer);
   
@@ -1356,7 +1367,7 @@ void llvm::WriteBitcodeToFile(const Module *M, std::ostream &Out) {
 
   
   // If writing to stdout, set binary mode.
-  if (llvm::cout == Out)
+  if (&llvm::outs() == &Out)
     sys::Program::ChangeStdoutToBinary();
 
   // Write the generated bitstream to "Out".