Subzero: Manage each Cfg as a std::unique_ptr<Cfg>.

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 1034 matching lines @@
 
 /// Parses function blocks in the bitcode file.
 class FunctionParser : public BlockParserBaseClass {
   FunctionParser(const FunctionParser &) = delete;
   FunctionParser &operator=(const FunctionParser &) = delete;
 
 public:
   FunctionParser(unsigned BlockID, BlockParserBaseClass *EnclosingParser)
       : BlockParserBaseClass(BlockID, EnclosingParser),
         Timer(Ice::TimerStack::TT_parseFunctions, getTranslator().getContext()),
-        Func(isIRGenerationDisabled()
-                 ? nullptr
-                 : Ice::Cfg::create(getTranslator().getContext())),
-        CurrentBbIndex(0), FcnId(Context->getNextFunctionBlockValueID()),
+        Func(nullptr), CurrentBbIndex(0),
+        FcnId(Context->getNextFunctionBlockValueID()),
         FuncDecl(Context->getFunctionByID(FcnId)),
         CachedNumGlobalValueIDs(Context->getNumGlobalIDs()),
         NextLocalInstIndex(Context->getNumGlobalIDs()),
-        InstIsTerminating(false) {
-    if (ALLOW_DUMP && getFlags().TimeEachFunction)
-      getTranslator().getContext()->pushTimer(
-          getTranslator().getContext()->getTimerID(
-              Ice::GlobalContext::TSK_Funcs, FuncDecl->getName()),
-          Ice::GlobalContext::TSK_Funcs);
+        InstIsTerminating(false) {}
+
+  bool convertFunction() {
+    const Ice::TimerStackIdT StackID = Ice::GlobalContext::TSK_Funcs;
+    Ice::TimerIdT TimerID = 0;
+    const bool TimeThisFunction = ALLOW_DUMP && getFlags().TimeEachFunction;
+    if (TimeThisFunction) {
+      TimerID = getTranslator().getContext()->getTimerID(StackID,
+                                                         FuncDecl->getName());
+      getTranslator().getContext()->pushTimer(TimerID, StackID);
+    }
+
+    if (!isIRGenerationDisabled())
+      Func = Ice::Cfg::create(getTranslator().getContext());
+    Ice::Cfg::setCurrentCfg(Func.get());
+
     // TODO(kschimpf) Clean up API to add a function signature to
     // a CFG.
     const Ice::FuncSigType &Signature = FuncDecl->getSignature();
     if (isIRGenerationDisabled()) {
       CurrentNode = nullptr;
       for (Ice::Type ArgType : Signature.getArgList()) {
         (void)ArgType;
         setNextLocalInstIndex(nullptr);
       }
     } else {
       Func->setFunctionName(FuncDecl->getName());
       Func->setReturnType(Signature.getReturnType());
       Func->setInternal(FuncDecl->getLinkage() == GlobalValue::InternalLinkage);
       CurrentNode = InstallNextBasicBlock();
       Func->setEntryNode(CurrentNode);
       for (Ice::Type ArgType : Signature.getArgList()) {
         Func->addArg(getNextInstVar(ArgType));
       }
     }
+    bool ParserResult = ParseThisBlock();
+
+    // Temporarily end per-function timing, which will be resumed by
+    // the translator function.  This is because translation may be
+    // done asynchronously in a separate thread.
+    if (TimeThisFunction)
+      getTranslator().getContext()->popTimer(TimerID, StackID);
+
+    Ice::Cfg::setCurrentCfg(nullptr);
+    // Note: Once any errors have been found, we turn off all
+    // translation of all remaining functions. This allows successive
+    // parsing errors to be reported, without adding extra checks to
+    // the translator for such parsing errors.
+    if (Context->getNumErrors() == 0) {
+      getTranslator().translateFcn(std::move(Func));
+      // The translator now has ownership of Func.
+    } else {
+      Func.reset();
+    }
+
+    return ParserResult;
   }
 
   ~FunctionParser() final {}
 
   const char *getBlockName() const override { return "function"; }
 
-  Ice::Cfg *getFunc() const { return Func; }
+  Ice::Cfg *getFunc() const { return Func.get(); }
 
   uint32_t getNumGlobalIDs() const { return CachedNumGlobalValueIDs; }
 
   void setNextLocalInstIndex(Ice::Operand *Op) {
     setOperand(NextLocalInstIndex++, Op);
   }
 
   // Set the next constant ID to the given constant C.
   void setNextConstantID(Ice::Constant *C) { setNextLocalInstIndex(C); }
 
@@ skipping 19 matching lines @@
       StrBuf << "Value index " << Index << " not defined!";
       Error(StrBuf.str());
       report_fatal_error("Unable to continue");
     }
     return Op;
   }
 
 private:
   Ice::TimerMarker Timer;
   // The corresponding ICE function defined by the function block.
