mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-25 00:29:20 +00:00
Revert 85678/85680. The decision is to stay with the current form of
indirectbr, thus we don't need "blockaddr(@func, null)". Eliminate it for simplicity. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@85699 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
de17fb6e4d
commit
cdfc940912
@ -2176,13 +2176,11 @@ has undefined behavior.</p>
|
||||
Blocks</a></div>
|
||||
<div class="doc_text">
|
||||
|
||||
<p><b><tt>blockaddress(@function, %block)</tt></b><br>
|
||||
<b><tt>blockaddress(@function, null)</tt></b></p>
|
||||
<p><b><tt>blockaddress(@function, %block)</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. The BasicBlock operand may also
|
||||
be null.</p>
|
||||
the address of the entry block is illegal.</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
|
||||
|
@ -567,10 +567,6 @@ 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
|
||||
|
@ -123,25 +123,20 @@ 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 (Refs[i].first.Kind == ValID::t_Null)
|
||||
Res = 0;
|
||||
else if (PFS) {
|
||||
if (PFS) {
|
||||
if (Refs[i].first.Kind == ValID::t_LocalName)
|
||||
Res = PFS->GetBB(Refs[i].first.StrVal, Refs[i].first.Loc);
|
||||
else {
|
||||
assert(Refs[i].first.Kind == ValID::t_LocalID);
|
||||
else
|
||||
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 && Refs[i].first.Kind != ValID::t_Null)
|
||||
if (Res == 0)
|
||||
return Error(Refs[i].first.Loc,
|
||||
"referenced value is not a basic block");
|
||||
|
||||
@ -2063,8 +2058,7 @@ bool LLParser::ParseValID(ValID &ID) {
|
||||
|
||||
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 &&
|
||||
Label.Kind != ValID::t_Null)
|
||||
if (Label.Kind != ValID::t_LocalID && Label.Kind != ValID::t_LocalName)
|
||||
return Error(Label.Loc, "expected basic block name in blockaddress");
|
||||
|
||||
// Make a global variable as a placeholder for this reference.
|
||||
|
@ -2274,12 +2274,11 @@ 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;
|
||||
BasicBlock *BB = BlockIdx == 0 ? 0 : FunctionBBs[BlockIdx-1];
|
||||
FwdRef->replaceAllUsesWith(BlockAddress::get(F, BB));
|
||||
FwdRef->replaceAllUsesWith(BlockAddress::get(F, FunctionBBs[BlockIdx]));
|
||||
FwdRef->eraseFromParent();
|
||||
}
|
||||
|
||||
|
@ -854,8 +854,7 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
|
||||
break;
|
||||
}
|
||||
} else if (const BlockAddress *BA = dyn_cast<BlockAddress>(C)) {
|
||||
assert((!BA->getBasicBlock() ||
|
||||
BA->getFunction() == BA->getBasicBlock()->getParent()) &&
|
||||
assert(BA->getFunction() == BA->getBasicBlock()->getParent() &&
|
||||
"Malformed blockaddress");
|
||||
Code = bitc::CST_CODE_BLOCKADDRESS;
|
||||
Record.push_back(VE.getTypeID(BA->getFunction()->getType()));
|
||||
|
@ -265,8 +265,6 @@ 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
|
||||
@ -278,6 +276,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);
|
||||
|
||||
// Finally, add the value. Doing this could make the ValueID reference be
|
||||
@ -418,10 +417,9 @@ 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;
|
||||
return Idx-1;
|
||||
|
||||
IncorporateFunctionInfoGlobalBBIDs(BB->getParent(), GlobalBasicBlockIDs);
|
||||
return getGlobalBasicBlockID(BB);
|
||||
|
@ -2345,7 +2345,8 @@ static bool EvaluateFunction(Function *F, Constant *&RetVal,
|
||||
Value *Val = getVal(Values, IBI->getAddress())->stripPointerCasts();
|
||||
if (BlockAddress *BA = dyn_cast<BlockAddress>(Val))
|
||||
NewBB = BA->getBasicBlock();
|
||||
if (NewBB == 0) return false; // Cannot determine.
|
||||
else
|
||||
return false; // Cannot determine.
|
||||
} else if (ReturnInst *RI = dyn_cast<ReturnInst>(CurInst)) {
|
||||
if (RI->getNumOperands())
|
||||
RetVal = getVal(Values, RI->getOperand(0));
|
||||
|
@ -113,13 +113,8 @@ Value *llvm::MapValue(const Value *V, ValueMapTy &VM) {
|
||||
|
||||
if (BlockAddress *BA = dyn_cast<BlockAddress>(C)) {
|
||||
Function *F = cast<Function>(MapValue(BA->getFunction(), VM));
|
||||
BasicBlock *BB = 0;
|
||||
if (BA->getBasicBlock()) {
|
||||
BB = cast_or_null<BasicBlock>(MapValue(BA->getBasicBlock(),VM));
|
||||
BB = BB ? BB : BA->getBasicBlock();
|
||||
}
|
||||
|
||||
return VM[V] = BlockAddress::get(F, BB);
|
||||
BasicBlock *BB = cast_or_null<BasicBlock>(MapValue(BA->getBasicBlock(),VM));
|
||||
return VM[V] = BlockAddress::get(F, BB ? BB : BA->getBasicBlock());
|
||||
}
|
||||
|
||||
llvm_unreachable("Unknown type of constant!");
|
||||
|
@ -1065,10 +1065,7 @@ static void WriteConstantInt(raw_ostream &Out, const Constant *CV,
|
||||
Out << "blockaddress(";
|
||||
WriteAsOperandInternal(Out, BA->getFunction(), &TypePrinter, Machine);
|
||||
Out << ", ";
|
||||
if (BA->getBasicBlock())
|
||||
WriteAsOperandInternal(Out, BA->getBasicBlock(), &TypePrinter, Machine);
|
||||
else
|
||||
Out << "null";
|
||||
Out << ")";
|
||||
return;
|
||||
}
|
||||
|
@ -63,13 +63,15 @@ 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, replacing them with BlockAddress(F, NULL). There are no other
|
||||
// possible uses at this point.
|
||||
// nodes. 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(BlockAddress::get(BA->getFunction(), 0));
|
||||
BA->replaceAllUsesWith(ConstantExpr::getIntToPtr(Replacement,
|
||||
BA->getType()));
|
||||
BA->destroyConstant();
|
||||
}
|
||||
}
|
||||
|
@ -1045,7 +1045,7 @@ BlockAddress::BlockAddress(Function *F, BasicBlock *BB)
|
||||
&Op<0>(), 2) {
|
||||
Op<0>() = F;
|
||||
Op<1>() = BB;
|
||||
if (BB) BB->AdjustBlockAddressRefCount(1);
|
||||
BB->AdjustBlockAddressRefCount(1);
|
||||
}
|
||||
|
||||
|
||||
@ -1054,8 +1054,7 @@ BlockAddress::BlockAddress(Function *F, BasicBlock *BB)
|
||||
void BlockAddress::destroyConstant() {
|
||||
getFunction()->getType()->getContext().pImpl
|
||||
->BlockAddresses.erase(std::make_pair(getFunction(), getBasicBlock()));
|
||||
if (BasicBlock *BB = getBasicBlock())
|
||||
BB->AdjustBlockAddressRefCount(-1);
|
||||
getBasicBlock()->AdjustBlockAddressRefCount(-1);
|
||||
destroyConstantImpl();
|
||||
}
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user