mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-01-04 21:30:49 +00:00
f718e70c7e
and num operands in the User class. this allows us to embed the operands
directly in the subclasses if possible. For example, for binary operators
we store the two operands in the derived class.
The has several effects:
1. it improves locality because the operands and instruction are together
2. it makes accesses to operands faster (one less load) if you access them
through the derived class pointer. For example this:
Value *GetBinaryOperatorOp(BinaryOperator *I, int i) {
return I->getOperand(i);
}
Was compiled to:
_Z19GetBinaryOperatorOpPN4llvm14BinaryOperatorEi:
movl 4(%esp), %edx
movl 8(%esp), %eax
sall $4, %eax
movl 24(%edx), %ecx
addl %ecx, %eax
movl (%eax), %eax
ret
and is now compiled to:
_Z19GetBinaryOperatorOpPN4llvm14BinaryOperatorEi:
movl 8(%esp), %eax
movl 4(%esp), %edx
sall $4, %eax
addl %edx, %eax
movl 44(%eax), %eax
ret
Accesses through "Instruction*" are unmodified.
3. This reduces memory consumption (by about 3%) by eliminating 1 word of
vector overhead and a malloc header on a seperate object.
4. This speeds up gccas about 10% (both debug and release builds) on
large things (such as 176.gcc). For example, it takes a debug build
from 172.9 -> 155.6s and a release gccas from 67.7 -> 61.8s
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19883 91177308-0d34-0410-b5e6-96231b3b80d8
116 lines
4.1 KiB
C++
116 lines
4.1 KiB
C++
//===-- llvm/User.h - User class definition ---------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file was developed by the LLVM research group and is distributed under
|
|
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This class defines the interface that one who 'use's a Value must implement.
|
|
// Each instance of the Value class keeps track of what User's have handles
|
|
// to it.
|
|
//
|
|
// * Instructions are the largest class of User's.
|
|
// * Constants may be users of other constants (think arrays and stuff)
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_USER_H
|
|
#define LLVM_USER_H
|
|
|
|
#include "llvm/Value.h"
|
|
#include <vector>
|
|
|
|
namespace llvm {
|
|
|
|
class User : public Value {
|
|
User(const User &); // Do not implement
|
|
protected:
|
|
/// OperandList - This is a pointer to the array of Users for this operand.
|
|
/// For nodes of fixed arity (e.g. a binary operator) this array will live
|
|
/// embedded into the derived class. For nodes of variable arity
|
|
/// (e.g. ConstantArrays, CallInst, PHINodes, etc), this memory will be
|
|
/// dynamically allocated and should be destroyed by the classes virtual dtor.
|
|
Use *OperandList;
|
|
|
|
/// NumOperands - The number of values used by this User.
|
|
///
|
|
unsigned NumOperands;
|
|
|
|
public:
|
|
User(const Type *Ty, unsigned vty, Use *OpList, unsigned NumOps,
|
|
const std::string &name = "")
|
|
: Value(Ty, vty, name), OperandList(OpList), NumOperands(NumOps) {}
|
|
|
|
Value *getOperand(unsigned i) const {
|
|
assert(i < NumOperands && "getOperand() out of range!");
|
|
return OperandList[i];
|
|
}
|
|
void setOperand(unsigned i, Value *Val) {
|
|
assert(i < NumOperands && "setOperand() out of range!");
|
|
OperandList[i] = Val;
|
|
}
|
|
unsigned getNumOperands() const { return NumOperands; }
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Operand Iterator interface...
|
|
//
|
|
typedef Use* op_iterator;
|
|
typedef const Use* const_op_iterator;
|
|
|
|
inline op_iterator op_begin() { return OperandList; }
|
|
inline const_op_iterator op_begin() const { return OperandList; }
|
|
inline op_iterator op_end() { return OperandList+NumOperands; }
|
|
inline const_op_iterator op_end() const { return OperandList+NumOperands; }
|
|
|
|
// dropAllReferences() - This function is in charge of "letting go" of all
|
|
// objects that this User refers to. This allows one to
|
|
// 'delete' a whole class at a time, even though there may be circular
|
|
// references... first all references are dropped, and all use counts go to
|
|
// zero. Then everything is delete'd for real. Note that no operations are
|
|
// valid on an object that has "dropped all references", except operator
|
|
// delete.
|
|
//
|
|
void dropAllReferences() {
|
|
Use *OL = OperandList;
|
|
for (unsigned i = 0, e = NumOperands; i != e; ++i)
|
|
OL[i].set(0);
|
|
}
|
|
|
|
/// replaceUsesOfWith - Replaces all references to the "From" definition with
|
|
/// references to the "To" definition.
|
|
///
|
|
void replaceUsesOfWith(Value *From, Value *To);
|
|
|
|
// Methods for support type inquiry through isa, cast, and dyn_cast:
|
|
static inline bool classof(const User *) { return true; }
|
|
static inline bool classof(const Value *V) {
|
|
return isa<Instruction>(V) || isa<Constant>(V);
|
|
}
|
|
};
|
|
|
|
template<> struct simplify_type<User::op_iterator> {
|
|
typedef Value* SimpleType;
|
|
|
|
static SimpleType getSimplifiedValue(const User::op_iterator &Val) {
|
|
return static_cast<SimpleType>(Val->get());
|
|
}
|
|
};
|
|
template<> struct simplify_type<const User::op_iterator>
|
|
: public simplify_type<User::op_iterator> {};
|
|
|
|
template<> struct simplify_type<User::const_op_iterator> {
|
|
typedef Value* SimpleType;
|
|
|
|
static SimpleType getSimplifiedValue(const User::const_op_iterator &Val) {
|
|
return static_cast<SimpleType>(Val->get());
|
|
}
|
|
};
|
|
template<> struct simplify_type<const User::const_op_iterator>
|
|
: public simplify_type<User::const_op_iterator> {};
|
|
|
|
} // End llvm namespace
|
|
|
|
#endif
|