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

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 61 matching lines @@
 // valid PNaCl bitcode. Otherwise, the behavior is undefined.
 class LLVM2ICEFunctionConverter : LLVM2ICEConverter {
   LLVM2ICEFunctionConverter(const LLVM2ICEFunctionConverter &) = delete;
   LLVM2ICEFunctionConverter &
   operator=(const LLVM2ICEFunctionConverter &) = delete;
 
 public:
   LLVM2ICEFunctionConverter(Ice::Converter &Converter)
       : LLVM2ICEConverter(Converter), Func(nullptr) {}
 
-  // Caller is expected to delete the returned Ice::Cfg object.
-  Ice::Cfg *convertFunction(const Function *F) {
+  void convertFunction(const Function *F) {
     VarMap.clear();
     NodeMap.clear();
     Func = Ice::Cfg::create(Ctx);
     Func->setFunctionName(F->getName());
     Func->setReturnType(convertToIceType(F->getReturnType()));
     Func->setInternal(F->hasInternalLinkage());
-    Ice::TimerMarker T(Ice::TimerStack::TT_llvmConvert, Func);
+    Ice::TimerMarker T(Ice::TimerStack::TT_llvmConvert, Func.get());
 
     // The initial definition/use of each arg is the entry node.
     for (auto ArgI = F->arg_begin(), ArgE = F->arg_end(); ArgI != ArgE;
          ++ArgI) {
       Func->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 (const BasicBlock &BBI : *F)
       mapBasicBlockToNode(&BBI);
     for (const BasicBlock &BBI : *F)
       convertBasicBlock(&BBI);
     Func->setEntryNode(mapBasicBlockToNode(&F->getEntryBlock()));
     Func->computePredecessors();
+  }
 
-    return Func;
-  }
+  std::unique_ptr<Ice::Cfg> release() { return std::move(Func); }

[JF, 2015/02/02 20:59:19]

That's nicer. Could you leave a TODO to fix?

[Jim Stichnoth, 2015/02/03 00:48:51]

Done.

 
   // 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(Offset, Decl->getName(),
                                  Decl->getSuppressMangling());
@@ skipping 19 matching lines @@
 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 convertToIceType on V.
   Ice::Variable *mapValueToIceVar(const Value *V, Ice::Type IceTy) {
     if (IceTy == Ice::IceType_void)
       return nullptr;
     if (VarMap.find(V) == VarMap.end()) {
       VarMap[V] = Func->makeVariable(IceTy);
       if (ALLOW_DUMP)
-        VarMap[V]->setName(Func, V->getName());
+        VarMap[V]->setName(Func.get(), V->getName());
     }
     return VarMap[V];
   }
 
   Ice::Variable *mapValueToIceVar(const Value *V) {
     return mapValueToIceVar(V, convertToIceType(V->getType()));
   }
 
   Ice::CfgNode *mapBasicBlockToNode(const BasicBlock *BB) {
     if (NodeMap.find(BB) == NodeMap.end()) {
@@ skipping 136 matching lines @@
                          LLVMObjectAsString(Inst));
     }
 
     llvm_unreachable("convertInstruction");
     return nullptr;
   }
 
   Ice::Inst *convertLoadInstruction(const LoadInst *Inst) {
     Ice::Operand *Src = convertOperand(Inst, 0);
     Ice::Variable *Dest = mapValueToIceVar(Inst);
-    return Ice::InstLoad::create(Func, Dest, Src);
+    return Ice::InstLoad::create(Func.get(), Dest, Src);
   }
 
   Ice::Inst *convertStoreInstruction(const StoreInst *Inst) {
     Ice::Operand *Addr = convertOperand(Inst, 1);
     Ice::Operand *Val = convertOperand(Inst, 0);
-    return Ice::InstStore::create(Func, Val, Addr);
+    return Ice::InstStore::create(Func.get(), Val, Addr);
   }
 
   Ice::Inst *convertArithInstruction(const Instruction *Inst,
                                      Ice::InstArithmetic::OpKind Opcode) {
     const auto BinOp = cast<BinaryOperator>(Inst);
     Ice::Operand *Src0 = convertOperand(Inst, 0);
     Ice::Operand *Src1 = convertOperand(Inst, 1);
     Ice::Variable *Dest = mapValueToIceVar(BinOp);
-    return Ice::InstArithmetic::create(Func, Opcode, Dest, Src0, Src1);
+    return Ice::InstArithmetic::create(Func.get(), Opcode, Dest, Src0, Src1);
   }
 
   Ice::Inst *convertPHINodeInstruction(const PHINode *Inst) {
     unsigned NumValues = Inst->getNumIncomingValues();
     Ice::InstPhi *IcePhi =
-        Ice::InstPhi::create(Func, NumValues, mapValueToIceVar(Inst));
+        Ice::InstPhi::create(Func.get(), NumValues, mapValueToIceVar(Inst));
     for (unsigned N = 0, E = NumValues; N != E; ++N) {
       IcePhi->addArgument(convertOperand(Inst, N),
                           mapBasicBlockToNode(Inst->getIncomingBlock(N)));
     }
     return IcePhi;
   }
 
   Ice::Inst *convertBrInstruction(const BranchInst *Inst) {
     if (Inst->isConditional()) {
       Ice::Operand *Src = convertOperand(Inst, 0);
       BasicBlock *BBThen = Inst->getSuccessor(0);
       BasicBlock *BBElse = Inst->getSuccessor(1);
       Ice::CfgNode *NodeThen = mapBasicBlockToNode(BBThen);
       Ice::CfgNode *NodeElse = mapBasicBlockToNode(BBElse);
-      return Ice::InstBr::create(Func, Src, NodeThen, NodeElse);
+      return Ice::InstBr::create(Func.get(), Src, NodeThen, NodeElse);
     } else {
       BasicBlock *BBSucc = Inst->getSuccessor(0);
-      return Ice::InstBr::create(Func, mapBasicBlockToNode(BBSucc));
+      return Ice::InstBr::create(Func.get(), mapBasicBlockToNode(BBSucc));
     }
   }
 
   Ice::Inst *convertIntToPtrInstruction(const IntToPtrInst *Inst) {
     Ice::Operand *Src = convertOperand(Inst, 0);
     Ice::Variable *Dest = mapValueToIceVar(Inst, Ice::getPointerType());
-    return Ice::InstAssign::create(Func, Dest, Src);
+    return Ice::InstAssign::create(Func.get(), 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);
+    return Ice::InstAssign::create(Func.get(), Dest, Src);
   }
 
   Ice::Inst *convertRetInstruction(const ReturnInst *Inst) {
     Ice::Operand *RetOperand = convertOperand(Inst, 0);
     if (RetOperand) {
-      return Ice::InstRet::create(Func, RetOperand);
+      return Ice::InstRet::create(Func.get(), RetOperand);
     } else {
-      return Ice::InstRet::create(Func);
+      return Ice::InstRet::create(Func.get());
     }
   }
 
   Ice::Inst *convertCastInstruction(const Instruction *Inst,
                                     Ice::InstCast::OpKind CastKind) {
     Ice::Operand *Src = convertOperand(Inst, 0);
     Ice::Variable *Dest = mapValueToIceVar(Inst);
-    return Ice::InstCast::create(Func, CastKind, Dest, Src);
+    return Ice::InstCast::create(Func.get(), CastKind, Dest, Src);
   }
 
   Ice::Inst *convertICmpInstruction(const ICmpInst *Inst) {
     Ice::Operand *Src0 = convertOperand(Inst, 0);
     Ice::Operand *Src1 = convertOperand(Inst, 1);
     Ice::Variable *Dest = mapValueToIceVar(Inst);
 
     Ice::InstIcmp::ICond Cond;
     switch (Inst->getPredicate()) {
     default:
@@ skipping 23 matching lines @@
       Cond = Ice::InstIcmp::Sge;
       break;
     case CmpInst::ICMP_SLT:
       Cond = Ice::InstIcmp::Slt;
       break;
     case CmpInst::ICMP_SLE:
       Cond = Ice::InstIcmp::Sle;
       break;
     }
 
-    return Ice::InstIcmp::create(Func, Cond, Dest, Src0, Src1);
+    return Ice::InstIcmp::create(Func.get(), Cond, Dest, Src0, Src1);
   }
 
   Ice::Inst *convertFCmpInstruction(const FCmpInst *Inst) {
     Ice::Operand *Src0 = convertOperand(Inst, 0);
     Ice::Operand *Src1 = convertOperand(Inst, 1);
     Ice::Variable *Dest = mapValueToIceVar(Inst);
 
     Ice::InstFcmp::FCond Cond;
     switch (Inst->getPredicate()) {
 
@@ skipping 43 matching lines @@
       Cond = Ice::InstFcmp::Une;
       break;
     case CmpInst::FCMP_UNO:
       Cond = Ice::InstFcmp::Uno;
       break;
     case CmpInst::FCMP_TRUE:
       Cond = Ice::InstFcmp::True;
       break;
     }
 
-    return Ice::InstFcmp::create(Func, Cond, Dest, Src0, Src1);
+    return Ice::InstFcmp::create(Func.get(), Cond, Dest, Src0, Src1);
   }
 
   Ice::Inst *convertExtractElementInstruction(const ExtractElementInst *Inst) {
     Ice::Variable *Dest = mapValueToIceVar(Inst);
     Ice::Operand *Source1 = convertValue(Inst->getOperand(0));
     Ice::Operand *Source2 = convertValue(Inst->getOperand(1));
-    return Ice::InstExtractElement::create(Func, Dest, Source1, Source2);
+    return Ice::InstExtractElement::create(Func.get(), Dest, Source1, Source2);
   }
 
   Ice::Inst *convertInsertElementInstruction(const InsertElementInst *Inst) {
     Ice::Variable *Dest = mapValueToIceVar(Inst);
     Ice::Operand *Source1 = convertValue(Inst->getOperand(0));
     Ice::Operand *Source2 = convertValue(Inst->getOperand(1));
     Ice::Operand *Source3 = convertValue(Inst->getOperand(2));
-    return Ice::InstInsertElement::create(Func, Dest, Source1, Source2,
+    return Ice::InstInsertElement::create(Func.get(), Dest, Source1, Source2,
                                           Source3);
   }
 
   Ice::Inst *convertSelectInstruction(const SelectInst *Inst) {
     Ice::Variable *Dest = mapValueToIceVar(Inst);
     Ice::Operand *Cond = convertValue(Inst->getCondition());
     Ice::Operand *Source1 = convertValue(Inst->getTrueValue());
     Ice::Operand *Source2 = convertValue(Inst->getFalseValue());
-    return Ice::InstSelect::create(Func, Dest, Cond, Source1, Source2);
+    return Ice::InstSelect::create(Func.get(), Dest, Cond, Source1, Source2);
   }
 
   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);
