[hwasan] have callbacks for 32 and 64 byte ops

[fmayer]

add test

[fmayer]

add store test

[fmayer]

simplify

[fmayer]

add more tests

[eugenis]

compiler-rt/lib/hwasan/hwasan.cpp

451

I think you need to update CheckAddress - it only ever checks the first granule.

And it would be great to have a runtime test that ex. 64-byte access checks the middle and the last granules.

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

74

rename it to something like kApi32NumberOfAccessSizes. "old" is too vague.

1049

as I understand, this will work for 64-byte access that is only 16-byte aligned. Could you add a test for this?

compiler-rt/lib/hwasan/hwasan.cpp

void __hwasan_load4(uptr p) {
   CheckAddress<ErrorAction::Abort, AccessType::Load, 2>(p);
 }
 void __hwasan_load8(uptr p) {
   CheckAddress<ErrorAction::Abort, AccessType::Load, 3>(p);
 }
 void __hwasan_load16(uptr p) {
   CheckAddress<ErrorAction::Abort, AccessType::Load, 4>(p);
 }
+void __hwasan_load32(uptr p) {
+  CheckAddress<ErrorAction::Abort, AccessType::Load, 5>(p);
+}
+void __hwasan_load64(uptr p) {
+  CheckAddress<ErrorAction::Abort, AccessType::Load, 6>(p);
+}
 
 void __hwasan_loadN_noabort(uptr p, uptr sz) {
   CheckAddressSized<ErrorAction::Recover, AccessType::Load>(p, sz);
 }
 void __hwasan_load1_noabort(uptr p) {
   CheckAddress<ErrorAction::Recover, AccessType::Load, 0>(p);
 }
 void __hwasan_load2_noabort(uptr p) {
   CheckAddress<ErrorAction::Recover, AccessType::Load, 1>(p);
 }
 void __hwasan_load4_noabort(uptr p) {
   CheckAddress<ErrorAction::Recover, AccessType::Load, 2>(p);
 }
 void __hwasan_load8_noabort(uptr p) {
   CheckAddress<ErrorAction::Recover, AccessType::Load, 3>(p);
 }
 void __hwasan_load16_noabort(uptr p) {
   CheckAddress<ErrorAction::Recover, AccessType::Load, 4>(p);
 }
+void __hwasan_load32_noabort(uptr p) {
+  CheckAddress<ErrorAction::Recover, AccessType::Load, 5>(p);
+}
+void __hwasan_load64_noabort(uptr p) {
+  CheckAddress<ErrorAction::Recover, AccessType::Load, 6>(p);
+}
 
 void __hwasan_storeN(uptr p, uptr sz) {
   CheckAddressSized<ErrorAction::Abort, AccessType::Store>(p, sz);
 }
 void __hwasan_store1(uptr p) {
   CheckAddress<ErrorAction::Abort, AccessType::Store, 0>(p);
 }
 void __hwasan_store2(uptr p) {
   CheckAddress<ErrorAction::Abort, AccessType::Store, 1>(p);
 }
 void __hwasan_store4(uptr p) {
   CheckAddress<ErrorAction::Abort, AccessType::Store, 2>(p);
 }
 void __hwasan_store8(uptr p) {
   CheckAddress<ErrorAction::Abort, AccessType::Store, 3>(p);
 }
 void __hwasan_store16(uptr p) {
   CheckAddress<ErrorAction::Abort, AccessType::Store, 4>(p);
 }
+void __hwasan_store32(uptr p) {
+  CheckAddress<ErrorAction::Abort, AccessType::Store, 5>(p);
+}
+void __hwasan_store64(uptr p) {
+  CheckAddress<ErrorAction::Abort, AccessType::Store, 6>(p);
+}
 
 void __hwasan_storeN_noabort(uptr p, uptr sz) {
   CheckAddressSized<ErrorAction::Recover, AccessType::Store>(p, sz);
 }
 void __hwasan_store1_noabort(uptr p) {
   CheckAddress<ErrorAction::Recover, AccessType::Store, 0>(p);
 }
 void __hwasan_store2_noabort(uptr p) {
   CheckAddress<ErrorAction::Recover, AccessType::Store, 1>(p);
 }
 void __hwasan_store4_noabort(uptr p) {
   CheckAddress<ErrorAction::Recover, AccessType::Store, 2>(p);
 }
 void __hwasan_store8_noabort(uptr p) {
   CheckAddress<ErrorAction::Recover, AccessType::Store, 3>(p);
 }
 void __hwasan_store16_noabort(uptr p) {
   CheckAddress<ErrorAction::Recover, AccessType::Store, 4>(p);
 }
