[llvm-branch-commits] [clang] [compiler-rt] clang: also check alloc_align and assume_aligned claims in return (PR #239729)
Augie Fackler via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Mon Nov 16 11:47:54 PST 2026
https://github.com/durin42 updated https://github.com/llvm/llvm-project/pull/239729
>From 2b831b8e1c81271ee860f194e4367f8447fbef2d Mon Sep 17 00:00:00 2001
From: Augie Fackler <augie at google.com>
Date: Wed, 4 Nov 2026 13:04:36 -0500
Subject: [PATCH] clang: also check alloc_align and assume_aligned claims in
return
Prior to this patch, we only check alloc_align and assume_aligned claims
in the caller. We are about to thread alloc_align information down into
LLVM, which would then have a chance to defeat the sanitizer checks by
performing optimizations. To avoid that, we also check alignment claims
in the called function prior to return.
Per review feedback on D121629:
- Also verify the alignment required by `AssumeAlignedAttr` in
`EmitReturnValueCheck`.
- Add a new `ReturnAlignmentAssumption` (`return_alignment_assumption`)
sanitizer handler in clang and compiler-rt that accepts the dynamic
return statement `SourceLocation` pointer loaded from `ReturnLocation`.
- Only emit the sanitizer check (and not a redundant `llvm.assume`) in
`EmitReturnValueCheck`.
This patch is originally from 2023 and was rebased and revised with
assistance from an LLM. I have manually reviewed the diffs to the
limit of my abilities (I don't do much in LLVM, and this is my first
time touching clang in a meaningful way) and they appear sensible. The
commit messages are entirely written by me.
Differential Revision: https://reviews.llvm.org/D121629
---
clang/lib/CodeGen/CGCall.cpp | 23 ++++
clang/lib/CodeGen/CodeGenFunction.cpp | 69 +++++++++---
clang/lib/CodeGen/CodeGenFunction.h | 5 +
clang/lib/CodeGen/SanitizerHandler.h | 2 +
...ibute-alloc_align-on-function-variable.cpp | 105 +++++++++++++++---
...tion-attribute-alloc_align-on-function.cpp | 105 +++++++++++++++---
...-assume_aligned-on-function-two-params.cpp | 95 +++++++++++++---
...n-attribute-assume_aligned-on-function.cpp | 92 ++++++++++++---
compiler-rt/lib/ubsan/ubsan_handlers.cpp | 56 ++++++++--
compiler-rt/lib/ubsan/ubsan_handlers.h | 11 ++
.../lib/ubsan/ubsan_handlers_internal.h | 6 +
compiler-rt/lib/ubsan/ubsan_interface.inc | 2 +
.../ubsan_minimal/ubsan_minimal_handlers.cpp | 1 +
...ibute-alloc_align-on-function-variable.cpp | 5 +-
...sume-attribute-alloc_align-on-function.cpp | 5 +-
...-assume_aligned-on-function-two-params.cpp | 5 +-
...e-attribute-assume_aligned-on-function.cpp | 5 +-
17 files changed, 504 insertions(+), 88 deletions(-)
diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp
index c1041a3dfc41c6..02324187d2faf5 100644
--- a/clang/lib/CodeGen/CGCall.cpp
+++ b/clang/lib/CodeGen/CGCall.cpp
@@ -4641,6 +4641,29 @@ void CodeGenFunction::EmitReturnValueCheck(llvm::Value *RV) {
if (ReturnBlock.isValid() && ReturnBlock.getBlock()->use_empty())
return;
+ if (SanOpts.has(SanitizerKind::Alignment)) {
+ if (const AllocAlignAttr *AA = CurCodeDecl->getAttr<AllocAlignAttr>()) {
+ if (isa<FunctionDecl>(CurCodeDecl)) {
+ unsigned PI = AA->getParamIndex().getLLVMIndex();
+ llvm::Value *Alignment = CurFn->getArg(PI);
+ emitReturnAlignmentAssumptionCheck(RV, FnRetTy, AA->getLocation(),
+ Alignment);
+ }
+ }
+ if (const AssumeAlignedAttr *AA =
+ CurCodeDecl->getAttr<AssumeAlignedAttr>()) {
+ llvm::Value *Alignment = EmitScalarExpr(AA->getAlignment());
+ llvm::ConstantInt *OffsetCI = nullptr;
+ if (Expr *Offset = AA->getOffset()) {
+ OffsetCI = cast<llvm::ConstantInt>(EmitScalarExpr(Offset));
+ if (OffsetCI->isNullValue()) // Canonicalize zero offset to no offset.
+ OffsetCI = nullptr;
+ }
+ emitReturnAlignmentAssumptionCheck(RV, FnRetTy, AA->getLocation(),
+ Alignment, OffsetCI);
+ }
+ }
+
ReturnsNonNullAttr *RetNNAttr = nullptr;
if (SanOpts.has(SanitizerKind::ReturnsNonnullAttribute))
RetNNAttr = CurCodeDecl->getAttr<ReturnsNonNullAttr>();
diff --git a/clang/lib/CodeGen/CodeGenFunction.cpp b/clang/lib/CodeGen/CodeGenFunction.cpp
index bcb00eb3c75ca8..932225f167c6a1 100644
--- a/clang/lib/CodeGen/CodeGenFunction.cpp
+++ b/clang/lib/CodeGen/CodeGenFunction.cpp
@@ -698,7 +698,11 @@ void CodeGenFunction::markAsIgnoreThreadCheckingAtRuntime(llvm::Function *Fn) {
bool CodeGenFunction::requiresReturnValueCheck() const {
return requiresReturnValueNullabilityCheck() ||
(SanOpts.has(SanitizerKind::ReturnsNonnullAttribute) && CurCodeDecl &&
- CurCodeDecl->getAttr<ReturnsNonNullAttr>());
+ CurCodeDecl->getAttr<ReturnsNonNullAttr>()) ||
+ (SanOpts.has(SanitizerKind::Alignment) && CurCodeDecl &&
+ ((isa<FunctionDecl>(CurCodeDecl) &&
+ CurCodeDecl->getAttr<AllocAlignAttr>()) ||
+ CurCodeDecl->getAttr<AssumeAlignedAttr>()));
}
static bool matchesStlAllocatorFn(const Decl *D, const ASTContext &Ctx) {
@@ -3289,21 +3293,23 @@ void CodeGenFunction::EmitX86MultiVersionResolver(
EmitTrapCallAndMakeUnreachable();
}
-// Loc - where the diagnostic will point, where in the source code this
-// alignment has failed.
+// Loc / DynamicLoc - where the diagnostic will point, where in the source code
+// this alignment has failed.
// AssumptionLoc - if present (will be present if sufficiently different from
// Loc), the diagnostic will additionally point a "Note:" to this location.
// It should be the location where the __attribute__((assume_aligned))
// was written e.g.
-void CodeGenFunction::emitAlignmentAssumptionCheck(llvm::Value *Ptr,
- QualType Ty,
- SourceLocation Loc,
- SourceLocation AssumptionLoc,
- llvm::Value *Alignment,
- llvm::Value *OffsetValue) {
- if (!SanOpts.has(SanitizerKind::Alignment))
+static void emitAlignmentAssumptionCheck(CodeGenFunction &CGF, llvm::Value *Ptr,
+ QualType Ty, SourceLocation Loc,
+ llvm::Value *DynamicLoc,
+ SourceLocation AssumptionLoc,
+ llvm::Value *Alignment,
+ llvm::Value *OffsetValue) {
+ if (!CGF.SanOpts.has(SanitizerKind::Alignment))
return;
+ CGBuilderTy &Builder = CGF.Builder;
+ llvm::IntegerType *IntPtrTy = CGF.IntPtrTy;
if (Alignment->getType() != IntPtrTy)
Alignment =
Builder.CreateIntCast(Alignment, IntPtrTy, false, "casted.align");
@@ -3334,18 +3340,45 @@ void CodeGenFunction::emitAlignmentAssumptionCheck(llvm::Value *Ptr,
return;
auto CheckOrdinal = SanitizerKind::SO_Alignment;
- auto CheckHandler = SanitizerHandler::AlignmentAssumption;
- SanitizerDebugLocation SanScope(this, {CheckOrdinal}, CheckHandler);
+ auto CheckHandler = !DynamicLoc ? SanitizerHandler::AlignmentAssumption
+ : SanitizerHandler::ReturnAlignmentAssumption;
+ SanitizerDebugLocation SanScope(&CGF, {CheckOrdinal}, CheckHandler);
if (!OffsetValue)
OffsetValue = Builder.getInt1(false); // no offset.
- llvm::Constant *StaticData[] = {EmitCheckSourceLocation(Loc),
- EmitCheckSourceLocation(AssumptionLoc),
- EmitCheckTypeDescriptor(Ty)};
- llvm::Value *DynamicData[] = {Ptr, Alignment, OffsetValue};
- EmitCheck({std::make_pair(TheCheck, CheckOrdinal)}, CheckHandler, StaticData,
- DynamicData);
+ if (!DynamicLoc) {
+ llvm::Constant *StaticData[] = {CGF.EmitCheckSourceLocation(Loc),
+ CGF.EmitCheckSourceLocation(AssumptionLoc),
+ CGF.EmitCheckTypeDescriptor(Ty)};
+ llvm::Value *DynamicData[] = {Ptr, Alignment, OffsetValue};
+ CGF.EmitCheck({std::make_pair(TheCheck, CheckOrdinal)}, CheckHandler,
+ StaticData, DynamicData);
+ } else {
+ llvm::Constant *StaticData[] = {CGF.EmitCheckSourceLocation(AssumptionLoc),
+ CGF.EmitCheckTypeDescriptor(Ty)};
+ llvm::Value *DynamicData[] = {DynamicLoc, Ptr, Alignment, OffsetValue};
+ CGF.EmitCheck({std::make_pair(TheCheck, CheckOrdinal)}, CheckHandler,
+ StaticData, DynamicData);
+ }
+}
+
+void CodeGenFunction::emitAlignmentAssumptionCheck(llvm::Value *Ptr,
+ QualType Ty,
+ SourceLocation Loc,
+ SourceLocation AssumptionLoc,
+ llvm::Value *Alignment,
+ llvm::Value *OffsetValue) {
+ ::emitAlignmentAssumptionCheck(*this, Ptr, Ty, Loc, nullptr, AssumptionLoc,
+ Alignment, OffsetValue);
+}
+
+void CodeGenFunction::emitReturnAlignmentAssumptionCheck(
+ llvm::Value *Ptr, QualType Ty, SourceLocation AssumptionLoc,
+ llvm::Value *Alignment, llvm::Value *OffsetValue) {
+ llvm::Value *SLocPtr = Builder.CreateLoad(ReturnLocation, "return.sloc.load");
+ ::emitAlignmentAssumptionCheck(*this, Ptr, Ty, SourceLocation(), SLocPtr,
+ AssumptionLoc, Alignment, OffsetValue);
}
llvm::DebugLoc CodeGenFunction::SourceLocToDebugLoc(SourceLocation Location) {
diff --git a/clang/lib/CodeGen/CodeGenFunction.h b/clang/lib/CodeGen/CodeGenFunction.h
index 6afd94a4b16c74..c73cae01f15084 100644
--- a/clang/lib/CodeGen/CodeGenFunction.h
+++ b/clang/lib/CodeGen/CodeGenFunction.h
@@ -3709,6 +3709,11 @@ class CodeGenFunction : public CodeGenTypeCache {
llvm::Value *Alignment,
llvm::Value *OffsetValue = nullptr);
+ void emitReturnAlignmentAssumptionCheck(llvm::Value *Ptr, QualType Ty,
+ SourceLocation AssumptionLoc,
+ llvm::Value *Alignment,
+ llvm::Value *OffsetValue = nullptr);
+
void emitAlignmentAssumption(llvm::Value *PtrValue, QualType Ty,
SourceLocation Loc, SourceLocation AssumptionLoc,
llvm::Value *Alignment,
diff --git a/clang/lib/CodeGen/SanitizerHandler.h b/clang/lib/CodeGen/SanitizerHandler.h
index 871e17c22d3fa8..8e70839ca42ad2 100644
--- a/clang/lib/CodeGen/SanitizerHandler.h
+++ b/clang/lib/CodeGen/SanitizerHandler.h
@@ -70,6 +70,8 @@
SANITIZER_CHECK( \
VLABoundNotPositive, vla_bound_not_positive, 0, \
"Variable length array bound evaluates to non-positive value") \
+ SANITIZER_CHECK(ReturnAlignmentAssumption, return_alignment_assumption, 0, \
+ "Alignment assumption violated") \
SANITIZER_CHECK(BoundsSafety, bounds_safety, 0, \
"") // BoundsSafety Msg is empty because it is not considered
// part of UBSan; therefore, no trap reason is emitted for
diff --git a/clang/test/CodeGen/catch-alignment-assumption-attribute-alloc_align-on-function-variable.cpp b/clang/test/CodeGen/catch-alignment-assumption-attribute-alloc_align-on-function-variable.cpp
index 74ee5686098aac..5af71455a14243 100644
--- a/clang/test/CodeGen/catch-alignment-assumption-attribute-alloc_align-on-function-variable.cpp
+++ b/clang/test/CodeGen/catch-alignment-assumption-attribute-alloc_align-on-function-variable.cpp
@@ -6,15 +6,88 @@
char **__attribute__((alloc_align(2)))
-// CHECK-LABEL: define dso_local noundef ptr @_Z11passthroughPPcm
-// CHECK-SAME: (ptr noundef [[X:%.*]], i64 noundef [[ALIGNMENT:%.*]]) #[[ATTR0:[0-9]+]] {
-// CHECK-NEXT: entry:
-// CHECK-NEXT: [[X_ADDR:%.*]] = alloca ptr, align 8
-// CHECK-NEXT: [[ALIGNMENT_ADDR:%.*]] = alloca i64, align 8
-// CHECK-NEXT: store ptr [[X]], ptr [[X_ADDR]], align 8
-// CHECK-NEXT: store i64 [[ALIGNMENT]], ptr [[ALIGNMENT_ADDR]], align 8
-// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[X_ADDR]], align 8
-// CHECK-NEXT: ret ptr [[TMP0]]
+// CHECK-NOSANITIZE-LABEL: define dso_local noundef ptr @_Z11passthroughPPcm
+// CHECK-NOSANITIZE-SAME: (ptr noundef [[X:%.*]], i64 noundef [[ALIGNMENT:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-NOSANITIZE-NEXT: entry:
+// CHECK-NOSANITIZE-NEXT: [[X_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-NOSANITIZE-NEXT: [[ALIGNMENT_ADDR:%.*]] = alloca i64, align 8
+// CHECK-NOSANITIZE-NEXT: store ptr [[X]], ptr [[X_ADDR]], align 8
+// CHECK-NOSANITIZE-NEXT: store i64 [[ALIGNMENT]], ptr [[ALIGNMENT_ADDR]], align 8
+// CHECK-NOSANITIZE-NEXT: [[TMP0:%.*]] = load ptr, ptr [[X_ADDR]], align 8
+// CHECK-NOSANITIZE-NEXT: ret ptr [[TMP0]]
+//
+// CHECK-SANITIZE-NORECOVER-LABEL: define dso_local noundef ptr @_Z11passthroughPPcm
+// CHECK-SANITIZE-NORECOVER-SAME: (ptr noundef [[X:%.*]], i64 noundef [[ALIGNMENT:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-SANITIZE-NORECOVER-NEXT: entry:
+// CHECK-SANITIZE-NORECOVER-NEXT: [[RETURN_SLOC_PTR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: [[X_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: [[ALIGNMENT_ADDR:%.*]] = alloca i64, align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: store ptr null, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: store ptr [[X]], ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: store i64 [[ALIGNMENT]], ptr [[ALIGNMENT_ADDR]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: store ptr @[[GLOB0:[0-9]+]], ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: [[TMP0:%.*]] = load ptr, ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: [[RETURN_SLOC_LOAD:%.*]] = load ptr, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[TMP0]] to i64
+// CHECK-SANITIZE-NORECOVER-NEXT: [[TMP1:%.*]] = sub i64 [[ALIGNMENT]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], [[TMP1]]
+// CHECK-SANITIZE-NORECOVER-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_RETURN_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-NORECOVER: handler.return_alignment_assumption:
+// CHECK-SANITIZE-NORECOVER-NEXT: [[TMP2:%.*]] = ptrtoint ptr [[RETURN_SLOC_LOAD]] to i64, !nosanitize [[META2]]
+// CHECK-SANITIZE-NORECOVER-NEXT: [[TMP3:%.*]] = ptrtoint ptr [[TMP0]] to i64, !nosanitize [[META2]]
+// CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_return_alignment_assumption_abort(ptr @[[GLOB2:[0-9]+]], i64 [[TMP2]], i64 [[TMP3]], i64 [[ALIGNMENT]], i64 0) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-NORECOVER-NEXT: unreachable, !nosanitize [[META2]]
+// CHECK-SANITIZE-NORECOVER: cont:
+// CHECK-SANITIZE-NORECOVER-NEXT: ret ptr [[TMP0]]
+//
+// CHECK-SANITIZE-RECOVER-LABEL: define dso_local noundef ptr @_Z11passthroughPPcm
+// CHECK-SANITIZE-RECOVER-SAME: (ptr noundef [[X:%.*]], i64 noundef [[ALIGNMENT:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-SANITIZE-RECOVER-NEXT: entry:
+// CHECK-SANITIZE-RECOVER-NEXT: [[RETURN_SLOC_PTR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-RECOVER-NEXT: [[X_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-RECOVER-NEXT: [[ALIGNMENT_ADDR:%.*]] = alloca i64, align 8
+// CHECK-SANITIZE-RECOVER-NEXT: store ptr null, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-RECOVER-NEXT: store ptr [[X]], ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-RECOVER-NEXT: store i64 [[ALIGNMENT]], ptr [[ALIGNMENT_ADDR]], align 8
+// CHECK-SANITIZE-RECOVER-NEXT: store ptr @[[GLOB0:[0-9]+]], ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-RECOVER-NEXT: [[TMP0:%.*]] = load ptr, ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-RECOVER-NEXT: [[RETURN_SLOC_LOAD:%.*]] = load ptr, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-RECOVER-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[TMP0]] to i64
+// CHECK-SANITIZE-RECOVER-NEXT: [[TMP1:%.*]] = sub i64 [[ALIGNMENT]], 1
+// CHECK-SANITIZE-RECOVER-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], [[TMP1]]
+// CHECK-SANITIZE-RECOVER-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
+// CHECK-SANITIZE-RECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_RETURN_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-RECOVER: handler.return_alignment_assumption:
+// CHECK-SANITIZE-RECOVER-NEXT: [[TMP2:%.*]] = ptrtoint ptr [[RETURN_SLOC_LOAD]] to i64, !nosanitize [[META2]]
+// CHECK-SANITIZE-RECOVER-NEXT: [[TMP3:%.*]] = ptrtoint ptr [[TMP0]] to i64, !nosanitize [[META2]]
+// CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_return_alignment_assumption(ptr @[[GLOB2:[0-9]+]], i64 [[TMP2]], i64 [[TMP3]], i64 [[ALIGNMENT]], i64 0) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-RECOVER-NEXT: br label [[CONT]], !nosanitize [[META2]]
+// CHECK-SANITIZE-RECOVER: cont:
+// CHECK-SANITIZE-RECOVER-NEXT: ret ptr [[TMP0]]
+//
+// CHECK-SANITIZE-TRAP-LABEL: define dso_local noundef ptr @_Z11passthroughPPcm
+// CHECK-SANITIZE-TRAP-SAME: (ptr noundef [[X:%.*]], i64 noundef [[ALIGNMENT:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-SANITIZE-TRAP-NEXT: entry:
+// CHECK-SANITIZE-TRAP-NEXT: [[RETURN_SLOC_PTR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-TRAP-NEXT: [[X_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-TRAP-NEXT: [[ALIGNMENT_ADDR:%.*]] = alloca i64, align 8
+// CHECK-SANITIZE-TRAP-NEXT: store ptr null, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-TRAP-NEXT: store ptr [[X]], ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-TRAP-NEXT: store i64 [[ALIGNMENT]], ptr [[ALIGNMENT_ADDR]], align 8
+// CHECK-SANITIZE-TRAP-NEXT: store ptr @[[GLOB0:[0-9]+]], ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-TRAP-NEXT: [[TMP0:%.*]] = load ptr, ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-TRAP-NEXT: [[RETURN_SLOC_LOAD:%.*]] = load ptr, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-TRAP-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[TMP0]] to i64
+// CHECK-SANITIZE-TRAP-NEXT: [[TMP1:%.*]] = sub i64 [[ALIGNMENT]], 1
+// CHECK-SANITIZE-TRAP-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], [[TMP1]]
+// CHECK-SANITIZE-TRAP-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
+// CHECK-SANITIZE-TRAP-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[TRAP:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-TRAP: trap:
+// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 25) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-TRAP-NEXT: unreachable, !nosanitize [[META2]]
+// CHECK-SANITIZE-TRAP: cont:
+// CHECK-SANITIZE-TRAP-NEXT: ret ptr [[TMP0]]
//
passthrough(char **x, unsigned long alignment) {
return x;
@@ -47,10 +120,10 @@ passthrough(char **x, unsigned long alignment) {
// CHECK-SANITIZE-NORECOVER-NEXT: [[TMP2:%.*]] = sub i64 [[TMP1]], 1
// CHECK-SANITIZE-NORECOVER-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], [[TMP2]]
// CHECK-SANITIZE-NORECOVER-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
-// CHECK-SANITIZE-NORECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-NORECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1]], !nosanitize [[META2]]
// CHECK-SANITIZE-NORECOVER: handler.alignment_assumption:
// CHECK-SANITIZE-NORECOVER-NEXT: [[TMP3:%.*]] = ptrtoint ptr [[CALL]] to i64, !nosanitize [[META2]]
-// CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(ptr @[[GLOB1:[0-9]+]], i64 [[TMP3]], i64 [[TMP1]], i64 0) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(ptr @[[GLOB3:[0-9]+]], i64 [[TMP3]], i64 [[TMP1]], i64 0) #[[ATTR3]], !nosanitize [[META2]]
// CHECK-SANITIZE-NORECOVER-NEXT: unreachable, !nosanitize [[META2]]
// CHECK-SANITIZE-NORECOVER: cont:
// CHECK-SANITIZE-NORECOVER-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[CALL]], i64 [[TMP1]]) ]
@@ -70,10 +143,10 @@ passthrough(char **x, unsigned long alignment) {
// CHECK-SANITIZE-RECOVER-NEXT: [[TMP2:%.*]] = sub i64 [[TMP1]], 1
// CHECK-SANITIZE-RECOVER-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], [[TMP2]]
// CHECK-SANITIZE-RECOVER-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
-// CHECK-SANITIZE-RECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-RECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1]], !nosanitize [[META2]]
// CHECK-SANITIZE-RECOVER: handler.alignment_assumption:
// CHECK-SANITIZE-RECOVER-NEXT: [[TMP3:%.*]] = ptrtoint ptr [[CALL]] to i64, !nosanitize [[META2]]
-// CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(ptr @[[GLOB1:[0-9]+]], i64 [[TMP3]], i64 [[TMP1]], i64 0) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(ptr @[[GLOB3:[0-9]+]], i64 [[TMP3]], i64 [[TMP1]], i64 0) #[[ATTR3]], !nosanitize [[META2]]
// CHECK-SANITIZE-RECOVER-NEXT: br label [[CONT]], !nosanitize [[META2]]
// CHECK-SANITIZE-RECOVER: cont:
// CHECK-SANITIZE-RECOVER-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[CALL]], i64 [[TMP1]]) ]
@@ -93,9 +166,9 @@ passthrough(char **x, unsigned long alignment) {
// CHECK-SANITIZE-TRAP-NEXT: [[TMP2:%.*]] = sub i64 [[TMP1]], 1
// CHECK-SANITIZE-TRAP-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], [[TMP2]]
// CHECK-SANITIZE-TRAP-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
-// CHECK-SANITIZE-TRAP-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[TRAP:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-TRAP-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[TRAP:%.*]], !prof [[PROF1]], !nosanitize [[META2]]
// CHECK-SANITIZE-TRAP: trap:
-// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 23) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 23) #[[ATTR3]], !nosanitize [[META2]]
// CHECK-SANITIZE-TRAP-NEXT: unreachable, !nosanitize [[META2]]
// CHECK-SANITIZE-TRAP: cont:
// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[CALL]], i64 [[TMP1]]) ]
@@ -105,3 +178,5 @@ char **caller(char **x, unsigned long alignment) {
#line 100
return passthrough(x, alignment);
}
+//// NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+// CHECK: {{.*}}
diff --git a/clang/test/CodeGen/catch-alignment-assumption-attribute-alloc_align-on-function.cpp b/clang/test/CodeGen/catch-alignment-assumption-attribute-alloc_align-on-function.cpp
index c031d25ac8f5f5..8fb70505eb573b 100644
--- a/clang/test/CodeGen/catch-alignment-assumption-attribute-alloc_align-on-function.cpp
+++ b/clang/test/CodeGen/catch-alignment-assumption-attribute-alloc_align-on-function.cpp
@@ -6,15 +6,88 @@
char **__attribute__((alloc_align(2)))
-// CHECK-LABEL: define dso_local noundef ptr @_Z11passthroughPPcm
-// CHECK-SAME: (ptr noundef [[X:%.*]], i64 noundef [[ALIGNMENT:%.*]]) #[[ATTR0:[0-9]+]] {
-// CHECK-NEXT: entry:
-// CHECK-NEXT: [[X_ADDR:%.*]] = alloca ptr, align 8
-// CHECK-NEXT: [[ALIGNMENT_ADDR:%.*]] = alloca i64, align 8
-// CHECK-NEXT: store ptr [[X]], ptr [[X_ADDR]], align 8
-// CHECK-NEXT: store i64 [[ALIGNMENT]], ptr [[ALIGNMENT_ADDR]], align 8
-// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[X_ADDR]], align 8
-// CHECK-NEXT: ret ptr [[TMP0]]
+// CHECK-NOSANITIZE-LABEL: define dso_local noundef ptr @_Z11passthroughPPcm
+// CHECK-NOSANITIZE-SAME: (ptr noundef [[X:%.*]], i64 noundef [[ALIGNMENT:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-NOSANITIZE-NEXT: entry:
+// CHECK-NOSANITIZE-NEXT: [[X_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-NOSANITIZE-NEXT: [[ALIGNMENT_ADDR:%.*]] = alloca i64, align 8
+// CHECK-NOSANITIZE-NEXT: store ptr [[X]], ptr [[X_ADDR]], align 8
+// CHECK-NOSANITIZE-NEXT: store i64 [[ALIGNMENT]], ptr [[ALIGNMENT_ADDR]], align 8
+// CHECK-NOSANITIZE-NEXT: [[TMP0:%.*]] = load ptr, ptr [[X_ADDR]], align 8
+// CHECK-NOSANITIZE-NEXT: ret ptr [[TMP0]]
+//
+// CHECK-SANITIZE-NORECOVER-LABEL: define dso_local noundef ptr @_Z11passthroughPPcm
+// CHECK-SANITIZE-NORECOVER-SAME: (ptr noundef [[X:%.*]], i64 noundef [[ALIGNMENT:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-SANITIZE-NORECOVER-NEXT: entry:
+// CHECK-SANITIZE-NORECOVER-NEXT: [[RETURN_SLOC_PTR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: [[X_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: [[ALIGNMENT_ADDR:%.*]] = alloca i64, align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: store ptr null, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: store ptr [[X]], ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: store i64 [[ALIGNMENT]], ptr [[ALIGNMENT_ADDR]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: store ptr @[[GLOB0:[0-9]+]], ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: [[TMP0:%.*]] = load ptr, ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: [[RETURN_SLOC_LOAD:%.*]] = load ptr, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[TMP0]] to i64
+// CHECK-SANITIZE-NORECOVER-NEXT: [[TMP1:%.*]] = sub i64 [[ALIGNMENT]], 1
+// CHECK-SANITIZE-NORECOVER-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], [[TMP1]]
+// CHECK-SANITIZE-NORECOVER-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_RETURN_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-NORECOVER: handler.return_alignment_assumption:
+// CHECK-SANITIZE-NORECOVER-NEXT: [[TMP2:%.*]] = ptrtoint ptr [[RETURN_SLOC_LOAD]] to i64, !nosanitize [[META2]]
+// CHECK-SANITIZE-NORECOVER-NEXT: [[TMP3:%.*]] = ptrtoint ptr [[TMP0]] to i64, !nosanitize [[META2]]
+// CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_return_alignment_assumption_abort(ptr @[[GLOB2:[0-9]+]], i64 [[TMP2]], i64 [[TMP3]], i64 [[ALIGNMENT]], i64 0) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-NORECOVER-NEXT: unreachable, !nosanitize [[META2]]
+// CHECK-SANITIZE-NORECOVER: cont:
+// CHECK-SANITIZE-NORECOVER-NEXT: ret ptr [[TMP0]]
+//
+// CHECK-SANITIZE-RECOVER-LABEL: define dso_local noundef ptr @_Z11passthroughPPcm
+// CHECK-SANITIZE-RECOVER-SAME: (ptr noundef [[X:%.*]], i64 noundef [[ALIGNMENT:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-SANITIZE-RECOVER-NEXT: entry:
+// CHECK-SANITIZE-RECOVER-NEXT: [[RETURN_SLOC_PTR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-RECOVER-NEXT: [[X_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-RECOVER-NEXT: [[ALIGNMENT_ADDR:%.*]] = alloca i64, align 8
+// CHECK-SANITIZE-RECOVER-NEXT: store ptr null, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-RECOVER-NEXT: store ptr [[X]], ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-RECOVER-NEXT: store i64 [[ALIGNMENT]], ptr [[ALIGNMENT_ADDR]], align 8
+// CHECK-SANITIZE-RECOVER-NEXT: store ptr @[[GLOB0:[0-9]+]], ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-RECOVER-NEXT: [[TMP0:%.*]] = load ptr, ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-RECOVER-NEXT: [[RETURN_SLOC_LOAD:%.*]] = load ptr, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-RECOVER-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[TMP0]] to i64
+// CHECK-SANITIZE-RECOVER-NEXT: [[TMP1:%.*]] = sub i64 [[ALIGNMENT]], 1
+// CHECK-SANITIZE-RECOVER-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], [[TMP1]]
+// CHECK-SANITIZE-RECOVER-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
+// CHECK-SANITIZE-RECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_RETURN_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-RECOVER: handler.return_alignment_assumption:
+// CHECK-SANITIZE-RECOVER-NEXT: [[TMP2:%.*]] = ptrtoint ptr [[RETURN_SLOC_LOAD]] to i64, !nosanitize [[META2]]
+// CHECK-SANITIZE-RECOVER-NEXT: [[TMP3:%.*]] = ptrtoint ptr [[TMP0]] to i64, !nosanitize [[META2]]
+// CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_return_alignment_assumption(ptr @[[GLOB2:[0-9]+]], i64 [[TMP2]], i64 [[TMP3]], i64 [[ALIGNMENT]], i64 0) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-RECOVER-NEXT: br label [[CONT]], !nosanitize [[META2]]
+// CHECK-SANITIZE-RECOVER: cont:
+// CHECK-SANITIZE-RECOVER-NEXT: ret ptr [[TMP0]]
+//
+// CHECK-SANITIZE-TRAP-LABEL: define dso_local noundef ptr @_Z11passthroughPPcm
+// CHECK-SANITIZE-TRAP-SAME: (ptr noundef [[X:%.*]], i64 noundef [[ALIGNMENT:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-SANITIZE-TRAP-NEXT: entry:
+// CHECK-SANITIZE-TRAP-NEXT: [[RETURN_SLOC_PTR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-TRAP-NEXT: [[X_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-TRAP-NEXT: [[ALIGNMENT_ADDR:%.*]] = alloca i64, align 8
+// CHECK-SANITIZE-TRAP-NEXT: store ptr null, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-TRAP-NEXT: store ptr [[X]], ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-TRAP-NEXT: store i64 [[ALIGNMENT]], ptr [[ALIGNMENT_ADDR]], align 8
+// CHECK-SANITIZE-TRAP-NEXT: store ptr @[[GLOB0:[0-9]+]], ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-TRAP-NEXT: [[TMP0:%.*]] = load ptr, ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-TRAP-NEXT: [[RETURN_SLOC_LOAD:%.*]] = load ptr, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-TRAP-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[TMP0]] to i64
+// CHECK-SANITIZE-TRAP-NEXT: [[TMP1:%.*]] = sub i64 [[ALIGNMENT]], 1
+// CHECK-SANITIZE-TRAP-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], [[TMP1]]
+// CHECK-SANITIZE-TRAP-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
+// CHECK-SANITIZE-TRAP-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[TRAP:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-TRAP: trap:
+// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 25) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-TRAP-NEXT: unreachable, !nosanitize [[META2]]
+// CHECK-SANITIZE-TRAP: cont:
+// CHECK-SANITIZE-TRAP-NEXT: ret ptr [[TMP0]]
//
passthrough(char **x, unsigned long alignment) {
return x;
@@ -39,10 +112,10 @@ passthrough(char **x, unsigned long alignment) {
// CHECK-SANITIZE-NORECOVER-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[CALL]] to i64
// CHECK-SANITIZE-NORECOVER-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 127
// CHECK-SANITIZE-NORECOVER-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
-// CHECK-SANITIZE-NORECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-NORECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1]], !nosanitize [[META2]]
// CHECK-SANITIZE-NORECOVER: handler.alignment_assumption:
// CHECK-SANITIZE-NORECOVER-NEXT: [[TMP1:%.*]] = ptrtoint ptr [[CALL]] to i64, !nosanitize [[META2]]
-// CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(ptr @[[GLOB1:[0-9]+]], i64 [[TMP1]], i64 128, i64 0) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(ptr @[[GLOB3:[0-9]+]], i64 [[TMP1]], i64 128, i64 0) #[[ATTR3]], !nosanitize [[META2]]
// CHECK-SANITIZE-NORECOVER-NEXT: unreachable, !nosanitize [[META2]]
// CHECK-SANITIZE-NORECOVER: cont:
// CHECK-SANITIZE-NORECOVER-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[CALL]], i64 128) ]
@@ -58,10 +131,10 @@ passthrough(char **x, unsigned long alignment) {
// CHECK-SANITIZE-RECOVER-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[CALL]] to i64
// CHECK-SANITIZE-RECOVER-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 127
// CHECK-SANITIZE-RECOVER-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
-// CHECK-SANITIZE-RECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-RECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1]], !nosanitize [[META2]]
// CHECK-SANITIZE-RECOVER: handler.alignment_assumption:
// CHECK-SANITIZE-RECOVER-NEXT: [[TMP1:%.*]] = ptrtoint ptr [[CALL]] to i64, !nosanitize [[META2]]
-// CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(ptr @[[GLOB1:[0-9]+]], i64 [[TMP1]], i64 128, i64 0) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(ptr @[[GLOB3:[0-9]+]], i64 [[TMP1]], i64 128, i64 0) #[[ATTR3]], !nosanitize [[META2]]
// CHECK-SANITIZE-RECOVER-NEXT: br label [[CONT]], !nosanitize [[META2]]
// CHECK-SANITIZE-RECOVER: cont:
// CHECK-SANITIZE-RECOVER-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[CALL]], i64 128) ]
@@ -77,9 +150,9 @@ passthrough(char **x, unsigned long alignment) {
// CHECK-SANITIZE-TRAP-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[CALL]] to i64
// CHECK-SANITIZE-TRAP-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 127
// CHECK-SANITIZE-TRAP-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
-// CHECK-SANITIZE-TRAP-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[TRAP:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-TRAP-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[TRAP:%.*]], !prof [[PROF1]], !nosanitize [[META2]]
// CHECK-SANITIZE-TRAP: trap:
-// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 23) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 23) #[[ATTR3]], !nosanitize [[META2]]
// CHECK-SANITIZE-TRAP-NEXT: unreachable, !nosanitize [[META2]]
// CHECK-SANITIZE-TRAP: cont:
// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[CALL]], i64 128) ]
@@ -89,3 +162,5 @@ char **caller(char **x) {
#line 100
return passthrough(x, 128);
}
+//// NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+// CHECK: {{.*}}
diff --git a/clang/test/CodeGen/catch-alignment-assumption-attribute-assume_aligned-on-function-two-params.cpp b/clang/test/CodeGen/catch-alignment-assumption-attribute-assume_aligned-on-function-two-params.cpp
index b2d59a4a340a19..396c4c78ab930d 100644
--- a/clang/test/CodeGen/catch-alignment-assumption-attribute-assume_aligned-on-function-two-params.cpp
+++ b/clang/test/CodeGen/catch-alignment-assumption-attribute-assume_aligned-on-function-two-params.cpp
@@ -6,13 +6,80 @@
char **__attribute__((assume_aligned(0x100000000, 42)))
-// CHECK-LABEL: define dso_local noundef ptr @_Z11passthroughPPc
-// CHECK-SAME: (ptr noundef [[X:%.*]]) #[[ATTR0:[0-9]+]] {
-// CHECK-NEXT: entry:
-// CHECK-NEXT: [[X_ADDR:%.*]] = alloca ptr, align 8
-// CHECK-NEXT: store ptr [[X]], ptr [[X_ADDR]], align 8
-// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[X_ADDR]], align 8
-// CHECK-NEXT: ret ptr [[TMP0]]
+// CHECK-NOSANITIZE-LABEL: define dso_local noundef ptr @_Z11passthroughPPc
+// CHECK-NOSANITIZE-SAME: (ptr noundef [[X:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-NOSANITIZE-NEXT: entry:
+// CHECK-NOSANITIZE-NEXT: [[X_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-NOSANITIZE-NEXT: store ptr [[X]], ptr [[X_ADDR]], align 8
+// CHECK-NOSANITIZE-NEXT: [[TMP0:%.*]] = load ptr, ptr [[X_ADDR]], align 8
+// CHECK-NOSANITIZE-NEXT: ret ptr [[TMP0]]
+//
+// CHECK-SANITIZE-NORECOVER-LABEL: define dso_local noundef ptr @_Z11passthroughPPc
+// CHECK-SANITIZE-NORECOVER-SAME: (ptr noundef [[X:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-SANITIZE-NORECOVER-NEXT: entry:
+// CHECK-SANITIZE-NORECOVER-NEXT: [[RETURN_SLOC_PTR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: [[X_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: store ptr null, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: store ptr [[X]], ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: store ptr @[[GLOB0:[0-9]+]], ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: [[TMP0:%.*]] = load ptr, ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: [[RETURN_SLOC_LOAD:%.*]] = load ptr, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[TMP0]] to i64
+// CHECK-SANITIZE-NORECOVER-NEXT: [[OFFSETPTR:%.*]] = sub i64 [[PTRINT]], 42
+// CHECK-SANITIZE-NORECOVER-NEXT: [[MASKEDPTR:%.*]] = and i64 [[OFFSETPTR]], 4294967295
+// CHECK-SANITIZE-NORECOVER-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_RETURN_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-NORECOVER: handler.return_alignment_assumption:
+// CHECK-SANITIZE-NORECOVER-NEXT: [[TMP1:%.*]] = ptrtoint ptr [[RETURN_SLOC_LOAD]] to i64, !nosanitize [[META2]]
+// CHECK-SANITIZE-NORECOVER-NEXT: [[TMP2:%.*]] = ptrtoint ptr [[TMP0]] to i64, !nosanitize [[META2]]
+// CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_return_alignment_assumption_abort(ptr @[[GLOB2:[0-9]+]], i64 [[TMP1]], i64 [[TMP2]], i64 4294967296, i64 42) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-NORECOVER-NEXT: unreachable, !nosanitize [[META2]]
+// CHECK-SANITIZE-NORECOVER: cont:
+// CHECK-SANITIZE-NORECOVER-NEXT: ret ptr [[TMP0]]
+//
+// CHECK-SANITIZE-RECOVER-LABEL: define dso_local noundef ptr @_Z11passthroughPPc
+// CHECK-SANITIZE-RECOVER-SAME: (ptr noundef [[X:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-SANITIZE-RECOVER-NEXT: entry:
+// CHECK-SANITIZE-RECOVER-NEXT: [[RETURN_SLOC_PTR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-RECOVER-NEXT: [[X_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-RECOVER-NEXT: store ptr null, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-RECOVER-NEXT: store ptr [[X]], ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-RECOVER-NEXT: store ptr @[[GLOB0:[0-9]+]], ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-RECOVER-NEXT: [[TMP0:%.*]] = load ptr, ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-RECOVER-NEXT: [[RETURN_SLOC_LOAD:%.*]] = load ptr, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-RECOVER-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[TMP0]] to i64
+// CHECK-SANITIZE-RECOVER-NEXT: [[OFFSETPTR:%.*]] = sub i64 [[PTRINT]], 42
+// CHECK-SANITIZE-RECOVER-NEXT: [[MASKEDPTR:%.*]] = and i64 [[OFFSETPTR]], 4294967295
+// CHECK-SANITIZE-RECOVER-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
+// CHECK-SANITIZE-RECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_RETURN_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-RECOVER: handler.return_alignment_assumption:
+// CHECK-SANITIZE-RECOVER-NEXT: [[TMP1:%.*]] = ptrtoint ptr [[RETURN_SLOC_LOAD]] to i64, !nosanitize [[META2]]
+// CHECK-SANITIZE-RECOVER-NEXT: [[TMP2:%.*]] = ptrtoint ptr [[TMP0]] to i64, !nosanitize [[META2]]
+// CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_return_alignment_assumption(ptr @[[GLOB2:[0-9]+]], i64 [[TMP1]], i64 [[TMP2]], i64 4294967296, i64 42) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-RECOVER-NEXT: br label [[CONT]], !nosanitize [[META2]]
+// CHECK-SANITIZE-RECOVER: cont:
+// CHECK-SANITIZE-RECOVER-NEXT: ret ptr [[TMP0]]
+//
+// CHECK-SANITIZE-TRAP-LABEL: define dso_local noundef ptr @_Z11passthroughPPc
+// CHECK-SANITIZE-TRAP-SAME: (ptr noundef [[X:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-SANITIZE-TRAP-NEXT: entry:
+// CHECK-SANITIZE-TRAP-NEXT: [[RETURN_SLOC_PTR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-TRAP-NEXT: [[X_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-TRAP-NEXT: store ptr null, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-TRAP-NEXT: store ptr [[X]], ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-TRAP-NEXT: store ptr @[[GLOB0:[0-9]+]], ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-TRAP-NEXT: [[TMP0:%.*]] = load ptr, ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-TRAP-NEXT: [[RETURN_SLOC_LOAD:%.*]] = load ptr, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-TRAP-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[TMP0]] to i64
+// CHECK-SANITIZE-TRAP-NEXT: [[OFFSETPTR:%.*]] = sub i64 [[PTRINT]], 42
+// CHECK-SANITIZE-TRAP-NEXT: [[MASKEDPTR:%.*]] = and i64 [[OFFSETPTR]], 4294967295
+// CHECK-SANITIZE-TRAP-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
+// CHECK-SANITIZE-TRAP-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[TRAP:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-TRAP: trap:
+// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 25) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-TRAP-NEXT: unreachable, !nosanitize [[META2]]
+// CHECK-SANITIZE-TRAP: cont:
+// CHECK-SANITIZE-TRAP-NEXT: ret ptr [[TMP0]]
//
passthrough(char **x) {
return x;
@@ -39,10 +106,10 @@ passthrough(char **x) {
// CHECK-SANITIZE-NORECOVER-NEXT: [[OFFSETPTR:%.*]] = sub i64 [[PTRINT]], 42
// CHECK-SANITIZE-NORECOVER-NEXT: [[MASKEDPTR:%.*]] = and i64 [[OFFSETPTR]], 4294967295
// CHECK-SANITIZE-NORECOVER-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
-// CHECK-SANITIZE-NORECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-NORECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1]], !nosanitize [[META2]]
// CHECK-SANITIZE-NORECOVER: handler.alignment_assumption:
// CHECK-SANITIZE-NORECOVER-NEXT: [[TMP1:%.*]] = ptrtoint ptr [[CALL]] to i64, !nosanitize [[META2]]
-// CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(ptr @[[GLOB1:[0-9]+]], i64 [[TMP1]], i64 4294967296, i64 42) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(ptr @[[GLOB3:[0-9]+]], i64 [[TMP1]], i64 4294967296, i64 42) #[[ATTR3]], !nosanitize [[META2]]
// CHECK-SANITIZE-NORECOVER-NEXT: unreachable, !nosanitize [[META2]]
// CHECK-SANITIZE-NORECOVER: cont:
// CHECK-SANITIZE-NORECOVER-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[CALL]], i64 4294967296, i64 42) ]
@@ -59,10 +126,10 @@ passthrough(char **x) {
// CHECK-SANITIZE-RECOVER-NEXT: [[OFFSETPTR:%.*]] = sub i64 [[PTRINT]], 42
// CHECK-SANITIZE-RECOVER-NEXT: [[MASKEDPTR:%.*]] = and i64 [[OFFSETPTR]], 4294967295
// CHECK-SANITIZE-RECOVER-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
-// CHECK-SANITIZE-RECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-RECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1]], !nosanitize [[META2]]
// CHECK-SANITIZE-RECOVER: handler.alignment_assumption:
// CHECK-SANITIZE-RECOVER-NEXT: [[TMP1:%.*]] = ptrtoint ptr [[CALL]] to i64, !nosanitize [[META2]]
-// CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(ptr @[[GLOB1:[0-9]+]], i64 [[TMP1]], i64 4294967296, i64 42) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(ptr @[[GLOB3:[0-9]+]], i64 [[TMP1]], i64 4294967296, i64 42) #[[ATTR3]], !nosanitize [[META2]]
// CHECK-SANITIZE-RECOVER-NEXT: br label [[CONT]], !nosanitize [[META2]]
// CHECK-SANITIZE-RECOVER: cont:
// CHECK-SANITIZE-RECOVER-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[CALL]], i64 4294967296, i64 42) ]
@@ -79,9 +146,9 @@ passthrough(char **x) {
// CHECK-SANITIZE-TRAP-NEXT: [[OFFSETPTR:%.*]] = sub i64 [[PTRINT]], 42
// CHECK-SANITIZE-TRAP-NEXT: [[MASKEDPTR:%.*]] = and i64 [[OFFSETPTR]], 4294967295
// CHECK-SANITIZE-TRAP-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
-// CHECK-SANITIZE-TRAP-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[TRAP:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-TRAP-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[TRAP:%.*]], !prof [[PROF1]], !nosanitize [[META2]]
// CHECK-SANITIZE-TRAP: trap:
-// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 23) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 23) #[[ATTR3]], !nosanitize [[META2]]
// CHECK-SANITIZE-TRAP-NEXT: unreachable, !nosanitize [[META2]]
// CHECK-SANITIZE-TRAP: cont:
// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[CALL]], i64 4294967296, i64 42) ]
@@ -91,3 +158,5 @@ char **caller(char **x) {
#line 100
return passthrough(x);
}
+//// NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+// CHECK: {{.*}}
diff --git a/clang/test/CodeGen/catch-alignment-assumption-attribute-assume_aligned-on-function.cpp b/clang/test/CodeGen/catch-alignment-assumption-attribute-assume_aligned-on-function.cpp
index 0c2be21dfd1787..27a2447af7c9e8 100644
--- a/clang/test/CodeGen/catch-alignment-assumption-attribute-assume_aligned-on-function.cpp
+++ b/clang/test/CodeGen/catch-alignment-assumption-attribute-assume_aligned-on-function.cpp
@@ -6,13 +6,77 @@
char **__attribute__((assume_aligned(128)))
-// CHECK-LABEL: define dso_local noundef ptr @_Z11passthroughPPc
-// CHECK-SAME: (ptr noundef [[X:%.*]]) #[[ATTR0:[0-9]+]] {
-// CHECK-NEXT: entry:
-// CHECK-NEXT: [[X_ADDR:%.*]] = alloca ptr, align 8
-// CHECK-NEXT: store ptr [[X]], ptr [[X_ADDR]], align 8
-// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[X_ADDR]], align 8
-// CHECK-NEXT: ret ptr [[TMP0]]
+// CHECK-NOSANITIZE-LABEL: define dso_local noundef ptr @_Z11passthroughPPc
+// CHECK-NOSANITIZE-SAME: (ptr noundef [[X:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-NOSANITIZE-NEXT: entry:
+// CHECK-NOSANITIZE-NEXT: [[X_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-NOSANITIZE-NEXT: store ptr [[X]], ptr [[X_ADDR]], align 8
+// CHECK-NOSANITIZE-NEXT: [[TMP0:%.*]] = load ptr, ptr [[X_ADDR]], align 8
+// CHECK-NOSANITIZE-NEXT: ret ptr [[TMP0]]
+//
+// CHECK-SANITIZE-NORECOVER-LABEL: define dso_local noundef ptr @_Z11passthroughPPc
+// CHECK-SANITIZE-NORECOVER-SAME: (ptr noundef [[X:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-SANITIZE-NORECOVER-NEXT: entry:
+// CHECK-SANITIZE-NORECOVER-NEXT: [[RETURN_SLOC_PTR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: [[X_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: store ptr null, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: store ptr [[X]], ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: store ptr @[[GLOB0:[0-9]+]], ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: [[TMP0:%.*]] = load ptr, ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: [[RETURN_SLOC_LOAD:%.*]] = load ptr, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-NORECOVER-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[TMP0]] to i64
+// CHECK-SANITIZE-NORECOVER-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 127
+// CHECK-SANITIZE-NORECOVER-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
+// CHECK-SANITIZE-NORECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_RETURN_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-NORECOVER: handler.return_alignment_assumption:
+// CHECK-SANITIZE-NORECOVER-NEXT: [[TMP1:%.*]] = ptrtoint ptr [[RETURN_SLOC_LOAD]] to i64, !nosanitize [[META2]]
+// CHECK-SANITIZE-NORECOVER-NEXT: [[TMP2:%.*]] = ptrtoint ptr [[TMP0]] to i64, !nosanitize [[META2]]
+// CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_return_alignment_assumption_abort(ptr @[[GLOB2:[0-9]+]], i64 [[TMP1]], i64 [[TMP2]], i64 128, i64 0) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-NORECOVER-NEXT: unreachable, !nosanitize [[META2]]
+// CHECK-SANITIZE-NORECOVER: cont:
+// CHECK-SANITIZE-NORECOVER-NEXT: ret ptr [[TMP0]]
+//
+// CHECK-SANITIZE-RECOVER-LABEL: define dso_local noundef ptr @_Z11passthroughPPc
+// CHECK-SANITIZE-RECOVER-SAME: (ptr noundef [[X:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-SANITIZE-RECOVER-NEXT: entry:
+// CHECK-SANITIZE-RECOVER-NEXT: [[RETURN_SLOC_PTR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-RECOVER-NEXT: [[X_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-RECOVER-NEXT: store ptr null, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-RECOVER-NEXT: store ptr [[X]], ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-RECOVER-NEXT: store ptr @[[GLOB0:[0-9]+]], ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-RECOVER-NEXT: [[TMP0:%.*]] = load ptr, ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-RECOVER-NEXT: [[RETURN_SLOC_LOAD:%.*]] = load ptr, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-RECOVER-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[TMP0]] to i64
+// CHECK-SANITIZE-RECOVER-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 127
+// CHECK-SANITIZE-RECOVER-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
+// CHECK-SANITIZE-RECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_RETURN_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-RECOVER: handler.return_alignment_assumption:
+// CHECK-SANITIZE-RECOVER-NEXT: [[TMP1:%.*]] = ptrtoint ptr [[RETURN_SLOC_LOAD]] to i64, !nosanitize [[META2]]
+// CHECK-SANITIZE-RECOVER-NEXT: [[TMP2:%.*]] = ptrtoint ptr [[TMP0]] to i64, !nosanitize [[META2]]
+// CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_return_alignment_assumption(ptr @[[GLOB2:[0-9]+]], i64 [[TMP1]], i64 [[TMP2]], i64 128, i64 0) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-RECOVER-NEXT: br label [[CONT]], !nosanitize [[META2]]
+// CHECK-SANITIZE-RECOVER: cont:
+// CHECK-SANITIZE-RECOVER-NEXT: ret ptr [[TMP0]]
+//
+// CHECK-SANITIZE-TRAP-LABEL: define dso_local noundef ptr @_Z11passthroughPPc
+// CHECK-SANITIZE-TRAP-SAME: (ptr noundef [[X:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-SANITIZE-TRAP-NEXT: entry:
+// CHECK-SANITIZE-TRAP-NEXT: [[RETURN_SLOC_PTR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-TRAP-NEXT: [[X_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-SANITIZE-TRAP-NEXT: store ptr null, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-TRAP-NEXT: store ptr [[X]], ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-TRAP-NEXT: store ptr @[[GLOB0:[0-9]+]], ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-TRAP-NEXT: [[TMP0:%.*]] = load ptr, ptr [[X_ADDR]], align 8
+// CHECK-SANITIZE-TRAP-NEXT: [[RETURN_SLOC_LOAD:%.*]] = load ptr, ptr [[RETURN_SLOC_PTR]], align 8
+// CHECK-SANITIZE-TRAP-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[TMP0]] to i64
+// CHECK-SANITIZE-TRAP-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 127
+// CHECK-SANITIZE-TRAP-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
+// CHECK-SANITIZE-TRAP-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[TRAP:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-TRAP: trap:
+// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 25) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-TRAP-NEXT: unreachable, !nosanitize [[META2]]
+// CHECK-SANITIZE-TRAP: cont:
+// CHECK-SANITIZE-TRAP-NEXT: ret ptr [[TMP0]]
//
passthrough(char **x) {
return x;
@@ -37,10 +101,10 @@ passthrough(char **x) {
// CHECK-SANITIZE-NORECOVER-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[CALL]] to i64
// CHECK-SANITIZE-NORECOVER-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 127
// CHECK-SANITIZE-NORECOVER-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
-// CHECK-SANITIZE-NORECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-NORECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1]], !nosanitize [[META2]]
// CHECK-SANITIZE-NORECOVER: handler.alignment_assumption:
// CHECK-SANITIZE-NORECOVER-NEXT: [[TMP1:%.*]] = ptrtoint ptr [[CALL]] to i64, !nosanitize [[META2]]
-// CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(ptr @[[GLOB1:[0-9]+]], i64 [[TMP1]], i64 128, i64 0) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(ptr @[[GLOB3:[0-9]+]], i64 [[TMP1]], i64 128, i64 0) #[[ATTR3]], !nosanitize [[META2]]
// CHECK-SANITIZE-NORECOVER-NEXT: unreachable, !nosanitize [[META2]]
// CHECK-SANITIZE-NORECOVER: cont:
// CHECK-SANITIZE-NORECOVER-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[CALL]], i64 128) ]
@@ -56,10 +120,10 @@ passthrough(char **x) {
// CHECK-SANITIZE-RECOVER-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[CALL]] to i64
// CHECK-SANITIZE-RECOVER-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 127
// CHECK-SANITIZE-RECOVER-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
-// CHECK-SANITIZE-RECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-RECOVER-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[HANDLER_ALIGNMENT_ASSUMPTION:%.*]], !prof [[PROF1]], !nosanitize [[META2]]
// CHECK-SANITIZE-RECOVER: handler.alignment_assumption:
// CHECK-SANITIZE-RECOVER-NEXT: [[TMP1:%.*]] = ptrtoint ptr [[CALL]] to i64, !nosanitize [[META2]]
-// CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(ptr @[[GLOB1:[0-9]+]], i64 [[TMP1]], i64 128, i64 0) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(ptr @[[GLOB3:[0-9]+]], i64 [[TMP1]], i64 128, i64 0) #[[ATTR3]], !nosanitize [[META2]]
// CHECK-SANITIZE-RECOVER-NEXT: br label [[CONT]], !nosanitize [[META2]]
// CHECK-SANITIZE-RECOVER: cont:
// CHECK-SANITIZE-RECOVER-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[CALL]], i64 128) ]
@@ -75,9 +139,9 @@ passthrough(char **x) {
// CHECK-SANITIZE-TRAP-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[CALL]] to i64
// CHECK-SANITIZE-TRAP-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 127
// CHECK-SANITIZE-TRAP-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
-// CHECK-SANITIZE-TRAP-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[TRAP:%.*]], !prof [[PROF1:![0-9]+]], !nosanitize [[META2:![0-9]+]]
+// CHECK-SANITIZE-TRAP-NEXT: br i1 [[MASKCOND]], label [[CONT:%.*]], label [[TRAP:%.*]], !prof [[PROF1]], !nosanitize [[META2]]
// CHECK-SANITIZE-TRAP: trap:
-// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 23) #[[ATTR3:[0-9]+]], !nosanitize [[META2]]
+// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 23) #[[ATTR3]], !nosanitize [[META2]]
// CHECK-SANITIZE-TRAP-NEXT: unreachable, !nosanitize [[META2]]
// CHECK-SANITIZE-TRAP: cont:
// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[CALL]], i64 128) ]
@@ -87,3 +151,5 @@ char **caller(char **x) {
#line 100
return passthrough(x);
}
+//// NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+// CHECK: {{.*}}
diff --git a/compiler-rt/lib/ubsan/ubsan_handlers.cpp b/compiler-rt/lib/ubsan/ubsan_handlers.cpp
index d60606ace7718d..d914b4e410f7fd 100644
--- a/compiler-rt/lib/ubsan/ubsan_handlers.cpp
+++ b/compiler-rt/lib/ubsan/ubsan_handlers.cpp
@@ -152,14 +152,11 @@ void __ubsan::__ubsan_handle_type_mismatch_v1_abort(TypeMismatchData *Data,
Die();
}
-void __ubsan::handleAlignmentAssumptionImpl(AlignmentAssumptionData *Data,
- ValueHandle Pointer,
- ValueHandle Alignment,
- ValueHandle Offset,
- ReportOptions Opts) {
- Location Loc = Data->Loc.acquire();
- SourceLocation AssumptionLoc = Data->AssumptionLoc.acquire();
-
+static void
+emitAlignmentAssumptionReport(Location Loc, SourceLocation AssumptionLoc,
+ const TypeDescriptor &Type, ValueHandle Pointer,
+ ValueHandle Alignment, ValueHandle Offset,
+ ReportOptions Opts) {
ErrorType ET = ErrorType::AlignmentAssumption;
if (ignoreReport(Loc.getSourceLocation(), Opts, ET))
@@ -177,12 +174,12 @@ void __ubsan::handleAlignmentAssumptionImpl(AlignmentAssumptionData *Data,
if (!Offset) {
Diag(Loc, DL_Error, ET,
"assumption of %0 byte alignment for pointer of type %1 failed")
- << Alignment << Data->Type;
+ << Alignment << Type;
} else {
Diag(Loc, DL_Error, ET,
"assumption of %0 byte alignment (with offset of %1 byte) for pointer "
"of type %2 failed")
- << Alignment << Offset << Data->Type;
+ << Alignment << Offset << Type;
}
if (!AssumptionLoc.isInvalid())
@@ -193,6 +190,17 @@ void __ubsan::handleAlignmentAssumptionImpl(AlignmentAssumptionData *Data,
<< (Offset ? "offset " : "") << ActualAlignment << MisAlignmentOffset;
}
+void __ubsan::handleAlignmentAssumptionImpl(AlignmentAssumptionData *Data,
+ ValueHandle Pointer,
+ ValueHandle Alignment,
+ ValueHandle Offset,
+ ReportOptions Opts) {
+ Location Loc = Data->Loc.acquire();
+ SourceLocation AssumptionLoc = Data->AssumptionLoc.acquire();
+ emitAlignmentAssumptionReport(Loc, AssumptionLoc, Data->Type, Pointer,
+ Alignment, Offset, Opts);
+}
+
void __ubsan::__ubsan_handle_alignment_assumption(AlignmentAssumptionData *Data,
ValueHandle Pointer,
ValueHandle Alignment,
@@ -208,6 +216,34 @@ void __ubsan::__ubsan_handle_alignment_assumption_abort(
Die();
}
+void __ubsan::handleReturnAlignmentAssumptionImpl(
+ ReturnAlignmentAssumptionData *Data, SourceLocation *LocPtr,
+ ValueHandle Pointer, ValueHandle Alignment, ValueHandle Offset,
+ ReportOptions Opts) {
+ if (!LocPtr)
+ UNREACHABLE("source location pointer is null!");
+
+ Location Loc = LocPtr->acquire();
+ emitAlignmentAssumptionReport(Loc, Data->AssumptionLoc, Data->Type, Pointer,
+ Alignment, Offset, Opts);
+}
+
+void __ubsan::__ubsan_handle_return_alignment_assumption(
+ ReturnAlignmentAssumptionData *Data, SourceLocation *LocPtr,
+ ValueHandle Pointer, ValueHandle Alignment, ValueHandle Offset) {
+ GET_REPORT_OPTIONS(false);
+ handleReturnAlignmentAssumptionImpl(Data, LocPtr, Pointer, Alignment, Offset,
+ Opts);
+}
+void __ubsan::__ubsan_handle_return_alignment_assumption_abort(
+ ReturnAlignmentAssumptionData *Data, SourceLocation *LocPtr,
+ ValueHandle Pointer, ValueHandle Alignment, ValueHandle Offset) {
+ GET_REPORT_OPTIONS(true);
+ handleReturnAlignmentAssumptionImpl(Data, LocPtr, Pointer, Alignment, Offset,
+ Opts);
+ Die();
+}
+
void __ubsan::handleIntegerOverflowImpl(OverflowData *Data, ValueHandle LHS,
const char *Operator, ValueHandle RHS,
ReportOptions Opts) {
diff --git a/compiler-rt/lib/ubsan/ubsan_handlers.h b/compiler-rt/lib/ubsan/ubsan_handlers.h
index 9420a1b69187ae..50aff53ce054bf 100644
--- a/compiler-rt/lib/ubsan/ubsan_handlers.h
+++ b/compiler-rt/lib/ubsan/ubsan_handlers.h
@@ -49,6 +49,17 @@ struct AlignmentAssumptionData {
RECOVERABLE(alignment_assumption, AlignmentAssumptionData *Data,
ValueHandle Pointer, ValueHandle Alignment, ValueHandle Offset)
+struct ReturnAlignmentAssumptionData {
+ SourceLocation AssumptionLoc;
+ const TypeDescriptor &Type;
+};
+
+/// \brief Handle a runtime alignment assumption check failure on a returned
+/// pointer, caused by a misaligned pointer.
+RECOVERABLE(return_alignment_assumption, ReturnAlignmentAssumptionData *Data,
+ SourceLocation *LocPtr, ValueHandle Pointer, ValueHandle Alignment,
+ ValueHandle Offset)
+
struct OverflowData {
SourceLocation Loc;
const TypeDescriptor &Type;
diff --git a/compiler-rt/lib/ubsan/ubsan_handlers_internal.h b/compiler-rt/lib/ubsan/ubsan_handlers_internal.h
index 3639124d70132c..f46cf948ce3eaf 100644
--- a/compiler-rt/lib/ubsan/ubsan_handlers_internal.h
+++ b/compiler-rt/lib/ubsan/ubsan_handlers_internal.h
@@ -24,6 +24,12 @@ void handleTypeMismatchImpl(TypeMismatchData *Data, ValueHandle Pointer,
void handleAlignmentAssumptionImpl(AlignmentAssumptionData *Data,
ValueHandle Pointer, ValueHandle Alignment,
ValueHandle Offset, ReportOptions Opts);
+void handleReturnAlignmentAssumptionImpl(ReturnAlignmentAssumptionData *Data,
+ SourceLocation *LocPtr,
+ ValueHandle Pointer,
+ ValueHandle Alignment,
+ ValueHandle Offset,
+ ReportOptions Opts);
void handleIntegerOverflowImpl(OverflowData *Data, ValueHandle LHS,
const char *Operator, ValueHandle RHS,
ReportOptions Opts);
diff --git a/compiler-rt/lib/ubsan/ubsan_interface.inc b/compiler-rt/lib/ubsan/ubsan_interface.inc
index 0d4a25daa7ab46..f3923f9baead14 100644
--- a/compiler-rt/lib/ubsan/ubsan_interface.inc
+++ b/compiler-rt/lib/ubsan/ubsan_interface.inc
@@ -11,6 +11,8 @@ INTERFACE_FUNCTION(__ubsan_handle_add_overflow)
INTERFACE_FUNCTION(__ubsan_handle_add_overflow_abort)
INTERFACE_FUNCTION(__ubsan_handle_alignment_assumption)
INTERFACE_FUNCTION(__ubsan_handle_alignment_assumption_abort)
+INTERFACE_FUNCTION(__ubsan_handle_return_alignment_assumption)
+INTERFACE_FUNCTION(__ubsan_handle_return_alignment_assumption_abort)
INTERFACE_FUNCTION(__ubsan_handle_builtin_unreachable)
INTERFACE_FUNCTION(__ubsan_handle_cfi_bad_type)
INTERFACE_FUNCTION(__ubsan_handle_cfi_check_fail)
diff --git a/compiler-rt/lib/ubsan_minimal/ubsan_minimal_handlers.cpp b/compiler-rt/lib/ubsan_minimal/ubsan_minimal_handlers.cpp
index 321ef1b9fc53e4..81e61c24e046a2 100644
--- a/compiler-rt/lib/ubsan_minimal/ubsan_minimal_handlers.cpp
+++ b/compiler-rt/lib/ubsan_minimal/ubsan_minimal_handlers.cpp
@@ -217,6 +217,7 @@ void NORETURN CheckFailed(const char *file, int, const char *cond, u64, u64) {
HANDLER(type_mismatch, "type-mismatch")
HANDLER(alignment_assumption, "alignment-assumption")
+HANDLER(return_alignment_assumption, "alignment-assumption")
HANDLER(add_overflow, "add-overflow")
HANDLER(sub_overflow, "sub-overflow")
HANDLER(mul_overflow, "mul-overflow")
diff --git a/compiler-rt/test/ubsan/TestCases/Pointer/align-assume-attribute-alloc_align-on-function-variable.cpp b/compiler-rt/test/ubsan/TestCases/Pointer/align-assume-attribute-alloc_align-on-function-variable.cpp
index 4a814843b7acd1..7cd6adbe28b698 100644
--- a/compiler-rt/test/ubsan/TestCases/Pointer/align-assume-attribute-alloc_align-on-function-variable.cpp
+++ b/compiler-rt/test/ubsan/TestCases/Pointer/align-assume-attribute-alloc_align-on-function-variable.cpp
@@ -23,9 +23,12 @@ int main(int argc, char* argv[]) {
alignment = 0x8000;
passthrough(ptr + 1, alignment);
- // CHECK: {{.*}}align-assume-{{.*}}.cpp:[[@LINE-1]]:3: runtime error: assumption of 32768 byte alignment for pointer of type 'char *' failed
+ // CHECK: {{.*}}align-assume-{{.*}}.cpp:[[@LINE-11]]:3: runtime error: assumption of 32768 byte alignment for pointer of type 'char *' failed
// CHECK: {{.*}}align-assume-{{.*}}.cpp:[[@LINE-14]]:22: note: alignment assumption was specified here
// CHECK: 0x{{.*}}: note: address is {{.*}} aligned, misalignment offset is {{.*}} byte
+ // CHECK: {{.*}}align-assume-{{.*}}.cpp:[[@LINE-4]]:3: runtime error: assumption of 32768 byte alignment for pointer of type 'char *' failed
+ // CHECK: {{.*}}align-assume-{{.*}}.cpp:[[@LINE-17]]:22: note: alignment assumption was specified here
+ // CHECK: 0x{{.*}}: note: address is {{.*}} aligned, misalignment offset is {{.*}} byte
free(ptr);
diff --git a/compiler-rt/test/ubsan/TestCases/Pointer/align-assume-attribute-alloc_align-on-function.cpp b/compiler-rt/test/ubsan/TestCases/Pointer/align-assume-attribute-alloc_align-on-function.cpp
index b442917e88ccce..59242da994e08d 100644
--- a/compiler-rt/test/ubsan/TestCases/Pointer/align-assume-attribute-alloc_align-on-function.cpp
+++ b/compiler-rt/test/ubsan/TestCases/Pointer/align-assume-attribute-alloc_align-on-function.cpp
@@ -19,9 +19,12 @@ int main(int argc, char* argv[]) {
char *ptr = (char *)malloc(2);
passthrough(ptr + 1, 0x8000);
- // CHECK: {{.*}}align-assume-{{.*}}.cpp:[[@LINE-1]]:3: runtime error: assumption of 32768 byte alignment for pointer of type 'char *' failed
+ // CHECK: {{.*}}align-assume-{{.*}}.cpp:[[@LINE-7]]:3: runtime error: assumption of 32768 byte alignment for pointer of type 'char *' failed
// CHECK: {{.*}}align-assume-{{.*}}.cpp:[[@LINE-10]]:22: note: alignment assumption was specified here
// CHECK: 0x{{.*}}: note: address is {{.*}} aligned, misalignment offset is {{.*}} byte
+ // CHECK: {{.*}}align-assume-{{.*}}.cpp:[[@LINE-4]]:3: runtime error: assumption of 32768 byte alignment for pointer of type 'char *' failed
+ // CHECK: {{.*}}align-assume-{{.*}}.cpp:[[@LINE-13]]:22: note: alignment assumption was specified here
+ // CHECK: 0x{{.*}}: note: address is {{.*}} aligned, misalignment offset is {{.*}} byte
free(ptr);
diff --git a/compiler-rt/test/ubsan/TestCases/Pointer/align-assume-attribute-assume_aligned-on-function-two-params.cpp b/compiler-rt/test/ubsan/TestCases/Pointer/align-assume-attribute-assume_aligned-on-function-two-params.cpp
index 95ec1f47218968..7537ec5223d365 100644
--- a/compiler-rt/test/ubsan/TestCases/Pointer/align-assume-attribute-assume_aligned-on-function-two-params.cpp
+++ b/compiler-rt/test/ubsan/TestCases/Pointer/align-assume-attribute-assume_aligned-on-function-two-params.cpp
@@ -18,9 +18,12 @@ int main(int argc, char* argv[]) {
char *ptr = (char *)malloc(3);
passthrough(ptr + 2);
- // CHECK: {{.*}}align-assume-{{.*}}.cpp:[[@LINE-1]]:3: runtime error: assumption of 32768 byte alignment (with offset of 1 byte) for pointer of type 'char *' failed
+ // CHECK: {{.*}}align-assume-{{.*}}.cpp:[[@LINE-7]]:3: runtime error: assumption of 32768 byte alignment (with offset of 1 byte) for pointer of type 'char *' failed
// CHECK: {{.*}}align-assume-{{.*}}.cpp:[[@LINE-9]]:22: note: alignment assumption was specified here
// CHECK: 0x{{.*}}: note: offset address is {{.*}} aligned, misalignment offset is {{.*}} byte
+ // CHECK: {{.*}}align-assume-{{.*}}.cpp:[[@LINE-4]]:3: runtime error: assumption of 32768 byte alignment (with offset of 1 byte) for pointer of type 'char *' failed
+ // CHECK: {{.*}}align-assume-{{.*}}.cpp:[[@LINE-12]]:22: note: alignment assumption was specified here
+ // CHECK: 0x{{.*}}: note: offset address is {{.*}} aligned, misalignment offset is {{.*}} byte
free(ptr);
diff --git a/compiler-rt/test/ubsan/TestCases/Pointer/align-assume-attribute-assume_aligned-on-function.cpp b/compiler-rt/test/ubsan/TestCases/Pointer/align-assume-attribute-assume_aligned-on-function.cpp
index 8921cd53690de5..9e1fa7003e81dc 100644
--- a/compiler-rt/test/ubsan/TestCases/Pointer/align-assume-attribute-assume_aligned-on-function.cpp
+++ b/compiler-rt/test/ubsan/TestCases/Pointer/align-assume-attribute-assume_aligned-on-function.cpp
@@ -18,9 +18,12 @@ int main(int argc, char* argv[]) {
char *ptr = (char *)malloc(2);
passthrough(ptr + 1);
- // CHECK: {{.*}}align-assume-{{.*}}.cpp:[[@LINE-1]]:3: runtime error: assumption of 32768 byte alignment for pointer of type 'char *' failed
+ // CHECK: {{.*}}align-assume-{{.*}}.cpp:[[@LINE-7]]:3: runtime error: assumption of 32768 byte alignment for pointer of type 'char *' failed
// CHECK: {{.*}}align-assume-{{.*}}.cpp:[[@LINE-9]]:22: note: alignment assumption was specified here
// CHECK: 0x{{.*}}: note: address is {{.*}} aligned, misalignment offset is {{.*}} byte
+ // CHECK: {{.*}}align-assume-{{.*}}.cpp:[[@LINE-4]]:3: runtime error: assumption of 32768 byte alignment for pointer of type 'char *' failed
+ // CHECK: {{.*}}align-assume-{{.*}}.cpp:[[@LINE-12]]:22: note: alignment assumption was specified here
+ // CHECK: 0x{{.*}}: note: address is {{.*}} aligned, misalignment offset is {{.*}} byte
free(ptr);
More information about the llvm-branch-commits
mailing list