-  Ice::Cfg *Func;
+  std::unique_ptr<Ice::Cfg> Func;
   // The index to the current basic block being built.
   uint32_t CurrentBbIndex;
   // The basic block being built.
   Ice::CfgNode *CurrentNode;
   // The ID for the function.
   unsigned FcnId;
   // The corresponding function declaration.
   Ice::FunctionDeclaration *FuncDecl;
   // Holds the dividing point between local and global absolute value indices.
   uint32_t CachedNumGlobalValueIDs;
   // Holds operands local to the function block, based on indices
   // defined in the bitcode file.
   std::vector<Ice::Operand *> LocalOperands;
   // Holds the index within LocalOperands corresponding to the next
   // instruction that generates a value.
   uint32_t NextLocalInstIndex;
   // True if the last processed instruction was a terminating
   // instruction.
   bool InstIsTerminating;
   // Upper limit of alignment power allowed by LLVM
   static const uint32_t AlignPowerLimit = 29;
 
-  void popTimerIfTimingEachFunction() const {
-    if (ALLOW_DUMP && getFlags().TimeEachFunction) {
-      getTranslator().getContext()->popTimer(
-          getTranslator().getContext()->getTimerID(
-              Ice::GlobalContext::TSK_Funcs, FuncDecl->getName()),
-          Ice::GlobalContext::TSK_Funcs);
-    }
-  }
-
   // Extracts the corresponding Alignment to use, given the AlignPower
   // (i.e. 2**(AlignPower-1), or 0 if AlignPower == 0). InstName is the
   // name of the instruction the alignment appears in.
   void extractAlignment(const char *InstName, uint32_t AlignPower,
                         uint32_t &Alignment) {
     if (AlignPower <= AlignPowerLimit + 1) {
       Alignment = (1 << AlignPower) >> 1;
       return;
     }
     std::string Buffer;
@@ skipping 638 matching lines @@
   // if the return type is void. In such cases, a placeholder value
   // for the badly formed instruction is not needed. Hence, if Ty is
   // void, an error instruction is not appended.
   // TODO(kschimpf) Remove error recovery once implementation complete.
   void appendErrorInstruction(Ice::Type Ty) {
     // Note: we don't worry about downstream translation errors because
     // the function will not be translated if any errors occur.
     if (Ty == Ice::IceType_void)
       return;
     Ice::Variable *Var = getNextInstVar(Ty);
-    CurrentNode->appendInst(Ice::InstAssign::create(Func, Var, Var));
+    CurrentNode->appendInst(Ice::InstAssign::create(Func.get(), Var, Var));
   }
 };
 
 void FunctionParser::ExitBlock() {
   if (isIRGenerationDisabled()) {
-    popTimerIfTimingEachFunction();
-    delete Func;
     return;
   }
   // Before translating, check for blocks without instructions, and
   // insert unreachable. This shouldn't happen, but be safe.
   unsigned Index = 0;
   for (Ice::CfgNode *Node : Func->getNodes()) {
     if (Node->getInsts().empty()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Basic block " << Index << " contains no instructions";
       Error(StrBuf.str());
       // TODO(kschimpf) Remove error recovery once implementation complete.
-      Node->appendInst(Ice::InstUnreachable::create(Func));
+      Node->appendInst(Ice::InstUnreachable::create(Func.get()));
     }
     ++Index;
   }
   Func->computePredecessors();
-  // Temporarily end per-function timing, which will be resumed by the
-  // translator function.  This is because translation may be done
-  // asynchronously in a separate thread.
-  popTimerIfTimingEachFunction();
-  // Note: Once any errors have been found, we turn off all
-  // translation of all remaining functions. This allows use to see
-  // multiple errors, without adding extra checks to the translator
-  // for such parsing errors.
-  if (Context->getNumErrors() == 0)
-    getTranslator().translateFcn(Func);
 }
 
 void FunctionParser::ReportInvalidBinaryOp(Ice::InstArithmetic::OpKind Op,
                                            Ice::Type OpTy) {
   std::string Buffer;
   raw_string_ostream StrBuf(Buffer);
   StrBuf << "Invalid operator type for " << Ice::InstArithmetic::getOpName(Op)
          << ". Found " << OpTy;
   Error(StrBuf.str());
 }
