Skip to content

Commit

Permalink
[MemProf] Optionally update hints on existing hot/cold new calls (#91047
Browse files Browse the repository at this point in the history 
)

If directed by an option, update hints on calls to new that already
provide a hot/cold hint.
  • Loading branch information
@teresajohnson
teresajohnson authored May 8, 2024
1 parent b52160d commit cec6665
Show file tree
Hide file tree
Showing 2 changed files with 288 additions and 25 deletions.
137 changes: 115 additions & 22 deletions llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -52,6 +52,10 @@ static cl::opt<bool>
static cl::opt<bool>
OptimizeHotColdNew("optimize-hot-cold-new", cl::Hidden, cl::init(false),
cl::desc("Enable hot/cold operator new library calls"));
static cl::opt<bool> OptimizeExistingHotColdNew(
"optimize-existing-hot-cold-new", cl::Hidden, cl::init(false),
cl::desc(
"Enable optimization of existing hot/cold operator new library calls"));

namespace {

Expand Down Expand Up @@ -81,6 +85,10 @@ struct HotColdHintParser : public cl::parser<unsigned> {
static cl::opt<unsigned, false, HotColdHintParser> ColdNewHintValue(
"cold-new-hint-value", cl::Hidden, cl::init(1),
cl::desc("Value to pass to hot/cold operator new for cold allocation"));
static cl::opt<unsigned, false, HotColdHintParser>
NotColdNewHintValue("notcold-new-hint-value", cl::Hidden, cl::init(128),
cl::desc("Value to pass to hot/cold operator new for "
"notcold (warm) allocation"));
static cl::opt<unsigned, false, HotColdHintParser> HotNewHintValue(
"hot-new-hint-value", cl::Hidden, cl::init(254),
cl::desc("Value to pass to hot/cold operator new for hot allocation"));
Expand Down Expand Up @@ -1722,45 +1730,122 @@ Value *LibCallSimplifier::optimizeNew(CallInst *CI, IRBuilderBase &B,
uint8_t HotCold;
if (CI->getAttributes().getFnAttr("memprof").getValueAsString() == "cold")
HotCold = ColdNewHintValue;
else if (CI->getAttributes().getFnAttr("memprof").getValueAsString() ==
"notcold")
HotCold = NotColdNewHintValue;
else if (CI->getAttributes().getFnAttr("memprof").getValueAsString() == "hot")
HotCold = HotNewHintValue;
else
return nullptr;

// For calls that already pass a hot/cold hint, only update the hint if
// directed by OptimizeExistingHotColdNew. For other calls to new, add a hint
// if cold or hot, and leave as-is for default handling if "notcold" aka warm.
// Note that in cases where we decide it is "notcold", it might be slightly
// better to replace the hinted call with a non hinted call, to avoid the
// extra paramter and the if condition check of the hint value in the
// allocator. This can be considered in the future.
switch (Func) {
case LibFunc_Znwm12__hot_cold_t:
if (OptimizeExistingHotColdNew)
return emitHotColdNew(CI->getArgOperand(0), B, TLI,
LibFunc_Znwm12__hot_cold_t, HotCold);
break;
case LibFunc_Znwm:
return emitHotColdNew(CI->getArgOperand(0), B, TLI,
LibFunc_Znwm12__hot_cold_t, HotCold);
if (HotCold != NotColdNewHintValue)
return emitHotColdNew(CI->getArgOperand(0), B, TLI,
LibFunc_Znwm12__hot_cold_t, HotCold);
break;
case LibFunc_Znam12__hot_cold_t:
if (OptimizeExistingHotColdNew)
return emitHotColdNew(CI->getArgOperand(0), B, TLI,
LibFunc_Znam12__hot_cold_t, HotCold);
break;
case LibFunc_Znam:
return emitHotColdNew(CI->getArgOperand(0), B, TLI,
LibFunc_Znam12__hot_cold_t, HotCold);
if (HotCold != NotColdNewHintValue)
return emitHotColdNew(CI->getArgOperand(0), B, TLI,
LibFunc_Znam12__hot_cold_t, HotCold);
break;
case LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t:
if (OptimizeExistingHotColdNew)
return emitHotColdNewNoThrow(
CI->getArgOperand(0), CI->getArgOperand(1), B, TLI,
LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t, HotCold);
break;
case LibFunc_ZnwmRKSt9nothrow_t:
return emitHotColdNewNoThrow(CI->getArgOperand(0), CI->getArgOperand(1), B,
TLI, LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t,
HotCold);
if (HotCold != NotColdNewHintValue)
return emitHotColdNewNoThrow(
CI->getArgOperand(0), CI->getArgOperand(1), B, TLI,
LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t, HotCold);
break;
case LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t:
if (OptimizeExistingHotColdNew)
return emitHotColdNewNoThrow(
CI->getArgOperand(0), CI->getArgOperand(1), B, TLI,
LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t, HotCold);
break;
case LibFunc_ZnamRKSt9nothrow_t:
return emitHotColdNewNoThrow(CI->getArgOperand(0), CI->getArgOperand(1), B,
TLI, LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t,
HotCold);
if (HotCold != NotColdNewHintValue)
return emitHotColdNewNoThrow(
CI->getArgOperand(0), CI->getArgOperand(1), B, TLI,
LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t, HotCold);
break;
case LibFunc_ZnwmSt11align_val_t12__hot_cold_t:
if (OptimizeExistingHotColdNew)
return emitHotColdNewAligned(
CI->getArgOperand(0), CI->getArgOperand(1), B, TLI,
LibFunc_ZnwmSt11align_val_t12__hot_cold_t, HotCold);
break;
case LibFunc_ZnwmSt11align_val_t:
return emitHotColdNewAligned(CI->getArgOperand(0), CI->getArgOperand(1), B,
TLI, LibFunc_ZnwmSt11align_val_t12__hot_cold_t,
HotCold);
if (HotCold != NotColdNewHintValue)
return emitHotColdNewAligned(
CI->getArgOperand(0), CI->getArgOperand(1), B, TLI,
LibFunc_ZnwmSt11align_val_t12__hot_cold_t, HotCold);
break;
case LibFunc_ZnamSt11align_val_t12__hot_cold_t:
if (OptimizeExistingHotColdNew)
return emitHotColdNewAligned(
CI->getArgOperand(0), CI->getArgOperand(1), B, TLI,
LibFunc_ZnamSt11align_val_t12__hot_cold_t, HotCold);
break;
case LibFunc_ZnamSt11align_val_t:
return emitHotColdNewAligned(CI->getArgOperand(0), CI->getArgOperand(1), B,
TLI, LibFunc_ZnamSt11align_val_t12__hot_cold_t,
HotCold);
if (HotCold != NotColdNewHintValue)
return emitHotColdNewAligned(
CI->getArgOperand(0), CI->getArgOperand(1), B, TLI,
LibFunc_ZnamSt11align_val_t12__hot_cold_t, HotCold);
break;
case LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t:
if (OptimizeExistingHotColdNew)
return emitHotColdNewAlignedNoThrow(
CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2), B,
TLI, LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t,
HotCold);
break;
case LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t:
return emitHotColdNewAlignedNoThrow(
CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2), B,
TLI, LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t, HotCold);
if (HotCold != NotColdNewHintValue)
return emitHotColdNewAlignedNoThrow(
CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2), B,
TLI, LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t,
HotCold);
break;
case LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t:
if (OptimizeExistingHotColdNew)
return emitHotColdNewAlignedNoThrow(
CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2), B,
TLI, LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t,
HotCold);
break;
case LibFunc_ZnamSt11align_val_tRKSt9nothrow_t:
return emitHotColdNewAlignedNoThrow(
CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2), B,
TLI, LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t, HotCold);
if (HotCold != NotColdNewHintValue)
return emitHotColdNewAlignedNoThrow(
CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2), B,
TLI, LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t,
HotCold);
break;
default:
return nullptr;
}
return nullptr;
}

