Skip to content

Commit 08d43f7

Browse files
wesleywiserwesleywiser
committed
Update frame layout & CFI generation to handle frames larger than 2gb
For very large stack frames, the offset from the stack pointer to a local can be more than 2^31 which overflows various `int` offsets in the frame lowering code. This patch updates the frame lowering code to calculate the offsets as 64-bit values and fixes CFI to use the corrected sizes. After this patch, additional work is needed to fix offset truncations in each target's codegen.
1 parent b042af3 commit 08d43f7

19 files changed

+65
-65
lines changed

‎llvm/include/llvm/CodeGen/MachineFrameInfo.h

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -251,7 +251,7 @@ class MachineFrameInfo {
251251
/// targets, this value is only used when generating debug info (via
252252
/// TargetRegisterInfo::getFrameIndexReference); when generating code, the
253253
/// corresponding adjustments are performed directly.
254-
int OffsetAdjustment = 0;
254+
int64_t OffsetAdjustment = 0;
255255

256256
/// The prolog/epilog code inserter may process objects that require greater
257257
/// alignment than the default alignment the target provides.
@@ -280,7 +280,7 @@ class MachineFrameInfo {
280280
/// setup/destroy pseudo instructions (as defined in the TargetFrameInfo
281281
/// class). This information is important for frame pointer elimination.
282282
/// It is only valid during and after prolog/epilog code insertion.
283-
unsigned MaxCallFrameSize = ~0u;
283+
uint64_t MaxCallFrameSize = ~UINT64_C(0);
284284

285285
/// The number of bytes of callee saved registers that the target wants to
286286
/// report for the current function in the CodeView S_FRAMEPROC record.
@@ -593,10 +593,10 @@ class MachineFrameInfo {
593593
uint64_t estimateStackSize(const MachineFunction &MF) const;
594594

595595
/// Return the correction for frame offsets.
596-
int getOffsetAdjustment() const { return OffsetAdjustment; }
596+
int64_t getOffsetAdjustment() const { return OffsetAdjustment; }
597597

598598
/// Set the correction for frame offsets.
599-
void setOffsetAdjustment(int Adj) { OffsetAdjustment = Adj; }
599+
void setOffsetAdjustment(int64_t Adj) { OffsetAdjustment = Adj; }
600600

601601
/// Return the alignment in bytes that this function must be aligned to,
602602
/// which is greater than the default stack alignment provided by the target.
@@ -663,17 +663,17 @@ class MachineFrameInfo {
663663
/// CallFrameSetup/Destroy pseudo instructions are used by the target, and
664664
/// then only during or after prolog/epilog code insertion.
665665
///
666-
unsigned getMaxCallFrameSize() const {
666+
uint64_t getMaxCallFrameSize() const {
667667
// TODO: Enable this assert when targets are fixed.
668668
//assert(isMaxCallFrameSizeComputed() && "MaxCallFrameSize not computed yet");
669669
if (!isMaxCallFrameSizeComputed())
670670
return 0;
671671
return MaxCallFrameSize;
672672
}
673673
bool isMaxCallFrameSizeComputed() const {
674-
return MaxCallFrameSize != ~0u;
674+
return MaxCallFrameSize != ~UINT64_C(0);
675675
}
676-
void setMaxCallFrameSize(unsigned S) { MaxCallFrameSize = S; }
676+
void setMaxCallFrameSize(uint64_t S) { MaxCallFrameSize = S; }
677677

678678
/// Returns how many bytes of callee-saved registers the target pushed in the
679679
/// prologue. Only used for debug info.

‎llvm/include/llvm/CodeGen/TargetFrameLowering.h

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -51,7 +51,7 @@ class TargetFrameLowering {
5151
// Maps a callee saved register to a stack slot with a fixed offset.
5252
struct SpillSlot {
5353
unsigned Reg;
54-
int Offset; // Offset relative to stack pointer on function entry.
54+
int64_t Offset; // Offset relative to stack pointer on function entry.
5555
};
5656

5757
struct DwarfFrameBase {
@@ -66,7 +66,7 @@ class TargetFrameLowering {
6666
// Used with FrameBaseKind::Register.
6767
unsigned Reg;
6868
// Used with FrameBaseKind::CFA.
69-
int Offset;
69+
int64_t Offset;
7070
struct WasmFrameBase WasmLoc;
7171
} Location;
7272
};

‎llvm/include/llvm/MC/MCAsmBackend.h

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -224,7 +224,7 @@ class MCAsmBackend {
224224
virtual void handleAssemblerFlag(MCAssemblerFlag Flag) {}
225225

226226
/// Generate the compact unwind encoding for the CFI instructions.
227-
virtual uint32_t generateCompactUnwindEncoding(const MCDwarfFrameInfo *FI,
227+
virtual uint64_t generateCompactUnwindEncoding(const MCDwarfFrameInfo *FI,
228228
const MCContext *Ctxt) const {
229229
return 0;
230230
}

‎llvm/include/llvm/MC/MCDwarf.h

Lines changed: 22 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -509,11 +509,11 @@ class MCCFIInstruction {
509509
union {
510510
struct {
511511
unsigned Register;
512-
int Offset;
512+
int64_t Offset;
513513
} RI;
514514
struct {
515515
unsigned Register;
516-
int Offset;
516+
int64_t Offset;
517517
unsigned AddressSpace;
518518
} RIA;
519519
struct {
@@ -527,7 +527,7 @@ class MCCFIInstruction {
527527
std::vector<char> Values;
528528
std::string Comment;
529529

530-
MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R, int O, SMLoc Loc,
530+
MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R, int64_t O, SMLoc Loc,
531531
StringRef V = "", StringRef Comment = "")
532532
: Label(L), Operation(Op), Loc(Loc), Values(V.begin(), V.end()),
533533
Comment(Comment) {
@@ -539,7 +539,7 @@ class MCCFIInstruction {
539539
assert(Op == OpRegister);
540540
U.RR = {R1, R2};
541541
}
542-
MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R, int O, unsigned AS,
542+
MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R, int64_t O, unsigned AS,
543543
SMLoc Loc)
544544
: Label(L), Operation(Op), Loc(Loc) {
545545
assert(Op == OpLLVMDefAspaceCfa);
@@ -555,30 +555,30 @@ class MCCFIInstruction {
555555
public:
556556
/// .cfi_def_cfa defines a rule for computing CFA as: take address from
557557
/// Register and add Offset to it.
558-
static MCCFIInstruction cfiDefCfa(MCSymbol *L, unsigned Register, int Offset,
559-
SMLoc Loc = {}) {
558+
static MCCFIInstruction cfiDefCfa(MCSymbol *L, unsigned Register,
559+
int64_t Offset, SMLoc Loc = {}) {
560560
return MCCFIInstruction(OpDefCfa, L, Register, Offset, Loc);
561561
}
562562

563563
/// .cfi_def_cfa_register modifies a rule for computing CFA. From now
564564
/// on Register will be used instead of the old one. Offset remains the same.
565565
static MCCFIInstruction createDefCfaRegister(MCSymbol *L, unsigned Register,
566566
SMLoc Loc = {}) {
567-
return MCCFIInstruction(OpDefCfaRegister, L, Register, 0, Loc);
567+
return MCCFIInstruction(OpDefCfaRegister, L, Register, INT64_C(0), Loc);
568568
}
569569

570570
/// .cfi_def_cfa_offset modifies a rule for computing CFA. Register
571571
/// remains the same, but offset is new. Note that it is the absolute offset
572572
/// that will be added to a defined register to the compute CFA address.
573-
static MCCFIInstruction cfiDefCfaOffset(MCSymbol *L, int Offset,
573+
static MCCFIInstruction cfiDefCfaOffset(MCSymbol *L, int64_t Offset,
574574
SMLoc Loc = {}) {
575575
return MCCFIInstruction(OpDefCfaOffset, L, 0, Offset, Loc);
576576
}
577577

578578
/// .cfi_adjust_cfa_offset Same as .cfi_def_cfa_offset, but
579579
/// Offset is a relative value that is added/subtracted from the previous
580580
/// offset.
581-
static MCCFIInstruction createAdjustCfaOffset(MCSymbol *L, int Adjustment,
581+
static MCCFIInstruction createAdjustCfaOffset(MCSymbol *L, int64_t Adjustment,
582582
SMLoc Loc = {}) {
583583
return MCCFIInstruction(OpAdjustCfaOffset, L, 0, Adjustment, Loc);
584584
}
@@ -588,7 +588,7 @@ class MCCFIInstruction {
588588
/// be the result of evaluating the DWARF operation expression
589589
/// `DW_OP_constu AS; DW_OP_aspace_bregx R, B` as a location description.
590590
static MCCFIInstruction createLLVMDefAspaceCfa(MCSymbol *L, unsigned Register,
591-
int Offset,
591+
int64_t Offset,
592592
unsigned AddressSpace,
593593
SMLoc Loc) {
594594
return MCCFIInstruction(OpLLVMDefAspaceCfa, L, Register, Offset,
@@ -598,15 +598,15 @@ class MCCFIInstruction {
598598
/// .cfi_offset Previous value of Register is saved at offset Offset
599599
/// from CFA.
600600
static MCCFIInstruction createOffset(MCSymbol *L, unsigned Register,
601-
int Offset, SMLoc Loc = {}) {
601+
int64_t Offset, SMLoc Loc = {}) {
602602
return MCCFIInstruction(OpOffset, L, Register, Offset, Loc);
603603
}
604604

605605
/// .cfi_rel_offset Previous value of Register is saved at offset
606606
/// Offset from the current CFA register. This is transformed to .cfi_offset
607607
/// using the known displacement of the CFA register from the CFA.
608608
static MCCFIInstruction createRelOffset(MCSymbol *L, unsigned Register,
609-
int Offset, SMLoc Loc = {}) {
609+
int64_t Offset, SMLoc Loc = {}) {
610610
return MCCFIInstruction(OpRelOffset, L, Register, Offset, Loc);
611611
}
612612

@@ -619,44 +619,44 @@ class MCCFIInstruction {
619619

620620
/// .cfi_window_save SPARC register window is saved.
621621
static MCCFIInstruction createWindowSave(MCSymbol *L, SMLoc Loc = {}) {
622-
return MCCFIInstruction(OpWindowSave, L, 0, 0, Loc);
622+
return MCCFIInstruction(OpWindowSave, L, 0, 0L, Loc);
623623
}
624624

625625
/// .cfi_negate_ra_state AArch64 negate RA state.
626626
static MCCFIInstruction createNegateRAState(MCSymbol *L, SMLoc Loc = {}) {
627-
return MCCFIInstruction(OpNegateRAState, L, 0, 0, Loc);
627+
return MCCFIInstruction(OpNegateRAState, L, 0, INT64_C(0), Loc);
628628
}
629629

630630
/// .cfi_restore says that the rule for Register is now the same as it
631631
/// was at the beginning of the function, after all initial instructions added
632632
/// by .cfi_startproc were executed.
633633
static MCCFIInstruction createRestore(MCSymbol *L, unsigned Register,
634634
SMLoc Loc = {}) {
635-
return MCCFIInstruction(OpRestore, L, Register, 0, Loc);
635+
return MCCFIInstruction(OpRestore, L, Register, INT64_C(0), Loc);
636636
}
637637

638638
/// .cfi_undefined From now on the previous value of Register can't be
639639
/// restored anymore.
640640
static MCCFIInstruction createUndefined(MCSymbol *L, unsigned Register,
641641
SMLoc Loc = {}) {
642-
return MCCFIInstruction(OpUndefined, L, Register, 0, Loc);
642+
return MCCFIInstruction(OpUndefined, L, Register, INT64_C(0), Loc);
643643
}
644644

645645
/// .cfi_same_value Current value of Register is the same as in the
646646
/// previous frame. I.e., no restoration is needed.
647647
static MCCFIInstruction createSameValue(MCSymbol *L, unsigned Register,
648648
SMLoc Loc = {}) {
649-
return MCCFIInstruction(OpSameValue, L, Register, 0, Loc);
649+
return MCCFIInstruction(OpSameValue, L, Register, INT64_C(0), Loc);
650650
}
651651

652652
/// .cfi_remember_state Save all current rules for all registers.
653653
static MCCFIInstruction createRememberState(MCSymbol *L, SMLoc Loc = {}) {
654-
return MCCFIInstruction(OpRememberState, L, 0, 0, Loc);
654+
return MCCFIInstruction(OpRememberState, L, 0, INT64_C(0), Loc);
655655
}
656656

657657
/// .cfi_restore_state Restore the previously saved state.
658658
static MCCFIInstruction createRestoreState(MCSymbol *L, SMLoc Loc = {}) {
659-
return MCCFIInstruction(OpRestoreState, L, 0, 0, Loc);
659+
return MCCFIInstruction(OpRestoreState, L, 0, INT64_C(0), Loc);
660660
}
661661

662662
/// .cfi_escape Allows the user to add arbitrary bytes to the unwind
@@ -667,7 +667,7 @@ class MCCFIInstruction {
667667
}
668668

669669
/// A special wrapper for .cfi_escape that indicates GNU_ARGS_SIZE
670-
static MCCFIInstruction createGnuArgsSize(MCSymbol *L, int Size,
670+
static MCCFIInstruction createGnuArgsSize(MCSymbol *L, int64_t Size,
671671
SMLoc Loc = {}) {
672672
return MCCFIInstruction(OpGnuArgsSize, L, 0, Size, Loc);
673673
}
@@ -702,7 +702,7 @@ class MCCFIInstruction {
702702
return U.RIA.AddressSpace;
703703
}
704704

705-
int getOffset() const {
705+
int64_t getOffset() const {
706706
if (Operation == OpLLVMDefAspaceCfa)
707707
return U.RIA.Offset;
708708
assert(Operation == OpDefCfa || Operation == OpOffset ||
@@ -736,7 +736,7 @@ struct MCDwarfFrameInfo {
736736
unsigned CurrentCfaRegister = 0;
737737
unsigned PersonalityEncoding = 0;
738738
unsigned LsdaEncoding = 0;
739-
uint32_t CompactUnwindEncoding = 0;
739+
uint64_t CompactUnwindEncoding = 0;
740740
bool IsSignalFrame = false;
741741
bool IsSimple = false;
742742
unsigned RAReg = static_cast<unsigned>(INT_MAX);

‎llvm/lib/CodeGen/CFIInstrInserter.cpp

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -68,9 +68,9 @@ class CFIInstrInserter : public MachineFunctionPass {
6868
struct MBBCFAInfo {
6969
MachineBasicBlock *MBB;
7070
/// Value of cfa offset valid at basic block entry.
71-
int IncomingCFAOffset = -1;
71+
int64_t IncomingCFAOffset = -1;
7272
/// Value of cfa offset valid at basic block exit.
73-
int OutgoingCFAOffset = -1;
73+
int64_t OutgoingCFAOffset = -1;
7474
/// Value of cfa register valid at basic block entry.
7575
unsigned IncomingCFARegister = 0;
7676
/// Value of cfa register valid at basic block exit.
@@ -120,7 +120,7 @@ class CFIInstrInserter : public MachineFunctionPass {
120120
/// Return the cfa offset value that should be set at the beginning of a MBB
121121
/// if needed. The negated value is needed when creating CFI instructions that
122122
/// set absolute offset.
123-
int getCorrectCFAOffset(MachineBasicBlock *MBB) {
123+
int64_t getCorrectCFAOffset(MachineBasicBlock *MBB) {
124124
return MBBVector[MBB->getNumber()].IncomingCFAOffset;
125125
}
126126

@@ -175,7 +175,7 @@ void CFIInstrInserter::calculateCFAInfo(MachineFunction &MF) {
175175

176176
void CFIInstrInserter::calculateOutgoingCFAInfo(MBBCFAInfo &MBBInfo) {
177177
// Outgoing cfa offset set by the block.
178-
int SetOffset = MBBInfo.IncomingCFAOffset;
178+
int64_t SetOffset = MBBInfo.IncomingCFAOffset;
179179
// Outgoing cfa register set by the block.
180180
unsigned SetRegister = MBBInfo.IncomingCFARegister;
181181
MachineFunction *MF = MBBInfo.MBB->getParent();
@@ -188,7 +188,7 @@ void CFIInstrInserter::calculateOutgoingCFAInfo(MBBCFAInfo &MBBInfo) {
188188
for (MachineInstr &MI : *MBBInfo.MBB) {
189189
if (MI.isCFIInstruction()) {
190190
std::optional<unsigned> CSRReg;
191-
std::optional<int> CSROffset;
191+
std::optional<int64_t> CSROffset;
192192
unsigned CFIIndex = MI.getOperand(0).getCFIIndex();
193193
const MCCFIInstruction &CFI = Instrs[CFIIndex];
194194
switch (CFI.getOperation()) {

‎llvm/lib/CodeGen/MachineFrameInfo.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -197,7 +197,7 @@ void MachineFrameInfo::computeMaxCallFrameSize(
197197
for (MachineInstr &MI : MBB) {
198198
unsigned Opcode = MI.getOpcode();
199199
if (Opcode == FrameSetupOpcode || Opcode == FrameDestroyOpcode) {
200-
unsigned Size = TII.getFrameSize(MI);
200+
uint64_t Size = TII.getFrameSize(MI);
201201
MaxCallFrameSize = std::max(MaxCallFrameSize, Size);
202202
if (FrameSDOps != nullptr)
203203
FrameSDOps->push_back(&MI);

‎llvm/lib/CodeGen/PrologEpilogInserter.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -366,8 +366,8 @@ void PEI::calculateCallFrameInfo(MachineFunction &MF) {
366366
return;
367367

368368
// (Re-)Compute the MaxCallFrameSize.
369-
[[maybe_unused]] uint32_t MaxCFSIn =
370-
MFI.isMaxCallFrameSizeComputed() ? MFI.getMaxCallFrameSize() : UINT32_MAX;
369+
[[maybe_unused]] uint64_t MaxCFSIn =
370+
MFI.isMaxCallFrameSizeComputed() ? MFI.getMaxCallFrameSize() : UINT64_MAX;
371371
std::vector<MachineBasicBlock::iterator> FrameSDOps;
372372
MFI.computeMaxCallFrameSize(MF, &FrameSDOps);
373373
assert(MFI.getMaxCallFrameSize() <= MaxCFSIn &&

‎llvm/lib/MC/MCDwarf.cpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1299,8 +1299,8 @@ static void EmitPersonality(MCStreamer &streamer, const MCSymbol &symbol,
12991299
namespace {
13001300

13011301
class FrameEmitterImpl {
1302-
int CFAOffset = 0;
1303-
int InitialCFAOffset = 0;
1302+
int64_t CFAOffset = 0;
1303+
int64_t InitialCFAOffset = 0;
13041304
bool IsEH;
13051305
MCObjectStreamer &Streamer;
13061306

@@ -1414,7 +1414,7 @@ void FrameEmitterImpl::emitCFIInstruction(const MCCFIInstruction &Instr) {
14141414
if (!IsEH)
14151415
Reg = MRI->getDwarfRegNumFromDwarfEHRegNum(Reg);
14161416

1417-
int Offset = Instr.getOffset();
1417+
int64_t Offset = Instr.getOffset();
14181418
if (IsRelative)
14191419
Offset -= CFAOffset;
14201420
Offset = Offset / dataAlignmentFactor;

‎llvm/lib/Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -599,7 +599,7 @@ class DarwinAArch64AsmBackend : public AArch64AsmBackend {
599599
}
600600

601601
/// Generate the compact unwind encoding from the CFI directives.
602-
uint32_t generateCompactUnwindEncoding(const MCDwarfFrameInfo *FI,
602+
uint64_t generateCompactUnwindEncoding(const MCDwarfFrameInfo *FI,
603603
const MCContext *Ctxt) const override {
604604
ArrayRef<MCCFIInstruction> Instrs = FI->Instructions;
605605
if (Instrs.empty())
@@ -609,10 +609,10 @@ class DarwinAArch64AsmBackend : public AArch64AsmBackend {
609609
return CU::UNWIND_ARM64_MODE_DWARF;
610610

611611
bool HasFP = false;
612-
unsigned StackSize = 0;
612+
uint64_t StackSize = 0;
613613

614-
uint32_t CompactUnwindEncoding = 0;
615-
int CurOffset = 0;
614+
uint64_t CompactUnwindEncoding = 0;
615+
int64_t CurOffset = 0;
616616
for (size_t i = 0, e = Instrs.size(); i != e; ++i) {
617617
const MCCFIInstruction &Inst = Instrs[i];
618618

‎llvm/lib/Target/ARM/ARMFrameLowering.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1167,7 +1167,7 @@ void ARMFrameLowering::emitPrologue(MachineFunction &MF,
11671167
if (STI.splitFramePushPop(MF)) {
11681168
unsigned DwarfReg = MRI->getDwarfRegNum(
11691169
Reg == ARM::R12 ? ARM::RA_AUTH_CODE : Reg, true);
1170-
unsigned Offset = MFI.getObjectOffset(FI);
1170+
int64_t Offset = MFI.getObjectOffset(FI);
11711171
unsigned CFIIndex = MF.addFrameInst(
11721172
MCCFIInstruction::createOffset(nullptr, DwarfReg, Offset));
11731173
BuildMI(MBB, Pos, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))
@@ -1189,7 +1189,7 @@ void ARMFrameLowering::emitPrologue(MachineFunction &MF,
11891189
if ((Reg >= ARM::D0 && Reg <= ARM::D31) &&
11901190
(Reg < ARM::D8 || Reg >= ARM::D8 + AFI->getNumAlignedDPRCS2Regs())) {
11911191
unsigned DwarfReg = MRI->getDwarfRegNum(Reg, true);
1192-
unsigned Offset = MFI.getObjectOffset(FI);
1192+
int64_t Offset = MFI.getObjectOffset(FI);
11931193
unsigned CFIIndex = MF.addFrameInst(
11941194
MCCFIInstruction::createOffset(nullptr, DwarfReg, Offset));
11951195
BuildMI(MBB, Pos, dl, TII.get(TargetOpcode::CFI_INSTRUCTION))

‎llvm/lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1146,7 +1146,7 @@ enum CompactUnwindEncodings {
11461146
/// instructions. If the CFI instructions describe a frame that cannot be
11471147
/// encoded in compact unwind, the method returns UNWIND_ARM_MODE_DWARF which
11481148
/// tells the runtime to fallback and unwind using dwarf.
1149-
uint32_t ARMAsmBackendDarwin::generateCompactUnwindEncoding(
1149+
uint64_t ARMAsmBackendDarwin::generateCompactUnwindEncoding(
11501150
const MCDwarfFrameInfo *FI, const MCContext *Ctxt) const {
11511151
DEBUG_WITH_TYPE("compact-unwind", llvm::dbgs() << "generateCU()\n");
11521152
// Only armv7k uses CFI based unwinding.

‎llvm/lib/Target/ARM/MCTargetDesc/ARMAsmBackendDarwin.h

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -34,7 +34,7 @@ class ARMAsmBackendDarwin : public ARMAsmBackend {
3434
/*Is64Bit=*/false, cantFail(MachO::getCPUType(TT)), Subtype);
3535
}
3636

37-
uint32_t generateCompactUnwindEncoding(const MCDwarfFrameInfo *FI,
37+
uint64_t generateCompactUnwindEncoding(const MCDwarfFrameInfo *FI,
3838
const MCContext *Ctxt) const override;
3939
};
4040
} // end namespace llvm

0 commit comments

Comments
 (0)