RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-24 03:33:20 +01:00
Code Issues Projects Releases Wiki Activity

MCAssembler: Switch MCFillFragment to only taking constant values. Symbolic expressions can always be emitted as data + fixups.

Browse Source 
llvm-svn: 96092
This commit is contained in:
Daniel Dunbar 2010-02-13 09:28:32 +00:00
parent cc282ba52e
commit 95ae012b0e
2 changed files with 9 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/llvm/MC/MCAssembler.h
View File

@ -244,7 +244,7 @@ public:
class MCFillFragment : public MCFragment {
/// Value - Value to use for filling bytes.
const MCExpr *Value;
int64_t Value;
/// ValueSize - The size (in bytes) of \arg Value to use when filling.
unsigned ValueSize;
@ -253,10 +253,10 @@ class MCFillFragment : public MCFragment {
uint64_t Count;
public:
MCFillFragment(const MCExpr &_Value, unsigned _ValueSize, uint64_t _Count,
MCFillFragment(int64_t _Value, unsigned _ValueSize, uint64_t _Count,
MCSectionData *SD = 0)
: MCFragment(FT_Fill, SD),
Value(&_Value), ValueSize(_ValueSize), Count(_Count) {}
Value(_Value), ValueSize(_ValueSize), Count(_Count) {}
/// @name Accessors
/// @{
@ -265,7 +265,7 @@ public:
return ValueSize * Count;
}
const MCExpr &getValue() const { return *Value; }
int64_t getValue() const { return Value; }
unsigned getValueSize() const { return ValueSize; }

52
lib/MC/MCAssembler.cpp
View File

@ -969,33 +969,10 @@ void MCAssembler::LayoutSection(MCSectionData &SD) {
}
case MCFragment::FT_Data:
case MCFragment::FT_Fill:
F.setFileSize(F.getMaxFileSize());
break;
case MCFragment::FT_Fill: {
MCFillFragment &FF = cast<MCFillFragment>(F);
F.setFileSize(F.getMaxFileSize());
MCValue Target;
if (!FF.getValue().EvaluateAsRelocatable(Target))
llvm_report_error("expected relocatable expression");
// If the fill value is constant, thats it.
if (Target.isAbsolute())
break;
// Otherwise, add fixups for the values.
//
// FIXME: What we want to do here is lower this to a data fragment once we
// realize it will need relocations. This means that the only place we
// need to worry about relocations and fixing is on data fragments.
for (uint64_t i = 0, e = FF.getCount(); i != e; ++i)
FF.getFixups().push_back(MCAsmFixup(i*FF.getValueSize(), FF.getValue(),
FF.getValueSize()));
break;
}
case MCFragment::FT_Org: {
MCOrgFragment &OF = cast<MCOrgFragment>(F);
@ -1094,33 +1071,14 @@ static void WriteFileData(raw_ostream &OS, const MCFragment &F,
case MCFragment::FT_Fill: {
MCFillFragment &FF = cast<MCFillFragment>(F);
int64_t Value = 0;
MCValue Target;
if (!FF.getValue().EvaluateAsRelocatable(Target))
llvm_report_error("expected relocatable expression");
if (Target.isAbsolute())
Value = Target.getConstant();
for (uint64_t i = 0, e = FF.getCount(); i != e; ++i) {
if (!Target.isAbsolute()) {
// Find the fixup.
//
// FIXME: Find a better way to write in the fixes (move to
// MCDataFragment).
const MCAsmFixup *Fixup = FF.LookupFixup(i * FF.getValueSize());
assert(Fixup && "Missing fixup for fill value!");
Value = Fixup->FixedValue;
}
switch (FF.getValueSize()) {
default:
assert(0 && "Invalid size!");
case 1: MOW.Write8 (uint8_t (Value)); break;
case 2: MOW.Write16(uint16_t(Value)); break;
case 4: MOW.Write32(uint32_t(Value)); break;
case 8: MOW.Write64(uint64_t(Value)); break;
case 1: MOW.Write8 (uint8_t (FF.getValue())); break;
case 2: MOW.Write16(uint16_t(FF.getValue())); break;
case 4: MOW.Write32(uint32_t(FF.getValue())); break;
case 8: MOW.Write64(uint64_t(FF.getValue())); break;
}
}
break;