@@ skipping 55 matching lines @@
       appendErrorInstruction(Type1);
       return;
     }
 
     Ice::InstArithmetic::OpKind Opcode;
     if (!convertBinopOpcode(Values[2], Type1, Opcode)) {
       appendErrorInstruction(Type1);
       return;
     }
     CurrentNode->appendInst(Ice::InstArithmetic::create(
-        Func, Opcode, getNextInstVar(Type1), Op1, Op2));
+        Func.get(), Opcode, getNextInstVar(Type1), Op1, Op2));
     return;
   }
   case naclbitc::FUNC_CODE_INST_CAST: {
     // CAST: [opval, destty, castopc]
     if (!isValidRecordSize(3, "cast"))
       return;
     Ice::Operand *Src = getRelativeOperand(Values[0], BaseIndex);
     Ice::Type CastType = Context->getSimpleTypeByID(Values[1]);
     Ice::InstCast::OpKind CastKind;
     if (isIRGenerationDisabled()) {
       assert(Src == nullptr);
       setNextLocalInstIndex(nullptr);
       return;
     }
     if (!convertCastOpToIceOp(Values[2], Src->getType(), CastType, CastKind)) {
       appendErrorInstruction(CastType);
       return;
     }
-    CurrentNode->appendInst(
-        Ice::InstCast::create(Func, CastKind, getNextInstVar(CastType), Src));
+    CurrentNode->appendInst(Ice::InstCast::create(
+        Func.get(), CastKind, getNextInstVar(CastType), Src));
     return;
   }
   case naclbitc::FUNC_CODE_INST_VSELECT: {
     // VSELECT: [opval, opval, pred]
     if (!isValidRecordSize(3, "select"))
       return;
     Ice::Operand *ThenVal = getRelativeOperand(Values[0], BaseIndex);
     Ice::Operand *ElseVal = getRelativeOperand(Values[1], BaseIndex);
     Ice::Operand *CondVal = getRelativeOperand(Values[2], BaseIndex);
     if (isIRGenerationDisabled()) {
@@ skipping 28 matching lines @@
     } else if (CondVal->getType() != Ice::IceType_i1) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Select condition " << CondVal
              << " not type i1. Found: " << CondVal->getType();
       Error(StrBuf.str());
       appendErrorInstruction(ThenType);
       return;
     }
     CurrentNode->appendInst(Ice::InstSelect::create(
-        Func, getNextInstVar(ThenType), CondVal, ThenVal, ElseVal));
+        Func.get(), getNextInstVar(ThenType), CondVal, ThenVal, ElseVal));
     return;
   }
   case naclbitc::FUNC_CODE_INST_EXTRACTELT: {
     // EXTRACTELT: [opval, opval]
     if (!isValidRecordSize(2, "extract element"))
       return;
     Ice::Operand *Vec = getRelativeOperand(Values[0], BaseIndex);
     Ice::Operand *Index = getRelativeOperand(Values[1], BaseIndex);
     if (isIRGenerationDisabled()) {
       assert(Vec == nullptr && Index == nullptr);
       setNextLocalInstIndex(nullptr);
       return;
     }
     Ice::Type VecType = Vec->getType();
     VectorIndexCheckValue IndexCheckValue = validateVectorIndex(Vec, Index);
     if (IndexCheckValue != VectorIndexValid) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       dumpVectorIndexCheckValue(StrBuf, IndexCheckValue);
       StrBuf << ": extractelement " << VecType << " " << *Vec << ", "
              << Index->getType() << " " << *Index;
       Error(StrBuf.str());
       appendErrorInstruction(VecType);
       return;
     }
     CurrentNode->appendInst(Ice::InstExtractElement::create(
-        Func, getNextInstVar(typeElementType(VecType)), Vec, Index));
+        Func.get(), getNextInstVar(typeElementType(VecType)), Vec, Index));
     return;
   }
   case naclbitc::FUNC_CODE_INST_INSERTELT: {
     // INSERTELT: [opval, opval, opval]
     if (!isValidRecordSize(3, "insert element"))
       return;
     Ice::Operand *Vec = getRelativeOperand(Values[0], BaseIndex);
     Ice::Operand *Elt = getRelativeOperand(Values[1], BaseIndex);
     Ice::Operand *Index = getRelativeOperand(Values[2], BaseIndex);
     if (isIRGenerationDisabled()) {
       assert(Vec == nullptr && Elt == nullptr && Index == nullptr);
       setNextLocalInstIndex(nullptr);
       return;
     }
     Ice::Type VecType = Vec->getType();
     VectorIndexCheckValue IndexCheckValue = validateVectorIndex(Vec, Index);
     if (IndexCheckValue != VectorIndexValid) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       dumpVectorIndexCheckValue(StrBuf, IndexCheckValue);
       StrBuf << ": insertelement " << VecType << " " << *Vec << ", "
              << Elt->getType() << " " << *Elt << ", " << Index->getType() << " "
              << *Index;
       Error(StrBuf.str());
       appendErrorInstruction(Elt->getType());
       return;
     }
     CurrentNode->appendInst(Ice::InstInsertElement::create(
-        Func, getNextInstVar(VecType), Vec, Elt, Index));
+        Func.get(), getNextInstVar(VecType), Vec, Elt, Index));
     return;
   }
   case naclbitc::FUNC_CODE_INST_CMP2: {
     // CMP2: [opval, opval, pred]
     if (!isValidRecordSize(3, "compare"))
       return;
     Ice::Operand *Op1 = getRelativeOperand(Values[0], BaseIndex);
     Ice::Operand *Op2 = getRelativeOperand(Values[1], BaseIndex);
     if (isIRGenerationDisabled()) {
       assert(Op1 == nullptr && Op2 == nullptr);
@@ skipping 24 matching lines @@
       Ice::InstIcmp::ICond Cond;
       if (!convertNaClBitcICmpOpToIce(Values[2], Cond)) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Compare record contains unknown integer predicate index: "
                << Values[2];
         Error(StrBuf.str());
         appendErrorInstruction(DestType);
       }
       CurrentNode->appendInst(
-          Ice::InstIcmp::create(Func, Cond, Dest, Op1, Op2));
+          Ice::InstIcmp::create(Func.get(), Cond, Dest, Op1, Op2));
     } else if (isFloatingType(Op1Type)) {
       Ice::InstFcmp::FCond Cond;
       if (!convertNaClBitcFCompOpToIce(Values[2], Cond)) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Compare record contains unknown float predicate index: "
                << Values[2];
         Error(StrBuf.str());
         appendErrorInstruction(DestType);
       }
       CurrentNode->appendInst(
-          Ice::InstFcmp::create(Func, Cond, Dest, Op1, Op2));
+          Ice::InstFcmp::create(Func.get(), Cond, Dest, Op1, Op2));
     } else {
       // Not sure this can happen, but be safe.
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Compare on type not understood: " << Op1Type;
       Error(StrBuf.str());
       appendErrorInstruction(DestType);
       return;
     }
     return;
   }
   case naclbitc::FUNC_CODE_INST_RET: {
     // RET: [opval?]
     if (!isValidRecordSizeInRange(0, 1, "return"))
       return;
     if (Values.empty()) {
       if (isIRGenerationDisabled())
         return;
-      CurrentNode->appendInst(Ice::InstRet::create(Func));
+      CurrentNode->appendInst(Ice::InstRet::create(Func.get()));
     } else {
       Ice::Operand *RetVal = getRelativeOperand(Values[0], BaseIndex);
       if (isIRGenerationDisabled()) {
         assert(RetVal == nullptr);
         return;
       }
-      CurrentNode->appendInst(Ice::InstRet::create(Func, RetVal));
+      CurrentNode->appendInst(Ice::InstRet::create(Func.get(), RetVal));
     }
     InstIsTerminating = true;
     return;
   }
   case naclbitc::FUNC_CODE_INST_BR: {
     if (Values.size() == 1) {
       // BR: [bb#]
       if (isIRGenerationDisabled())
         return;
       Ice::CfgNode *Block = getBranchBasicBlock(Values[0]);
       if (Block == nullptr)
         return;
-      CurrentNode->appendInst(Ice::InstBr::create(Func, Block));
+      CurrentNode->appendInst(Ice::InstBr::create(Func.get(), Block));
     } else {
       // BR: [bb#, bb#, opval]
       if (!isValidRecordSize(3, "branch"))
         return;
       Ice::Operand *Cond = getRelativeOperand(Values[2], BaseIndex);
       if (isIRGenerationDisabled()) {
         assert(Cond == nullptr);
         return;
       }
       if (Cond->getType() != Ice::IceType_i1) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Branch condition " << *Cond
                << " not i1. Found: " << Cond->getType();
         Error(StrBuf.str());
         return;
       }
       Ice::CfgNode *ThenBlock = getBranchBasicBlock(Values[0]);
       Ice::CfgNode *ElseBlock = getBranchBasicBlock(Values[1]);
       if (ThenBlock == nullptr || ElseBlock == nullptr)
         return;
       CurrentNode->appendInst(
-          Ice::InstBr::create(Func, Cond, ThenBlock, ElseBlock));
+          Ice::InstBr::create(Func.get(), Cond, ThenBlock, ElseBlock));
     }
     InstIsTerminating = true;
     return;
   }
   case naclbitc::FUNC_CODE_INST_SWITCH: {
     // SWITCH: [Condty, Cond, BbIndex, NumCases Case ...]
     // where Case = [1, 1, Value, BbIndex].
     //
     // Note: Unlike most instructions, we don't infer the type of
     // Cond, but provide it as a separate field. There are also
@@ skipping 26 matching lines @@
       return;
     }
     Ice::CfgNode *DefaultLabel =
         isIRGenDisabled ? nullptr : getBranchBasicBlock(Values[2]);
     unsigned NumCases = Values[3];
 
     // Now recognize each of the cases.
     if (!isValidRecordSize(4 + NumCases * 4, "switch"))
       return;
     Ice::InstSwitch *Switch =
