[llvm] [MC] Add -reservation-station-buffer-scale option (PR #195638)
Tomer Shafir via llvm-commits
llvm-commits at lists.llvm.org
Mon May 4 07:18:38 PDT 2026
https://github.com/tomershafir updated https://github.com/llvm/llvm-project/pull/195638
>From bbf2aa26e78ca2e1da41794aa25f84b79cbef43f Mon Sep 17 00:00:00 2001
From: tomershafir <tomer.shafir8 at gmail.com>
Date: Mon, 4 May 2026 14:56:47 +0300
Subject: [PATCH] [MC] Add -reservation-station-scale-factor option
This patch adds a new CLI option to the MC layer called `-reservation-station-scale-factor` that enables to scale the buffer size of reservation station (RS) for resources in the scheduling model by a non-negative `float` factor. For maximal flexibility, it only scales RS resources in isolation, and not load/store queues which are also modeled as standrad resources. This can be used for example to try find headroom in post-RA instruction scheduling for OOO cores - e.g. scale RS size by 2 and observe IPC gains, if so the code may be senetitive to the schedule and we may do better.
The implementation adds a new method `MCSchedule::getResourceBufferSize()` that calculates the buffer size and exits early by default. It is wrapped on `TargetSchedule` for CodeGen, or other users call it directly. For `ResourceState` we add a scheduling model context to the contructor. `LSUnit` still uses `BufferSize` directly, as it has inline logic for load/store queues handling. So is `llvm/lib/Target/SystemZ/SystemZHazardRecognizer.cpp` which is target specific. Testing through `llvm-mca` debug output. We could syntesize a BB that is sensitive to the schedule and check an IPC improvement, but it would be more compilated.
This only impacts llvm-mca at the moment. However, I think it should logically belong to the MC layer, which owns the scheduling model infrastructure, as the option is coupled to the model and not MCA. Thus, this patch adds it speculatively to the MC layer, e.g. so that we can easily observe how a RS-based scheduler performs for next-generation larger-RS target without re-coding and re-building LLVM. Following up, we may even move other such options to from the `llvm-mca` tool to the MC library like dispatch width etc.
---
llvm/include/llvm/CodeGen/TargetSchedule.h | 5 +-
llvm/include/llvm/MC/MCSchedule.h | 5 ++
.../llvm/MCA/HardwareUnits/ResourceManager.h | 2 +-
llvm/lib/CodeGen/MachineScheduler.cpp | 2 +-
llvm/lib/CodeGen/ScheduleDAGInstrs.cpp | 2 +-
llvm/lib/CodeGen/TargetSchedule.cpp | 2 +-
llvm/lib/MC/MCSchedule.cpp | 29 +++++++
.../lib/MCA/HardwareUnits/ResourceManager.cpp | 6 +-
llvm/lib/MCA/InstrBuilder.cpp | 10 +--
.../reservation-station-scale-factor.s | 81 +++++++++++++++++++
.../llvm-mca/Views/SchedulerStatistics.cpp | 10 +--
llvm/tools/llvm-mca/Views/TimelineView.cpp | 6 +-
12 files changed, 137 insertions(+), 23 deletions(-)
create mode 100644 llvm/test/tools/llvm-mca/reservation-station-scale-factor.s
diff --git a/llvm/include/llvm/CodeGen/TargetSchedule.h b/llvm/include/llvm/CodeGen/TargetSchedule.h
index 74f8ed5a18d33..cdb3fd639bb15 100644
--- a/llvm/include/llvm/CodeGen/TargetSchedule.h
+++ b/llvm/include/llvm/CodeGen/TargetSchedule.h
@@ -172,10 +172,9 @@ class TargetSchedModel {
/// Number of micro-ops that may be buffered for OOO execution.
unsigned getMicroOpBufferSize() const { return SchedModel.MicroOpBufferSize; }
- /// Number of resource units that may be buffered for OOO execution.
- /// \return The buffer size in resource units or -1 for unlimited.
+ /// Return the scaled buffer size for a processor resource.
int getResourceBufferSize(unsigned PIdx) const {
- return SchedModel.getProcResource(PIdx)->BufferSize;
+ return SchedModel.getResourceBufferSize(PIdx);
}
/// Compute operand latency based on the available machine model.
diff --git a/llvm/include/llvm/MC/MCSchedule.h b/llvm/include/llvm/MC/MCSchedule.h
index d41a7412a9830..00d095fb2147c 100644
--- a/llvm/include/llvm/MC/MCSchedule.h
+++ b/llvm/include/llvm/MC/MCSchedule.h
@@ -420,6 +420,11 @@ struct MCSchedModel {
LLVM_ABI static unsigned getBypassDelayCycles(const MCSubtargetInfo &STI,
const MCSchedClassDesc &SCDesc);
+ /// Return the buffer size of the resource. If a valid scale factor
+ /// is provided, the size is being scaled accordingly.
+ /// \return The scaled buffer size of the resource or -1 for unlimited.
+ LLVM_ABI int getResourceBufferSize(unsigned ProcResourceIdx) const;
+
/// Returns the default initialized model.
LLVM_ABI static const MCSchedModel Default;
};
diff --git a/llvm/include/llvm/MCA/HardwareUnits/ResourceManager.h b/llvm/include/llvm/MCA/HardwareUnits/ResourceManager.h
index ff5b6b40ff93a..346394ca52aa7 100644
--- a/llvm/include/llvm/MCA/HardwareUnits/ResourceManager.h
+++ b/llvm/include/llvm/MCA/HardwareUnits/ResourceManager.h
@@ -217,7 +217,7 @@ class ResourceState {
public:
LLVM_ABI ResourceState(const MCProcResourceDesc &Desc, unsigned Index,
- uint64_t Mask);
+ uint64_t Mask, const MCSchedModel &SM);
unsigned getProcResourceID() const { return ProcResourceDescIndex; }
uint64_t getResourceMask() const { return ResourceMask; }
diff --git a/llvm/lib/CodeGen/MachineScheduler.cpp b/llvm/lib/CodeGen/MachineScheduler.cpp
index 2c8898ffcd09c..786fe1d0b8fe3 100644
--- a/llvm/lib/CodeGen/MachineScheduler.cpp
+++ b/llvm/lib/CodeGen/MachineScheduler.cpp
@@ -3013,7 +3013,7 @@ void SchedBoundary::bumpNode(SUnit *SU) {
PI = SchedModel->getWriteProcResBegin(SC),
PE = SchedModel->getWriteProcResEnd(SC); PI != PE; ++PI) {
unsigned PIdx = PI->ProcResourceIdx;
- if (SchedModel->getProcResource(PIdx)->BufferSize == 0) {
+ if (SchedModel->getResourceBufferSize(PIdx) == 0) {
if (SchedModel && SchedModel->enableIntervals()) {
unsigned ReservedUntil, InstanceIdx;
diff --git a/llvm/lib/CodeGen/ScheduleDAGInstrs.cpp b/llvm/lib/CodeGen/ScheduleDAGInstrs.cpp
index 9662511e584c0..34392004465d4 100644
--- a/llvm/lib/CodeGen/ScheduleDAGInstrs.cpp
+++ b/llvm/lib/CodeGen/ScheduleDAGInstrs.cpp
@@ -621,7 +621,7 @@ void ScheduleDAGInstrs::initSUnits() {
for (const MCWriteProcResEntry &PRE :
make_range(SchedModel.getWriteProcResBegin(SC),
SchedModel.getWriteProcResEnd(SC))) {
- switch (SchedModel.getProcResource(PRE.ProcResourceIdx)->BufferSize) {
+ switch (SchedModel.getResourceBufferSize(PRE.ProcResourceIdx)) {
case 0:
SU->hasReservedResource = true;
break;
diff --git a/llvm/lib/CodeGen/TargetSchedule.cpp b/llvm/lib/CodeGen/TargetSchedule.cpp
index cd951a1a4f53e..07a3205fbc644 100644
--- a/llvm/lib/CodeGen/TargetSchedule.cpp
+++ b/llvm/lib/CodeGen/TargetSchedule.cpp
@@ -293,7 +293,7 @@ computeOutputLatency(const MachineInstr *DefMI, unsigned DefOperIdx,
if (SCDesc->isValid()) {
for (const MCWriteProcResEntry *PRI = STI->getWriteProcResBegin(SCDesc),
*PRE = STI->getWriteProcResEnd(SCDesc); PRI != PRE; ++PRI) {
- if (!SchedModel.getProcResource(PRI->ProcResourceIdx)->BufferSize)
+ if (!SchedModel.getResourceBufferSize(PRI->ProcResourceIdx))
return 1;
}
}
diff --git a/llvm/lib/MC/MCSchedule.cpp b/llvm/lib/MC/MCSchedule.cpp
index 527ccf3fc36e0..20b649a52ce0f 100644
--- a/llvm/lib/MC/MCSchedule.cpp
+++ b/llvm/lib/MC/MCSchedule.cpp
@@ -15,11 +15,18 @@
#include "llvm/MC/MCInstrDesc.h"
#include "llvm/MC/MCInstrInfo.h"
#include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/Support/CommandLine.h"
#include <optional>
#include <type_traits>
using namespace llvm;
+static cl::opt<float> ReservationStationScaleFactor(
+ "reservation-station-scale-factor", cl::Hidden, cl::init(1.0f),
+ cl::desc("Scale buffer size for all reservation stations by a non-negative "
+ "factor. Can only scale non-negative buffer sizes. Computed sizes "
+ "are truncated towards zero"));
+
static_assert(std::is_trivial_v<MCSchedModel>,
"MCSchedModel is required to be a trivial type");
const MCSchedModel MCSchedModel::Default = {DefaultIssueWidth,
@@ -212,3 +219,25 @@ unsigned MCSchedModel::getBypassDelayCycles(const MCSubtargetInfo &STI,
// Unable to find WriteResourceID in MCReadAdvanceEntry Entries
return 0;
}
+
+int MCSchedModel::getResourceBufferSize(unsigned ProcResourceIdx) const {
+ int BufferSize = getProcResource(ProcResourceIdx)->BufferSize;
+
+ // Early exit by default
+ if (ReservationStationScaleFactor == 1)
+ return BufferSize;
+
+ if (ReservationStationScaleFactor < 0 || BufferSize <= 0)
+ return BufferSize;
+
+ // Do not scale load/store queues
+ if (hasExtraProcessorInfo()) {
+ const auto &EPI = getExtraProcessorInfo();
+ if (ProcResourceIdx == EPI.LoadQueueID ||
+ ProcResourceIdx == EPI.StoreQueueID)
+ return BufferSize;
+ }
+
+ // Scale and truncate a non-negative computed size towards zero
+ return static_cast<int>(BufferSize * ReservationStationScaleFactor);
+}
diff --git a/llvm/lib/MCA/HardwareUnits/ResourceManager.cpp b/llvm/lib/MCA/HardwareUnits/ResourceManager.cpp
index 7671348ff29da..cdf3439e07d61 100644
--- a/llvm/lib/MCA/HardwareUnits/ResourceManager.cpp
+++ b/llvm/lib/MCA/HardwareUnits/ResourceManager.cpp
@@ -70,11 +70,11 @@ static uint64_t computeResourceSizeMask(uint64_t Mask, bool IsAGroup,
}
ResourceState::ResourceState(const MCProcResourceDesc &Desc, unsigned Index,
- uint64_t Mask)
+ uint64_t Mask, const MCSchedModel &SM)
: ProcResourceDescIndex(Index), ResourceMask(Mask),
IsAGroup(llvm::popcount(ResourceMask) > 1),
ResourceSizeMask(computeResourceSizeMask(Mask, IsAGroup, Desc.NumUnits)),
- BufferSize(Desc.BufferSize) {
+ BufferSize(SM.getResourceBufferSize(Index)) {
ReadyMask = ResourceSizeMask;
AvailableSlots = BufferSize == -1 ? 0U : static_cast<unsigned>(BufferSize);
Unavailable = false;
@@ -131,7 +131,7 @@ ResourceManager::ResourceManager(const MCSchedModel &SM)
uint64_t Mask = ProcResID2Mask[I];
unsigned Index = getResourceStateIndex(Mask);
Resources[Index] =
- std::make_unique<ResourceState>(*SM.getProcResource(I), I, Mask);
+ std::make_unique<ResourceState>(*SM.getProcResource(I), I, Mask, SM);
Strategies[Index] = getStrategyFor(*Resources[Index]);
}
diff --git a/llvm/lib/MCA/InstrBuilder.cpp b/llvm/lib/MCA/InstrBuilder.cpp
index 72184ccd84cae..b7819daca5a66 100644
--- a/llvm/lib/MCA/InstrBuilder.cpp
+++ b/llvm/lib/MCA/InstrBuilder.cpp
@@ -83,12 +83,13 @@ static void initializeUsedResources(InstrDesc &ID,
}
uint64_t Mask = ProcResourceMasks[PRE->ProcResourceIdx];
- if (PR.BufferSize < 0) {
+ const int BufferSize = SM.getResourceBufferSize(PRE->ProcResourceIdx);
+ if (BufferSize < 0) {
AllInOrderResources = false;
} else {
Buffers.setBit(getResourceStateIndex(Mask));
- AnyDispatchHazards |= (PR.BufferSize == 0);
- AllInOrderResources &= (PR.BufferSize <= 1);
+ AnyDispatchHazards |= (BufferSize == 0);
+ AllInOrderResources &= (BufferSize <= 1);
}
CycleSegment RCy(0, PRE->ReleaseAtCycle, false);
@@ -186,8 +187,7 @@ static void initializeUsedResources(InstrDesc &ID,
// Identify extra buffers that are consumed through super resources.
for (const std::pair<uint64_t, unsigned> &SR : SuperResources) {
for (unsigned I = 1, E = NumProcResources; I < E; ++I) {
- const MCProcResourceDesc &PR = *SM.getProcResource(I);
- if (PR.BufferSize == -1)
+ if (SM.getResourceBufferSize(I) == -1)
continue;
uint64_t Mask = ProcResourceMasks[I];
diff --git a/llvm/test/tools/llvm-mca/reservation-station-scale-factor.s b/llvm/test/tools/llvm-mca/reservation-station-scale-factor.s
new file mode 100644
index 0000000000000..db575d63b5533
--- /dev/null
+++ b/llvm/test/tools/llvm-mca/reservation-station-scale-factor.s
@@ -0,0 +1,81 @@
+# REQUIRES: asserts
+# REQUIRES: aarch64-registered-target
+
+## Note: negative buffer size is not scaled
+# RUN: llvm-mca < %s -mtriple=aarch64 -mcpu=apple-m1 -reservation-station-scale-factor=2 -debug 2>&1 | FileCheck %s --check-prefix=UPSCALE
+# RUN: llvm-mca < %s -mtriple=aarch64 -mcpu=apple-m1 -reservation-station-scale-factor=0.5 -debug 2>&1 | FileCheck %s --check-prefix=DOWNSCALE
+
+## Default scale factor is 1
+# RUN: llvm-mca < %s -mtriple=aarch64 -mcpu=apple-m1 -debug 2>&1 | FileCheck %s --check-prefix=ORIGINAL
+
+## Negative scale factor is ignored
+# RUN: llvm-mca < %s -mtriple=aarch64 -mcpu=apple-m1 -reservation-station-scale-factor=-1 -debug 2>&1 | FileCheck %s --check-prefix=ORIGINAL
+
+## BufferSize=0 is not scaled
+# RUN: llvm-mca < %s -mtriple=aarch64 -mcpu=cortex-a53 -reservation-station-scale-factor=2 -debug 2>&1 | FileCheck %s --check-prefix=ZERO-BUFFER
+
+# LLVM-MCA-BEGIN foo
+add x2, x0, x1
+# LLVM-MCA-END
+
+# ORIGINAL-COUNT-1: Processor resources:
+# ORIGINAL-NEXT: [ 0] - 0x00000000000000 - InvalidUnit
+# ORIGINAL-NEXT: [ 1] - 0x00000000000001 - CyUnitB (BufferSize=24)
+# ORIGINAL-NEXT: [ 2] - 0x00000000000002 - CyUnitBR (BufferSize=-1)
+# ORIGINAL-NEXT: [ 3] - 0x00000000000004 - CyUnitFloatDiv (BufferSize=-1)
+# ORIGINAL-NEXT: [ 4] - 0x00000000000008 - CyUnitI (BufferSize=48)
+# ORIGINAL-NEXT: [ 5] - 0x00000000000010 - CyUnitID (BufferSize=16)
+# ORIGINAL-NEXT: [ 6] - 0x00000000000020 - CyUnitIM (BufferSize=32)
+# ORIGINAL-NEXT: [ 7] - 0x00000000000040 - CyUnitIS (BufferSize=24)
+# ORIGINAL-NEXT: [ 8] - 0x00000000000080 - CyUnitIntDiv (BufferSize=-1)
+# ORIGINAL-NEXT: [ 9] - 0x00000000000100 - CyUnitLS (BufferSize=28)
+# ORIGINAL-NEXT: [10] - 0x00000000000200 - CyUnitV (BufferSize=48)
+# ORIGINAL-NEXT: [11] - 0x00000000000400 - CyUnitVC (BufferSize=16)
+# ORIGINAL-NEXT: [12] - 0x00000000000800 - CyUnitVD (BufferSize=16)
+# ORIGINAL-NEXT: [13] - 0x00000000001000 - CyUnitVM (BufferSize=32)
+# ORIGINAL: [0] Code Region - foo
+
+# DOWNSCALE-COUNT-1: Processor resources:
+# DOWNSCALE-NEXT: [ 0] - 0x00000000000000 - InvalidUnit
+# DOWNSCALE-NEXT: [ 1] - 0x00000000000001 - CyUnitB (BufferSize=12)
+# DOWNSCALE-NEXT: [ 2] - 0x00000000000002 - CyUnitBR (BufferSize=-1)
+# DOWNSCALE-NEXT: [ 3] - 0x00000000000004 - CyUnitFloatDiv (BufferSize=-1)
+# DOWNSCALE-NEXT: [ 4] - 0x00000000000008 - CyUnitI (BufferSize=24)
+# DOWNSCALE-NEXT: [ 5] - 0x00000000000010 - CyUnitID (BufferSize=8)
+# DOWNSCALE-NEXT: [ 6] - 0x00000000000020 - CyUnitIM (BufferSize=16)
+# DOWNSCALE-NEXT: [ 7] - 0x00000000000040 - CyUnitIS (BufferSize=12)
+# DOWNSCALE-NEXT: [ 8] - 0x00000000000080 - CyUnitIntDiv (BufferSize=-1)
+# DOWNSCALE-NEXT: [ 9] - 0x00000000000100 - CyUnitLS (BufferSize=14)
+# DOWNSCALE-NEXT: [10] - 0x00000000000200 - CyUnitV (BufferSize=24)
+# DOWNSCALE-NEXT: [11] - 0x00000000000400 - CyUnitVC (BufferSize=8)
+# DOWNSCALE-NEXT: [12] - 0x00000000000800 - CyUnitVD (BufferSize=8)
+# DOWNSCALE-NEXT: [13] - 0x00000000001000 - CyUnitVM (BufferSize=16)
+# DOWNSCALE: [0] Code Region - foo
+
+# UPSCALE-COUNT-1: Processor resources:
+# UPSCALE-NEXT: [ 0] - 0x00000000000000 - InvalidUnit
+# UPSCALE-NEXT: [ 1] - 0x00000000000001 - CyUnitB (BufferSize=48)
+# UPSCALE-NEXT: [ 2] - 0x00000000000002 - CyUnitBR (BufferSize=-1)
+# UPSCALE-NEXT: [ 3] - 0x00000000000004 - CyUnitFloatDiv (BufferSize=-1)
+# UPSCALE-NEXT: [ 4] - 0x00000000000008 - CyUnitI (BufferSize=96)
+# UPSCALE-NEXT: [ 5] - 0x00000000000010 - CyUnitID (BufferSize=32)
+# UPSCALE-NEXT: [ 6] - 0x00000000000020 - CyUnitIM (BufferSize=64)
+# UPSCALE-NEXT: [ 7] - 0x00000000000040 - CyUnitIS (BufferSize=48)
+# UPSCALE-NEXT: [ 8] - 0x00000000000080 - CyUnitIntDiv (BufferSize=-1)
+# UPSCALE-NEXT: [ 9] - 0x00000000000100 - CyUnitLS (BufferSize=56)
+# UPSCALE-NEXT: [10] - 0x00000000000200 - CyUnitV (BufferSize=96)
+# UPSCALE-NEXT: [11] - 0x00000000000400 - CyUnitVC (BufferSize=32)
+# UPSCALE-NEXT: [12] - 0x00000000000800 - CyUnitVD (BufferSize=32)
+# UPSCALE-NEXT: [13] - 0x00000000001000 - CyUnitVM (BufferSize=64)
+# UPSCALE: [0] Code Region - foo
+
+# ZERO-BUFFER-COUNT-1: Processor resources:
+# ZERO-BUFFER-NEXT: [0] - 0x00000000000000 - InvalidUnit
+# ZERO-BUFFER-NEXT: [1] - 0x00000000000001 - A53UnitALU (BufferSize=0)
+# ZERO-BUFFER-NEXT: [2] - 0x00000000000004 - A53UnitMAC (BufferSize=0)
+# ZERO-BUFFER-NEXT: [3] - 0x00000000000008 - A53UnitDiv (BufferSize=0)
+# ZERO-BUFFER-NEXT: [4] - 0x00000000000010 - A53UnitLdSt (BufferSize=0)
+# ZERO-BUFFER-NEXT: [5] - 0x00000000000020 - A53UnitB (BufferSize=0)
+# ZERO-BUFFER-NEXT: [6] - 0x00000000000040 - A53UnitFPALU (BufferSize=0)
+# ZERO-BUFFER-NEXT: [7] - 0x00000000000080 - A53UnitFPMDS (BufferSize=0)
+# ZERO-BUFFER: [0] Code Region - foo
diff --git a/llvm/tools/llvm-mca/Views/SchedulerStatistics.cpp b/llvm/tools/llvm-mca/Views/SchedulerStatistics.cpp
index 43f8b62864af7..94c208d4a9958 100644
--- a/llvm/tools/llvm-mca/Views/SchedulerStatistics.cpp
+++ b/llvm/tools/llvm-mca/Views/SchedulerStatistics.cpp
@@ -138,12 +138,13 @@ void SchedulerStatistics::printSchedulerUsage(raw_ostream &OS) const {
bool HasColors = FOS.has_colors();
for (unsigned I = 0, E = SM.getNumProcResourceKinds(); I < E; ++I) {
const MCProcResourceDesc &ProcResource = *SM.getProcResource(I);
- if (ProcResource.BufferSize <= 0)
+ const int BufferSize = SM.getResourceBufferSize(I);
+ if (BufferSize <= 0)
continue;
const BufferUsage &BU = Usage[I];
double AvgUsage = (double)BU.CumulativeNumUsedSlots / NumCycles;
- double AlmostFullThreshold = (double)(ProcResource.BufferSize * 4) / 5;
+ double AlmostFullThreshold = (double)(BufferSize * 4) / 5;
unsigned NormalizedAvg = floor((AvgUsage * 10) + 0.5) / 10;
unsigned NormalizedThreshold = floor((AlmostFullThreshold * 10) + 0.5) / 10;
@@ -155,14 +156,13 @@ void SchedulerStatistics::printSchedulerUsage(raw_ostream &OS) const {
if (HasColors)
FOS.resetColor();
FOS.PadToColumn(28);
- if (HasColors &&
- BU.MaxUsedSlots == static_cast<unsigned>(ProcResource.BufferSize))
+ if (HasColors && BU.MaxUsedSlots == static_cast<unsigned>(BufferSize))
FOS.changeColor(raw_ostream::RED, true, false);
FOS << BU.MaxUsedSlots;
if (HasColors)
FOS.resetColor();
FOS.PadToColumn(39);
- FOS << ProcResource.BufferSize << '\n';
+ FOS << BufferSize << '\n';
}
FOS.flush();
diff --git a/llvm/tools/llvm-mca/Views/TimelineView.cpp b/llvm/tools/llvm-mca/Views/TimelineView.cpp
index 193bceca190df..a788438144d02 100644
--- a/llvm/tools/llvm-mca/Views/TimelineView.cpp
+++ b/llvm/tools/llvm-mca/Views/TimelineView.cpp
@@ -46,10 +46,10 @@ void TimelineView::onReservedBuffers(const InstRef &IR,
const MCSchedModel &SM = getSubTargetInfo().getSchedModel();
std::pair<unsigned, int> BufferInfo = {0, -1};
for (const unsigned Buffer : Buffers) {
- const MCProcResourceDesc &MCDesc = *SM.getProcResource(Buffer);
- if (!BufferInfo.first || BufferInfo.second > MCDesc.BufferSize) {
+ const int BufferSize = SM.getResourceBufferSize(Buffer);
+ if (!BufferInfo.first || BufferInfo.second > BufferSize) {
BufferInfo.first = Buffer;
- BufferInfo.second = MCDesc.BufferSize;
+ BufferInfo.second = BufferSize;
}
}
More information about the llvm-commits
mailing list