//===----------------------------------------------------------------------===//
Expand Down Expand Up @@ -3675,6 +3760,14 @@ Value *LibCallSimplifier::optimizeStringMemoryLibCall(CallInst *CI,
case LibFunc_ZnamRKSt9nothrow_t:
case LibFunc_ZnamSt11align_val_t:
case LibFunc_ZnamSt11align_val_tRKSt9nothrow_t:
case LibFunc_Znwm12__hot_cold_t:
case LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t:
case LibFunc_ZnwmSt11align_val_t12__hot_cold_t:
case LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t:
case LibFunc_Znam12__hot_cold_t:
case LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t:
case LibFunc_ZnamSt11align_val_t12__hot_cold_t:
case LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t:
return optimizeNew(CI, Builder, Func);
default:
break;
Expand Down
176 changes: 173 additions & 3 deletions llvm/test/Transforms/InstCombine/simplify-libcalls-new.ll
View file
Original file line number Diff line number Diff line change
@@ -1,13 +1,19 @@
;; Test behavior of -optimize-hot-cold-new and related options.

;; Check that we don't get hot/cold new calls without enabling it explicitly.
; RUN: opt < %s -passes=instcombine -S | FileCheck %s --implicit-check-not=hot_cold_t
; RUN: opt < %s -passes=instcombine -S | FileCheck %s --check-prefix=OFF
; OFF-NOT: hot_cold_t
; OFF-LABEL: @new_hot_cold()

;; First check with the default cold and hot hint values (255 = -2).
; RUN: opt < %s -passes=instcombine -optimize-hot-cold-new -S | FileCheck %s --check-prefix=HOTCOLD -DCOLD=1 -DHOT=-2
; RUN: opt < %s -passes=instcombine -optimize-hot-cold-new -S | FileCheck %s --check-prefix=HOTCOLD -DCOLD=1 -DHOT=-2 -DPREVHINTCOLD=7 -DPREVHINTNOTCOLD=7 -DPREVHINTHOT=7

;; Next check with the non-default cold and hot hint values (200 =-56).
; RUN: opt < %s -passes=instcombine -optimize-hot-cold-new -cold-new-hint-value=5 -hot-new-hint-value=200 -S | FileCheck %s --check-prefix=HOTCOLD -DCOLD=5 -DHOT=-56
; RUN: opt < %s -passes=instcombine -optimize-hot-cold-new -cold-new-hint-value=5 -hot-new-hint-value=200 -S | FileCheck %s --check-prefix=HOTCOLD -DCOLD=5 -DHOT=-56 -DPREVHINTCOLD=7 -DPREVHINTNOTCOLD=7 -DPREVHINTHOT=7

;; Try again with the non-default cold and hot hint values (200 =-56), and this
;; time specify that existing hints should be updated.
; RUN: opt < %s -passes=instcombine -optimize-hot-cold-new -cold-new-hint-value=5 -notcold-new-hint-value=100 -hot-new-hint-value=200 -optimize-existing-hot-cold-new -S | FileCheck %s --check-prefix=HOTCOLD -DCOLD=5 -DHOT=-56 -DPREVHINTCOLD=5 -DPREVHINTNOTCOLD=100 -DPREVHINTHOT=-56

;; Make sure that values not in 0..255 are flagged with an error
; RUN: not opt < %s -passes=instcombine -optimize-hot-cold-new -cold-new-hint-value=256 -S 2>&1 | FileCheck %s --check-prefix=ERROR
Expand Down Expand Up @@ -178,6 +184,162 @@ define void @array_new_align_nothrow() {
ret void
}

;; Check that operator new(unsigned long, __hot_cold_t)
;; optionally has its hint updated.
; HOTCOLD-LABEL: @new_hot_cold()
define void @new_hot_cold() {
;; Attribute cold converted to __hot_cold_t cold value.
; HOTCOLD: @_Znwm12__hot_cold_t(i64 10, i8 [[PREVHINTCOLD]])
%call = call ptr @_Znwm12__hot_cold_t(i64 10, i8 7) #0
call void @dummy(ptr %call)
;; Attribute notcold converted to __hot_cold_t notcold value.
; HOTCOLD: @_Znwm12__hot_cold_t(i64 10, i8 [[PREVHINTNOTCOLD]])
%call1 = call ptr @_Znwm12__hot_cold_t(i64 10, i8 7) #1
call void @dummy(ptr %call1)
;; Attribute hot converted to __hot_cold_t hot value.
; HOTCOLD: @_Znwm12__hot_cold_t(i64 10, i8 [[PREVHINTHOT]])
%call2 = call ptr @_Znwm12__hot_cold_t(i64 10, i8 7) #2
call void @dummy(ptr %call2)
ret void
}

;; Check that operator new(unsigned long, std::align_val_t, __hot_cold_t)
;; optionally has its hint updated.
; HOTCOLD-LABEL: @new_align_hot_cold()
define void @new_align_hot_cold() {
;; Attribute cold converted to __hot_cold_t cold value.
; HOTCOLD: @_ZnwmSt11align_val_t12__hot_cold_t(i64 10, i64 8, i8 [[PREVHINTCOLD]])
%call = call ptr @_ZnwmSt11align_val_t12__hot_cold_t(i64 10, i64 8, i8 7) #0
call void @dummy(ptr %call)
;; Attribute notcold converted to __hot_cold_t notcold value.
; HOTCOLD: @_ZnwmSt11align_val_t12__hot_cold_t(i64 10, i64 8, i8 [[PREVHINTNOTCOLD]])
%call1 = call ptr @_ZnwmSt11align_val_t12__hot_cold_t(i64 10, i64 8, i8 7) #1
call void @dummy(ptr %call1)
;; Attribute hot converted to __hot_cold_t hot value.
; HOTCOLD: @_ZnwmSt11align_val_t12__hot_cold_t(i64 10, i64 8, i8 [[PREVHINTHOT]])
%call2 = call ptr @_ZnwmSt11align_val_t12__hot_cold_t(i64 10, i64 8, i8 7) #2
call void @dummy(ptr %call2)
ret void
}

;; Check that operator new(unsigned long, const std::nothrow_t&, __hot_cold_t)
;; optionally has its hint updated.
; HOTCOLD-LABEL: @new_nothrow_hot_cold()
define void @new_nothrow_hot_cold() {
%nt = alloca i8
;; Attribute cold converted to __hot_cold_t cold value.
; HOTCOLD: @_ZnwmRKSt9nothrow_t12__hot_cold_t(i64 10, ptr nonnull %nt, i8 [[PREVHINTCOLD]])
%call = call ptr @_ZnwmRKSt9nothrow_t12__hot_cold_t(i64 10, ptr %nt, i8 7) #0
call void @dummy(ptr %call)
;; Attribute notcold converted to __hot_cold_t notcold value.
; HOTCOLD: @_ZnwmRKSt9nothrow_t12__hot_cold_t(i64 10, ptr nonnull %nt, i8 [[PREVHINTNOTCOLD]])
%call1 = call ptr @_ZnwmRKSt9nothrow_t12__hot_cold_t(i64 10, ptr %nt, i8 7) #1
call void @dummy(ptr %call1)
;; Attribute hot converted to __hot_cold_t hot value.
; HOTCOLD: @_ZnwmRKSt9nothrow_t12__hot_cold_t(i64 10, ptr nonnull %nt, i8 [[PREVHINTHOT]])
%call2 = call ptr @_ZnwmRKSt9nothrow_t12__hot_cold_t(i64 10, ptr %nt, i8 7) #2
call void @dummy(ptr %call2)
ret void
}

;; Check that operator new(unsigned long, std::align_val_t, const std::nothrow_t&, __hot_cold_t)
;; optionally has its hint updated.
; HOTCOLD-LABEL: @new_align_nothrow_hot_cold()
define void @new_align_nothrow_hot_cold() {
%nt = alloca i8
;; Attribute cold converted to __hot_cold_t cold value.
; HOTCOLD: @_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t(i64 10, i64 8, ptr nonnull %nt, i8 [[PREVHINTCOLD]])
%call = call ptr @_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t(i64 10, i64 8, ptr %nt, i8 7) #0
call void @dummy(ptr %call)
;; Attribute notcold converted to __hot_cold_t notcold value.
; HOTCOLD: @_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t(i64 10, i64 8, ptr nonnull %nt, i8 [[PREVHINTNOTCOLD]])
%call1 = call ptr @_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t(i64 10, i64 8, ptr %nt, i8 7) #1
call void @dummy(ptr %call1)
;; Attribute hot converted to __hot_cold_t hot value.
; HOTCOLD: @_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t(i64 10, i64 8, ptr nonnull %nt, i8 [[PREVHINTHOT]])
%call2 = call ptr @_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t(i64 10, i64 8, ptr %nt, i8 7) #2
call void @dummy(ptr %call2)
ret void
}

;; Check that operator new[](unsigned long, __hot_cold_t)
;; optionally has its hint updated.
; HOTCOLD-LABEL: @array_new_hot_cold()
define void @array_new_hot_cold() {
;; Attribute cold converted to __hot_cold_t cold value.
; HOTCOLD: @_Znam12__hot_cold_t(i64 10, i8 [[PREVHINTCOLD]])
%call = call ptr @_Znam12__hot_cold_t(i64 10, i8 7) #0
call void @dummy(ptr %call)
;; Attribute notcold converted to __hot_cold_t notcold value.
; HOTCOLD: @_Znam12__hot_cold_t(i64 10, i8 [[PREVHINTNOTCOLD]])
%call1 = call ptr @_Znam12__hot_cold_t(i64 10, i8 7) #1
call void @dummy(ptr %call1)
;; Attribute hot converted to __hot_cold_t hot value.
; HOTCOLD: @_Znam12__hot_cold_t(i64 10, i8 [[PREVHINTHOT]])
%call2 = call ptr @_Znam12__hot_cold_t(i64 10, i8 7) #2
call void @dummy(ptr %call2)
ret void
}

;; Check that operator new[](unsigned long, std::align_val_t, __hot_cold_t)
;; optionally has its hint updated.
; HOTCOLD-LABEL: @array_new_align_hot_cold()
define void @array_new_align_hot_cold() {
;; Attribute cold converted to __hot_cold_t cold value.
; HOTCOLD: @_ZnamSt11align_val_t12__hot_cold_t(i64 10, i64 8, i8 [[PREVHINTCOLD]])
%call = call ptr @_ZnamSt11align_val_t12__hot_cold_t(i64 10, i64 8, i8 7) #0
call void @dummy(ptr %call)
;; Attribute notcold converted to __hot_cold_t notcold value.
; HOTCOLD: @_ZnamSt11align_val_t12__hot_cold_t(i64 10, i64 8, i8 [[PREVHINTNOTCOLD]])
%call1 = call ptr @_ZnamSt11align_val_t12__hot_cold_t(i64 10, i64 8, i8 7) #1
call void @dummy(ptr %call1)
;; Attribute hot converted to __hot_cold_t hot value.
; HOTCOLD: @_ZnamSt11align_val_t12__hot_cold_t(i64 10, i64 8, i8 [[PREVHINTHOT]])
%call2 = call ptr @_ZnamSt11align_val_t12__hot_cold_t(i64 10, i64 8, i8 7) #2
call void @dummy(ptr %call2)
ret void
}

;; Check that operator new[](unsigned long, const std::nothrow_t&, __hot_cold_t)
;; optionally has its hint updated.
; HOTCOLD-LABEL: @array_new_nothrow_hot_cold()
define void @array_new_nothrow_hot_cold() {
%nt = alloca i8
;; Attribute cold converted to __hot_cold_t cold value.
; HOTCOLD: @_ZnamRKSt9nothrow_t12__hot_cold_t(i64 10, ptr nonnull %nt, i8 [[PREVHINTCOLD]])
%call = call ptr @_ZnamRKSt9nothrow_t12__hot_cold_t(i64 10, ptr %nt, i8 7) #0
call void @dummy(ptr %call)
;; Attribute notcold converted to __hot_cold_t notcold value.
; HOTCOLD: @_ZnamRKSt9nothrow_t12__hot_cold_t(i64 10, ptr nonnull %nt, i8 [[PREVHINTNOTCOLD]])
%call1 = call ptr @_ZnamRKSt9nothrow_t12__hot_cold_t(i64 10, ptr %nt, i8 7) #1
call void @dummy(ptr %call1)
;; Attribute hot converted to __hot_cold_t hot value.
; HOTCOLD: @_ZnamRKSt9nothrow_t12__hot_cold_t(i64 10, ptr nonnull %nt, i8 [[PREVHINTHOT]])
%call2 = call ptr @_ZnamRKSt9nothrow_t12__hot_cold_t(i64 10, ptr %nt, i8 7) #2
call void @dummy(ptr %call2)
ret void
}

;; Check that operator new[](unsigned long, std::align_val_t, const std::nothrow_t&, __hot_cold_t)
;; optionally has its hint updated.
; HOTCOLD-LABEL: @array_new_align_nothrow_hot_cold()
define void @array_new_align_nothrow_hot_cold() {
%nt = alloca i8
;; Attribute cold converted to __hot_cold_t cold value.
; HOTCOLD: @_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t(i64 10, i64 8, ptr nonnull %nt, i8 [[PREVHINTCOLD]])
%call = call ptr @_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t(i64 10, i64 8, ptr %nt, i8 7) #0
call void @dummy(ptr %call)
;; Attribute notcold converted to __hot_cold_t notcold value.
; HOTCOLD: @_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t(i64 10, i64 8, ptr nonnull %nt, i8 [[PREVHINTNOTCOLD]])
%call1 = call ptr @_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t(i64 10, i64 8, ptr %nt, i8 7) #1
call void @dummy(ptr %call1)
;; Attribute hot converted to __hot_cold_t hot value.
; HOTCOLD: @_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t(i64 10, i64 8, ptr nonnull %nt, i8 [[PREVHINTHOT]])
%call2 = call ptr @_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t(i64 10, i64 8, ptr %nt, i8 7) #2
call void @dummy(ptr %call2)
ret void
}

;; So that instcombine doesn't optimize out the call.
declare void @dummy(ptr)

Expand All @@ -189,6 +351,14 @@ declare ptr @_Znam(i64)
declare ptr @_ZnamSt11align_val_t(i64, i64)
declare ptr @_ZnamRKSt9nothrow_t(i64, ptr)
declare ptr @_ZnamSt11align_val_tRKSt9nothrow_t(i64, i64, ptr)
declare ptr @_Znwm12__hot_cold_t(i64, i8)
declare ptr @_ZnwmSt11align_val_t12__hot_cold_t(i64, i64, i8)
declare ptr @_ZnwmRKSt9nothrow_t12__hot_cold_t(i64, ptr, i8)
declare ptr @_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t(i64, i64, ptr, i8)
declare ptr @_Znam12__hot_cold_t(i64, i8)
declare ptr @_ZnamSt11align_val_t12__hot_cold_t(i64, i64, i8)
declare ptr @_ZnamRKSt9nothrow_t12__hot_cold_t(i64, ptr, i8)
declare ptr @_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t(i64, i64, ptr, i8)

attributes #0 = { builtin allocsize(0) "memprof"="cold" }
attributes #1 = { builtin allocsize(0) "memprof"="notcold" }
Expand Down

0 comments on commit cec6665

Please sign in to comment.