Clean up implementation reading literal constants.

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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file implements the PNaCl bitcode file to Ice, to machine code
 /// translator.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "PNaClTranslator.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"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-parameter"
@@ skipping 130 matching lines @@
     break;
   }
   case FuncSig: {
     Stream << " " << Signature;
   }
   default:
     break;
   }
 }
 
+// Models integer literals as a sequence of bits. Used to read integer values
+// from bitcode files. Based on llvm::APInt.
+class BitcodeInt {
+  BitcodeInt() = delete;
+  BitcodeInt(const BitcodeInt &) = delete;
+  BitcodeInt &operator=(const BitcodeInt &) = delete;
+
+public:
+  BitcodeInt(Ice::SizeT Bits, uint64_t Val) : BitWidth(Bits), Val(Val) {
+    assert(Bits && "bitwidth too small");
+    assert(Bits <= BITS_PER_WORD && "bitwidth too big");
+    clearUnusedBits();
+  }
+
+  int64_t getSExtValue() const {
+    return static_cast<int64_t>(Val << (BITS_PER_WORD - BitWidth)) >>
+           (BITS_PER_WORD - BitWidth);
+  }
+
+  template <typename IntType, typename FpType>
+  inline FpType convertToFp() const {
+    static_assert(sizeof(IntType) == sizeof(FpType),
+                  "IntType and FpType should be the same width");
+    assert(BitWidth == sizeof(IntType) * CHAR_BIT);
+    auto V = static_cast<IntType>(Val);
+    return reinterpret_cast<FpType &>(V);
+  }
+
+private:
+  /// Bits in the (internal) value.
+  static const Ice::SizeT BITS_PER_WORD = sizeof(uint64_t) * CHAR_BIT;
+
+  uint32_t BitWidth; /// The number of bits in the floating point number.
+  uint64_t Val;      /// The (64-bit) equivalent integer value.
+
+  /// Clear unused high order bits.
+  void clearUnusedBits() {
+    // If all bits are used, we want to leave the value alone.
+    if (BitWidth == BITS_PER_WORD)
+      return;
+
+    // Mask out the high bits.
+    Val &= ~static_cast<uint64_t>(0) >> (BITS_PER_WORD - BitWidth);
+  }
+};
+
 class BlockParserBaseClass;
 
 // Top-level class to read PNaCl bitcode files, and translate to ICE.
 class TopLevelParser : public NaClBitcodeParser {
   TopLevelParser() = delete;
   TopLevelParser(const TopLevelParser &) = delete;
   TopLevelParser &operator=(const TopLevelParser &) = delete;
 
 public:
   TopLevelParser(Ice::Translator &Translator, NaClBitstreamCursor &Cursor,
@@ skipping 2347 matching lines @@
     for (uint32_t 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;
       }
-      Ice::APInt Value(BitWidth,
+      BitcodeInt Value(BitWidth,
                        NaClDecodeSignRotatedValue(Values[ValCaseIndex + 2]));
       if (isIRGenDisabled)
         continue;
       Ice::CfgNode *Label = getBranchBasicBlock(Values[ValCaseIndex + 3]);
       if (Label == nullptr)
         return;
       Switch->addBranch(CaseIndex, Value.getSExtValue(), Label);
     }
     if (isIRGenDisabled)
       return;
@@ skipping 369 matching lines @@
     // INTEGER: [intval]
     if (!isValidRecordSize(1, "integer"))
       return;
     if (!isValidNextConstantType())
       return;
     if (isIRGenerationDisabled()) {
       FuncParser->setNextConstantID(nullptr);
       return;
     }
     if (Ice::isScalarIntegerType(NextConstantType)) {
-      Ice::APInt Value(Ice::getScalarIntBitWidth(NextConstantType),
+      BitcodeInt Value(Ice::getScalarIntBitWidth(NextConstantType),
                        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: {
-      const Ice::APInt IntValue(32, static_cast<uint32_t>(Values[0]));
-      float FpValue = Ice::convertAPIntToFp<int32_t, float>(IntValue);
+      const BitcodeInt Value(32, static_cast<uint32_t>(Values[0]));
+      float FpValue = Value.convertToFp<int32_t, float>();
       FuncParser->setNextConstantID(getContext()->getConstantFloat(FpValue));
       return;
     }
     case Ice::IceType_f64: {
-      const Ice::APInt IntValue(64, Values[0]);
-      double FpValue = Ice::convertAPIntToFp<uint64_t, double>(IntValue);
+      const BitcodeInt Value(64, Values[0]);
+      double FpValue = Value.convertToFp<uint64_t, double>();
       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 325 matching lines @@
     raw_string_ostream StrBuf(Buffer);
     StrBuf << IRFilename << ": Does not contain a module!";
     llvm::report_fatal_error(StrBuf.str());
   }
   if (InputStreamFile.getBitcodeBytes().getExtent() % 4 != 0) {
     llvm::report_fatal_error("Bitcode stream should be a multiple of 4 bytes");
   }
 }
 
 } // end of namespace Ice