Start processing function blocks in Subzero.

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.
 //
 //===----------------------------------------------------------------------===//
 
 #include "IceConverter.h"
 
 #include "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceClFlags.h"
 #include "IceDefs.h"
 #include "IceGlobalContext.h"
 #include "IceInst.h"
 #include "IceOperand.h"
 #include "IceTargetLowering.h"
 #include "IceTypes.h"
+#include "IceTypeConverter.h"
 
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 
 #include <iostream>
@@ skipping 12 matching lines @@
 
 // Converter from LLVM to ICE. The entry point is the convertFunction method.
 //
 // Note: this currently assumes that the given IR was verified to be valid PNaCl
 // bitcode:
 // https://developers.google.com/native-client/dev/reference/pnacl-bitcode-abi
 // If not, all kinds of assertions may fire.
 //
 class LLVM2ICEConverter {
 public:
-  LLVM2ICEConverter(Ice::GlobalContext *Ctx)
-      : Ctx(Ctx), Func(NULL), CurrentNode(NULL) {
+  LLVM2ICEConverter(Ice::GlobalContext *Ctx, LLVMContext& LlvmContext)

[jvoung (off chromium), 2014/07/17 23:57:55]

Before we get too many instances of "Llvm", I'd like to bikeshed a bit... I
personally prefer LLVM, since also matches the capitalization of things like
LLVMContext, but I guess if you guys really prefer Llvm, then okay...

[Karl, 2014/07/18 20:27:42]

Consensus is to use LLVM. Changing.

+      : Ctx(Ctx), Func(NULL), CurrentNode(NULL), TypeConverter(LlvmContext) {
     // All PNaCl pointer widths are 32 bits because of the sandbox
     // model.
-    SubzeroPointerType = Ice::IceType_i32;
   }
 
   // Caller is expected to delete the returned Ice::Cfg object.
   Ice::Cfg *convertFunction(const Function *F) {
     VarMap.clear();
     NodeMap.clear();
     Func = new Ice::Cfg(Ctx);
     Func->setFunctionName(F->getName());
-    Func->setReturnType(convertType(F->getReturnType()));
+    Func->setReturnType(convertToIceType(F->getReturnType()));
     Func->setInternal(F->hasInternalLinkage());
 
     // The initial definition/use of each arg is the entry node.
     CurrentNode = mapBasicBlockToNode(&F->getEntryBlock());
     for (Function::const_arg_iterator ArgI = F->arg_begin(),
                                       ArgE = F->arg_end();
          ArgI != ArgE; ++ArgI) {
       Func->addArg(mapValueToIceVar(ArgI));
     }
 
@@ skipping 14 matching lines @@
     Func->computePredecessors();
 
     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 GlobalValue *GV = dyn_cast<GlobalValue>(Const)) {
-      return Ctx->getConstantSym(convertType(GV->getType()), 0, GV->getName());
+      return Ctx->getConstantSym(convertToIceType(GV->getType()),
+                                 0, GV->getName());
     } else if (const ConstantInt *CI = dyn_cast<ConstantInt>(Const)) {
-      return Ctx->getConstantInt(convertIntegerType(CI->getType()),
+      return Ctx->getConstantInt(convertToIceType(CI->getType()),
                                  CI->getZExtValue());
     } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(Const)) {
-      Ice::Type Type = convertType(CFP->getType());
+      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(convertType(CU->getType()));
+      return Ctx->getConstantUndef(convertToIceType(CU->getType()));
     } else {
       llvm_unreachable("Unhandled constant type");
       return NULL;
     }
   }
 
 private:
   // LLVM values (instructions, etc.) are mapped directly to ICE variables.
   // mapValueToIceVar has a version that forces an ICE type on the variable,
-  // and a version that just uses convertType on V.
+  // and a version that just uses convertToIceType on V.
   Ice::Variable *mapValueToIceVar(const Value *V, Ice::Type IceTy) {
     if (IceTy == Ice::IceType_void)
       return NULL;
     if (VarMap.find(V) == VarMap.end()) {
       assert(CurrentNode);
       VarMap[V] = Func->makeVariable(IceTy, CurrentNode, V->getName());
     }
     return VarMap[V];
   }
 
   Ice::Variable *mapValueToIceVar(const Value *V) {
-    return mapValueToIceVar(V, convertType(V->getType()));
+    return mapValueToIceVar(V, convertToIceType(V->getType()));
   }
 
   Ice::CfgNode *mapBasicBlockToNode(const BasicBlock *BB) {
     if (NodeMap.find(BB) == NodeMap.end()) {
       NodeMap[BB] = Func->makeNode(BB->getName());
     }
     return NodeMap[BB];
   }
 
-  Ice::Type convertIntegerType(const IntegerType *IntTy) const {
-    switch (IntTy->getBitWidth()) {
-    case 1:
-      return Ice::IceType_i1;
-    case 8:
-      return Ice::IceType_i8;
-    case 16:
-      return Ice::IceType_i16;
-    case 32:
-      return Ice::IceType_i32;
-    case 64:
-      return Ice::IceType_i64;
-    default:
-      report_fatal_error(std::string("Invalid PNaCl int type: ") +
-                         LLVMObjectAsString(IntTy));
-      return Ice::IceType_void;
-    }
-  }
-
-  Ice::Type convertVectorType(const VectorType *VecTy) const {
-    unsigned NumElements = VecTy->getNumElements();
-    const Type *ElementType = VecTy->getElementType();
-
-    if (ElementType->isFloatTy()) {
-      if (NumElements == 4)
-        return Ice::IceType_v4f32;
-    } else if (ElementType->isIntegerTy()) {
-      switch (cast<IntegerType>(ElementType)->getBitWidth()) {
-      case 1:
-        if (NumElements == 4)
-          return Ice::IceType_v4i1;
-        if (NumElements == 8)
-          return Ice::IceType_v8i1;
-        if (NumElements == 16)
-          return Ice::IceType_v16i1;
-        break;
-      case 8:
-        if (NumElements == 16)
-          return Ice::IceType_v16i8;
-        break;
-      case 16:
-        if (NumElements == 8)
-          return Ice::IceType_v8i16;
-        break;
-      case 32:
-        if (NumElements == 4)
-          return Ice::IceType_v4i32;
-        break;
-      }
-    }
-
-    report_fatal_error(std::string("Unhandled vector type: ") +
-                       LLVMObjectAsString(VecTy));
-    return Ice::IceType_void;
-  }
-
-  Ice::Type convertType(const Type *Ty) const {
-    switch (Ty->getTypeID()) {
-    case Type::VoidTyID:
-      return Ice::IceType_void;
-    case Type::IntegerTyID:
-      return convertIntegerType(cast<IntegerType>(Ty));
-    case Type::FloatTyID:
-      return Ice::IceType_f32;
-    case Type::DoubleTyID:
-      return Ice::IceType_f64;
-    case Type::PointerTyID:
-      return SubzeroPointerType;
-    case Type::FunctionTyID:
-      return SubzeroPointerType;
-    case Type::VectorTyID:
-      return convertVectorType(cast<VectorType>(Ty));
-    default:
-      report_fatal_error(std::string("Invalid PNaCl type: ") +
-                         LLVMObjectAsString(Ty));
-    }
-
-    llvm_unreachable("convertType");
-    return Ice::IceType_void;
+  Ice::Type convertToIceType(Type *LlvmTy) const {
+    Ice::Type IceTy = TypeConverter.convertToIceType(LlvmTy);
+    if (IceTy == Ice::IceType_NUM)
+      llvm::report_fatal_error(std::string("Invalid PNaCl type ") +
+                               LLVMObjectAsString(LlvmTy));
+    return IceTy;
   }
 
   // Given an LLVM instruction and an operand number, produce the
   // Ice::Operand this refers to. If there's no such operand, return
   // NULL.
   Ice::Operand *convertOperand(const Instruction *Inst, unsigned OpNum) {
     if (OpNum >= Inst->getNumOperands()) {
       return NULL;
     }
     const Value *Op = Inst->getOperand(OpNum);
@@ skipping 154 matching lines @@
       Ice::CfgNode *NodeElse = mapBasicBlockToNode(BBElse);
       return Ice::InstBr::create(Func, Src, NodeThen, NodeElse);
     } else {
       BasicBlock *BBSucc = Inst->getSuccessor(0);
       return Ice::InstBr::create(Func, mapBasicBlockToNode(BBSucc));
     }
   }
 
   Ice::Inst *convertIntToPtrInstruction(const IntToPtrInst *Inst) {
     Ice::Operand *Src = convertOperand(Inst, 0);
-    Ice::Variable *Dest = mapValueToIceVar(Inst, SubzeroPointerType);
+    Ice::Variable *Dest =
+        mapValueToIceVar(Inst, TypeConverter.getIcePointerType());
     return Ice::InstAssign::create(Func, Dest, Src);
   }
 
   Ice::Inst *convertPtrToIntInstruction(const PtrToIntInst *Inst) {
     Ice::Operand *Src = convertOperand(Inst, 0);
     Ice::Variable *Dest = mapValueToIceVar(Inst);
     return Ice::InstAssign::create(Func, Dest, Src);
   }
 
   Ice::Inst *convertRetInstruction(const ReturnInst *Inst) {
@@ skipping 181 matching lines @@
     if (Info) {
       validateIntrinsicCall(NewInst, Info);
     }
     return NewInst;
   }
 
   Ice::Inst *convertAllocaInstruction(const AllocaInst *Inst) {
     // PNaCl bitcode only contains allocas of byte-granular objects.
     Ice::Operand *ByteCount = convertValue(Inst->getArraySize());
     uint32_t Align = Inst->getAlignment();
-    Ice::Variable *Dest = mapValueToIceVar(Inst, SubzeroPointerType);
+    Ice::Variable *Dest =
+        mapValueToIceVar(Inst, TypeConverter.getIcePointerType());
 
     return Ice::InstAlloca::create(Func, ByteCount, Align, Dest);
   }
 
   Ice::Inst *convertUnreachableInstruction(const UnreachableInst * /*Inst*/) {
     return Ice::InstUnreachable::create(Func);
   }
 
   Ice::CfgNode *convertBasicBlock(const BasicBlock *BB) {
     Ice::CfgNode *Node = mapBasicBlockToNode(BB);
@@ skipping 28 matching lines @@
         report_fatal_error("Mismatched argument type.");
       }
     }
   }
 
 private:
   // Data
   Ice::GlobalContext *Ctx;
   Ice::Cfg *Func;
   Ice::CfgNode *CurrentNode;
