RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2025-01-27 07:12:06 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Rejected r156374: Ordinary PR1255 patch. Due to clang-x86_64-debian-fnt buildbot failure.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@156377 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Stepan Dyatkovskiy 2012-05-08 08:33:21 +00:00
parent 189bce48c7
commit 1f9838347f
6 changed files with 39 additions and 236 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
include/llvm/ConstantRangesSet.h
View File

@ -48,15 +48,8 @@ class ConstantRangesSet {
Constant *Array; Constant *Array;
public: public:
bool IsWide;
// implicit // implicit
ConstantRangesSet(Constant *V) : Array(V) { ConstantRangesSet(Constant *V) : Array(V) {}
ArrayType *ArrTy = cast<ArrayType>(Array->getType());
VectorType *VecTy = cast<VectorType>(ArrTy->getElementType());
IntegerType *IntTy = cast<IntegerType>(VecTy->getElementType());
IsWide = IntTy->getBitWidth() > 64;
}
operator Constant*() { return Array; } operator Constant*() { return Array; }
operator const Constant*() const { return Array; } operator const Constant*() const { return Array; }
@ -237,13 +230,6 @@ public:
return cast<ArrayType>(Array->getType())->getNumElements(); return cast<ArrayType>(Array->getType())->getNumElements();
} }
bool isWideNumberFormat() const { return IsWide; }
bool isSingleNumber(unsigned idx) const {
Constant *CV = Array->getAggregateElement(idx);
return cast<VectorType>(CV->getType())->getNumElements() == 1;
}
/// Returns set the size, that equals number of all values + sizes of all /// Returns set the size, that equals number of all values + sizes of all
/// ranges. /// ranges.
/// Ranges set is considered as flat numbers collection. /// Ranges set is considered as flat numbers collection.

48
include/llvm/Instructions.h
View File

