Skip to content

Commit 2b1968f

Browse files
rastogishubhamrastogishubham
committed
WIP fix MCCAS, builds but round trip verification error due to FragType not staying the same after materialization, does it not get saved?
1 parent 524585c commit 2b1968f

File tree

3 files changed

+160
-20
lines changed

3 files changed

+160
-20
lines changed

‎llvm/include/llvm/MCCAS/MCCASObjectV1.def

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -85,3 +85,4 @@ MCFRAGMENT_NODE_REF(MCCVDefRangeFragment, FT_CVDefRange, mc:cv_def_range)
8585

8686
#undef MCFRAGMENT_NODE_REF
8787
#endif /* MCFRAGMENT_NODE_REF */
88+

‎llvm/include/llvm/MCCAS/MCCASObjectV1.h

Lines changed: 57 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -418,6 +418,63 @@ class SpecificRef : public MCObjectProxy {
418418
};
419419
#include "llvm/MCCAS/MCCASObjectV1.def"
420420

421+
class MCGenericFragmentRef : public SpecificRef<MCGenericFragmentRef> {
422+
using SpecificRefT = SpecificRef<MCGenericFragmentRef>;
423+
friend class SpecificRef<MCGenericFragmentRef>;
424+
425+
public:
426+
MCGenericFragmentRef(SpecificRefT ST, MCFragment::FragmentType FragType)
427+
: SpecificRef<MCGenericFragmentRef>(ST), FragType(FragType) {}
428+
MCFragment::FragmentType FragType;
429+
static constexpr StringLiteral KindString = "mc:generic_fragment";
430+
static Expected<MCGenericFragmentRef> create(MCCASBuilder &MB,
431+
const MCFragment &Fragment,
432+
unsigned FragmentSize,
433+
ArrayRef<char> FragmentContents);
434+
static Expected<MCGenericFragmentRef> get(Expected<MCObjectProxy> Ref,
435+
MCFragment::FragmentType FragType) {
436+
auto Specific = SpecificRefT::getSpecific(std::move(Ref));
437+
if (!Specific)
438+
return Specific.takeError();
439+
return MCGenericFragmentRef(*Specific, FragType);
440+
}
441+
static Expected<MCGenericFragmentRef> get(const MCSchema &Schema,
442+
cas::ObjectRef ID,
443+
MCFragment::FragmentType FragType) {
444+
return get(Schema.get(ID), FragType);
445+
}
446+
static std::optional<MCGenericFragmentRef> Cast(MCObjectProxy Ref) {
447+
auto Specific = SpecificRefT::Cast(Ref);
448+
if (!Specific)
449+
return std::nullopt;
450+
return MCGenericFragmentRef(*Specific);
451+
}
452+
Expected<uint64_t> materialize(const MCFragment::FragmentType FragType,
453+
MCCASReader &Reader,
454+
raw_ostream *Stream) const;
455+
456+
static Expected<MCGenericFragmentRef>
457+
createGenericAlignFragmentRef(MCCASBuilder &MB, const MCFragment &F,
458+
unsigned FragmentSize,
459+
ArrayRef<char> FragmentContents);
460+
461+
static Expected<MCGenericFragmentRef>
462+
createGenericLEBFragmentRef(MCCASBuilder &MB, const MCFragment &F,
463+
unsigned FragmentSize,
464+
ArrayRef<char> FragmentContents);
465+
466+
Expected<uint64_t>
467+
materializeGenericAlignFragmentRef(MCCASReader &Reader,
468+
raw_ostream *Stream) const;
469+
470+
Expected<uint64_t>
471+
materializeGenericLEBFragmentRef(MCCASReader &Reader,
472+
raw_ostream *Stream) const;
473+
474+
private:
475+
explicit MCGenericFragmentRef(SpecificRefT Ref) : SpecificRefT(Ref) {}
476+
};
477+
421478
class PaddingRef : public SpecificRef<PaddingRef> {
422479
using SpecificRefT = SpecificRef<PaddingRef>;
423480
friend class SpecificRef<PaddingRef>;

‎llvm/lib/MCCAS/MCCASObjectV1.cpp

Lines changed: 102 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -48,6 +48,7 @@ constexpr StringLiteral PaddingRef::KindString;
4848
#define MCFRAGMENT_NODE_REF(MCFragmentName, MCEnumName, MCEnumIdentifier) \
4949
constexpr StringLiteral MCFragmentName##Ref::KindString;
5050
#include "llvm/MCCAS/MCCASObjectV1.def"
51+
constexpr StringLiteral MCGenericFragmentRef::KindString;
5152
constexpr StringLiteral DebugInfoSectionRef::KindString;
5253

5354
void MCSchema::anchor() {}
@@ -172,6 +173,7 @@ Error MCSchema::fillCache() {
172173
PaddingRef::KindString,
173174
MCAssemblerRef::KindString,
174175
DebugInfoSectionRef::KindString,
176+
MCGenericFragmentRef::KindString,
175177
#define CASV1_SIMPLE_DATA_REF(RefName, IdentifierName) RefName::KindString,
176178
#define CASV1_SIMPLE_GROUP_REF(RefName, IdentifierName) RefName::KindString,
177179
#define MCFRAGMENT_NODE_REF(MCFragmentName, MCEnumName, MCEnumIdentifier) \
@@ -1531,34 +1533,33 @@ Expected<uint64_t> AtomRef::materialize(MCCASReader &Reader,
15311533
return Size;
15321534
}
15331535

1534-
Expected<MCAlignFragmentRef>
1535-
MCAlignFragmentRef::create(MCCASBuilder &MB, const MCAlignFragment &F,
1536-
unsigned FragmentSize,
1537-
ArrayRef<char> FragmentContents) {
1536+
Expected<MCGenericFragmentRef>
1537+
MCGenericFragmentRef::createGenericAlignFragmentRef(
1538+
MCCASBuilder &MB, const MCFragment &F, unsigned FragmentSize,
1539+
ArrayRef<char> FragmentContents) {
15381540
Expected<Builder> B = Builder::startNode(MB.Schema, KindString);
15391541
if (!B)
15401542
return B.takeError();
15411543

1542-
uint64_t Count = FragmentSize / F.getFillLen();
1543-
if (F.hasEmitNops()) {
1544+
uint64_t Count = FragmentSize / F.getAlignFillLen();
1545+
if (F.hasAlignEmitNops()) {
15441546
// Write 0 as size and use backend to emit nop.
15451547
writeVBR8(0, B->Data);
15461548
if (!MB.Asm.getBackend().writeNopData(MB.FragmentOS, Count,
15471549
F.getSubtargetInfo()))
15481550
report_fatal_error("unable to write nop sequence of " + Twine(Count) +
15491551
" bytes");
15501552
B->Data.append(MB.FragmentData);
1551-
return get(B->build());
1553+
return get(B->build(), MCFragment::FT_Align);
15521554
}
15531555
writeVBR8(Count, B->Data);
1554-
writeVBR8(F.getFill(), B->Data);
1555-
writeVBR8(F.getFillLen(), B->Data);
1556-
return get(B->build());
1556+
writeVBR8(F.getAlignFill(), B->Data);
1557+
writeVBR8(F.getAlignFillLen(), B->Data);
1558+
return get(B->build(), MCFragment::FT_Align);
15571559
}
15581560

1559-
Expected<uint64_t> MCAlignFragmentRef::materialize(MCCASReader &Reader,
1560-
raw_ostream *Stream) const
1561-
{
1561+
Expected<uint64_t> MCGenericFragmentRef::materializeGenericAlignFragmentRef(
1562+
MCCASReader &Reader, raw_ostream *Stream) const {
15621563
uint64_t Count;
15631564
auto Remaining = getData();
15641565
auto Endian = Reader.getEndian();
@@ -1686,23 +1687,76 @@ Expected<uint64_t> MCFillFragmentRef::materialize(MCCASReader &Reader,
16861687
return Size;
16871688
}
16881689

1689-
Expected<MCLEBFragmentRef>
1690-
MCLEBFragmentRef::create(MCCASBuilder &MB, const MCLEBFragment &F,
1691-
unsigned FragmentSize,
1692-
ArrayRef<char> FragmentContents) {
1690+
Expected<MCGenericFragmentRef>
1691+
MCGenericFragmentRef::createGenericLEBFragmentRef(
1692+
MCCASBuilder &MB, const MCFragment &F, unsigned FragmentSize,
1693+
ArrayRef<char> FragmentContents) {
16931694
Expected<Builder> B = Builder::startNode(MB.Schema, KindString);
16941695
if (!B)
16951696
return B.takeError();
16961697
llvm::append_range(B->Data, F.getContents());
1697-
return get(B->build());
1698+
return get(B->build(), MCFragment::FT_LEB);
16981699
}
16991700

1700-
Expected<uint64_t> MCLEBFragmentRef::materialize(MCCASReader &Reader,
1701-
raw_ostream *Stream) const {
1701+
Expected<uint64_t> MCGenericFragmentRef::materializeGenericLEBFragmentRef(
1702+
MCCASReader &Reader, raw_ostream *Stream) const {
17021703
*Stream << getData();
17031704
return getData().size();
17041705
}
17051706

1707+
Expected<MCGenericFragmentRef>
1708+
MCGenericFragmentRef::create(MCCASBuilder &MB, const MCFragment &Fragment,
1709+
unsigned int FragmentSize,
1710+
ArrayRef<char> FragmentContents) {
1711+
auto FragType = Fragment.getKind();
1712+
switch (FragType) {
1713+
case MCFragment::FT_Align:
1714+
return createGenericAlignFragmentRef(MB, Fragment, FragmentSize,
1715+
FragmentContents);
1716+
case MCFragment::FT_LEB:
1717+
return createGenericLEBFragmentRef(MB, Fragment, FragmentSize,
1718+
FragmentContents);
1719+
case MCFragment::FT_Relaxable:
1720+
case MCFragment::FT_Data:
1721+
case MCFragment::FT_Dwarf:
1722+
case MCFragment::FT_DwarfFrame: {
1723+
Expected<Builder> B = Builder::startNode(MB.Schema, KindString);
1724+
if (!B)
1725+
return B.takeError();
1726+
B->Data.append(MB.FragmentData);
1727+
B->Data.append(FragmentContents.begin(), FragmentContents.end());
1728+
assert(((MB.FragmentData.empty() && Fragment.getContents().empty()) ||
1729+
(MB.FragmentData.size() + Fragment.getContents().size() ==
1730+
FragmentSize)) &&
1731+
"Size should match");
1732+
return get(B->build(), FragType);
1733+
}
1734+
default:
1735+
llvm_unreachable("Other Fragment Kinds should be handled elsewhere!");
1736+
}
1737+
}
1738+
1739+
Expected<uint64_t>
1740+
MCGenericFragmentRef::materialize(const MCFragment::FragmentType FragType,
1741+
MCCASReader &Reader,
1742+
raw_ostream *Stream) const {
1743+
switch (FragType) {
1744+
case MCFragment::FT_Align:
1745+
return materializeGenericAlignFragmentRef(Reader, Stream);
1746+
case MCFragment::FT_LEB:
1747+
return materializeGenericLEBFragmentRef(Reader, Stream);
1748+
case MCFragment::FT_Relaxable:
1749+
case MCFragment::FT_Data:
1750+
case MCFragment::FT_Dwarf:
1751+
case MCFragment::FT_DwarfFrame: {
1752+
*Stream << getData();
1753+
return getData().size();
1754+
}
1755+
default:
1756+
llvm_unreachable("Other Fragment Kinds should be handled elsewhere!");
1757+
}
1758+
}
1759+
17061760
Expected<MCNopsFragmentRef>
17071761
MCNopsFragmentRef::create(MCCASBuilder &MB, const MCNopsFragment &F,
17081762
unsigned FragmentSize,
@@ -1858,6 +1912,18 @@ Error MCCASBuilder::buildFragment(const MCFragment &F, unsigned Size,
18581912
return Error::success(); \
18591913
}
18601914
#include "llvm/MCCAS/MCCASObjectV1.def"
1915+
case MCFragment::FT_Relaxable:
1916+
case MCFragment::FT_Data:
1917+
case MCFragment::FT_Align:
1918+
case MCFragment::FT_Dwarf:
1919+
case MCFragment::FT_DwarfFrame:
1920+
case MCFragment::FT_LEB: {
1921+
auto GF = MCGenericFragmentRef::create(*this, F, Size, FragmentContents);
1922+
if (!GF)
1923+
return GF.takeError();
1924+
addNode(*GF);
1925+
return Error::success();
1926+
}
18611927
}
18621928
llvm_unreachable("unknown fragment");
18631929
}
@@ -1984,6 +2050,14 @@ Error MCDataFragmentMerger::emitMergedFragments() {
19842050
return E;
19852051
break;
19862052
}
2053+
case MCFragment::FT_Relaxable:
2054+
case MCFragment::FT_Data:
2055+
case MCFragment::FT_Dwarf:
2056+
case MCFragment::FT_DwarfFrame:
2057+
case MCFragment::FT_LEB: {
2058+
FragmentData.append(CandidateContents);
2059+
break;
2060+
}
19872061
default:
19882062
llvm_unreachable("other framgents should not be added");
19892063
}
@@ -2861,6 +2935,11 @@ static ArrayRef<char> getFragmentContents(const MCFragment &Fragment) {
28612935
cast<MCCVInlineLineTableFragment>(Fragment);
28622936
return SF.getContents();
28632937
}
2938+
case MCFragment::FT_Relaxable:
2939+
case MCFragment::FT_Data:
2940+
case MCFragment::FT_Align:
2941+
case MCFragment::FT_Dwarf:
2942+
case MCFragment::FT_DwarfFrame:
28642943
case MCFragment::FT_LEB: {
28652944
return Fragment.getContents();
28662945
}
@@ -3602,6 +3681,9 @@ Expected<uint64_t> MCCASReader::materializeAtom(cas::ObjectRef ID,
36023681
return F->materialize(*Stream);
36033682
if (auto F = MergedFragmentRef::Cast(*Node))
36043683
return F->materialize(*Stream);
3684+
if (auto F = MCGenericFragmentRef::Cast(*Node)) {
3685+
return F->materialize(F->FragType, *this, Stream);
3686+
}
36053687

36063688
return createStringError(inconvertibleErrorCode(),
36073689
"unsupported CAS node for fragment");

0 commit comments

Comments
 (0)