+        Ice::InstSwitch::create(Func.get(), 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()->getSExtValue();
       Ice::CfgNode *CaseSuccessor = mapBasicBlockToNode(I.getCaseSuccessor());
       Switch->addBranch(CurrentCase, CaseValue, CaseSuccessor);
     }
     return Switch;
   }
 
@@ skipping 11 matching lines @@
       static const char LLVMPrefix[] = "llvm.";
       const size_t LLVMPrefixLen = strlen(LLVMPrefix);
       Ice::IceString Name = Target->getName();
       if (Name.substr(0, LLVMPrefixLen) == LLVMPrefix) {
         Ice::IceString NameSuffix = Name.substr(LLVMPrefixLen);
         Info = Ctx->getIntrinsicsInfo().find(NameSuffix);
         if (!Info) {
           report_fatal_error(std::string("Invalid PNaCl intrinsic call: ") +
                              LLVMObjectAsString(Inst));
         }
-        NewInst = Ice::InstIntrinsicCall::create(Func, NumArgs, Dest,
+        NewInst = Ice::InstIntrinsicCall::create(Func.get(), NumArgs, Dest,
                                                  CallTarget, Info->Info);
       }
     }
 
     // Not an intrinsic call.
     if (NewInst == nullptr) {
-      NewInst = Ice::InstCall::create(Func, NumArgs, Dest, CallTarget,
+      NewInst = Ice::InstCall::create(Func.get(), NumArgs, Dest, CallTarget,
                                       Inst->isTailCall());
     }
     for (unsigned i = 0; i < NumArgs; ++i) {
       NewInst->addArg(convertOperand(Inst, i));
     }
     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, Ice::getPointerType());
 
