Implement __builtin_alloca_with_align for GCC compatibility

[rnk]

Summary

GCC documents that the alignment parameter is in bits and it must be:

• an integer constant
• a power of two
• a multiple of CHAR_BITS
• below an unspecified limit

This lines up directly with the requirements for LLVM's alloca
instruction, so I went ahead and wired it up. We limit the alignment to
1<<29, which is the maximum alignment supported by LLVM's alloca.

Implements feature request in PR30658

[rsmith]

lib/CodeGen/CGBuiltin.cpp

1037–1039

This takes the alignment in bits? That's so ridiculously dumb that I would feel bad about accepting this patch unless it comes with a warning for people writing the obvious-but-wrong __builtin_alloca_with_align(sizeof(T), alignof(T)).

1038–1039

EvaluateKnownConstInt, perhaps?

1040–1041

CGM.getContext().toCharUnitsFromBits maybe?

lib/Sema/SemaChecking.cpp

971–972

EvaluateKnownConstInt, perhaps?

973

Well, this comment won't cause that to happen. Do you anticipate that value changing?

test/Sema/builtin-alloca.c

7

Can you also add tests for -1 and (__int128)1 << 100? (They should both pass, already, but seem like interesting corner cases regardless.)

[rnk]

@majnemer did this in rL285544

include/clang/Basic/Builtins.def

 BUILTIN(__builtin_prefetch, "vvC*.", "nc")
 BUILTIN(__builtin_readcyclecounter, "ULLi", "n")
 BUILTIN(__builtin_trap, "v", "nr")
 BUILTIN(__builtin_debugtrap, "v", "n")
 BUILTIN(__builtin_unreachable, "v", "nr")
 BUILTIN(__builtin_shufflevector, "v."   , "nc")
 BUILTIN(__builtin_convertvector, "v."   , "nct")
 BUILTIN(__builtin_alloca, "v*z"   , "Fn")
+BUILTIN(__builtin_alloca_with_align, "v*zIz", "n")
 BUILTIN(__builtin_call_with_static_chain, "v.", "nt")
 
 // "Overloaded" Atomic operator builtins.  These are overloaded to support data
 // types of i8, i16, i32, i64, and i128.  The front-end sees calls to the
 // non-suffixed version of these (which has a bogus type) and transforms them to
 // the right overloaded version in Sema (plus casts).
 
 // FIXME: These assume that char -> i8, short -> i16, int -> i32,

include/clang/Basic/DiagnosticSemaKinds.td

def err_no_accessor_for_property : Error<
   "no %select{getter|setter}0 defined for property %1">;
 def error_cannot_find_suitable_accessor : Error<
   "cannot find suitable %select{getter|setter}0 for property %1">;
 
 def err_alignment_not_power_of_two : Error<
   "requested alignment is not a power of 2">;
 def err_alignment_dependent_typedef_name : Error<
   "requested alignment is dependent but declaration is not dependent">;
+def err_alignment_not_char_width : Error<
+  "requested bit alignment is not a multiple of CHAR_WIDTH">;
 
 def err_attribute_aligned_too_great : Error<
   "requested alignment must be %0 bytes or smaller">;
 def warn_redeclaration_without_attribute_prev_attribute_ignored : Warning<
   "%q0 redeclared without %1 attribute: previous %1 ignored">,
   InGroup<MicrosoftInconsistentDllImport>;
 def warn_redeclaration_without_import_attribute : Warning<
   "%q0 redeclared without 'dllimport' attribute: 'dllexport' attribute added">,

lib/CodeGen/CGBuiltin.cpp

RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
   }
 
   case Builtin::BIalloca:
   case Builtin::BI_alloca:
   case Builtin::BI__builtin_alloca: {
     Value *Size = EmitScalarExpr(E->getArg(0));
     return RValue::get(Builder.CreateAlloca(Builder.getInt8Ty(), Size));
   }
