mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-20 11:29:24 +00:00
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@5620 91177308-0d34-0410-b5e6-96231b3b80d8
266 lines
9.4 KiB
C++
266 lines
9.4 KiB
C++
//===-- llvm/iMemory.h - Memory Operator node definitions --------*- C++ -*--=//
|
|
//
|
|
// This file contains the declarations of all of the memory related operators.
|
|
// This includes: malloc, free, alloca, load, store, getfield, putfield
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_IMEMORY_H
|
|
#define LLVM_IMEMORY_H
|
|
|
|
#include "llvm/Instruction.h"
|
|
class PointerType;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// AllocationInst Class
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// AllocationInst - This class is the common base class of MallocInst and
|
|
// AllocaInst.
|
|
//
|
|
class AllocationInst : public Instruction {
|
|
protected:
|
|
AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy,
|
|
const std::string &Name = "", Instruction *InsertBefore = 0);
|
|
public:
|
|
|
|
// isArrayAllocation - Return true if there is an allocation size parameter
|
|
// to the allocation instruction that is not 1.
|
|
//
|
|
bool isArrayAllocation() const;
|
|
|
|
// getArraySize - Get the number of element allocated, for a simple allocation
|
|
// of a single element, this will return a constant 1 value.
|
|
//
|
|
inline const Value *getArraySize() const { return Operands[0]; }
|
|
inline Value *getArraySize() { return Operands[0]; }
|
|
|
|
// getType - Overload to return most specific pointer type...
|
|
inline const PointerType *getType() const {
|
|
return (const PointerType*)Instruction::getType();
|
|
}
|
|
|
|
// getAllocatedType - Return the type that is being allocated by the
|
|
// instruction.
|
|
//
|
|
const Type *getAllocatedType() const;
|
|
|
|
virtual Instruction *clone() const = 0;
|
|
|
|
// Methods for support type inquiry through isa, cast, and dyn_cast:
|
|
static inline bool classof(const AllocationInst *) { return true; }
|
|
static inline bool classof(const Instruction *I) {
|
|
return I->getOpcode() == Instruction::Alloca ||
|
|
I->getOpcode() == Instruction::Malloc;
|
|
}
|
|
static inline bool classof(const Value *V) {
|
|
return isa<Instruction>(V) && classof(cast<Instruction>(V));
|
|
}
|
|
};
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// MallocInst Class
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
class MallocInst : public AllocationInst {
|
|
MallocInst(const MallocInst &MI);
|
|
public:
|
|
MallocInst(const Type *Ty, Value *ArraySize = 0, const std::string &Name = "",
|
|
Instruction *InsertBefore = 0)
|
|
: AllocationInst(Ty, ArraySize, Malloc, Name, InsertBefore) {}
|
|
|
|
virtual Instruction *clone() const {
|
|
return new MallocInst(*this);
|
|
}
|
|
|
|
// Methods for support type inquiry through isa, cast, and dyn_cast:
|
|
static inline bool classof(const MallocInst *) { return true; }
|
|
static inline bool classof(const Instruction *I) {
|
|
return (I->getOpcode() == Instruction::Malloc);
|
|
}
|
|
static inline bool classof(const Value *V) {
|
|
return isa<Instruction>(V) && classof(cast<Instruction>(V));
|
|
}
|
|
};
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// AllocaInst Class
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
class AllocaInst : public AllocationInst {
|
|
AllocaInst(const AllocaInst &);
|
|
public:
|
|
AllocaInst(const Type *Ty, Value *ArraySize = 0, const std::string &Name = "",
|
|
Instruction *InsertBefore = 0)
|
|
: AllocationInst(Ty, ArraySize, Alloca, Name, InsertBefore) {}
|
|
|
|
virtual Instruction *clone() const {
|
|
return new AllocaInst(*this);
|
|
}
|
|
|
|
// Methods for support type inquiry through isa, cast, and dyn_cast:
|
|
static inline bool classof(const AllocaInst *) { return true; }
|
|
static inline bool classof(const Instruction *I) {
|
|
return (I->getOpcode() == Instruction::Alloca);
|
|
}
|
|
static inline bool classof(const Value *V) {
|
|
return isa<Instruction>(V) && classof(cast<Instruction>(V));
|
|
}
|
|
};
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// FreeInst Class
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
struct FreeInst : public Instruction {
|
|
FreeInst(Value *Ptr, Instruction *InsertBefore = 0);
|
|
|
|
virtual Instruction *clone() const { return new FreeInst(Operands[0]); }
|
|
|
|
virtual bool mayWriteToMemory() const { return true; }
|
|
|
|
// Methods for support type inquiry through isa, cast, and dyn_cast:
|
|
static inline bool classof(const FreeInst *) { return true; }
|
|
static inline bool classof(const Instruction *I) {
|
|
return (I->getOpcode() == Instruction::Free);
|
|
}
|
|
static inline bool classof(const Value *V) {
|
|
return isa<Instruction>(V) && classof(cast<Instruction>(V));
|
|
}
|
|
};
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// LoadInst Class
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
class LoadInst : public Instruction {
|
|
LoadInst(const LoadInst &LI) : Instruction(LI.getType(), Load) {
|
|
Operands.reserve(1);
|
|
Operands.push_back(Use(LI.Operands[0], this));
|
|
}
|
|
public:
|
|
LoadInst(Value *Ptr, const std::string &Name = "",
|
|
Instruction *InsertBefore = 0);
|
|
|
|
virtual Instruction *clone() const { return new LoadInst(*this); }
|
|
|
|
Value *getPointerOperand() { return getOperand(0); }
|
|
const Value *getPointerOperand() const { return getOperand(0); }
|
|
static unsigned getPointerOperandIndex() { return 0U; }
|
|
|
|
// Methods for support type inquiry through isa, cast, and dyn_cast:
|
|
static inline bool classof(const LoadInst *) { return true; }
|
|
static inline bool classof(const Instruction *I) {
|
|
return (I->getOpcode() == Instruction::Load);
|
|
}
|
|
static inline bool classof(const Value *V) {
|
|
return isa<Instruction>(V) && classof(cast<Instruction>(V));
|
|
}
|
|
};
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// StoreInst Class
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
class StoreInst : public Instruction {
|
|
StoreInst(const StoreInst &SI) : Instruction(SI.getType(), Store) {
|
|
Operands.reserve(2);
|
|
Operands.push_back(Use(SI.Operands[0], this));
|
|
Operands.push_back(Use(SI.Operands[1], this));
|
|
}
|
|
public:
|
|
StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore = 0);
|
|
virtual Instruction *clone() const { return new StoreInst(*this); }
|
|
|
|
virtual bool mayWriteToMemory() const { return true; }
|
|
|
|
Value *getPointerOperand() { return getOperand(1); }
|
|
const Value *getPointerOperand() const { return getOperand(1); }
|
|
static unsigned getPointerOperandIndex() { return 1U; }
|
|
|
|
// Methods for support type inquiry through isa, cast, and dyn_cast:
|
|
static inline bool classof(const StoreInst *) { return true; }
|
|
static inline bool classof(const Instruction *I) {
|
|
return (I->getOpcode() == Instruction::Store);
|
|
}
|
|
static inline bool classof(const Value *V) {
|
|
return isa<Instruction>(V) && classof(cast<Instruction>(V));
|
|
}
|
|
};
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// GetElementPtrInst Class
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
class GetElementPtrInst : public Instruction {
|
|
GetElementPtrInst(const GetElementPtrInst &EPI)
|
|
: Instruction((Type*)EPI.getType(), GetElementPtr) {
|
|
Operands.reserve(EPI.Operands.size());
|
|
for (unsigned i = 0, E = EPI.Operands.size(); i != E; ++i)
|
|
Operands.push_back(Use(EPI.Operands[i], this));
|
|
}
|
|
public:
|
|
GetElementPtrInst(Value *Ptr, const std::vector<Value*> &Idx,
|
|
const std::string &Name = "", Instruction *InsertBefore =0);
|
|
virtual Instruction *clone() const { return new GetElementPtrInst(*this); }
|
|
|
|
// getType - Overload to return most specific pointer type...
|
|
inline const PointerType *getType() const {
|
|
return (PointerType*)Instruction::getType();
|
|
}
|
|
|
|
/// getIndexedType - Returns the type of the element that would be loaded with
|
|
/// a load instruction with the specified parameters.
|
|
///
|
|
/// A null type is returned if the indices are invalid for the specified
|
|
/// pointer type.
|
|
///
|
|
static const Type *getIndexedType(const Type *Ptr,
|
|
const std::vector<Value*> &Indices,
|
|
bool AllowStructLeaf = false);
|
|
|
|
inline op_iterator idx_begin() {
|
|
return op_begin()+1;
|
|
}
|
|
inline const_op_iterator idx_begin() const {
|
|
return op_begin()+1;
|
|
}
|
|
inline op_iterator idx_end() { return op_end(); }
|
|
inline const_op_iterator idx_end() const { return op_end(); }
|
|
|
|
Value *getPointerOperand() {
|
|
return getOperand(0);
|
|
}
|
|
const Value *getPointerOperand() const {
|
|
return getOperand(0);
|
|
}
|
|
static unsigned getPointerOperandIndex() {
|
|
return 0U; // get index for modifying correct operand
|
|
}
|
|
|
|
inline unsigned getNumIndices() const { // Note: always non-negative
|
|
return getNumOperands() - 1;
|
|
}
|
|
|
|
inline bool hasIndices() const {
|
|
return getNumOperands() > 1;
|
|
}
|
|
|
|
// Methods for support type inquiry through isa, cast, and dyn_cast:
|
|
static inline bool classof(const GetElementPtrInst *) { return true; }
|
|
static inline bool classof(const Instruction *I) {
|
|
return (I->getOpcode() == Instruction::GetElementPtr);
|
|
}
|
|
static inline bool classof(const Value *V) {
|
|
return isa<Instruction>(V) && classof(cast<Instruction>(V));
|
|
}
|
|
};
|
|
|
|
#endif // LLVM_IMEMORY_H
|