mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-10-01 10:57:21 +00:00
aaa3fa61d2
This is to try make it very clear that subclasses shouldn't be changing the value directly. Now that OperandList for normal instructions is computed using the NumOperands, its critical that the NumOperands is accurate or we could compute the wrong offset to the first operand. I looked over all places which update NumOperands and they are all safe. Hung off use User's don't use NumOperands to compute the OperandList so they are safe to continue to manipulate it. The only other User which changed it was GlobalVariable which has an optional init list but always allocated space for a single Use. It was correctly setting NumOperands to 1 before setting an initializer, and setting it to 0 after clearing the init list, so the order was safe. Added some comments to that code to make sure that this isn't changed in future without being aware of this constraint. Reviewed by Duncan Exon Smith. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@239621 91177308-0d34-0410-b5e6-96231b3b80d8
122 lines
4.5 KiB
C++
122 lines
4.5 KiB
C++
//===-- User.cpp - Implement the User class -------------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/IR/User.h"
|
|
#include "llvm/IR/Constant.h"
|
|
#include "llvm/IR/GlobalValue.h"
|
|
#include "llvm/IR/Operator.h"
|
|
|
|
namespace llvm {
|
|
class BasicBlock;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// User Class
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
void User::anchor() {}
|
|
|
|
void User::replaceUsesOfWith(Value *From, Value *To) {
|
|
if (From == To) return; // Duh what?
|
|
|
|
assert((!isa<Constant>(this) || isa<GlobalValue>(this)) &&
|
|
"Cannot call User::replaceUsesOfWith on a constant!");
|
|
|
|
for (unsigned i = 0, E = getNumOperands(); i != E; ++i)
|
|
if (getOperand(i) == From) { // Is This operand is pointing to oldval?
|
|
// The side effects of this setOperand call include linking to
|
|
// "To", adding "this" to the uses list of To, and
|
|
// most importantly, removing "this" from the use list of "From".
|
|
setOperand(i, To); // Fix it now...
|
|
}
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// User allocHungoffUses Implementation
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
void User::allocHungoffUses(unsigned N, bool IsPhi) {
|
|
// Allocate the array of Uses, followed by a pointer (with bottom bit set) to
|
|
// the User.
|
|
size_t size = N * sizeof(Use) + sizeof(Use::UserRef);
|
|
if (IsPhi)
|
|
size += N * sizeof(BasicBlock *);
|
|
Use *Begin = static_cast<Use*>(::operator new(size));
|
|
Use *End = Begin + N;
|
|
(void) new(End) Use::UserRef(const_cast<User*>(this), 1);
|
|
setOperandList(Use::initTags(Begin, End));
|
|
// Tag this operand list as being a hung off.
|
|
HasHungOffUses = true;
|
|
}
|
|
|
|
void User::growHungoffUses(unsigned NewNumUses, bool IsPhi) {
|
|
assert(HasHungOffUses && "realloc must have hung off uses");
|
|
|
|
unsigned OldNumUses = getNumOperands();
|
|
|
|
// We don't support shrinking the number of uses. We wouldn't have enough
|
|
// space to copy the old uses in to the new space.
|
|
assert(NewNumUses > OldNumUses && "realloc must grow num uses");
|
|
|
|
Use *OldOps = getOperandList();
|
|
allocHungoffUses(NewNumUses, IsPhi);
|
|
Use *NewOps = getOperandList();
|
|
|
|
// Now copy from the old operands list to the new one.
|
|
std::copy(OldOps, OldOps + OldNumUses, NewOps);
|
|
|
|
// If this is a Phi, then we need to copy the BB pointers too.
|
|
if (IsPhi) {
|
|
auto *OldPtr =
|
|
reinterpret_cast<char *>(OldOps + OldNumUses) + sizeof(Use::UserRef);
|
|
auto *NewPtr =
|
|
reinterpret_cast<char *>(NewOps + NewNumUses) + sizeof(Use::UserRef);
|
|
std::copy(OldPtr, OldPtr + (OldNumUses * sizeof(BasicBlock *)), NewPtr);
|
|
}
|
|
Use::zap(OldOps, OldOps + OldNumUses, true);
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// User operator new Implementations
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
void *User::operator new(size_t s, unsigned Us) {
|
|
assert(Us < (1u << NumUserOperandsBits) && "Too many operands");
|
|
void *Storage = ::operator new(s + sizeof(Use) * Us);
|
|
Use *Start = static_cast<Use*>(Storage);
|
|
Use *End = Start + Us;
|
|
User *Obj = reinterpret_cast<User*>(End);
|
|
Obj->setOperandList(Start);
|
|
Obj->HasHungOffUses = false;
|
|
Obj->NumUserOperands = Us;
|
|
Use::initTags(Start, End);
|
|
return Obj;
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// User operator delete Implementation
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
void User::operator delete(void *Usr) {
|
|
User *Start = static_cast<User*>(Usr);
|
|
Use *Storage = static_cast<Use*>(Usr) - Start->NumUserOperands;
|
|
// If there were hung-off uses, they will have been freed already and
|
|
// NumOperands reset to 0, so here we just free the User itself.
|
|
::operator delete(Storage);
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Operator Class
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
Operator::~Operator() {
|
|
llvm_unreachable("should never destroy an Operator");
|
|
}
|
|
|
|
} // End llvm namespace
|