+void __hwasan_store32_noabort(uptr p) {
+  CheckAddress<ErrorAction::Recover, AccessType::Store, 5>(p);
+}
+void __hwasan_store64_noabort(uptr p) {
+  CheckAddress<ErrorAction::Recover, AccessType::Store, 6>(p);
+}
 
 void __hwasan_tag_memory(uptr p, u8 tag, uptr sz) {
   TagMemoryAligned(p, sz, tag);
 }
 
 uptr __hwasan_tag_pointer(uptr p, u8 tag) {
   return AddTagToPointer(p, tag);
 }

compiler-rt/lib/hwasan/hwasan_interface_internal.h

 SANITIZER_INTERFACE_ATTRIBUTE
 void __hwasan_load2(uptr);
 SANITIZER_INTERFACE_ATTRIBUTE
 void __hwasan_load4(uptr);
 SANITIZER_INTERFACE_ATTRIBUTE
 void __hwasan_load8(uptr);
 SANITIZER_INTERFACE_ATTRIBUTE
 void __hwasan_load16(uptr);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __hwasan_load32(uptr);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __hwasan_load64(uptr);
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void __hwasan_loadN_noabort(uptr, uptr);
 SANITIZER_INTERFACE_ATTRIBUTE
 void __hwasan_load1_noabort(uptr);
 SANITIZER_INTERFACE_ATTRIBUTE
 void __hwasan_load2_noabort(uptr);
 SANITIZER_INTERFACE_ATTRIBUTE
 void __hwasan_load4_noabort(uptr);
 SANITIZER_INTERFACE_ATTRIBUTE
 void __hwasan_load8_noabort(uptr);
 SANITIZER_INTERFACE_ATTRIBUTE
 void __hwasan_load16_noabort(uptr);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __hwasan_load32_noabort(uptr);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __hwasan_load64_noabort(uptr);
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void __hwasan_storeN(uptr, uptr);
 SANITIZER_INTERFACE_ATTRIBUTE
 void __hwasan_store1(uptr);
 SANITIZER_INTERFACE_ATTRIBUTE
 void __hwasan_store2(uptr);
 SANITIZER_INTERFACE_ATTRIBUTE
 void __hwasan_store4(uptr);
 SANITIZER_INTERFACE_ATTRIBUTE
 void __hwasan_store8(uptr);
 SANITIZER_INTERFACE_ATTRIBUTE
 void __hwasan_store16(uptr);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __hwasan_store32(uptr);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __hwasan_store64(uptr);
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void __hwasan_storeN_noabort(uptr, uptr);
 SANITIZER_INTERFACE_ATTRIBUTE
 void __hwasan_store1_noabort(uptr);
 SANITIZER_INTERFACE_ATTRIBUTE
 void __hwasan_store2_noabort(uptr);
 SANITIZER_INTERFACE_ATTRIBUTE
 void __hwasan_store4_noabort(uptr);
 SANITIZER_INTERFACE_ATTRIBUTE
 void __hwasan_store8_noabort(uptr);
 SANITIZER_INTERFACE_ATTRIBUTE
 void __hwasan_store16_noabort(uptr);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __hwasan_store32_noabort(uptr);
+SANITIZER_INTERFACE_ATTRIBUTE
+void __hwasan_store64_noabort(uptr);
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void __hwasan_tag_memory(uptr p, u8 tag, uptr sz);
 
 SANITIZER_INTERFACE_ATTRIBUTE
 uptr __hwasan_tag_pointer(uptr p, u8 tag);
 
 SANITIZER_INTERFACE_ATTRIBUTE

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

 const char kHwasanModuleCtorName[] = "hwasan.module_ctor";
 const char kHwasanNoteName[] = "hwasan.note";
 const char kHwasanInitName[] = "__hwasan_init";
 const char kHwasanPersonalityThunkName[] = "__hwasan_personality_thunk";
 
 const char kHwasanShadowMemoryDynamicAddress[] =
     "__hwasan_shadow_memory_dynamic_address";
 
