RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2024-11-29 14:40:25 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Eliminated the Unique class in favor of NonCopyable and NonCopyableV

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@280 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2001-07-23 18:26:21 +00:00
parent 57dbb3ad63
commit 4bc3daaa3f
10 changed files with 61 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/llvm/CodeGen/InstrForest.h
View File

@ -24,7 +24,7 @@
#ifndef LLVM_CODEGEN_INSTRFOREST_H
#define LLVM_CODEGEN_INSTRFOREST_H
#include "llvm/Support/Unique.h"
#include "llvm/Support/NonCopyable.h"
#include "llvm/Instruction.h"
#include <hash_map>
#include <hash_set>
@ -128,7 +128,7 @@ MainTreeNode(BasicTreeNode* node) {
}
class InstrTreeNode: public Unique {
class InstrTreeNode : public NonCopyableV {
public:
enum InstrTreeNodeType { NTInstructionNode,
NTVRegListNode,
@ -144,7 +144,7 @@ protected:
public:
/*ctor*/ InstrTreeNode (InstrTreeNodeType nodeType,
Value* _val);
/*dtor*/ virtual ~InstrTreeNode ();
/*dtor*/ virtual ~InstrTreeNode () {}
BasicTreeNode* getBasicNode () { return &basicNode; }
@ -239,7 +239,7 @@ protected:
//------------------------------------------------------------------------
class InstrForest :
public Unique,
public NonCopyable,
private hash_map<const Instruction*, InstructionNode*> {
private:

6
include/llvm/CodeGen/MachineInstr.h
View File

@ -17,7 +17,7 @@
#include "llvm/CodeGen/InstrForest.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/Unique.h"
#include "llvm/Support/NonCopyable.h"
#include "llvm/CodeGen/TargetMachine.h"
//---------------------------------------------------------------------------
@ -177,7 +177,7 @@ MachineOperand::InitializeReg(unsigned int _regNum)
// opcode and set bits in opCodeMask for each of these flags.
//---------------------------------------------------------------------------
class MachineInstr : public Unique {
class MachineInstr : public NonCopyable {
private:
MachineOpCode opCode;
OpCodeMask opCodeMask; // extra bits for variants of an opcode
@ -187,7 +187,7 @@ public:
/*ctor*/ MachineInstr (MachineOpCode _opCode,
OpCodeMask _opCodeMask = 0x0);
/*dtor*/ ~MachineInstr ();
inline ~MachineInstr () {}
const MachineOpCode getOpCode () const;

4
include/llvm/CodeGen/TargetMachine.h
View File

@ -12,7 +12,7 @@
#ifndef LLVM_CODEGEN_TARGETMACHINE_H
#define LLVM_CODEGEN_TARGETMACHINE_H
#include "llvm/Support/Unique.h"
#include "llvm/Support/NonCopyable.h"
#include "llvm/Support/DataTypes.h"
#include <string>
@ -70,7 +70,7 @@ extern const MachineInstrInfo* TargetMachineInstrInfo;
//
//---------------------------------------------------------------------------
class TargetMachine: public Unique {
class TargetMachine : public NonCopyableV {
public:
int optSizeForSubWordData;
int intSize;

4
include/llvm/DerivedTypes.h
View File

@ -120,7 +120,7 @@ public:
unsigned int getStorageSize(const TargetMachine& tmi) const {
if (layoutCache->targetInfo && *layoutCache->targetInfo != tmi) {
if (layoutCache->targetInfo && layoutCache->targetInfo != &tmi) {
// target machine has changed (hey it could happen). discard cached info.
ResetCachedInfo();
layoutCache->targetInfo = &tmi;
@ -134,7 +134,7 @@ public:
}
unsigned int getElementOffset(int i, const TargetMachine& tmi) const {
// target machine has changed (hey it could happen). discard cached info.
if (layoutCache->targetInfo && *layoutCache->targetInfo != tmi)
if (layoutCache->targetInfo && layoutCache->targetInfo != &tmi)
ResetCachedInfo();
if (layoutCache->memberOffsets[i] < 0) {

18
include/llvm/Support/DataTypes.h
View File

@ -1,3 +1,16 @@
//===-- include/Support/DataTypes.h - Define fixed size types ----*- C++ -*--=//
//
// This file contains definitions to figure out the size of _HOST_ data types.
// This file is important because different host OS's define different macros,
// which makes portability tough. This file exports the following definitions:
//
// LITTLE_ENDIAN: is #define'd if the host is little endian
// int64_t : is a typedef for the signed 64 bit system type
// uint64_t : is a typedef for the unsigned 64 bit system type
//
// No library is required when using these functinons.
//
//===----------------------------------------------------------------------===//
// TODO: This file sucks. Not only does it not work, but this stuff should be
// autoconfiscated anyways. Major FIXME
@ -6,11 +19,6 @@
#ifndef LLVM_SUPPORT_DATATYPES_H
#define LLVM_SUPPORT_DATATYPES_H
// Should define the following:
// LITTLE_ENDIAN if applicable
// int64_t
// uint64_t
#ifdef LINUX
#include <stdint.h> // Defined by ISO C 99
#include <endian.h>

37
include/llvm/Support/NonCopyable.h Normal file
View File

@ -0,0 +1,37 @@
//===-- NonCopyable.h - Disable copy ctor and op= in subclasses --*- C++ -*--=//
//
// This file defines the NonCopyable and NonCopyableV classes. These mixin
// classes may be used to mark a class not being copyable. You should derive
// from NonCopyable if you don't want to have a virtual dtor, or NonCopyableV
// if you do want polymorphic behavior in your class.
//
// No library is required when using these functinons.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_SUPPORT_NONCOPYABLE_H
#define LLVM_SUPPORT_NONCOPYABLE_H
class NonCopyable {
// Disable the copy constructor and the assignment operator
// by making them both private:
//
NonCopyable(const NonCopyable &); // DO NOT IMPLEMENT
NonCopyable &operator=(const NonCopyable &); // DO NOT IMPLEMENT
protected:
inline NonCopyable() {}
inline ~NonCopyable() {}
};
class NonCopyableV {
// Disable the copy constructor and the assignment operator
// by making them both private:
//
NonCopyableV(const NonCopyableV &); // DO NOT IMPLEMENT
NonCopyableV &operator=(const NonCopyableV &); // DO NOT IMPLEMENT
protected:
inline NonCopyableV() {}
virtual ~NonCopyableV() {}
};
#endif

56
include/llvm/Support/Unique.h
View File

@ -1,56 +0,0 @@
//************************************************************-*- C++ -*-
// class Unique:
// Mixin class for classes that should never be copied.
//
// Purpose:
// This mixin disables both the copy constructor and the
// assignment operator. It also provides a default equality operator.
//
// History:
// 09/24/96 - vadve - Created (adapted from dHPF).
//
//***************************************************************************
#ifndef UNIQUE_H
#define UNIQUE_H
#include <assert.h>
class Unique
{
protected:
/*ctor*/ Unique () {}
/*dtor*/ virtual ~Unique () {}
public:
virtual bool operator== (const Unique& u1) const;
virtual bool operator!= (const Unique& u1) const;
private:
//
// Disable the copy constructor and the assignment operator
// by making them both private:
//
/*ctor*/ Unique (Unique&) { assert(0); }
virtual Unique& operator= (const Unique& u1) { assert(0);
return *this; }
};
// Unique object equality.
inline bool
Unique::operator==(const Unique& u2) const
{
return (bool) (this == &u2);
}
// Unique object inequality.
inline bool
Unique::operator!=(const Unique& u2) const
{
return (bool) !(this == &u2);
}
#endif

4
lib/CodeGen/InstrSelection/InstrForest.cpp
View File

@ -50,10 +50,6 @@ InstrTreeNode::InstrTreeNode(InstrTreeNodeType nodeType,
basicNode.treeNodePtr = this;
}
InstrTreeNode::~InstrTreeNode()
{}
void
InstrTreeNode::dump(int dumpChildren,
int indent) const

4
lib/CodeGen/MachineInstr.cpp
View File

@ -45,10 +45,6 @@ MachineInstr::MachineInstr(MachineOpCode _opCode,
{
}
MachineInstr::~MachineInstr()
{
}
void
MachineInstr::SetMachineOperand(unsigned int i,
MachineOperand::MachineOperandType operandType,

4
lib/Target/SparcV9/InstrSelection/InstrForest.cpp
View File

@ -50,10 +50,6 @@ InstrTreeNode::InstrTreeNode(InstrTreeNodeType nodeType,
basicNode.treeNodePtr = this;
}
InstrTreeNode::~InstrTreeNode()
{}
void
InstrTreeNode::dump(int dumpChildren,
int indent) const