@ -20,8 +20,6 @@
#include "llvm/DerivedTypes.h" #include "llvm/DerivedTypes.h"
#include "llvm/Attributes.h" #include "llvm/Attributes.h"
#include "llvm/CallingConv.h" #include "llvm/CallingConv.h"
#include "llvm/ConstantRangesSet.h"
#include "llvm/CRSBuilder.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include "llvm/Support/ErrorHandling.h" #include "llvm/Support/ErrorHandling.h"
@ -2502,19 +2500,9 @@ public:
} }
/// Resolves case value for current case. /// Resolves case value for current case.
/// @Deprecated
ConstantIntTy *getCaseValue() { ConstantIntTy *getCaseValue() {
assert(Index < SI->getNumCases() && "Index out the number of cases."); assert(Index < SI->getNumCases() && "Index out the number of cases.");
ConstantRangesSet CRS = return reinterpret_cast<ConstantIntTy*>(SI->getOperand(2 + Index*2));
reinterpret_cast<Constant*>(SI->getOperand(2 + Index*2));
ConstantRangesSet::Range R = CRS.getItem(0);
return R.Low;
}
/// Resolves case value for current case.
ConstantRangesSet getCaseValueEx() {
assert(Index < SI->getNumCases() && "Index out the number of cases.");
return reinterpret_cast<Constant*>(SI->getOperand(2 + Index*2));
} }
/// Resolves successor for current case. /// Resolves successor for current case.
@ -2584,19 +2572,9 @@ public:
CaseIt(SwitchInst *SI, unsigned CaseNum) : ParentTy(SI, CaseNum) {} CaseIt(SwitchInst *SI, unsigned CaseNum) : ParentTy(SI, CaseNum) {}
/// Sets the new value for current case. /// Sets the new value for current case.
/// @Deprecated.
void setValue(ConstantInt *V) { void setValue(ConstantInt *V) {
assert(Index < SI->getNumCases() && "Index out the number of cases."); assert(Index < SI->getNumCases() && "Index out the number of cases.");
CRSBuilder CB; SI->setOperand(2 + Index*2, reinterpret_cast<Value*>(V));
CB.add(V);
SI->setOperand(2 + Index*2,
reinterpret_cast<Value*>((Constant*)CB.getCase()));
}
/// Sets the new value for current case.
void setValueEx(ConstantRangesSet& V) {
assert(Index < SI->getNumCases() && "Index out the number of cases.");
SI->setOperand(2 + Index*2, reinterpret_cast<Value*>((Constant*)V));
} }
/// Sets the new successor for current case. /// Sets the new successor for current case.
@ -2676,13 +2654,13 @@ public:
/// that it is handled by the default handler. /// that it is handled by the default handler.
CaseIt findCaseValue(const ConstantInt *C) { CaseIt findCaseValue(const ConstantInt *C) {
for (CaseIt i = case_begin(), e = case_end(); i != e; ++i) for (CaseIt i = case_begin(), e = case_end(); i != e; ++i)
if (i.getCaseValueEx().isSatisfies(C)) if (i.getCaseValue() == C)
return i; return i;
return case_default(); return case_default();
} }
ConstCaseIt findCaseValue(const ConstantInt *C) const { ConstCaseIt findCaseValue(const ConstantInt *C) const {
for (ConstCaseIt i = case_begin(), e = case_end(); i != e; ++i) for (ConstCaseIt i = case_begin(), e = case_end(); i != e; ++i)
if (i.getCaseValueEx().isSatisfies(C)) if (i.getCaseValue() == C)
return i; return i;
return case_default(); return case_default();
} }
@ -2703,17 +2681,10 @@ public:
} }
/// addCase - Add an entry to the switch instruction... /// addCase - Add an entry to the switch instruction...
/// @Deprecated
/// Note: /// Note:
/// This action invalidates case_end(). Old case_end() iterator will /// This action invalidates case_end(). Old case_end() iterator will
/// point to the added case. /// point to the added case.
void addCase(ConstantInt *OnVal, BasicBlock *Dest); void addCase(ConstantInt *OnVal, BasicBlock *Dest);
/// addCase - Add an entry to the switch instruction.
/// Note:
/// This action invalidates case_end(). Old case_end() iterator will
/// point to the added case.
void addCase(ConstantRangesSet& OnVal, BasicBlock *Dest);
/// removeCase - This method removes the specified case and its successor /// removeCase - This method removes the specified case and its successor
/// from the switch instruction. Note that this operation may reorder the /// from the switch instruction. Note that this operation may reorder the
@ -2732,17 +2703,6 @@ public:
assert(idx < getNumSuccessors() && "Successor # out of range for switch!"); assert(idx < getNumSuccessors() && "Successor # out of range for switch!");
setOperand(idx*2+1, (Value*)NewSucc); setOperand(idx*2+1, (Value*)NewSucc);
} }
uint16_t Hash() const {
uint32_t NumberOfCases = (uint32_t)getNumCases();
uint16_t Hash = (0xFFFF & NumberOfCases) ^ (NumberOfCases >> 16);
for (ConstCaseIt i = case_begin(), e = case_end();
i != e; ++i) {
uint32_t NumItems = (uint32_t)i.getCaseValueEx().getNumItems();
Hash = (Hash << 1) ^ (0xFFFF & NumItems) ^ (NumItems >> 16);
}
return Hash;
}
// Methods for support type inquiry through isa, cast, and dyn_cast: // Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const SwitchInst *) { return true; } static inline bool classof(const SwitchInst *) { return true; }

82
lib/Bitcode/Reader/BitcodeReader.cpp
View File

