Make blockaddress(@func, null) be valid, and make 'deleting a basic

block with a blockaddress still referring to it' replace the invalid 
blockaddress with a new blockaddress(@func, null) instead of a 
inttoptr(1).

This changes the bitcode encoding format, and still needs codegen 
support (this should produce a non-zero value, referring to the entry
block of the function would also be quite reasonable).

llvm-svn: 85678

llvm/docs/LangRef.html

@@ -2176,11 +2176,13 @@ has undefined behavior.</p>
     Blocks</a></div>
 <div class="doc_text">
 
-<p><b><tt>blockaddress(@function, %block)</tt></b></p>
+<p><b><tt>blockaddress(@function, %block)</tt></b><br>
+   <b><tt>blockaddress(@function, null)</tt></b></p>
 
 <p>The '<tt>blockaddress</tt>' constant computes the address of the specified
    basic block in the specified function, and always has an i8* type.  Taking
-   the address of the entry block is illegal.</p>
+   the address of the entry block is illegal.  The BasicBlock operand may also
+   be null.</p>
      
 <p>This value only has defined behavior when used as an operand to the
    '<a href="#i_indirectbr"><tt>indirectbr</tt></a>' instruction or for comparisons

llvm/include/llvm/Constants.h

@@ -567,6 +567,10 @@ public:
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
   
   Function *getFunction() const { return (Function*)Op<0>().get(); }
+  
+  /// getBasicBlock - This returns the block associated with this BlockAddress.
+  /// Note that this can return null if the block this originally referred to
+  /// was deleted.
   BasicBlock *getBasicBlock() const { return (BasicBlock*)Op<1>().get(); }
   
   /// isNullValue - Return true if this is the value that would be returned by

llvm/lib/AsmParser/LLParser.cpp

