Subzero: Simplify the constant pools.

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
@@ skipping 307 matching lines @@
     } else {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Reference to global not defined: " << ID;
       Error(StrBuf.str());
       // TODO(kschimpf) Remove error recovery once implementation complete.
       Name = "??";
       SuppressMangling = false;
     }
     const Ice::RelocOffsetT Offset = 0;
-    C = getTranslator().getContext()->getConstantSym(
-        getIcePointerType(), Offset, Name, SuppressMangling);
+    C = getTranslator().getContext()->getConstantSym(Offset, Name,
+                                                     SuppressMangling);
     ValueIDConstants[ID] = C;
     return C;
   }
 
   /// Returns the number of function declarations in the bitcode file.
   unsigned getNumFunctionIDs() const { return NumFunctionIds; }
 
   /// Returns the number of global declarations (i.e. IDs) defined in
   /// the bitcode file.
   unsigned getNumGlobalIDs() const {
@@ skipping 1093 matching lines @@
   // Returns whether the given vector index (for insertelement and
   // extractelement instructions) is valid.
   VectorIndexCheckValue validateVectorIndex(const Ice::Operand *Vec,
                                             const Ice::Operand *Index) const {
     Ice::Type VecType = Vec->getType();
     if (!Ice::isVectorType(VecType))
       return VectorIndexNotVector;
     const auto *C = dyn_cast<Ice::ConstantInteger32>(Index);
     if (C == nullptr)
       return VectorIndexNotConstant;
-    if (C->getValue() >= typeNumElements(VecType))
+    if (static_cast<size_t>(C->getValue()) >= typeNumElements(VecType))
       return VectorIndexNotInRange;
     if (Index->getType() != Ice::IceType_i32)
       return VectorIndexNotI32;
     return VectorIndexValid;
   }
 
   // Reports that the given binary Opcode, for the given type Ty,
   // is not understood.
   void ReportInvalidBinopOpcode(unsigned Opcode, Ice::Type Ty);
 
@@ skipping 1038 matching lines @@
       return;
     if (!isValidNextConstantType())
       return;
     if (isIRGenerationDisabled()) {
       FuncParser->setNextConstantID(nullptr);
       return;
     }
     if (IntegerType *IType = dyn_cast<IntegerType>(
             Context->convertToLLVMType(NextConstantType))) {
       APInt Value(IType->getBitWidth(), NaClDecodeSignRotatedValue(Values[0]));
-      Ice::Constant *C = (NextConstantType == Ice::IceType_i64)
-                             ? getContext()->getConstantInt64(
-                                   NextConstantType, Value.getSExtValue())
-                             : getContext()->getConstantInt32(
-                                   NextConstantType, Value.getSExtValue());
-      FuncParser->setNextConstantID(C);
-      return;
+      Ice::Constant *C = nullptr;
+      switch (NextConstantType) {

[Karl, 2014/11/19 18:45:28]

Why not provide a helper function (in IceGlobalContext.h) that does this.

[Jim Stichnoth, 2014/11/20 00:08:57]

Done.

+      default:
+        assert(0);
+        break;
+      case Ice::IceType_i1:
+        C = getContext()->getConstantInt1(Value.getSExtValue());
+        break;
+      case Ice::IceType_i8:
+        C = getContext()->getConstantInt8(Value.getSExtValue());
+        break;
+      case Ice::IceType_i16:
+        C = getContext()->getConstantInt16(Value.getSExtValue());
+        break;
+      case Ice::IceType_i32:
+        C = getContext()->getConstantInt32(Value.getSExtValue());
+        break;
+      case Ice::IceType_i64:
+        C = getContext()->getConstantInt64(Value.getSExtValue());
+        break;
+      }
+      if (C) {
+        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]
@@ skipping 353 matching lines @@
 
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus = true;
   }
 }
 
 } // end of namespace Ice