Subzero: Simplify the constant pools.

src/IceConverter.cpp

 //===- subzero/src/IceConverter.cpp - Converts LLVM to Ice  ---------------===//
 //
 //                        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 LLVM to ICE converter.
@@ skipping 98 matching lines @@
     return Func;
   }
 
   // convertConstant() does not use Func or require it to be a valid
   // Ice::Cfg pointer.  As such, it's suitable for e.g. constructing
   // global initializers.
   Ice::Constant *convertConstant(const Constant *Const) {
     if (const auto GV = dyn_cast<GlobalValue>(Const)) {
       Ice::GlobalDeclaration *Decl = getConverter().getGlobalDeclaration(GV);
       const Ice::RelocOffsetT Offset = 0;
-      return Ctx->getConstantSym(TypeConverter.getIcePointerType(),
-                                 Offset, Decl->getName(),
+      return Ctx->getConstantSym(Offset, Decl->getName(),
                                  Decl->getSuppressMangling());
     } else if (const auto CI = dyn_cast<ConstantInt>(Const)) {
       Ice::Type Ty = convertToIceType(CI->getType());
-      if (Ty == Ice::IceType_i64) {
-        return Ctx->getConstantInt64(Ty, CI->getSExtValue());
-      } else {
-        return Ctx->getConstantInt32(Ty, CI->getSExtValue());
+      switch (Ty) {

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

Why not move this switch into IceGlobalcontext.{h,cpp}.

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

Done.

+      default:
+        llvm_unreachable("Unhandled constant integer type");
+        return nullptr;
+      case Ice::IceType_i1:
+        return Ctx->getConstantInt1(CI->getSExtValue());
+      case Ice::IceType_i8:
+        return Ctx->getConstantInt8(CI->getSExtValue());
+      case Ice::IceType_i16:
+        return Ctx->getConstantInt16(CI->getSExtValue());
+      case Ice::IceType_i32:
+        return Ctx->getConstantInt32(CI->getSExtValue());
+      case Ice::IceType_i64:
+        return Ctx->getConstantInt64(CI->getSExtValue());
       }
     } else if (const auto CFP = dyn_cast<ConstantFP>(Const)) {
       Ice::Type Type = convertToIceType(CFP->getType());
       if (Type == Ice::IceType_f32)
         return Ctx->getConstantFloat(CFP->getValueAPF().convertToFloat());
       else if (Type == Ice::IceType_f64)
         return Ctx->getConstantDouble(CFP->getValueAPF().convertToDouble());
       llvm_unreachable("Unexpected floating point type");
       return nullptr;
     } else if (const auto CU = dyn_cast<UndefValue>(Const)) {
@@ skipping 759 matching lines @@
     Cfg *Fcn = FunctionConverter.convertFunction(&I);
     translateFcn(Fcn);
     if (Ctx->getFlags().TimeEachFunction)
       Ctx->popTimer(TimerID, StackID);
   }
 
   emitConstants();
 }
 
 } // end of namespace Ice