@ -28,10 +28,6 @@
#include "llvm/OperandTraits.h" #include "llvm/OperandTraits.h"
using namespace llvm; using namespace llvm;
enum {
SWITCH_INST_MAGIC = 0x4B5 // May 2012 => 1205 => Hex
};
void BitcodeReader::materializeForwardReferencedFunctions() { void BitcodeReader::materializeForwardReferencedFunctions() {
while (!BlockAddrFwdRefs.empty()) { while (!BlockAddrFwdRefs.empty()) {
Function *F = BlockAddrFwdRefs.begin()->first; Function *F = BlockAddrFwdRefs.begin()->first;
@ -981,17 +977,6 @@ bool BitcodeReader::ResolveGlobalAndAliasInits() {
return false; return false;
} }
template <typename intty>
APInt ReadWideAPInt(const intty *Vals, unsigned ActiveWords,
unsigned TypeBits) {
SmallVector<uint64_t, 8> Words;
Words.resize(ActiveWords);
for (unsigned i = 0; i != ActiveWords; ++i)
Words[i] = DecodeSignRotatedValue(Vals[i]);
return APInt(TypeBits, Words);
}
bool BitcodeReader::ParseConstants() { bool BitcodeReader::ParseConstants() {
if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID)) if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID))
return Error("Malformed block record"); return Error("Malformed block record");
@ -1048,11 +1033,13 @@ bool BitcodeReader::ParseConstants() {
return Error("Invalid WIDE_INTEGER record"); return Error("Invalid WIDE_INTEGER record");
unsigned NumWords = Record.size(); unsigned NumWords = Record.size();
SmallVector<uint64_t, 8> Words;
APInt VInt = ReadWideAPInt(&Record[0], NumWords, Words.resize(NumWords);
cast<IntegerType>(CurTy)->getBitWidth()); for (unsigned i = 0; i != NumWords; ++i)
V = ConstantInt::get(Context, VInt); Words[i] = DecodeSignRotatedValue(Record[i]);
V = ConstantInt::get(Context,
APInt(cast<IntegerType>(CurTy)->getBitWidth(),
Words));
break; break;
} }
case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval] case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval]
@ -2284,61 +2271,6 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
break; break;
} }
case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...] case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...]
// Check magic
if ((Record[0] >> 16) == SWITCH_INST_MAGIC) {
// New SwitchInst format with case ranges.
Type *OpTy = getTypeByID(Record[1]);
unsigned ValueBitWidth = cast<IntegerType>(OpTy)->getBitWidth();
Value *Cond = getFnValueByID(Record[2], OpTy);
BasicBlock *Default = getBasicBlock(Record[3]);
if (OpTy == 0 || Cond == 0 || Default == 0)
return Error("Invalid SWITCH record");
unsigned NumCases = Record[4];
SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases);
unsigned CurIdx = 5;
for (unsigned i = 0; i != NumCases; ++i) {
CRSBuilder CaseBuilder;
unsigned NumItems = Record[CurIdx++];
for (unsigned ci = 0; ci != NumItems; ++ci) {
bool isSingleNumber = Record[CurIdx++];
APInt Low;
unsigned ActiveWords = 1;
if (ValueBitWidth > 64)
ActiveWords = Record[CurIdx++];
Low = ReadWideAPInt(&Record[CurIdx], ActiveWords, ValueBitWidth);
CurIdx += ActiveWords;
if (!isSingleNumber) {
ActiveWords = 1;
if (ValueBitWidth > 64)
ActiveWords = Record[CurIdx++];
APInt High =
ReadWideAPInt(&Record[CurIdx], ActiveWords, ValueBitWidth);
CaseBuilder.add(cast<ConstantInt>(ConstantInt::get(OpTy, Low)),
cast<ConstantInt>(ConstantInt::get(OpTy, High)));
CurIdx += ActiveWords;
} else
CaseBuilder.add(cast<ConstantInt>(ConstantInt::get(OpTy, Low)));
}
BasicBlock *DestBB = getBasicBlock(Record[CurIdx++]);
ConstantRangesSet Case = CaseBuilder.getCase();
SI->addCase(Case, DestBB);
}
uint16_t Hash = SI->Hash();
if (Hash != (Record[0] & 0xFFFF))
return Error("Invalid SWITCH record");
I = SI;
break;
}
// Old SwitchInst format without case ranges.
if (Record.size() < 3 || (Record.size() & 1) == 0) if (Record.size() < 3 || (Record.size() & 1) == 0)
return Error("Invalid SWITCH record"); return Error("Invalid SWITCH record");
Type *OpTy = getTypeByID(Record[0]); Type *OpTy = getTypeByID(Record[0]);

87
lib/Bitcode/Writer/BitcodeWriter.cpp
View File