-// Accesses sizes are powers of two: 1, 2, 4, 8, 16.
-static const size_t kNumberOfAccessSizes = 5;
+// Access-sizes that are supported in call-based instrumentation on old version
+// of Android.
+static const size_t kOldNumberOfAccessSizes = 5;
+// Accesses sizes are powers of two: 1, 2, 4, 8, 16, 32, 64.
+static const size_t kNumberOfAccessSizes = 7;
 
 static const size_t kDefaultShadowScale = 4;
 static const uint64_t kDynamicShadowSentinel =
     std::numeric_limits<uint64_t>::max();
 
 static const unsigned kShadowBaseAlignment = 32;
 
 static cl::opt<std::string>
private:
   bool Recover;
   bool OutlinedChecks;
   bool UseShortGranules;
   bool InstrumentLandingPads;
   bool InstrumentWithCalls;
   bool InstrumentStack;
   bool DetectUseAfterScope;
   bool UsePageAliases;
+  size_t UsableNumberOfAccessCallbacks;
 
   bool HasMatchAllTag = false;
   uint8_t MatchAllTag = 0;
 
   unsigned PointerTagShift;
   uint64_t TagMaskByte;
 
   Function *HwasanCtorFunction;
void HWAddressSanitizer::initializeModule() {
   HwasanCtorFunction = nullptr;
 
   // Older versions of Android do not have the required runtime support for
   // short granules, global or personality function instrumentation. On other
   // platforms we currently require using the latest version of the runtime.
   bool NewRuntime =
       !TargetTriple.isAndroid() || !TargetTriple.isAndroidVersionLT(30);
 
+  UsableNumberOfAccessCallbacks =
+      TargetTriple.isAndroid() && TargetTriple.isAndroidVersionLT(32)
+          ? kOldNumberOfAccessSizes
+          : kNumberOfAccessSizes;
+
   UseShortGranules =
       ClUseShortGranules.getNumOccurrences() ? ClUseShortGranules : NewRuntime;
   OutlinedChecks =
       TargetTriple.isAArch64() && TargetTriple.isOSBinFormatELF() &&
       (ClInlineAllChecks.getNumOccurrences() ? !ClInlineAllChecks : !Recover);
 
   if (ClMatchAllTag.getNumOccurrences()) {
     if (ClMatchAllTag != -1) {
void HWAddressSanitizer::initializeCallbacks(Module &M) {
   for (size_t AccessIsWrite = 0; AccessIsWrite <= 1; AccessIsWrite++) {
     const std::string TypeStr = AccessIsWrite ? "store" : "load";
     const std::string EndingStr = Recover ? "_noabort" : "";
 
     HwasanMemoryAccessCallbackSized[AccessIsWrite] = M.getOrInsertFunction(
         ClMemoryAccessCallbackPrefix + TypeStr + "N" + EndingStr,
         FunctionType::get(IRB.getVoidTy(), {IntptrTy, IntptrTy}, false));
 
-    for (size_t AccessSizeIndex = 0; AccessSizeIndex < kNumberOfAccessSizes;
-         AccessSizeIndex++) {
+    for (size_t AccessSizeIndex = 0;
+         AccessSizeIndex < UsableNumberOfAccessCallbacks; AccessSizeIndex++) {
       HwasanMemoryAccessCallback[AccessIsWrite][AccessSizeIndex] =
           M.getOrInsertFunction(
               ClMemoryAccessCallbackPrefix + TypeStr +
                   itostr(1ULL << AccessSizeIndex) + EndingStr,
               FunctionType::get(IRB.getVoidTy(), {IntptrTy}, false));
     }
   }
 
bool HWAddressSanitizer::instrumentMemAccess(InterestingMemoryOperand &O) {
   Value *Addr = O.getPtr();
 
   LLVM_DEBUG(dbgs() << "Instrumenting: " << O.getInsn() << "\n");
 
   if (O.MaybeMask)
     return false; // FIXME
 
   IRBuilder<> IRB(O.getInsn());
+  auto MaxAccessNumber = InstrumentWithCalls ? UsableNumberOfAccessCallbacks
+                                             : kNumberOfAccessSizes;
   if (isPowerOf2_64(O.TypeSize) &&
-      (O.TypeSize / 8 <= (1ULL << (kNumberOfAccessSizes - 1))) &&
+      (O.TypeSize / 8 <= (1ULL << (MaxAccessNumber - 1))) &&
       (!O.Alignment || *O.Alignment >= (1ULL << Mapping.Scale) ||
        *O.Alignment >= O.TypeSize / 8)) {
     size_t AccessSizeIndex = TypeSizeToSizeIndex(O.TypeSize);
     if (InstrumentWithCalls) {
+      assert(AccessSizeIndex < UsableNumberOfAccessCallbacks);
       IRB.CreateCall(HwasanMemoryAccessCallback[O.IsWrite][AccessSizeIndex],
                      IRB.CreatePointerCast(Addr, IntptrTy));
     } else if (OutlinedChecks) {
       instrumentMemAccessOutline(Addr, O.IsWrite, AccessSizeIndex, O.getInsn());
     } else {
       instrumentMemAccessInline(Addr, O.IsWrite, AccessSizeIndex, O.getInsn());
     }
   } else {

llvm/test/Instrumentation/HWAddressSanitizer/basic.ll

 ; CHECK: %[[G:[^ ]*]] = load i128, i128* %a, align 16
 ; CHECK: ret i128 %[[G]]
 
 entry:
   %b = load i128, i128* %a, align 16
   ret i128 %b
 }
 
+define i256 @test_load256(i256* %a) sanitize_hwaddress {
+; CHECK-LABEL: @test_load256(
+; RECOVER: %[[A:[^ ]*]] = ptrtoint i256* %a to i64
+; RECOVER: %[[B:[^ ]*]] = lshr i64 %[[A]], 56
+; RECOVER: %[[PTRTAG:[^ ]*]] = trunc i64 %[[B]] to i8
+; RECOVER: %[[C:[^ ]*]] = and i64 %[[A]], 72057594037927935
+; RECOVER: %[[D:[^ ]*]] = lshr i64 %[[C]], 4
+; RECOVER-DYNAMIC-SHADOW: %[[E:[^ ]*]] = getelementptr i8, i8* %.hwasan.shadow, i64 %4
+; RECOVER-ZERO-BASED-SHADOW: %[[E:[^ ]*]] = inttoptr i64 %[[D]] to i8*
+; RECOVER: %[[MEMTAG:[^ ]*]] = load i8, i8* %[[E]]
+; RECOVER: %[[F:[^ ]*]] = icmp ne i8 %[[PTRTAG]], %[[MEMTAG]]
+; RECOVER: br i1 %[[F]], label {{.*}}, label {{.*}}, !prof {{.*}}
+
+; RECOVER: call void asm sideeffect "brk #2341", "{x0}"(i64 %[[A]])
+; RECOVER: br label
+
+; ABORT: %[[A:[^ ]*]] = bitcast i256* %a to i8*
+; ABORT: call void @llvm.hwasan.check.memaccess.shortgranules(i8* %.hwasan.shadow, i8* %[[A]], i32 5)
+
+; CHECK: %[[G:[^ ]*]] = load i256, i256* %a, align 16
+; CHECK: ret i256 %[[G]]
+
+entry:
+  %b = load i256, i256* %a, align 16
+  ret i256 %b
+}
+
+define i512 @test_load512(i512* %a) sanitize_hwaddress {
+; CHECK-LABEL: @test_load512(
+; RECOVER: %[[A:[^ ]*]] = ptrtoint i512* %a to i64
+; RECOVER: %[[B:[^ ]*]] = lshr i64 %[[A]], 56
+; RECOVER: %[[PTRTAG:[^ ]*]] = trunc i64 %[[B]] to i8
+; RECOVER: %[[C:[^ ]*]] = and i64 %[[A]], 72057594037927935
+; RECOVER: %[[D:[^ ]*]] = lshr i64 %[[C]], 4
+; RECOVER-DYNAMIC-SHADOW: %[[E:[^ ]*]] = getelementptr i8, i8* %.hwasan.shadow, i64 %4
+; RECOVER-ZERO-BASED-SHADOW: %[[E:[^ ]*]] = inttoptr i64 %[[D]] to i8*
+; RECOVER: %[[MEMTAG:[^ ]*]] = load i8, i8* %[[E]]
+; RECOVER: %[[F:[^ ]*]] = icmp ne i8 %[[PTRTAG]], %[[MEMTAG]]
+; RECOVER: br i1 %[[F]], label {{.*}}, label {{.*}}, !prof {{.*}}
+
+; RECOVER: call void asm sideeffect "brk #2342", "{x0}"(i64 %[[A]])
+; RECOVER: br label
+
+; ABORT: %[[A:[^ ]*]] = bitcast i512* %a to i8*
+; ABORT: call void @llvm.hwasan.check.memaccess.shortgranules(i8* %.hwasan.shadow, i8* %[[A]], i32 6)
+
+; CHECK: %[[G:[^ ]*]] = load i512, i512* %a, align 16
+; CHECK: ret i512 %[[G]]
+entry:
+  %b = load i512, i512* %a, align 16
+  ret i512 %b
+}
+
 define i40 @test_load40(i40* %a) sanitize_hwaddress {
 ; CHECK-LABEL: @test_load40(
 ; CHECK: %[[A:[^ ]*]] = ptrtoint i40* %a to i64
 ; ABORT: call void @__hwasan_loadN(i64 %[[A]], i64 5)
 ; RECOVER: call void @__hwasan_loadN_noabort(i64 %[[A]], i64 5)
 ; CHECK: %[[B:[^ ]*]] = load i40, i40* %a
 ; CHECK: ret i40 %[[B]]
 

 ; CHECK: store i128 %b, i128* %a, align 16
 ; CHECK: ret void
 
 entry:
   store i128 %b, i128* %a, align 16
   ret void
 }
 
+
+define void @test_store256(i256* %a, i256 %b) sanitize_hwaddress {
+; CHECK-LABEL: @test_store256(
+; RECOVER: %[[A:[^ ]*]] = ptrtoint i256* %a to i64
+; RECOVER: %[[B:[^ ]*]] = lshr i64 %[[A]], 56
+; RECOVER: %[[PTRTAG:[^ ]*]] = trunc i64 %[[B]] to i8
+; RECOVER: %[[C:[^ ]*]] = and i64 %[[A]], 72057594037927935
+; RECOVER: %[[D:[^ ]*]] = lshr i64 %[[C]], 4
+; RECOVER-DYNAMIC-SHADOW: %[[E:[^ ]*]] = getelementptr i8, i8* %.hwasan.shadow, i64 %4
+; RECOVER-ZERO-BASED-SHADOW: %[[E:[^ ]*]] = inttoptr i64 %[[D]] to i8*
+; RECOVER: %[[MEMTAG:[^ ]*]] = load i8, i8* %[[E]]
+; RECOVER: %[[F:[^ ]*]] = icmp ne i8 %[[PTRTAG]], %[[MEMTAG]]
+; RECOVER: br i1 %[[F]], label {{.*}}, label {{.*}}, !prof {{.*}}
+
+; RECOVER: call void asm sideeffect "brk #2357", "{x0}"(i64 %[[A]])
+; RECOVER: br label
+
+; ABORT: %[[A:[^ ]*]] = bitcast i256* %a to i8*
+; ABORT: call void @llvm.hwasan.check.memaccess.shortgranules(i8* %.hwasan.shadow, i8* %[[A]], i32 21)
+
+; CHECK: store i256 %b, i256* %a, align 16
+; CHECK: ret void
+entry:
+  store i256 %b, i256* %a, align 16
+  ret void
+}
+
+define void @test_store512(i512* %a, i512 %b) sanitize_hwaddress {
+; CHECK-LABEL: @test_store512(
+; RECOVER: %[[A:[^ ]*]] = ptrtoint i512* %a to i64
+; RECOVER: %[[B:[^ ]*]] = lshr i64 %[[A]], 56
+; RECOVER: %[[PTRTAG:[^ ]*]] = trunc i64 %[[B]] to i8
+; RECOVER: %[[C:[^ ]*]] = and i64 %[[A]], 72057594037927935
+; RECOVER: %[[D:[^ ]*]] = lshr i64 %[[C]], 4
+; RECOVER-DYNAMIC-SHADOW: %[[E:[^ ]*]] = getelementptr i8, i8* %.hwasan.shadow, i64 %4
+; RECOVER-ZERO-BASED-SHADOW: %[[E:[^ ]*]] = inttoptr i64 %[[D]] to i8*
+; RECOVER: %[[MEMTAG:[^ ]*]] = load i8, i8* %[[E]]
+; RECOVER: %[[F:[^ ]*]] = icmp ne i8 %[[PTRTAG]], %[[MEMTAG]]
+; RECOVER: br i1 %[[F]], label {{.*}}, label {{.*}}, !prof {{.*}}
+
+; RECOVER: call void asm sideeffect "brk #2358", "{x0}"(i64 %[[A]])
+; RECOVER: br label
+
+; ABORT: %[[A:[^ ]*]] = bitcast i512* %a to i8*
+; ABORT: call void @llvm.hwasan.check.memaccess.shortgranules(i8* %.hwasan.shadow, i8* %[[A]], i32 22)
+
+; CHECK: store i512 %b, i512* %a, align 16
+; CHECK: ret void
+entry:
+  store i512 %b, i512* %a, align 16
+  ret void
+}
+
 define void @test_store40(i40* %a, i40 %b) sanitize_hwaddress {
 ; CHECK-LABEL: @test_store40(
 ; CHECK: %[[A:[^ ]*]] = ptrtoint i40* %a to i64
 ; ABORT: call void @__hwasan_storeN(i64 %[[A]], i64 5)
 ; RECOVER: call void @__hwasan_storeN_noabort(i64 %[[A]], i64 5)
 ; CHECK: store i40 %b, i40* %a
 ; CHECK: ret void
 

llvm/test/Instrumentation/HWAddressSanitizer/with-calls.ll

 ; Test basic address sanitizer instrumentation.
 ;
-; RUN: opt < %s -passes=hwasan -hwasan-instrument-with-calls -S | FileCheck %s --check-prefixes=CHECK,ABORT
-; RUN: opt < %s -passes=hwasan -hwasan-instrument-with-calls -hwasan-recover=1 -S | FileCheck %s --check-prefixes=CHECK,RECOVER
+; RUN: opt < %s -passes=hwasan -hwasan-instrument-with-calls -S | FileCheck %s --check-prefixes=CHECK,ABORT,OLDRUNTIME-ABORT
+; RUN: opt < %s -passes=hwasan -hwasan-instrument-with-calls -hwasan-recover=1 -S | FileCheck %s --check-prefixes=CHECK,RECOVER,OLDRUNTIME-RECOVER
+; RUN: opt < %s -mtriple aarch64--linux-gnu -passes=hwasan -hwasan-instrument-with-calls -S | FileCheck %s --check-prefixes=CHECK,ABORT,NEWRUNTIME-ABORT
+; RUN: opt < %s -mtriple aarch64--linux-gnu -passes=hwasan -hwasan-instrument-with-calls -hwasan-recover=1 -S | FileCheck %s --check-prefixes=CHECK,RECOVER,NEWRUNTIME-RECOVER
+; RUN: opt < %s -mtriple aarch64--linux-android32 -passes=hwasan -hwasan-instrument-with-calls -S | FileCheck %s --check-prefixes=CHECK,ABORT,NEWRUNTIME-ABORT
+; RUN: opt < %s -mtriple aarch64--linux-android32 -passes=hwasan -hwasan-instrument-with-calls -hwasan-recover=1 -S | FileCheck %s --check-prefixes=CHECK,RECOVER,NEWRUNTIME-RECOVER
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 target triple = "aarch64--linux-android"
 
 define i8 @test_load8(i8* %a) sanitize_hwaddress {
 ; CHECK-LABEL: @test_load8(
 ; CHECK: %[[A:[^ ]*]] = ptrtoint i8* %a to i64
 ; ABORT: call void @__hwasan_load1(i64 %[[A]])

 ; CHECK: %[[B:[^ ]*]] = load i128, i128* %a
 ; CHECK: ret i128 %[[B]]
 
 entry:
   %b = load i128, i128* %a, align 16
   ret i128 %b
 }
 
+define i256 @test_load256(i256* %a) sanitize_hwaddress {
+; CHECK-LABEL: @test_load256(
+; CHECK: %[[A:[^ ]*]] = ptrtoint i256* %a to i64
+; OLDRUNTIME-ABORT: call void @__hwasan_loadN(i64 %[[A]], i64 32)
+; OLDRUNTIME-RECOVER: call void @__hwasan_loadN_noabort(i64 %[[A]], i64 32)
+; NEWRUNTIME-ABORT: call void @__hwasan_load32(i64 %[[A]])
+; NEWRUNTIME-RECOVER: call void @__hwasan_load32_noabort(i64 %[[A]])
+; CHECK: %[[B:[^ ]*]] = load i256, i256* %a
+; CHECK: ret i256 %[[B]]
+
+entry:
+  %b = load i256, i256* %a, align 16
+  ret i256 %b
+}
+
+define i512 @test_load512(i512* %a) sanitize_hwaddress {
+; CHECK-LABEL: @test_load512(
+; CHECK: %[[A:[^ ]*]] = ptrtoint i512* %a to i64
+; OLDRUNTIME-ABORT: call void @__hwasan_loadN(i64 %[[A]], i64 64)
+; OLDRUNTIME-RECOVER: call void @__hwasan_loadN_noabort(i64 %[[A]], i64 64)
+; NEWRUNTIME-ABORT: call void @__hwasan_load64(i64 %[[A]])
+; NEWRUNTIME-RECOVER: call void @__hwasan_load64_noabort(i64 %[[A]])
+; CHECK: %[[B:[^ ]*]] = load i512, i512* %a
+; CHECK: ret i512 %[[B]]
+
+entry:
+  %b = load i512, i512* %a, align 16
+  ret i512 %b
+}
+
 define i40 @test_load40(i40* %a) sanitize_hwaddress {
 ; CHECK-LABEL: @test_load40(
 ; CHECK: %[[A:[^ ]*]] = ptrtoint i40* %a to i64
 ; ABORT: call void @__hwasan_loadN(i64 %[[A]], i64 5)
 ; RECOVER: call void @__hwasan_loadN_noabort(i64 %[[A]], i64 5)
 ; CHECK: %[[B:[^ ]*]] = load i40, i40* %a
 ; CHECK: ret i40 %[[B]]
 

 ; CHECK: store i128 %b, i128* %a
 ; CHECK: ret void
 
 entry:
   store i128 %b, i128* %a, align 16
   ret void
 }
 
+define void @test_store256(i256* %a, i256 %b) sanitize_hwaddress {
+; CHECK-LABEL: @test_store256(
+; CHECK: %[[A:[^ ]*]] = ptrtoint i256* %a to i64
+; OLDRUNTIME-ABORT: call void @__hwasan_storeN(i64 %[[A]], i64 32)
+; OLDRUNTIME-RECOVER: call void @__hwasan_storeN_noabort(i64 %[[A]], i64 32)
+; NEWRUNTIME-ABORT: call void @__hwasan_store32(i64 %[[A]])
+; NEWRUNTIME-RECOVER: call void @__hwasan_store32_noabort(i64 %[[A]])
+; CHECK: store i256 %b, i256* %a
+; CHECK: ret void
+
+entry:
+  store i256 %b, i256* %a, align 16
+  ret void
+}
+
+define void @test_store512(i512* %a, i512 %b) sanitize_hwaddress {
+; CHECK-LABEL: @test_store512(
+; CHECK: %[[A:[^ ]*]] = ptrtoint i512* %a to i64
+; OLDRUNTIME-ABORT: call void @__hwasan_storeN(i64 %[[A]], i64 64)
+; OLDRUNTIME-RECOVER: call void @__hwasan_storeN_noabort(i64 %[[A]], i64 64)
+; NEWRUNTIME-ABORT: call void @__hwasan_store64(i64 %[[A]])
+; NEWRUNTIME-RECOVER: call void @__hwasan_store64_noabort(i64 %[[A]])
+; CHECK: store i512 %b, i512* %a
+; CHECK: ret void
+
+entry:
+  store i512 %b, i512* %a, align 16
+  ret void
+}
+
 define void @test_store40(i40* %a, i40 %b) sanitize_hwaddress {
 ; CHECK-LABEL: @test_store40(
 ; CHECK: %[[A:[^ ]*]] = ptrtoint i40* %a to i64
 ; ABORT: call void @__hwasan_storeN(i64 %[[A]], i64 5)
 ; RECOVER: call void @__hwasan_storeN_noabort(i64 %[[A]], i64 5)
 ; CHECK: store i40 %b, i40* %a
 ; CHECK: ret void