@@ -123,20 +123,25 @@ bool LLParser::ResolveForwardRefBlockAddresses(Function *TheFn,
   // Loop over all the references, resolving them.
   for (unsigned i = 0, e = Refs.size(); i != e; ++i) {
     BasicBlock *Res;
-    if (PFS) {
+    if (Refs[i].first.Kind == ValID::t_Null)
+      Res = 0;
+    else if (PFS) {
       if (Refs[i].first.Kind == ValID::t_LocalName)
         Res = PFS->GetBB(Refs[i].first.StrVal, Refs[i].first.Loc);
-      else
+      else {
+        assert(Refs[i].first.Kind == ValID::t_LocalID);
         Res = PFS->GetBB(Refs[i].first.UIntVal, Refs[i].first.Loc);
+      }
     } else if (Refs[i].first.Kind == ValID::t_LocalID) {
       return Error(Refs[i].first.Loc,
        "cannot take address of numeric label after it the function is defined");
     } else {
+      assert(Refs[i].first.Kind == ValID::t_LocalName);
       Res = dyn_cast_or_null<BasicBlock>(
                      TheFn->getValueSymbolTable().lookup(Refs[i].first.StrVal));
     }
     
-    if (Res == 0)
+    if (Res == 0 && Refs[i].first.Kind != ValID::t_Null)
       return Error(Refs[i].first.Loc,
                    "referenced value is not a basic block");
     
@@ -2055,10 +2060,11 @@ bool LLParser::ParseValID(ValID &ID) {
         ParseValID(Label) ||
         ParseToken(lltok::rparen, "expected ')' in block address expression"))
       return true;
-    
+      
     if (Fn.Kind != ValID::t_GlobalID && Fn.Kind != ValID::t_GlobalName)
       return Error(Fn.Loc, "expected function name in blockaddress");
-    if (Label.Kind != ValID::t_LocalID && Label.Kind != ValID::t_LocalName)
+    if (Label.Kind != ValID::t_LocalID && Label.Kind != ValID::t_LocalName &&
+        Label.Kind != ValID::t_Null)
       return Error(Label.Loc, "expected basic block name in blockaddress");
     
     // Make a global variable as a placeholder for this reference.

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

@@ -2274,11 +2274,12 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
     std::vector<BlockAddrRefTy> &RefList = BAFRI->second;
     for (unsigned i = 0, e = RefList.size(); i != e; ++i) {
       unsigned BlockIdx = RefList[i].first;
-      if (BlockIdx >= FunctionBBs.size())
+      if (BlockIdx > FunctionBBs.size())
         return Error("Invalid blockaddress block #");
     
       GlobalVariable *FwdRef = RefList[i].second;
-      FwdRef->replaceAllUsesWith(BlockAddress::get(F, FunctionBBs[BlockIdx]));
+      BasicBlock *BB = BlockIdx == 0 ? 0 : FunctionBBs[BlockIdx-1];
+      FwdRef->replaceAllUsesWith(BlockAddress::get(F, BB));
       FwdRef->eraseFromParent();
     }
     

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

@@ -854,7 +854,8 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
         break;
       }
     } else if (const BlockAddress *BA = dyn_cast<BlockAddress>(C)) {
-      assert(BA->getFunction() == BA->getBasicBlock()->getParent() &&
+      assert((!BA->getBasicBlock() ||
+              BA->getFunction() == BA->getBasicBlock()->getParent()) &&
              "Malformed blockaddress");
       Code = bitc::CST_CODE_BLOCKADDRESS;
       Record.push_back(VE.getTypeID(BA->getFunction()->getType()));

llvm/lib/Bitcode/Writer/ValueEnumerator.cpp

@@ -265,6 +265,8 @@ void ValueEnumerator::EnumerateValue(const Value *V) {
       // Do not enumerate the initializers for an array of simple characters.
       // The initializers just polute the value table, and we emit the strings
       // specially.
+    } else if (isa<BlockAddress>(C)) {
+      // Don't enumerate function or block.
     } else if (C->getNumOperands()) {
       // If a constant has operands, enumerate them.  This makes sure that if a
       // constant has uses (for example an array of const ints), that they are
@@ -276,8 +278,7 @@ void ValueEnumerator::EnumerateValue(const Value *V) {
       // graph that don't go through a global variable.
       for (User::const_op_iterator I = C->op_begin(), E = C->op_end();
            I != E; ++I)
-        if (!isa<BasicBlock>(*I)) // Don't enumerate BB operand to BlockAddress.
-          EnumerateValue(*I);
+        EnumerateValue(*I);
 
       // Finally, add the value.  Doing this could make the ValueID reference be
       // dangling, don't reuse it.
@@ -417,9 +418,10 @@ static void IncorporateFunctionInfoGlobalBBIDs(const Function *F,
 /// specified basic block.  This is relatively expensive information, so it
 /// should only be used by rare constructs such as address-of-label.
 unsigned ValueEnumerator::getGlobalBasicBlockID(const BasicBlock *BB) const {
+  if (BB == 0) return 0;
   unsigned &Idx = GlobalBasicBlockIDs[BB];
   if (Idx != 0)
-    return Idx-1;
+    return Idx;
 
   IncorporateFunctionInfoGlobalBBIDs(BB->getParent(), GlobalBasicBlockIDs);
   return getGlobalBasicBlockID(BB);

llvm/lib/VMCore/AsmWriter.cpp

@@ -1065,7 +1065,10 @@ static void WriteConstantInt(raw_ostream &Out, const Constant *CV,
     Out << "blockaddress(";
     WriteAsOperandInternal(Out, BA->getFunction(), &TypePrinter, Machine);
     Out << ", ";
-    WriteAsOperandInternal(Out, BA->getBasicBlock(), &TypePrinter, Machine);
+    if (BA->getBasicBlock())
+      WriteAsOperandInternal(Out, BA->getBasicBlock(), &TypePrinter, Machine);
+    else
+      Out << "null";
     Out << ")";
     return;
   }

llvm/lib/VMCore/BasicBlock.cpp

@@ -63,15 +63,13 @@ BasicBlock::~BasicBlock() {
   // hanging off the block, or an undefined use of the block (source code
   // expecting the address of a label to keep the block alive even though there
   // is no indirect branch).  Handle these cases by zapping the BlockAddress
-  // nodes.  There are no other possible uses at this point.
+  // nodes, replacing them with BlockAddress(F, NULL).  There are no other
+  // possible uses at this point.
   if (hasAddressTaken()) {
     assert(!use_empty() && "There should be at least one blockaddress!");
-    Constant *Replacement =
-      ConstantInt::get(llvm::Type::getInt32Ty(getContext()), 1);
     while (!use_empty()) {
       BlockAddress *BA = cast<BlockAddress>(use_back());
-      BA->replaceAllUsesWith(ConstantExpr::getIntToPtr(Replacement,
-                                                       BA->getType()));
+      BA->replaceAllUsesWith(BlockAddress::get(BA->getFunction(), 0));
       BA->destroyConstant();
     }
   }

llvm/lib/VMCore/Constants.cpp

@@ -1045,7 +1045,7 @@ BlockAddress::BlockAddress(Function *F, BasicBlock *BB)
            &Op<0>(), 2) {
   Op<0>() = F;
   Op<1>() = BB;
-  BB->AdjustBlockAddressRefCount(1);
+  if (BB) BB->AdjustBlockAddressRefCount(1);
 }
 
 
@@ -1054,7 +1054,8 @@ BlockAddress::BlockAddress(Function *F, BasicBlock *BB)
 void BlockAddress::destroyConstant() {
   getFunction()->getType()->getContext().pImpl
     ->BlockAddresses.erase(std::make_pair(getFunction(), getBasicBlock()));
-  getBasicBlock()->AdjustBlockAddressRefCount(-1);
+  if (BasicBlock *BB = getBasicBlock())
+    BB->AdjustBlockAddressRefCount(-1);
   destroyConstantImpl();
 }