-  Ice::Type SubzeroPointerType;
   std::map<const Value *, Ice::Variable *> VarMap;
   std::map<const BasicBlock *, Ice::CfgNode *> NodeMap;
+  Ice::TypeConverter TypeConverter;
 };
 
 } // end of anonymous namespace.
 
 namespace Ice {
 
-void Converter::convertToIce(Module *Mod) {
-  convertGlobals(Mod);
-  convertFunctions(Mod);
+void Converter::convertToIce() {
+  convertGlobals();
+  convertFunctions();
 }
 
-void Converter::convertGlobals(Module *Mod) {
+void Converter::convertGlobals() {
   OwningPtr<TargetGlobalInitLowering> GlobalLowering(
       TargetGlobalInitLowering::createLowering(Ctx->getTargetArch(), Ctx));
   for (Module::const_global_iterator I = Mod->global_begin(),
                                      E = Mod->global_end();
        I != E; ++I) {
     if (!I->hasInitializer())
       continue;
     const llvm::Constant *Initializer = I->getInitializer();
     IceString Name = I->getName();
     unsigned Align = I->getAlignment();
@@ skipping 21 matching lines @@
     } else {
       llvm_unreachable("Unhandled global initializer");
     }
 
     GlobalLowering->lower(Name, Align, IsInternal, IsConst, IsZeroInitializer,
                           NumElements, Data, Flags.DisableTranslation);
   }
   GlobalLowering.reset();
 }
 
-void Converter::convertFunctions(Module *Mod) {
+void Converter::convertFunctions() {
   for (Module::const_iterator I = Mod->begin(), E = Mod->end(); I != E; ++I) {
     if (I->empty())
       continue;
-    LLVM2ICEConverter FunctionConverter(Ctx);
+    LLVM2ICEConverter FunctionConverter(Ctx, Mod->getContext());
 
     Timer TConvert;
     Cfg *Fcn = FunctionConverter.convertFunction(I);
     if (Flags.SubzeroTimingEnabled) {
       std::cerr << "[Subzero timing] Convert function "
                 << Fcn->getFunctionName() << ": " << TConvert.getElapsedSec()
                 << " sec\n";
     }
     translateFcn(Fcn);
   }
 
   emitConstants();
 }
 
 } // end of Ice namespace.