Subzero: Render constants in dump() to be more like LLVM.

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 85 matching lines @@
 
   // 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 GlobalValue *GV = dyn_cast<GlobalValue>(Const)) {
       return Ctx->getConstantSym(convertToIceType(GV->getType()), 0,
                                  GV->getName());
     } else if (const ConstantInt *CI = dyn_cast<ConstantInt>(Const)) {
       return Ctx->getConstantInt(convertToIceType(CI->getType()),
-                                 CI->getZExtValue());
+                                 CI->getSExtValue());
     } else if (const ConstantFP *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 NULL;
     } else if (const UndefValue *CU = dyn_cast<UndefValue>(Const)) {
       return Ctx->getConstantUndef(convertToIceType(CU->getType()));
@@ skipping 373 matching lines @@
 
   Ice::Inst *convertSwitchInstruction(const SwitchInst *Inst) {
     Ice::Operand *Source = convertValue(Inst->getCondition());
     Ice::CfgNode *LabelDefault = mapBasicBlockToNode(Inst->getDefaultDest());
     unsigned NumCases = Inst->getNumCases();
     Ice::InstSwitch *Switch =
         Ice::InstSwitch::create(Func, NumCases, Source, LabelDefault);
     unsigned CurrentCase = 0;
     for (SwitchInst::ConstCaseIt I = Inst->case_begin(), E = Inst->case_end();
          I != E; ++I, ++CurrentCase) {
-      uint64_t CaseValue = I.getCaseValue()->getZExtValue();
+      uint64_t CaseValue = I.getCaseValue()->getSExtValue();
       Ice::CfgNode *CaseSuccessor = mapBasicBlockToNode(I.getCaseSuccessor());
       Switch->addBranch(CurrentCase, CaseValue, CaseSuccessor);
     }
     return Switch;
   }
 
   Ice::Inst *convertCallInstruction(const CallInst *Inst) {
     Ice::Variable *Dest = mapValueToIceVar(Inst);
     Ice::Operand *CallTarget = convertValue(Inst->getCalledValue());
     unsigned NumArgs = Inst->getNumArgOperands();
@@ skipping 158 matching lines @@
                 << Fcn->getFunctionName() << ": " << TConvert.getElapsedSec()
                 << " sec\n";
     }
     translateFcn(Fcn);
   }
 
   emitConstants();
 }
 
 } // end of namespace Ice