Failure to infer alignment of pointer returned from `malloc`

[Kmeakin]

According to cppreference, malloc should always return pointers that are at least as aligned as max_align_t. So the alignment test should always be true. gcc optimises this but LLVM does not:

https://godbolt.org/z/GnbEfbseE
https://alive2.llvm.org/ce/z/QZign2

bool src(void) {
    void* p = malloc(1);
    return ((uintptr_t)p % alignof(max_align_t)) == 0;
}

bool tgt(void) { return true; }

[dtcxzyw]

patch:

diff --git a/llvm/include/llvm/Analysis/TargetLibraryInfo.h b/llvm/include/llvm/Analysis/TargetLibraryInfo.h
index f51d2bb9d50a..4c06fa3189e6 100644
--- a/llvm/include/llvm/Analysis/TargetLibraryInfo.h
+++ b/llvm/include/llvm/Analysis/TargetLibraryInfo.h
@@ -251,6 +251,9 @@ public:
   /// Returns the size of the size_t type in bits.
   unsigned getSizeTSize(const Module &M) const;
 
+  /// Returns alignof(max_align_t)
+  Align getMaxAlignTAlignment(const Module &M) const;
+
   /// Get size of a C-level int or unsigned int, in bits.
   unsigned getIntSize() const {
     return SizeOfInt;
@@ -567,6 +570,9 @@ public:
   /// \copydoc TargetLibraryInfoImpl::getSizeTSize()
   unsigned getSizeTSize(const Module &M) const { return Impl->getSizeTSize(M); }
 
+  /// \copydoc TargetLibraryInfoImpl::getMaxAlignTAlignment()
+  Align getMaxAlignTAlignment(const Module &M) const { return Impl->getMaxAlignTAlignment(M); }
+
   /// Returns an IntegerType corresponding to size_t.
   IntegerType *getSizeTType(const Module &M) const {
     return IntegerType::get(M.getContext(), getSizeTSize(M));
diff --git a/llvm/lib/Analysis/TargetLibraryInfo.cpp b/llvm/lib/Analysis/TargetLibraryInfo.cpp
index 8557901192e4..ae4c8797559b 100644
--- a/llvm/lib/Analysis/TargetLibraryInfo.cpp
+++ b/llvm/lib/Analysis/TargetLibraryInfo.cpp
@@ -1471,6 +1471,12 @@ unsigned TargetLibraryInfoImpl::getSizeTSize(const Module &M) const {
   return M.getDataLayout().getIndexSizeInBits(/*AddressSpace=*/0);
 }
 
+Align TargetLibraryInfoImpl::getMaxAlignTAlignment(const Module &M) const {
+  auto &DL = M.getDataLayout();
+  auto &Ctx = M.getContext();
+  return std::max(DL.getABITypeAlign(Type::getInt64Ty(Ctx)), DL.getABITypeAlign(Type::getDoubleTy(Ctx)));
+}
+
 TargetLibraryInfoWrapperPass::TargetLibraryInfoWrapperPass()
     : ImmutablePass(ID), TLA(TargetLibraryInfoImpl()) {
   initializeTargetLibraryInfoWrapperPassPass(*PassRegistry::getPassRegistry());
diff --git a/llvm/lib/Transforms/Utils/BuildLibCalls.cpp b/llvm/lib/Transforms/Utils/BuildLibCalls.cpp
index 7a5326c25583..c18a79a46aa1 100644
--- a/llvm/lib/Transforms/Utils/BuildLibCalls.cpp
+++ b/llvm/lib/Transforms/Utils/BuildLibCalls.cpp
@@ -270,6 +270,13 @@ static bool setAllocKind(Function &F, AllocFnKind K) {
   return true;
 }
 
+static bool setMaxAlign(Function &F, const TargetLibraryInfo &TLI) {
+  if (F.hasRetAttribute(Attribute::Alignment))
+    return false;
+  F.addRetAttr(Attribute::getWithAlignment(F.getContext(), TLI.getMaxAlignTAlignment(*F.getParent())));
+  return true;
+}
+
 bool llvm::inferNonMandatoryLibFuncAttrs(Module *M, StringRef Name,
                                          const TargetLibraryInfo &TLI) {
   Function *F = M->getFunction(Name);
@@ -480,6 +487,7 @@ bool llvm::inferNonMandatoryLibFuncAttrs(Function &F,
     Changed |= setDoesNotThrow(F);
     Changed |= setRetDoesNotAlias(F);
     Changed |= setWillReturn(F);
+    Changed |= setMaxAlign(F, TLI);
     break;
   case LibFunc_memcmp:
     Changed |= setOnlyAccessesArgMemory(F);
@@ -666,6 +674,7 @@ bool llvm::inferNonMandatoryLibFuncAttrs(Function &F,
     Changed |= setDoesNotThrow(F);
     Changed |= setRetDoesNotAlias(F);
     Changed |= setWillReturn(F);
+    Changed |= setMaxAlign(F, TLI);
     break;
   case LibFunc_chmod:
   case LibFunc_chown:

Unfortunately, we don't know the exact value of alignof(max_align_t). We may pass this value from clang frontend as we did for wchar_size.

[frederick-vs-ja]

However, see WG14 N2293 which has been adopted for C23. IMO it is essentially a Defect Report and cppreference should be updated.

The paper legitimated some weak-alignment implementations where the result of malloc(1) is only required to be aligned as char. If we want to achieve the desired optimization, it might be necessary to detect strong-alignment environments statically.