+  case Builtin::BI__builtin_alloca_with_align: {
+    // FIXME: The GCC docs say that the "lifetime of the allocated object ends
+    // at the end of the block in which the function was called", but "the
+    // allocated storage is released no later than just before the calling
+    // function returns to its caller". Our implementation behaves like a normal
+    // alloca, which releases the allocated memory on function return.
+    Value *Size = EmitScalarExpr(E->getArg(0));
+    llvm::APSInt AlignInBits;
+    if (!E->getArg(1)->EvaluateAsInt(AlignInBits, CGM.getContext()))
+      break;
+    unsigned Align =
+        AlignInBits.getZExtValue() / CGM.getContext().getCharWidth();
+    return RValue::get(
+        Builder.Insert(new AllocaInst(Builder.getInt8Ty(), Size, Align)));
+  }
   case Builtin::BIbzero:
   case Builtin::BI__builtin_bzero: {
     Address Dest = EmitPointerWithAlignment(E->getArg(0));
     Value *SizeVal = EmitScalarExpr(E->getArg(1));
     EmitNonNullArgCheck(RValue::get(Dest.getPointer()), E->getArg(0)->getType(),
                         E->getArg(0)->getExprLoc(), FD, 0);
     Builder.CreateMemSet(Dest, Builder.getInt8(0), SizeVal, false);
     return RValue::get(Dest.getPointer());

lib/Sema/SemaChecking.cpp

if (!getLangOpts().CPlusPlus) {
         << "C++";
       return ExprError();
     }
     // CodeGen assumes it can find the global new and delete to call,
     // so ensure that they are declared.
     DeclareGlobalNewDelete();
     break;
 
+  case Builtin::BI__builtin_alloca_with_align: {
+    llvm::APSInt AlignAP;
+    bool AlignIsConst = TheCall->getArg(1)->EvaluateAsInt(AlignAP, Context);
+    assert(AlignIsConst && "basic checking failed");
+    // Keep this in sync with llvm::Value::MaximumAlignment.
+    unsigned MaxAlignBytes = 1U << 29;
+    if (!AlignAP.isPowerOf2()) {
+      Diag(TheCall->getExprLoc(), diag::err_alignment_not_power_of_two);
+      return ExprError();
+    }
+    if (AlignAP > MaxAlignBytes * 8ULL) {
+      Diag(TheCall->getExprLoc(), diag::err_attribute_aligned_too_great)
+          << MaxAlignBytes;
+      return ExprError();
+    }
+    if (AlignAP.getZExtValue() % Context.getCharWidth() != 0) {
+      Diag(TheCall->getExprLoc(), diag::err_alignment_not_char_width);
+      return ExprError();
+    }
+    break;
+  }
+
   // check secure string manipulation functions where overflows
   // are detectable at compile time
   case Builtin::BI__builtin___memcpy_chk:
   case Builtin::BI__builtin___memmove_chk:
   case Builtin::BI__builtin___memset_chk:
   case Builtin::BI__builtin___strlcat_chk:
   case Builtin::BI__builtin___strlcpy_chk:
   case Builtin::BI__builtin___strncat_chk:

test/CodeGen/alloca.c

-// RUN: %clang_cc1 -emit-llvm %s  -o /dev/null
+// RUN: %clang_cc1 -triple x86_64-linux -emit-llvm %s -o - | FileCheck %s
 
 typedef __SIZE_TYPE__ size_t;
 void *alloca(size_t size);
 char *strcpy(char *restrict s1, const char *restrict s2);
 int puts(const char *s);
 int main(int argc, char **argv) {
   char *C = (char*)alloca(argc);
   strcpy(C, argv[0]);
   puts(C);
 }
+
+// CHECK-LABEL: define i32 @main
+// CHECK: alloca i8, i64 %{{.*}}
+// CHECK: call i8* @strcpy
+
+
+void aligned_alloca(size_t n) {
+  __builtin_alloca_with_align(n, 8);
+  __builtin_alloca_with_align(n, 64);
+  __builtin_alloca_with_align(n, 128);
+  __builtin_alloca_with_align(n, 4096);
+}
+
+// CHECK-LABEL: define void @aligned_alloca
+// CHECK: alloca i8, i64 %{{[^,]*}}, align 1
+// CHECK: alloca i8, i64 %{{[^,]*}}, align 8
+// CHECK: alloca i8, i64 %{{[^,]*}}, align 16
+// CHECK: alloca i8, i64 %{{[^,]*}}, align 512

test/Sema/builtin-alloca.c

+// RUN: %clang_cc1 %s -verify -triple=x86_64-linux
+
+void aligned_alloca(__SIZE_TYPE__ n) {
+  __builtin_alloca_with_align(n, n); // expected-error {{argument to '__builtin_alloca_with_align' must be a constant integer}}
+  __builtin_alloca_with_align(n, 3); // expected-error {{requested alignment is not a power of 2}}
+  __builtin_alloca_with_align(n, 4); // expected-error {{requested bit alignment is not a multiple of CHAR_WIDTH}}
+  __builtin_alloca_with_align(n, 8ULL<<30); // expected-error {{requested alignment must be 536870912 bytes or smaller}}
+  __builtin_alloca_with_align(n, 8);
+  __builtin_alloca_with_align(n, 64);
+  __builtin_alloca_with_align(n, 128);
+  __builtin_alloca_with_align(n, 4096);
+}