@ -62,10 +62,7 @@ enum {
FUNCTION_INST_CAST_ABBREV, FUNCTION_INST_CAST_ABBREV,
FUNCTION_INST_RET_VOID_ABBREV, FUNCTION_INST_RET_VOID_ABBREV,
FUNCTION_INST_RET_VAL_ABBREV, FUNCTION_INST_RET_VAL_ABBREV,
FUNCTION_INST_UNREACHABLE_ABBREV, FUNCTION_INST_UNREACHABLE_ABBREV
// SwitchInst Magic
SWITCH_INST_MAGIC = 0x4B5 // May 2012 => 1205 => Hex
}; };
static unsigned GetEncodedCastOpcode(unsigned Opcode) { static unsigned GetEncodedCastOpcode(unsigned Opcode) {
@ -722,42 +719,6 @@ static void WriteModuleMetadataStore(const Module *M, BitstreamWriter &Stream) {
Stream.ExitBlock(); Stream.ExitBlock();
} }
template <typename intty>
static void EmitAPInt(SmallVectorImpl<intty> &Vals,
unsigned &Code, unsigned &AbbrevToUse, const APInt &Val,
bool EmitSizeForWideNumbers = false
) {
if (Val.getBitWidth() <= 64) {
uint64_t V = Val.getSExtValue();
if ((int64_t)V >= 0)
Vals.push_back(V << 1);
else
Vals.push_back((-V << 1) | 1);
Code = bitc::CST_CODE_INTEGER;
AbbrevToUse = CONSTANTS_INTEGER_ABBREV;
} else {
// Wide integers, > 64 bits in size.
// We have an arbitrary precision integer value to write whose
// bit width is > 64. However, in canonical unsigned integer
// format it is likely that the high bits are going to be zero.
// So, we only write the number of active words.
unsigned NWords = Val.getActiveWords();
if (EmitSizeForWideNumbers)
Vals.push_back(NWords);
const uint64_t *RawWords = Val.getRawData();
for (unsigned i = 0; i != NWords; ++i) {
int64_t V = RawWords[i];
if (V >= 0)
Vals.push_back(V << 1);
else
Vals.push_back((-V << 1) | 1);
}
Code = bitc::CST_CODE_WIDE_INTEGER;
}
}
static void WriteConstants(unsigned FirstVal, unsigned LastVal, static void WriteConstants(unsigned FirstVal, unsigned LastVal,
const ValueEnumerator &VE, const ValueEnumerator &VE,
BitstreamWriter &Stream, bool isGlobal) { BitstreamWriter &Stream, bool isGlobal) {
@ -840,7 +801,30 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
} else if (isa<UndefValue>(C)) { } else if (isa<UndefValue>(C)) {
Code = bitc::CST_CODE_UNDEF; Code = bitc::CST_CODE_UNDEF;
} else if (const ConstantInt *IV = dyn_cast<ConstantInt>(C)) { } else if (const ConstantInt *IV = dyn_cast<ConstantInt>(C)) {
EmitAPInt(Record, Code, AbbrevToUse, IV->getValue()); if (IV->getBitWidth() <= 64) {
uint64_t V = IV->getSExtValue();
if ((int64_t)V >= 0)
Record.push_back(V << 1);
else
Record.push_back((-V << 1) | 1);
Code = bitc::CST_CODE_INTEGER;
AbbrevToUse = CONSTANTS_INTEGER_ABBREV;
} else { // Wide integers, > 64 bits in size.
// We have an arbitrary precision integer value to write whose
// bit width is > 64. However, in canonical unsigned integer
// format it is likely that the high bits are going to be zero.
// So, we only write the number of active words.
unsigned NWords = IV->getValue().getActiveWords();
const uint64_t *RawWords = IV->getValue().getRawData();
for (unsigned i = 0; i != NWords; ++i) {
int64_t V = RawWords[i];
if (V >= 0)
Record.push_back(V << 1);
else
Record.push_back((-V << 1) | 1);
}
Code = bitc::CST_CODE_WIDE_INTEGER;
}
} else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C)) { } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
Code = bitc::CST_CODE_FLOAT; Code = bitc::CST_CODE_FLOAT;
Type *Ty = CFP->getType(); Type *Ty = CFP->getType();
@ -1155,31 +1139,12 @@ static void WriteInstruction(const Instruction &I, unsigned InstID,
{ {
Code = bitc::FUNC_CODE_INST_SWITCH; Code = bitc::FUNC_CODE_INST_SWITCH;
SwitchInst &SI = cast<SwitchInst>(I); SwitchInst &SI = cast<SwitchInst>(I);
uint32_t SwitchRecordHeader = SI.Hash() | (SWITCH_INST_MAGIC << 16);
Vals.push_back(SwitchRecordHeader);
Vals.push_back(VE.getTypeID(SI.getCondition()->getType())); Vals.push_back(VE.getTypeID(SI.getCondition()->getType()));
Vals.push_back(VE.getValueID(SI.getCondition())); Vals.push_back(VE.getValueID(SI.getCondition()));
Vals.push_back(VE.getValueID(SI.getDefaultDest())); Vals.push_back(VE.getValueID(SI.getDefaultDest()));
Vals.push_back(SI.getNumCases());
for (SwitchInst::CaseIt i = SI.case_begin(), e = SI.case_end(); for (SwitchInst::CaseIt i = SI.case_begin(), e = SI.case_end();
i != e; ++i) { i != e; ++i) {
ConstantRangesSet CRS = i.getCaseValueEx(); Vals.push_back(VE.getValueID(i.getCaseValue()));
Vals.push_back(CRS.getNumItems());
for (unsigned ri = 0, rn = CRS.getNumItems(); ri != rn; ++ri) {
ConstantRangesSet::Range r = CRS.getItem(ri);
Vals.push_back(CRS.isSingleNumber(ri));
const APInt &Low = r.Low->getValue();
const APInt &High = r.High->getValue();
unsigned Code, Abbrev; // will unused.
EmitAPInt(Vals, Code, Abbrev, Low, true);
if (r.Low != r.High)
EmitAPInt(Vals, Code, Abbrev, High, true);
}
Vals.push_back(VE.getValueID(i.getCaseSuccessor())); Vals.push_back(VE.getValueID(i.getCaseSuccessor()));
} }
} }

9
lib/VMCore/Instructions.cpp
View File

@ -3169,13 +3169,6 @@ SwitchInst::~SwitchInst() {
/// addCase - Add an entry to the switch instruction... /// addCase - Add an entry to the switch instruction...
/// ///
void SwitchInst::addCase(ConstantInt *OnVal, BasicBlock *Dest) { void SwitchInst::addCase(ConstantInt *OnVal, BasicBlock *Dest) {
CRSBuilder CB;
CB.add(OnVal);
ConstantRangesSet CRS = CB.getCase();
addCase(CRS, Dest);
}
void SwitchInst::addCase(ConstantRangesSet& OnVal, BasicBlock *Dest) {
unsigned NewCaseIdx = getNumCases(); unsigned NewCaseIdx = getNumCases();
unsigned OpNo = NumOperands; unsigned OpNo = NumOperands;
if (OpNo+2 > ReservedSpace) if (OpNo+2 > ReservedSpace)
@ -3184,7 +3177,7 @@ void SwitchInst::addCase(ConstantRangesSet& OnVal, BasicBlock *Dest) {
assert(OpNo+1 < ReservedSpace && "Growing didn't work!"); assert(OpNo+1 < ReservedSpace && "Growing didn't work!");
NumOperands = OpNo+2; NumOperands = OpNo+2;
CaseIt Case(this, NewCaseIdx); CaseIt Case(this, NewCaseIdx);
Case.setValueEx(OnVal); Case.setValue(OnVal);
Case.setSuccessor(Dest); Case.setSuccessor(Dest);
} }

33
test/Bitcode/2012-05-07-SwitchInstRangesSupport.ll
View File

@ -1,33 +0,0 @@
; RUN: rm -f %t.bc
; RUN: rm -f %t.ll
; RUN: rm -f %t2.bc
; RUN: rm -f %t2.ll
; RUN: llvm-as %s -o %t.bc
; RUN: llvm-dis %t.bc -o - | tail -n +2 > %t.ll
; RUN: llvm-as %t.ll -o %t2.bc
; RUN: llvm-dis %t2.bc -o - | tail -n +2 > %t2.ll
; RUN: diff %t.ll %t2.ll | not grep .*
define void @test() {
%mem = alloca i32
store i32 2, i32* %mem
%c = load i32* %mem
switch i32 %c, label %exit [
i32 1, label %exit
i32 2, label %exit
]
exit:
ret void
}
define void @test_wide() {
%mem = alloca i256
store i256 2, i256* %mem
%c = load i256* %mem
switch i256 %c, label %exit [
i256 123456789012345678901234567890, label %exit
i256 2, label %exit
]
exit:
ret void
}