-    return Ice::InstAlloca::create(Func, ByteCount, Align, Dest);
+    return Ice::InstAlloca::create(Func.get(), ByteCount, Align, Dest);
   }
 
   Ice::Inst *convertUnreachableInstruction(const UnreachableInst * /*Inst*/) {
-    return Ice::InstUnreachable::create(Func);
+    return Ice::InstUnreachable::create(Func.get());
   }
 
   Ice::CfgNode *convertBasicBlock(const BasicBlock *BB) {
     Ice::CfgNode *Node = mapBasicBlockToNode(BB);
     for (const Instruction &II : *BB) {
       Ice::Inst *Inst = convertInstruction(&II);
       Node->appendInst(Inst);
     }
     return Node;
   }
@@ skipping 27 matching lines @@
              << I->getArgType(ArgIndex)
              << ". Found: " << Call->getArg(ArgIndex)->getType();
       report_fatal_error(StrBuf.str());
       break;
     }
     }
   }
 
 private:
   // Data
-  Ice::Cfg *Func;
+  std::unique_ptr<Ice::Cfg> Func;
   std::map<const Value *, Ice::Variable *> VarMap;
   std::map<const BasicBlock *, Ice::CfgNode *> NodeMap;
 };
 
 // Converter from LLVM global variables to ICE. The entry point is the
 // convertGlobalsToIce method.
 //
 // Note: this currently assumes that the given IR was verified to be
 // valid PNaCl bitcode. Othewise, the behavior is undefined.
 class LLVM2ICEGlobalsConverter : public LLVM2ICEConverter {
@@ skipping 236 matching lines @@
   lowerGlobals(VariableDeclarations);
 }
 
 void Converter::convertFunctions() {
   TimerStackIdT StackID = GlobalContext::TSK_Funcs;
   for (const Function &I : *Mod) {
     if (I.empty())
       continue;
 
     TimerIdT TimerID = 0;
-    if (ALLOW_DUMP && Ctx->getFlags().TimeEachFunction) {
+    const bool TimeThisFunction =
+        ALLOW_DUMP && Ctx->getFlags().TimeEachFunction;
+    if (TimeThisFunction) {
       TimerID = Ctx->getTimerID(StackID, I.getName());
       Ctx->pushTimer(TimerID, StackID);
     }
     LLVM2ICEFunctionConverter FunctionConverter(*this);
-
-    Cfg *Fcn = FunctionConverter.convertFunction(&I);
-    translateFcn(Fcn);
-    if (ALLOW_DUMP && Ctx->getFlags().TimeEachFunction)
+    FunctionConverter.convertFunction(&I);
+    translateFcn(FunctionConverter.release());
+    if (TimeThisFunction)
       Ctx->popTimer(TimerID, StackID);
   }
 }
 
 } // end of namespace Ice