6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-02-06 06:33:24 +00:00
Code Issues Projects Releases Wiki Activity

Add support for volatile loads/stores

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@8393 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2003-09-08 17:45:59 +00:00
parent ebd2220152
commit e5e475e09d
3 changed files with 55 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
include/llvm/iMemory.h
View File

@ -1,7 +1,7 @@
//===-- llvm/iMemory.h - Memory Operator node definitions --------*- 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
// This includes: malloc, free, alloca, load, store, and getelementptr
//
//===----------------------------------------------------------------------===//
@ -139,13 +139,24 @@ struct FreeInst : public Instruction {
class LoadInst : public Instruction {
LoadInst(const LoadInst &LI) : Instruction(LI.getType(), Load) {
Volatile = LI.isVolatile();
Operands.reserve(1);
Operands.push_back(Use(LI.Operands[0], this));
}
bool Volatile; // True if this is a volatile load
public:
LoadInst(Value *Ptr, const std::string &Name = "",
LoadInst(Value *Ptr, const std::string &Name, Instruction *InsertBefore);
LoadInst(Value *Ptr, const std::string &Name = "", bool isVolatile = false,
Instruction *InsertBefore = 0);
/// isVolatile - Return true if this is a load from a volatile memory
/// location.
bool isVolatile() const { return Volatile; }
/// setVolatile - Specify whether this is a volatile load or not.
///
void setVolatile(bool V) { Volatile = V; }
virtual Instruction *clone() const { return new LoadInst(*this); }
Value *getPointerOperand() { return getOperand(0); }
@ -155,7 +166,7 @@ public:
// 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);
return I->getOpcode() == Instruction::Load;
}
static inline bool classof(const Value *V) {
return isa<Instruction>(V) && classof(cast<Instruction>(V));
@ -169,12 +180,26 @@ public:
class StoreInst : public Instruction {
StoreInst(const StoreInst &SI) : Instruction(SI.getType(), Store) {
Volatile = SI.isVolatile();
Operands.reserve(2);
Operands.push_back(Use(SI.Operands[0], this));
Operands.push_back(Use(SI.Operands[1], this));
}
bool Volatile; // True if this is a volatile store
public:
StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore = 0);
StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore);
StoreInst(Value *Val, Value *Ptr, bool isVolatile = false,
Instruction *InsertBefore = 0);
/// isVolatile - Return true if this is a load from a volatile memory
/// location.
bool isVolatile() const { return Volatile; }
/// setVolatile - Specify whether this is a volatile load or not.
///
void setVolatile(bool V) { Volatile = V; }
virtual Instruction *clone() const { return new StoreInst(*this); }
virtual bool mayWriteToMemory() const { return true; }
@ -186,7 +211,7 @@ public:
// 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);
return I->getOpcode() == Instruction::Store;
}
static inline bool classof(const Value *V) {
return isa<Instruction>(V) && classof(cast<Instruction>(V));

5
lib/VMCore/AsmWriter.cpp
View File

@ -771,6 +771,11 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
if (I.hasName())
Out << getLLVMName(I.getName()) << " = ";
// If this is a volatile load or store, print out the volatile marker
if ((isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) ||
(isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile()))
Out << "volatile ";
// Print out the opcode...
Out << I.getOpcodeName();

22
lib/VMCore/iMemory.cpp
View File

@ -1,4 +1,4 @@
//===-- iMemory.cpp - Implement Memory instructions --------------*- C++ -*--=//
//===-- iMemory.cpp - Implement Memory instructions -----------------------===//
//
// This file implements the various memory related classes defined in iMemory.h
//
@ -58,18 +58,34 @@ FreeInst::FreeInst(Value *Ptr, Instruction *InsertBefore)
LoadInst::LoadInst(Value *Ptr, const std::string &Name, Instruction *InsertBef)
: Instruction(cast<PointerType>(Ptr->getType())->getElementType(),
Load, Name, InsertBef) {
Load, Name, InsertBef), Volatile(false) {
Operands.reserve(1);
Operands.push_back(Use(Ptr, this));
}
LoadInst::LoadInst(Value *Ptr, const std::string &Name, bool isVolatile,
Instruction *InsertBef)
: Instruction(cast<PointerType>(Ptr->getType())->getElementType(),
Load, Name, InsertBef), Volatile(isVolatile) {
Operands.reserve(1);
Operands.push_back(Use(Ptr, this));
}
//===----------------------------------------------------------------------===//
// StoreInst Implementation
//===----------------------------------------------------------------------===//
StoreInst::StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore)
: Instruction(Type::VoidTy, Store, "", InsertBefore) {
: Instruction(Type::VoidTy, Store, "", InsertBefore), Volatile(false) {
Operands.reserve(2);
Operands.push_back(Use(Val, this));
Operands.push_back(Use(Ptr, this));
}
StoreInst::StoreInst(Value *Val, Value *Ptr, bool isVolatile,
Instruction *InsertBefore)
: Instruction(Type::VoidTy, Store, "", InsertBefore), Volatile(isVolatile) {
Operands.reserve(2);
Operands.push_back(Use(Val, this));