[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 12:49:32 PST 2026


https://github.com/durin42 updated https://github.com/llvm/llvm-project/pull/239729

>From ed20fb094acaa508907468c3a3fc6a4f2a3b22ad 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