Simplify LLVM's APInt and APFloat for use in Subzero.

src/PNaClTranslator.cpp

 //===- subzero/src/PNaClTranslator.cpp - ICE from bitcode -----------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the PNaCl bitcode file to Ice, to machine code
 // translator.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Bitcode/NaCl/NaClBitcodeDecoders.h"
 #include "llvm/Bitcode/NaCl/NaClBitcodeHeader.h"
 #include "llvm/Bitcode/NaCl/NaClBitcodeParser.h"
 #include "llvm/Bitcode/NaCl/NaClReaderWriter.h"
-#include "llvm/IR/Constants.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 
+#include "IceAPInt.h"
+#include "IceAPFloat.h"
 #include "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceClFlags.h"
 #include "IceDefs.h"
 #include "IceGlobalInits.h"
 #include "IceInst.h"
 #include "IceOperand.h"
 #include "IceTypeConverter.h"
 #include "PNaClTranslator.h"
 
@@ skipping 2144 matching lines @@
     for (unsigned CaseIndex = 0; CaseIndex < NumCases;
          ++CaseIndex, ValCaseIndex += 4) {
       if (Values[ValCaseIndex] != 1 || Values[ValCaseIndex+1] != 1) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Sequence [1, 1, value, label] expected for case entry "
                << "in switch record. (at index" << ValCaseIndex << ")";
         Error(StrBuf.str());
         return;
       }
-      APInt Value(BitWidth,
-                  NaClDecodeSignRotatedValue(Values[ValCaseIndex + 2]),
-                  true);
+      Ice::APInt Value(BitWidth,
+                       NaClDecodeSignRotatedValue(Values[ValCaseIndex + 2]));
       if (isIRGenDisabled)
         continue;
       Ice::CfgNode *Label = getBranchBasicBlock(Values[ValCaseIndex + 3]);
       Switch->addBranch(CaseIndex, Value.getSExtValue(), Label);
     }
     if (isIRGenDisabled)
       return;
     CurrentNode->appendInst(Switch);
     InstIsTerminating = true;
     return;
@@ skipping 352 matching lines @@
     if (!isValidRecordSize(1, "integer"))
       return;
     if (!isValidNextConstantType())
       return;
     if (isIRGenerationDisabled()) {
       FuncParser->setNextConstantID(nullptr);
       return;
     }
     if (auto IType = dyn_cast<IntegerType>(
             Context->convertToLLVMType(NextConstantType))) {
-      APInt Value(IType->getBitWidth(), NaClDecodeSignRotatedValue(Values[0]));
+      Ice::APInt Value(IType->getBitWidth(),
+                       NaClDecodeSignRotatedValue(Values[0]));
       if (Ice::Constant *C = getContext()->getConstantInt(
               NextConstantType, Value.getSExtValue())) {
         FuncParser->setNextConstantID(C);
         return;
       }
     }
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << "constant block integer record for non-integer type "
            << NextConstantType;
     Error(StrBuf.str());
     return;
   }
   case naclbitc::CST_CODE_FLOAT: {
     // FLOAT: [fpval]
     if (!isValidRecordSize(1, "float"))
       return;
     if (!isValidNextConstantType())
       return;
     if (isIRGenerationDisabled()) {
       FuncParser->setNextConstantID(nullptr);
       return;
     }
     switch (NextConstantType) {
     case Ice::IceType_f32: {
-      APFloat Value(APFloat::IEEEsingle,
-                    APInt(32, static_cast<uint32_t>(Values[0])));
-      FuncParser->setNextConstantID(
-          getContext()->getConstantFloat(Value.convertToFloat()));
+      const Ice::APInt IntValue(32, static_cast<uint32_t>(Values[0]));
+      float FpValue = Ice::convertAPIntToFp<int32_t, float>(IntValue);
+      FuncParser->setNextConstantID(getContext()->getConstantFloat(FpValue));
       return;
     }
     case Ice::IceType_f64: {
-      APFloat Value(APFloat::IEEEdouble, APInt(64, Values[0]));
-      FuncParser->setNextConstantID(
-          getContext()->getConstantDouble(Value.convertToDouble()));
+      const Ice::APInt IntValue(64, Values[0]);
+      double FpValue = Ice::convertAPIntToFp<uint64_t, double>(IntValue);
+      FuncParser->setNextConstantID(getContext()->getConstantDouble(FpValue));
       return;
     }
     default: {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "constant block float record for non-floating type "
              << NextConstantType;
       Error(StrBuf.str());
       return;
     }
@@ skipping 326 matching lines @@
 
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus = true;
   }
 }
 
 } // end of namespace Ice