Initial skeleton of Subzero.

src/llvm2ice.cpp

+//===- subzero/src/llvm2ice.cpp - Driver for testing ----------------------===//
+//
+//                        The Subzero Code Generator
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines a driver that uses LLVM capabilities to parse a
+// bitcode file and build the LLVM IR, and then convert the LLVM basic
+// blocks, instructions, and operands into their Subzero equivalents.
+//
+//===----------------------------------------------------------------------===//
+
+#include "IceCfg.h"
+#include "IceCfgNode.h"
+#include "IceDefs.h"
+#include "IceInst.h"
+#include "IceOperand.h"
+#include "IceTypes.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 "llvm/IRReader/IRReader.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/raw_os_ostream.h"
+#include "llvm/Support/SourceMgr.h"
+
+#include <fstream>
+#include <iostream>
+
+using namespace llvm;
+
+// Debugging helper
+template <typename T> static std::string LLVMObjectAsString(const T *O) {
+  std::string Dump;
+  raw_string_ostream Stream(Dump);
+  O->print(Stream);
+  return Stream.str();
+}
+
+// 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() : Cfg(NULL), CurrentNode(NULL) {}
+
+  IceCfg *convertFunction(const Function *F) {
+    VarMap.clear();
+    NodeMap.clear();
+    Cfg = new IceCfg;
+    Cfg->setName(F->getName());
+    Cfg->setReturnType(convertType(F->getReturnType()));
+    Cfg->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) {
+      Cfg->addArg(mapValueToIceVar(ArgI));
+    }
+
+    // Make an initial pass through the block list just to resolve the
+    // blocks in the original linearized order.  Otherwise the ICE
+    // linearized order will be affected by branch targets in
+    // terminator instructions.
+    for (Function::const_iterator BBI = F->begin(), BBE = F->end(); BBI != BBE;
+         ++BBI) {
+      mapBasicBlockToNode(BBI);
+    }
+    for (Function::const_iterator BBI = F->begin(), BBE = F->end(); BBI != BBE;
+         ++BBI) {
+      CurrentNode = mapBasicBlockToNode(BBI);
+      convertBasicBlock(BBI);
+    }
+    Cfg->setEntryNode(mapBasicBlockToNode(&F->getEntryBlock()));
+    Cfg->registerEdges();
+
+    return Cfg;
+  }
+
+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.
+  IceVariable *mapValueToIceVar(const Value *V, IceType IceTy) {
+    if (IceTy == IceType_void)
+      return NULL;
+    if (VarMap.find(V) == VarMap.end()) {
+      assert(CurrentNode);
+      VarMap[V] = Cfg->makeVariable(IceTy, CurrentNode, V->getName());
+    }
+    return VarMap[V];
+  }
+
+  IceVariable *mapValueToIceVar(const Value *V) {
+    return mapValueToIceVar(V, convertType(V->getType()));
+  }
+
+  IceCfgNode *mapBasicBlockToNode(const BasicBlock *BB) {
+    if (NodeMap.find(BB) == NodeMap.end()) {
+      NodeMap[BB] = Cfg->makeNode(BB->getName());
+    }
+    return NodeMap[BB];
+  }
+
+  IceType convertIntegerType(const IntegerType *IntTy) {

[jvoung (off chromium), 2014/03/22 00:29:39]

is this const?

[Jim Stichnoth, 2014/03/24 13:18:53]

Done, also convertType() below.

+    switch (IntTy->getBitWidth()) {
+    case 1:
+      return IceType_i1;
+    case 8:
+      return IceType_i8;
+    case 16:
+      return IceType_i16;
+    case 32:
+      return IceType_i32;
+    case 64:
+      return IceType_i64;
+    default:
+      report_fatal_error(std::string("Invalid PNaCl int type: ") +
+                         LLVMObjectAsString(IntTy));
+      return IceType_void;
+    }
+  }
+
+  IceType convertType(const Type *Ty) {
+    switch (Ty->getTypeID()) {
+    case Type::VoidTyID:
+      return IceType_void;
+    case Type::IntegerTyID:
+      return convertIntegerType(cast<IntegerType>(Ty));
+    case Type::FloatTyID:
+      return IceType_f32;
+    case Type::DoubleTyID:
+      return IceType_f64;
+    case Type::PointerTyID: {
+      const PointerType *PTy = cast<PointerType>(Ty);
+      return convertType(PTy->getElementType());

[jvoung (off chromium), 2014/03/28 16:17:07]

Should this also return i32? Otherwise wouldn't it return the pointed-to type
instead of being a straight conversion?

[jvoung (off chromium), 2014/03/28 23:21:53]

ping?

[Jim Stichnoth, 2014/03/29 14:23:22]

Sorry, done.  This was left over from earlier representation/lowering of the
Load and Store instructions, where I wanted to capture the pointed-to type of
the address operand.  It worked because Load and Store instructions are
basically the only places where we find pointers in the simplified PNaCl
bitcode.  However, we actually get the pointed-to type of the address operand by
looking at the data operand in the instruction, so this conversion is
unnecessary.

(Making this simplification exposed a bug in the constant pooling code, where
the immediate offset wasn't being included in the lookup key.  This caused the
two halves of an i64 global to be collapsed to the same address during
lowering.)

+    }
+    case Type::FunctionTyID:
+      return IceType_i32;

[jvoung (off chromium), 2014/03/22 00:29:39]

This i32 is for function ptr, or function-but-not-function-pointer? If it is a
pointer, perhaps there should be something like intptr_t, so that the code is a
bit more parametric w.r.t pointer size?

[Jim Stichnoth, 2014/03/24 13:18:53]

Generally I was following
https://developers.google.com/native-client/dev/reference/pnacl-bitcode-abi#d...
which fixes pointers to i32.  This means using IceType_i32 here should be fine,
but only as long as the target is PNaCl (or the target pointer size is actually
32 bits).

But given long-term goals of Subzero, plus the fact that the initial x86-64
prototype will be native (unsandboxed), you're right and we should have a
high-level pointer type that gets lowered to i32 or i64.  I'll work on that as a
separate patchset.

[Jim Stichnoth, 2014/03/28 13:52:18]

I looked into this some more.  In addition to this particular line of code
(which btw returns the type of a function pointer), the alloca construction also
makes a pointer size decision.  There is also the ptrtoint handling, but as I
understand it, ptrtoint is not really in a proper PNaCl bitcode file, but rather
is generated as part of the bitcode writer to make types consistent.

I think that in these two (or three) cases, it will be best to continue to
pre-lower the pointer types before the initial ICE construction, since we
already know the target, and avoid adding an abstract pointer type to ICE.

[jvoung (off chromium), 2014/03/28 16:17:07]

Okay seems fine to keep this the way it is then. I wasn't actually suggesting to
add IceType_PtrTy in the enums, but something more like LLVM's
Subtarget->getPointerTy() which returns MVT::i32 (which would seem like
IceType_i32).

[Jim Stichnoth, 2014/03/28 16:45:08]

Done.

+    default:
+      report_fatal_error(std::string("Invalid PNaCl type: ") +
+                         LLVMObjectAsString(Ty));
+    }
+
+    llvm_unreachable("convertType");
+    return IceType_void;
+  }
+
+  // Given a LLVM instruction and an operand number, produce the IceOperand this
+  // refers to. If there's no such operand, return NULL.
+  IceOperand *convertOperand(const Instruction *Inst, unsigned OpNum) {
+    if (OpNum >= Inst->getNumOperands()) {
+      return NULL;
+    }
+    const Value *Op = Inst->getOperand(OpNum);
+    return convertValue(Op);
+  }
+
+  IceOperand *convertValue(const Value *Op) {
+    if (const Constant *Const = dyn_cast<Constant>(Op)) {
+      if (const GlobalValue *GV = dyn_cast<GlobalValue>(Const)) {
+        return Cfg->getConstantSym(convertType(GV->getType()), GV, 0,
+                                   GV->getName());
+      } else if (const ConstantInt *CI = dyn_cast<ConstantInt>(Const)) {
+        return Cfg->getConstantInt(convertIntegerType(CI->getType()),
+                                   CI->getZExtValue());
+      } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(Const)) {
+        IceType Type = convertType(CFP->getType());
+        if (Type == IceType_f32)
+          return Cfg->getConstantFloat(CFP->getValueAPF().convertToFloat());
+        else if (Type == IceType_f64)
+          return Cfg->getConstantDouble(CFP->getValueAPF().convertToDouble());
+        assert(0 && "Unexpected floating point type");
+        return NULL;
+      } else {
+        assert(0 && "Unhandled constant type");
+        return NULL;
+      }
+    } else {
+      return mapValueToIceVar(Op);
+    }
+  }
+
+  // Note: this currently assumes a 1x1 mapping between LLVM IR and Ice
+  // instructions.
+  IceInst *convertInstruction(const Instruction *Inst) {
+    switch (Inst->getOpcode()) {
+    case Instruction::PHI:
+      return convertPHINodeInstruction(cast<PHINode>(Inst));
+    case Instruction::Br:
+      return convertBrInstruction(cast<BranchInst>(Inst));
+    case Instruction::Ret:
+      return convertRetInstruction(cast<ReturnInst>(Inst));
+    case Instruction::IntToPtr:
+      return convertIntToPtrInstruction(cast<IntToPtrInst>(Inst));
+    case Instruction::PtrToInt:
+      return convertPtrToIntInstruction(cast<PtrToIntInst>(Inst));
+    case Instruction::ICmp:
+      return convertICmpInstruction(cast<ICmpInst>(Inst));
+    case Instruction::FCmp:
+      return convertFCmpInstruction(cast<FCmpInst>(Inst));
+    case Instruction::Select:
+      return convertSelectInstruction(cast<SelectInst>(Inst));
+    case Instruction::Switch:
+      return convertSwitchInstruction(cast<SwitchInst>(Inst));
+    case Instruction::Load:
+      return convertLoadInstruction(cast<LoadInst>(Inst));
+    case Instruction::Store:
+      return convertStoreInstruction(cast<StoreInst>(Inst));
+    case Instruction::ZExt:
+      return convertCastInstruction(cast<ZExtInst>(Inst), IceInstCast::Zext);
+    case Instruction::SExt:
+      return convertCastInstruction(cast<SExtInst>(Inst), IceInstCast::Sext);
+    case Instruction::Trunc:
+      return convertCastInstruction(cast<TruncInst>(Inst), IceInstCast::Trunc);
+    case Instruction::FPTrunc:
+      return convertCastInstruction(cast<FPTruncInst>(Inst),
+                                    IceInstCast::Fptrunc);
+    case Instruction::FPExt:
+      return convertCastInstruction(cast<FPExtInst>(Inst), IceInstCast::Fpext);
+    case Instruction::FPToSI:
+      return convertCastInstruction(cast<FPToSIInst>(Inst),
+                                    IceInstCast::Fptosi);
+    case Instruction::FPToUI:
+      return convertCastInstruction(cast<FPToUIInst>(Inst),
+                                    IceInstCast::Fptoui);
+    case Instruction::SIToFP:
+      return convertCastInstruction(cast<SIToFPInst>(Inst),
+                                    IceInstCast::Sitofp);
+    case Instruction::UIToFP:
+      return convertCastInstruction(cast<UIToFPInst>(Inst),
+                                    IceInstCast::Uitofp);
+    case Instruction::Add:
+      return convertArithInstruction(Inst, IceInstArithmetic::Add);
+    case Instruction::Sub:
+      return convertArithInstruction(Inst, IceInstArithmetic::Sub);
+    case Instruction::Mul:
+      return convertArithInstruction(Inst, IceInstArithmetic::Mul);
+    case Instruction::UDiv:
+      return convertArithInstruction(Inst, IceInstArithmetic::Udiv);
+    case Instruction::SDiv:
+      return convertArithInstruction(Inst, IceInstArithmetic::Sdiv);
+    case Instruction::URem:
+      return convertArithInstruction(Inst, IceInstArithmetic::Urem);
+    case Instruction::SRem:
+      return convertArithInstruction(Inst, IceInstArithmetic::Srem);
+    case Instruction::Shl:
+      return convertArithInstruction(Inst, IceInstArithmetic::Shl);
+    case Instruction::LShr:
+      return convertArithInstruction(Inst, IceInstArithmetic::Lshr);
+    case Instruction::AShr:
+      return convertArithInstruction(Inst, IceInstArithmetic::Ashr);
+    case Instruction::FAdd:
+      return convertArithInstruction(Inst, IceInstArithmetic::Fadd);
+    case Instruction::FSub:
+      return convertArithInstruction(Inst, IceInstArithmetic::Fsub);
+    case Instruction::FMul:
+      return convertArithInstruction(Inst, IceInstArithmetic::Fmul);
+    case Instruction::FDiv:
+      return convertArithInstruction(Inst, IceInstArithmetic::Fdiv);
+    case Instruction::FRem:
+      return convertArithInstruction(Inst, IceInstArithmetic::Frem);
+    case Instruction::And:
+      return convertArithInstruction(Inst, IceInstArithmetic::And);
+    case Instruction::Or:
+      return convertArithInstruction(Inst, IceInstArithmetic::Or);
+    case Instruction::Xor:
+      return convertArithInstruction(Inst, IceInstArithmetic::Xor);
+    case Instruction::Call:
+      return convertCallInstruction(cast<CallInst>(Inst));
+    case Instruction::Alloca:
+      return convertAllocaInstruction(cast<AllocaInst>(Inst));
+    default:
+      report_fatal_error(std::string("Invalid PNaCl instruction: ") +
+                         LLVMObjectAsString(Inst));
+    }
+
+    llvm_unreachable("convertInstruction");
+    return NULL;
+  }
+
+  IceInst *convertLoadInstruction(const LoadInst *Inst) {
+    IceOperand *Src = convertOperand(Inst, 0);
+    IceVariable *Dest = mapValueToIceVar(Inst);
+    return IceInstLoad::create(Cfg, Dest, Src);
+  }
+
+  IceInst *convertStoreInstruction(const StoreInst *Inst) {
+    IceOperand *Addr = convertOperand(Inst, 1);
+    IceOperand *Val = convertOperand(Inst, 0);
+    return IceInstStore::create(Cfg, Val, Addr);
+  }
+
+  IceInst *convertArithInstruction(const Instruction *Inst,
+                                   IceInstArithmetic::OpKind Opcode) {
+    const BinaryOperator *BinOp = cast<BinaryOperator>(Inst);
+    IceOperand *Src0 = convertOperand(Inst, 0);
+    IceOperand *Src1 = convertOperand(Inst, 1);
+    IceVariable *Dest = mapValueToIceVar(BinOp);
+    return IceInstArithmetic::create(Cfg, Opcode, Dest, Src0, Src1);
+  }
+
+  IceInst *convertPHINodeInstruction(const PHINode *Inst) {
+    unsigned NumValues = Inst->getNumIncomingValues();
+    IceInstPhi *IcePhi =
+        IceInstPhi::create(Cfg, NumValues, mapValueToIceVar(Inst));
+    for (unsigned N = 0, E = NumValues; N != E; ++N) {
+      IcePhi->addArgument(convertOperand(Inst, N),
+                          mapBasicBlockToNode(Inst->getIncomingBlock(N)));
+    }
+    return IcePhi;
+  }
+
+  IceInst *convertBrInstruction(const BranchInst *Inst) {
+    if (Inst->isConditional()) {
+      IceOperand *Src = convertOperand(Inst, 0);
+      BasicBlock *BBThen = Inst->getSuccessor(0);
+      BasicBlock *BBElse = Inst->getSuccessor(1);
+      IceCfgNode *NodeThen = mapBasicBlockToNode(BBThen);
+      IceCfgNode *NodeElse = mapBasicBlockToNode(BBElse);
+      return IceInstBr::create(Cfg, Src, NodeThen, NodeElse);
+    } else {
+      BasicBlock *BBSucc = Inst->getSuccessor(0);
+      return IceInstBr::create(Cfg, mapBasicBlockToNode(BBSucc));
+    }
+  }
+
+  IceInst *convertIntToPtrInstruction(const IntToPtrInst *Inst) {
+    IceOperand *Src = convertOperand(Inst, 0);
+    IceVariable *Dest = mapValueToIceVar(Inst, IceType_i32);
+    return IceInstAssign::create(Cfg, Dest, Src);
+  }
+
+  IceInst *convertPtrToIntInstruction(const PtrToIntInst *Inst) {
+    IceOperand *Src = convertOperand(Inst, 0);
+    IceVariable *Dest = mapValueToIceVar(Inst);
+    return IceInstAssign::create(Cfg, Dest, Src);
+  }
+
+  IceInst *convertRetInstruction(const ReturnInst *Inst) {
+    IceOperand *RetOperand = convertOperand(Inst, 0);
+    if (RetOperand) {
+      return IceInstRet::create(Cfg, RetOperand);
+    } else {
+      return IceInstRet::create(Cfg);
+    }
+  }
+
+  IceInst *convertCastInstruction(const Instruction *Inst,
+                                  IceInstCast::OpKind CastKind) {
+    IceOperand *Src = convertOperand(Inst, 0);
+    IceVariable *Dest = mapValueToIceVar(Inst);
+    return IceInstCast::create(Cfg, CastKind, Dest, Src);
+  }
+
+  IceInst *convertICmpInstruction(const ICmpInst *Inst) {
+    IceOperand *Src0 = convertOperand(Inst, 0);
+    IceOperand *Src1 = convertOperand(Inst, 1);
+    IceVariable *Dest = mapValueToIceVar(Inst);
+
+    IceInstIcmp::ICond Cond;
+    switch (Inst->getPredicate()) {
+    default:
+      llvm_unreachable("ICmpInst predicate");
+    case CmpInst::ICMP_EQ:
+      Cond = IceInstIcmp::Eq;
+      break;
+    case CmpInst::ICMP_NE:
+      Cond = IceInstIcmp::Ne;
+      break;
+    case CmpInst::ICMP_UGT:
+      Cond = IceInstIcmp::Ugt;
+      break;
+    case CmpInst::ICMP_UGE:
+      Cond = IceInstIcmp::Uge;
+      break;
+    case CmpInst::ICMP_ULT:
+      Cond = IceInstIcmp::Ult;
+      break;
+    case CmpInst::ICMP_ULE:
+      Cond = IceInstIcmp::Ule;
+      break;
+    case CmpInst::ICMP_SGT:
+      Cond = IceInstIcmp::Sgt;
+      break;
+    case CmpInst::ICMP_SGE:
+      Cond = IceInstIcmp::Sge;
+      break;
+    case CmpInst::ICMP_SLT:
+      Cond = IceInstIcmp::Slt;
+      break;
+    case CmpInst::ICMP_SLE:
+      Cond = IceInstIcmp::Sle;
+      break;
+    }
+
+    return IceInstIcmp::create(Cfg, Cond, Dest, Src0, Src1);
+  }
+
+  IceInst *convertFCmpInstruction(const FCmpInst *Inst) {
+    IceOperand *Src0 = convertOperand(Inst, 0);
+    IceOperand *Src1 = convertOperand(Inst, 1);
+    IceVariable *Dest = mapValueToIceVar(Inst);
+
+    IceInstFcmp::FCond Cond;
+    switch (Inst->getPredicate()) {
+
+    default:
+      llvm_unreachable("FCmpInst predicate");
+
+    case CmpInst::FCMP_FALSE:
+      Cond = IceInstFcmp::False;
+      break;
+    case CmpInst::FCMP_OEQ:
+      Cond = IceInstFcmp::Oeq;
+      break;
+    case CmpInst::FCMP_OGT:
+      Cond = IceInstFcmp::Ogt;
+      break;
+    case CmpInst::FCMP_OGE:
+      Cond = IceInstFcmp::Oge;
+      break;
+    case CmpInst::FCMP_OLT:
+      Cond = IceInstFcmp::Olt;
+      break;
+    case CmpInst::FCMP_OLE:
+      Cond = IceInstFcmp::Ole;
+      break;
+    case CmpInst::FCMP_ONE:
+      Cond = IceInstFcmp::One;
+      break;
+    case CmpInst::FCMP_ORD:
+      Cond = IceInstFcmp::Ord;
+      break;
+    case CmpInst::FCMP_UEQ:
+      Cond = IceInstFcmp::Ueq;
+      break;
+    case CmpInst::FCMP_UGT:
+      Cond = IceInstFcmp::Ugt;
+      break;
+    case CmpInst::FCMP_UGE:
+      Cond = IceInstFcmp::Uge;
+      break;
+    case CmpInst::FCMP_ULT:
+      Cond = IceInstFcmp::Ult;
+      break;
+    case CmpInst::FCMP_ULE:
+      Cond = IceInstFcmp::Ule;
+      break;
+    case CmpInst::FCMP_UNE:
+      Cond = IceInstFcmp::Une;
+      break;
+    case CmpInst::FCMP_UNO:
+      Cond = IceInstFcmp::Uno;
+      break;
+    case CmpInst::FCMP_TRUE:
+      Cond = IceInstFcmp::True;
+      break;
+    }
+
+    return IceInstFcmp::create(Cfg, Cond, Dest, Src0, Src1);
+  }
+
+  IceInst *convertSelectInstruction(const SelectInst *Inst) {
+    IceVariable *Dest = mapValueToIceVar(Inst);
+    IceOperand *Cond = convertValue(Inst->getCondition());
+    IceOperand *Source1 = convertValue(Inst->getTrueValue());
+    IceOperand *Source2 = convertValue(Inst->getFalseValue());
+    return IceInstSelect::create(Cfg, Dest, Cond, Source1, Source2);
+  }
+
+  IceInst *convertSwitchInstruction(const SwitchInst *Inst) {
+    IceOperand *Source = convertValue(Inst->getCondition());
+    IceCfgNode *LabelDefault = mapBasicBlockToNode(Inst->getDefaultDest());
+    unsigned NumCases = Inst->getNumCases();
+    IceInstSwitch *Switch =
+        IceInstSwitch::create(Cfg, 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();
+      IceCfgNode *CaseSuccessor = mapBasicBlockToNode(I.getCaseSuccessor());
+      Switch->addBranch(CurrentCase, CaseValue, CaseSuccessor);
+    }
+    return Switch;
+  }
+
+  IceInst *convertCallInstruction(const CallInst *Inst) {
+    IceVariable *Dest = mapValueToIceVar(Inst);
+    IceOperand *CallTarget = convertValue(Inst->getCalledValue());
+    unsigned NumArgs = Inst->getNumArgOperands();
+    IceInstCall *NewInst =
+        IceInstCall::create(Cfg, NumArgs, Dest, CallTarget, Inst->isTailCall());
+    for (unsigned i = 0; i < NumArgs; ++i) {
+      NewInst->addArg(convertOperand(Inst, i));
+    }
+    return NewInst;
+  }
+
+  IceInst *convertAllocaInstruction(const AllocaInst *Inst) {
+    // PNaCl bitcode only contains allocas of byte-granular objects.
+    IceOperand *ByteCount = convertValue(Inst->getArraySize());
+    uint32_t Align = Inst->getAlignment();
+    IceVariable *Dest = mapValueToIceVar(Inst, IceType_i32);
+
+    return IceInstAlloca::create(Cfg, ByteCount, Align, Dest);
+  }
+
+  IceCfgNode *convertBasicBlock(const BasicBlock *BB) {
+    IceCfgNode *Node = mapBasicBlockToNode(BB);
+    for (BasicBlock::const_iterator II = BB->begin(), II_e = BB->end();
+         II != II_e; ++II) {
+      IceInst *Inst = convertInstruction(II);
+      Node->appendInst(Inst);
+    }
+    return Node;
+  }
+
+private:
+  // Data
+  IceCfg *Cfg;
+  IceCfgNode *CurrentNode;
+  std::map<const Value *, IceVariable *> VarMap;
+  std::map<const BasicBlock *, IceCfgNode *> NodeMap;
+};
+
+static cl::list<IceVerbose> VerboseList(
+    "verbose", cl::CommaSeparated,
+    cl::desc("Verbose options (can be comma-separated):"),
+    cl::values(
+        clEnumValN(IceV_Instructions, "inst", "Print basic instructions"),
+        clEnumValN(IceV_Deleted, "del", "Include deleted instructions"),
+        clEnumValN(IceV_InstNumbers, "instnum", "Print instruction numbers"),
+        clEnumValN(IceV_Preds, "pred", "Show predecessors"),
+        clEnumValN(IceV_Succs, "succ", "Show successors"),
+        clEnumValN(IceV_Liveness, "live", "Liveness information"),
+        clEnumValN(IceV_RegManager, "rmgr", "Register manager status"),
+        clEnumValN(IceV_RegOrigins, "orig", "Physical register origins"),
+        clEnumValN(IceV_LinearScan, "regalloc", "Linear scan details"),
+        clEnumValN(IceV_Frame, "frame", "Stack frame layout details"),
+        clEnumValN(IceV_Timing, "time", "Pass timing details"),
+        clEnumValN(IceV_All, "all", "Use all verbose options"),
+        clEnumValN(IceV_None, "none", "No verbosity"), clEnumValEnd));
+static cl::opt<std::string> IRFilename(cl::Positional, cl::desc("<IR file>"),
+                                       cl::Required);
+static cl::opt<std::string> OutputFilename("o",
+                                           cl::desc("Override output filename"),
+                                           cl::init("-"),
+                                           cl::value_desc("filename"));
+static cl::opt<std::string>
+TestPrefix("prefix", cl::desc("Prepend a prefix to symbol names for testing"),
+           cl::init(""), cl::value_desc("prefix"));
+static cl::opt<bool>
+DisableInternal("external",
+                cl::desc("Disable 'internal' linkage type for testing"));
+static cl::opt<bool>
+DisableTranslation("notranslate", cl::desc("Disable Subzero translation"));
+
+static cl::opt<bool> SubzeroTimingEnabled(
+    "timing", cl::desc("Enable breakdown timing of Subzero translation"));
+
+int main(int argc, char **argv) {
+  cl::ParseCommandLineOptions(argc, argv);
+
+  // Parse the input LLVM IR file into a module.
+  SMDiagnostic Err;
+  Module *Mod;
+
+  {
+    IceTimer T;
+    Mod = ParseIRFile(IRFilename, Err, getGlobalContext());
+
+    if (SubzeroTimingEnabled) {
+      std::cerr << "[Subzero timing] IR Parsing: " << T.getElapsedSec()
+                << " sec\n";
+    }
+  }
+
+  if (!Mod) {
+    Err.print(argv[0], errs());
+    return 1;
+  }
+
+  IceVerboseMask VerboseMask = IceV_None;
+  for (unsigned i = 0; i != VerboseList.size(); ++i)
+    VerboseMask |= VerboseList[i];
+
+  std::ofstream Ofs;
+  if (OutputFilename != "-") {
+    Ofs.open(OutputFilename.c_str(), std::ofstream::out);
+  }
+  raw_os_ostream *Os =
+      new raw_os_ostream(OutputFilename == "-" ? std::cout : Ofs);
+  Os->SetUnbuffered();
+
+  for (Module::const_iterator I = Mod->begin(), E = Mod->end(); I != E; ++I) {
+    if (I->empty())
+      continue;
+    LLVM2ICEConverter FunctionConverter;
+
+    IceTimer TConvert;
+    IceCfg *Cfg = FunctionConverter.convertFunction(I);
+    if (DisableInternal)
+      Cfg->setInternal(false);
+
+    if (SubzeroTimingEnabled) {
+      std::cerr << "[Subzero timing] Convert function " << Cfg->getName()
+                << ": " << TConvert.getElapsedSec() << " sec\n";
+    }
+
+    Cfg->setTestPrefix(TestPrefix);
+    Cfg->Str.Stream = Os;
+    Cfg->Str.setVerbose(VerboseMask);
+    if (DisableTranslation) {
+      Cfg->dump();
+    }
+  }
+
+  return 0;
+}