-        isIRGenDisabled ? nullptr : Ice::InstSwitch::create(Func, NumCases,
-                                                            Cond, DefaultLabel);
+        isIRGenDisabled
+            ? nullptr
+            : Ice::InstSwitch::create(Func.get(), NumCases, Cond, DefaultLabel);
     unsigned ValCaseIndex = 4; // index to beginning of case entry.
     for (unsigned CaseIndex = 0; CaseIndex < NumCases;
          ++CaseIndex, ValCaseIndex += 4) {
       if (Values[ValCaseIndex] != 1 || Values[ValCaseIndex + 1] != 1) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Sequence [1, 1, value, label] expected for case entry "
                << "in switch record. (at index" << ValCaseIndex << ")";
         Error(StrBuf.str());
         return;
@@ skipping 10 matching lines @@
     CurrentNode->appendInst(Switch);
     InstIsTerminating = true;
     return;
   }
   case naclbitc::FUNC_CODE_INST_UNREACHABLE: {
     // UNREACHABLE: []
     if (!isValidRecordSize(0, "unreachable"))
       return;
     if (isIRGenerationDisabled())
       return;
-    CurrentNode->appendInst(Ice::InstUnreachable::create(Func));
+    CurrentNode->appendInst(Ice::InstUnreachable::create(Func.get()));
     InstIsTerminating = true;
     return;
   }
   case naclbitc::FUNC_CODE_INST_PHI: {
     // PHI: [ty, val1, bb1, ..., valN, bbN] for n >= 2.
     if (!isValidRecordSizeAtLeast(3, "phi"))
       return;
     Ice::Type Ty = Context->getSimpleTypeByID(Values[0]);
     if ((Values.size() & 0x1) == 0) {
       // Not an odd number of values.
@@ skipping 11 matching lines @@
     if (isIRGenerationDisabled()) {
       // Verify arguments are defined before quitting.
       for (unsigned i = 1; i < Values.size(); i += 2) {
         assert(getRelativeOperand(NaClDecodeSignRotatedValue(Values[i]),
                                   BaseIndex) == nullptr);
       }
       setNextLocalInstIndex(nullptr);
       return;
     }
     Ice::Variable *Dest = getNextInstVar(Ty);
-    Ice::InstPhi *Phi = Ice::InstPhi::create(Func, Values.size() >> 1, Dest);
+    Ice::InstPhi *Phi =
+        Ice::InstPhi::create(Func.get(), Values.size() >> 1, Dest);
     for (unsigned i = 1; i < Values.size(); i += 2) {
       Ice::Operand *Op =
           getRelativeOperand(NaClDecodeSignRotatedValue(Values[i]), BaseIndex);
       if (Op->getType() != Ty) {
         std::string Buffer;
         raw_string_ostream StrBuf(Buffer);
         StrBuf << "Value " << *Op << " not type " << Ty
                << " in phi instruction. Found: " << Op->getType();
         Error(StrBuf.str());
         appendErrorInstruction(Ty);
@@ skipping 18 matching lines @@
     }
     Ice::Type PtrTy = Ice::getPointerType();
     if (ByteCount->getType() != Ice::IceType_i32) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Alloca on non-i32 value. Found: " << *ByteCount;
       Error(StrBuf.str());
       appendErrorInstruction(PtrTy);
       return;
     }
-    CurrentNode->appendInst(Ice::InstAlloca::create(Func, ByteCount, Alignment,
-                                                    getNextInstVar(PtrTy)));
+    CurrentNode->appendInst(Ice::InstAlloca::create(
+        Func.get(), ByteCount, Alignment, getNextInstVar(PtrTy)));
     return;
   }
   case naclbitc::FUNC_CODE_INST_LOAD: {
     // LOAD: [address, align, ty]
     if (!isValidRecordSize(3, "load"))
       return;
     Ice::Operand *Address = getRelativeOperand(Values[0], BaseIndex);
     Ice::Type Ty = Context->getSimpleTypeByID(Values[2]);
     uint32_t Alignment;
     extractAlignment("Load", Values[1], Alignment);
     if (isIRGenerationDisabled()) {
       assert(Address == nullptr);
       setNextLocalInstIndex(nullptr);
       return;
     }
     if (!isValidPointerType(Address, "Load")) {
       appendErrorInstruction(Ty);
       return;
     }
     if (!isValidLoadStoreAlignment(Alignment, Ty, "Load")) {
       appendErrorInstruction(Ty);
       return;
     }
-    CurrentNode->appendInst(
-        Ice::InstLoad::create(Func, getNextInstVar(Ty), Address, Alignment));
+    CurrentNode->appendInst(Ice::InstLoad::create(
+        Func.get(), getNextInstVar(Ty), Address, Alignment));
     return;
   }
   case naclbitc::FUNC_CODE_INST_STORE: {
     // STORE: [address, value, align]
     if (!isValidRecordSize(3, "store"))
       return;
     Ice::Operand *Address = getRelativeOperand(Values[0], BaseIndex);
     Ice::Operand *Value = getRelativeOperand(Values[1], BaseIndex);
     uint32_t Alignment;
     extractAlignment("Store", Values[2], Alignment);
     if (isIRGenerationDisabled()) {
       assert(Address == nullptr && Value == nullptr);
       return;
     }
     if (!isValidPointerType(Address, "Store"))
       return;
     if (!isValidLoadStoreAlignment(Alignment, Value->getType(), "Store"))
       return;
     CurrentNode->appendInst(
-        Ice::InstStore::create(Func, Value, Address, Alignment));
+        Ice::InstStore::create(Func.get(), Value, Address, Alignment));
     return;
   }
   case naclbitc::FUNC_CODE_INST_CALL:
   case naclbitc::FUNC_CODE_INST_CALL_INDIRECT: {
     // CALL: [cc, fnid, arg0, arg1...]
     // CALL_INDIRECT: [cc, fn, returnty, args...]
     //
     // Note: The difference between CALL and CALL_INDIRECT is that
     // CALL has a reference to an explicit function declaration, while
     // the CALL_INDIRECT is just an address. For CALL, we can infer
@@ skipping 68 matching lines @@
         setNextLocalInstIndex(nullptr);
       return;
     }
 
     // Create the call instruction.
     Ice::Variable *Dest = (ReturnType == Ice::IceType_void)
                               ? nullptr
                               : getNextInstVar(ReturnType);
     Ice::InstCall *Inst = nullptr;
     if (IntrinsicInfo) {
-      Inst = Ice::InstIntrinsicCall::create(Func, NumParams, Dest, Callee,
+      Inst = Ice::InstIntrinsicCall::create(Func.get(), NumParams, Dest, Callee,
                                             IntrinsicInfo->Info);
     } else {
-      Inst = Ice::InstCall::create(Func, NumParams, Dest, Callee, IsTailCall);
+      Inst = Ice::InstCall::create(Func.get(), NumParams, Dest, Callee,
+                                   IsTailCall);
     }
 
     // Add parameters.
     for (Ice::SizeT ParamIndex = 0; ParamIndex < NumParams; ++ParamIndex) {
       Inst->addArg(
           getRelativeOperand(Values[ParamsStartIndex + ParamIndex], BaseIndex));
     }
 
     // If intrinsic call, validate call signature.
     if (IntrinsicInfo) {
@@ skipping 374 matching lines @@
     GlobalsParser Parser(BlockID, this);
     return Parser.ParseThisBlock();
   }
   case naclbitc::VALUE_SYMTAB_BLOCK_ID: {
     ModuleValuesymtabParser Parser(BlockID, this);
     return Parser.ParseThisBlock();
   }
   case naclbitc::FUNCTION_BLOCK_ID: {
     InstallGlobalNamesAndGlobalVarInitializers();
     FunctionParser Parser(BlockID, this);
-    return Parser.ParseThisBlock();
+    return Parser.convertFunction();
   }
   default:
     return BlockParserBaseClass::ParseBlock(BlockID);
   }
 }
 
 void ModuleParser::ProcessRecord() {
   const NaClBitcodeRecord::RecordVector &Values = Record.GetValues();
   switch (Record.GetCode()) {
   case naclbitc::MODULE_CODE_VERSION: {
@@ skipping 106 matching lines @@
 
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus.assign(EC_Bitcode);
   }
 }
 
 } // end of namespace Ice