Invariants (and Assume Aligned) - Clang

[hfinkel]

Summary

Clang patch for __builtin_assume_aligned; making use of LLVM IR invariants.

lib/CodeGen/CGBuiltin.cpp

400

You can replace this with a simple array.

[gribozavr]

lib/Sema/SemaChecking.cpp

1951–1952

Maybe three slashes to make it a Doxygen comment?

test/Sema/builtin-assume-aligned.c

28

Please add tests for every Diag() in semantic analysis: too many/too few args, dependent argument, a 64-bit alignment, a non-pow2 alignment, a non-ICE 3rd argument and a 3rd argument with bad type.

[hfinkel]

Test cases have been enhanced. We now use @llvm.invariant.

[gribozavr]

Please update docs/LanguageExtensions.html with descriptions of these two new builtins.

lib/Sema/SemaChecking.cpp

1965

Should we just reject these cases? Seems like we would silently accept it without checking.

Or would it get checked during template instantiation?

1970–1973

What is the purpose of the '+' in '+llvm::Value::MaximumAlignment'?

test/Sema/builtin-assume-aligned.c

38

Still not enough :)

Please add:

__builtin_assume_aligned(a, 1ULL << 63);
int test9(int *a, int z) {
  a = __builtin_assume_aligned(a, z + 1); // not a constant expression
  return a[0];
}
template<int z>
int test10(int *a) {
  a = __builtin_assume_aligned(a, z + 1); // value-dependent
  return a[0];
}
void test10_inst(int *a) {
  test10<32>(a); // power of 2
  test10<42>(a); // not a power of 2
}
template<typename T>
int test11(int *a, T z) {
  a = __builtin_assume_aligned(a, z + 1); // value-dependent
  return a[0];
}
void test11_inst(int *a) {
  test11(a, 42);
}
int test12(int *a) {
  a = __builtin_assume_aligned(a, 32, "abc"); // wrong type
  return a[0];
}
int test13(int *a, int z) {
  a = __builtin_assume_aligned(a, z); // not a constant
  return a[0];
}

[hfinkel]

More, and more explicit, test cases. Removed unneeded '+' operators. Added documentation.

[gribozavr]

I don't have more comments, so this looks good to me, but please wait for another review.

docs/LanguageExtensions.html

1400 ↗

(On Diff #441)

typo: he -> the

1409–1412 ↗

(On Diff #441)

Same comment as for LLVM intrinsic:

What about adding explicitly: "If the condition does not hold during execution, the behavior is undefined"?

[hfinkel]

• Original Message -----

From: "Dmitri Gribenko" <[e-mail]>
To: [e-mail]
Cc: [e-mail], [e-mail], [e-mail]
Sent: Wednesday, December 5, 2012 5:57:58 PM
Subject: Re: [PATCH] Invariants (and Assume Aligned) - Clang

I don't have more comments, so this looks good to me, but please
wait for another review.

Thanks! I will do (this also depends on the LLVM patch(es); and those would need to go in first).

-Hal

Comment at: docs/LanguageExtensions.html:1409-1412
@@ +1408,6 @@
+
+<p>The boolean argument to this function is defined to be true. The
optimizer
+may analyze the expression used to compute the argument and deduce
from that
+analysis information used to optimize the program.
+</p>

+

Same comment as for LLVM intrinsic:

What about adding explicitly: "If the condition does not hold during
execution, the behavior is undefined"?

Comment at: docs/LanguageExtensions.html:1400
@@ +1399,3 @@
+
+ if (x == 0) // he optimizer may short-circuit this check using the
invariant.

+ return do_something();

typo: he -> the

http://llvm-reviews.chandlerc.com/D149

[hfinkel]

• Original Message -----

From: "Dmitri Gribenko" <[e-mail]>
To: [e-mail]
Cc: [e-mail], [e-mail], [e-mail]
Sent: Wednesday, December 5, 2012 5:57:58 PM
Subject: Re: [PATCH] Invariants (and Assume Aligned) - Clang

I don't have more comments, so this looks good to me, but please
wait for another review.

Thanks! I will do (this also depends on the LLVM patch(es); and those would need to go in first).

-Hal

Comment at: docs/LanguageExtensions.html:1409-1412
@@ +1408,6 @@
+
+<p>The boolean argument to this function is defined to be true. The
optimizer
+may analyze the expression used to compute the argument and deduce
from that
+analysis information used to optimize the program.
+</p>

+

Same comment as for LLVM intrinsic:

What about adding explicitly: "If the condition does not hold during
execution, the behavior is undefined"?

Comment at: docs/LanguageExtensions.html:1400
@@ +1399,3 @@
+
+ if (x == 0) // he optimizer may short-circuit this check using the
invariant.

+ return do_something();

typo: he -> the

http://llvm-reviews.chandlerc.com/D149

[gribozavr]

A couple of quality-of-implementation things that would be nice to implement:

• a warning if __builtin_assume_aligned is used to weaken alignment
• extend th undefined behavior sanitizer with codegen for these builtins so that alignment and other invariants are checked at runtime

[hfinkel]

Rebased (and also hooked up MSVC's assume along with builtin_assume).

An updated version of the associated LLVM patches is coming soon.

[hfinkel]

Use +llvm::Value::MaximumAlignment in Sema to force evaluation and prevent errors like this (in Debug builds):

libclang.so: undefined reference to `llvm::Value::MaximumAlignment'

(which is the same thing that is done in lib/Transforms/Utils/Local.cpp)

[rsmith]

docs/LanguageExtensions.rst

1267–1269

You should indicate whether and when the condition is evaluated here. IIRC, MS' __assume does not evaluate its argument, so if this builtin differs from that we should be explicit about that difference.

lib/AST/ExprConstant.cpp

6089

Please also add handling of BI__builtin_assume to VoidExprEvaluator.

lib/CodeGen/CGBuiltin.cpp

407

Skip this if the OffsetValue is the ConstantInt 0? (I'm kinda surprised the IRBuilder doesn't already do that...)

418

Is this really correct? As noted above, I think __assume doesn't evaluate its argument. Perhaps I'm mistaken.

lib/Sema/SemaChecking.cpp

38

I'm not happy about this dependency. But see below...

1961

This is a bit confusing. These seem to be two entirely unrelated facts (the alignment is argument 1).

1970–1973

What's the purpose of this check? If I want to claim that my pointer is 0x8000'0000'0000ull bytes aligned, I don't see why we should diagnose that, even if LLVM can't represent that alignment. CodeGen doesn't care about this being a valid LLVM alignment.

1976

This seems like an odd diagnostic ID to reuse. If you want to use it, please change its name to not mention an attribute.

1984–1985

I don't see how LLVM's supported alignment values have any impact here?

1988

Again, this is a weird diagnostic ID to reuse. This has nothing to do with converted constant expressions. (And you never even tried to do any conversion, so you can't reasonably claim the argument is not implicitly convertible to a particular type.)

Instead of all this, please perform the appropriate conversion from the argument to type size_t:

InitializedEntity Entity = InitializedEntity::InitializeParameter(Context, Context.getSizeType(), false);
Arg = PerformCopyInitialization(Entity, SourceLocation(), Arg);
if (Arg.isInvalid()) return true;

[hfinkel]

I'll update, thanks!

docs/LanguageExtensions.rst

1267–1269

Interesting point. MS's documentation says, "no code is generated", but does not otherwise specify the semantics of what is done with the arguments. With the LLVM intrinsic, although IR is generated, no assembly is generated.

Are you asking whether assume is more like decltype? Or could assume(*a > 0) trap if a were nullptr? I'm pretty sure that the answers are no and yes, respectively. MS's documentation specifically talks about using __assume as a production-build replacement for assert, and I assume so must evaluate its inputs in a similar-enough way to make that workable.

[hfinkel]

docs/LanguageExtensions.rst

1267–1269

After writing that, it occurred to me that whether or not assert evaluates its arguments depends on the preprocessor state, so there is little to infer from that comparison.

What is true is that MS has a compiler warning: C4557 (The value passed to an assume statement was modified.) which triggers on code like assume(i++).

[hfinkel]

docs/LanguageExtensions.rst

1267–1269

echristo just confirmed for me on IRC that __assume does not evaluate its arguments. I'll need to filter for side effects.

[hfinkel]

Thanks! Will post updated patch soon.

docs/LanguageExtensions.rst

1267–1269

Done.

lib/AST/ExprConstant.cpp

6089

Done.

lib/CodeGen/CGBuiltin.cpp

407

Done.

418

No, you're right. I added a side-effects check.

lib/Sema/SemaChecking.cpp

38

Removed.

1961

Agreed. I removed the bit about argument 0 (I'm not sure it really adds anything).

1970–1973

Good point.

1976

Renamed.

1984–1985

Fair enough.

1988

Thanks!

[hfinkel]

Rebased and updated per Richard's comments.

[hfinkel]

The LLVM intrinsic has been renamed to llvm.assume (from llvm.invariant) based on community feedback.

[hfinkel]

Same functionality, but extracted a EmitAlignmentAssumption CGF helper function to make it easier for other code to also emit alignment assumptions.

[hfinkel]

Moved .cpp test from Sema to SemaCXX (and rebased).

[hfinkel]

(will close)

[hfinkel]

r217349, thanks!

docs/LanguageExtensions.rst

 syntax to be used with ``std::complex`` with the same meaning.)
 
 Builtin Functions
 =================
 
 Clang supports a number of builtin library functions with the same syntax as
 GCC, including things like ``__builtin_nan``, ``__builtin_constant_p``,
 ``__builtin_choose_expr``, ``__builtin_types_compatible_p``,
-``__sync_fetch_and_add``, etc.  In addition to the GCC builtins, Clang supports
-a number of builtins that GCC does not, which are listed here.
+``__builtin_assume_aligned``, ``__sync_fetch_and_add``, etc.  In addition to
+the GCC builtins, Clang supports a number of builtins that GCC does not, which
+are listed here.
 
 Please note that Clang does not and will not support all of the GCC builtins
 for vector operations.  Instead of using builtins, you should use the functions
 defined in target-specific header files like ``<xmmintrin.h>``, which define
 portable wrappers for these.  Many of the Clang versions of these functions are
 implemented directly in terms of :ref:`extended vector support
 <langext-vectors>` instead of builtins, in order to reduce the number of
 builtins that we need to implement.
 
+``__builtin_assume``
+------------------------------
+
+``__builtin_assume`` is used to provide the optimizer with a boolean
+invariant that is defined to be true.
+
+**Syntax**:
+
+.. code-block:: c++
+
+  __builtin_assume(bool)
+
+**Example of Use**:
+
+.. code-block:: c++
+
+  int foo(int x) {
+    __builtin_assume(x != 0);
+
+    // The optimizer may short-circuit this check using the invariant.
+    if (x == 0)
+      return do_something();
+
+    return do_something_else();
+  }
+
+**Description**:
+
+The boolean argument to this function is defined to be true. The optimizer may
+analyze the expression used to compute the argument and deduce from that
+information used to optimize the program. If the condition is violated during
+execution, the behavior is undefined.
+
+Query for this feature with ``__has_builtin(__builtin_assume)``.
+
 ``__builtin_readcyclecounter``
 ------------------------------
 
 ``__builtin_readcyclecounter`` is used to access the cycle counter register (or
 a similar low-latency, high-accuracy clock) on those targets that support it.
 
 **Syntax**:
 

include/clang/Basic/Builtins.def

 BUILTIN(__builtin_constant_p, "i.", "nctu")
 BUILTIN(__builtin_classify_type, "i.", "nctu")
 BUILTIN(__builtin___CFStringMakeConstantString, "FC*cC*", "nc")
 BUILTIN(__builtin___NSStringMakeConstantString, "FC*cC*", "nc")
 BUILTIN(__builtin_va_start, "vA.", "nt")
 BUILTIN(__builtin_va_end, "vA", "n")
 BUILTIN(__builtin_va_copy, "vAA", "n")
 BUILTIN(__builtin_stdarg_start, "vA.", "n")
+BUILTIN(__builtin_assume_aligned, "v*vC*z.", "nc")
 BUILTIN(__builtin_bcmp, "iv*v*z", "n")
 BUILTIN(__builtin_bcopy, "vv*v*z", "n")
 BUILTIN(__builtin_bzero, "vv*z", "nF")
 BUILTIN(__builtin_fprintf, "iP*cC*.", "Fp:1:")
 BUILTIN(__builtin_memchr, "v*vC*iz", "nF")
 BUILTIN(__builtin_memcmp, "ivC*vC*z", "nF")
 BUILTIN(__builtin_memcpy, "v*v*vC*z", "nF")
 BUILTIN(__builtin_memmove, "v*v*vC*z", "nF")

 // Blocks runtime Builtin math library functions
 LIBBUILTIN(_Block_object_assign, "vv*vC*iC", "f", "Blocks.h", ALL_LANGUAGES)
 LIBBUILTIN(_Block_object_dispose, "vvC*iC", "f", "Blocks.h", ALL_LANGUAGES)
 // FIXME: Also declare NSConcreteGlobalBlock and NSConcreteStackBlock.
 
 // Annotation function
 BUILTIN(__builtin_annotation, "v.", "tn")
 
+// Invariants
+BUILTIN(__builtin_assume, "vb", "n")
+
 // Multiprecision Arithmetic Builtins.
 BUILTIN(__builtin_addcb, "UcUcCUcCUcCUc*", "n")
 BUILTIN(__builtin_addcs, "UsUsCUsCUsCUs*", "n")
 BUILTIN(__builtin_addc, "UiUiCUiCUiCUi*", "n")
 BUILTIN(__builtin_addcl, "ULiULiCULiCULiCULi*", "n")
 BUILTIN(__builtin_addcll, "ULLiULLiCULLiCULLiCULLi*", "n")
 BUILTIN(__builtin_subcb, "UcUcCUcCUcCUc*", "n")
 BUILTIN(__builtin_subcs, "UsUsCUsCUsCUs*", "n")

include/clang/Sema/Sema.h

public:
   // Used by C++ template instantiation.
   ExprResult SemaBuiltinShuffleVector(CallExpr *TheCall);
   ExprResult SemaConvertVectorExpr(Expr *E, TypeSourceInfo *TInfo,
                                    SourceLocation BuiltinLoc,
                                    SourceLocation RParenLoc);
 
 private:
   bool SemaBuiltinPrefetch(CallExpr *TheCall);
+  bool SemaBuiltinAssumeAligned(CallExpr *TheCall);
   bool SemaBuiltinLongjmp(CallExpr *TheCall);
   ExprResult SemaBuiltinAtomicOverloaded(ExprResult TheCallResult);
   ExprResult SemaAtomicOpsOverloaded(ExprResult TheCallResult,
                                      AtomicExpr::AtomicOp Op);
   bool SemaBuiltinConstantArg(CallExpr *TheCall, int ArgNum,
                               llvm::APSInt &Result);
   bool SemaBuiltinConstantArgRange(CallExpr *TheCall, int ArgNum,
                                    int Low, int High);

lib/AST/ExprConstant.cpp

bool IntExprEvaluator::VisitCallExpr(const CallExpr *E) {
   }
 
   case Builtin::BI__builtin_eh_return_data_regno: {
     int Operand = E->getArg(0)->EvaluateKnownConstInt(Info.Ctx).getZExtValue();
     Operand = Info.Ctx.getTargetInfo().getEHDataRegisterNumber(Operand);
     return Success(Operand, E);
   }
 
+  case Builtin::BI__builtin_assume_aligned:
   case Builtin::BI__builtin_expect:
     return Visit(E->getArg(0));
 
   case Builtin::BI__builtin_ffs:
   case Builtin::BI__builtin_ffsl:
   case Builtin::BI__builtin_ffsll: {
     APSInt Val;
     if (!EvaluateInteger(E->getArg(0), Val, Info))

lib/CodeGen/CGBuiltin.cpp

case Builtin::BI__builtin_expect: {
 
     Value *FnExpect = CGM.getIntrinsic(Intrinsic::expect, ArgType);
     Value *ExpectedValue = EmitScalarExpr(E->getArg(1));
 
     Value *Result = Builder.CreateCall2(FnExpect, ArgValue, ExpectedValue,
                                         "expval");
     return RValue::get(Result);
   }
+  case Builtin::BI__builtin_assume_aligned: {
+    Value *PtrValue = EmitScalarExpr(E->getArg(0));
+    Value *PtrIntValue =
+      Builder.CreatePtrToInt(PtrValue, IntPtrTy, "ptrint");
+
+    Value *AlignmentValue = EmitScalarExpr(E->getArg(1));
+    ConstantInt *AlignmentCI = cast<ConstantInt>(AlignmentValue);
+    unsigned Alignment = (unsigned) AlignmentCI->getZExtValue();
+
+    Value *Mask = llvm::ConstantInt::get(IntPtrTy,
+      Alignment > 0 ? Alignment - 1 : 0);
+    if (E->getNumArgs() > 2) {
+      Value *OffsetValue = EmitScalarExpr(E->getArg(2));
+      if (OffsetValue->getType() != IntPtrTy)
+        OffsetValue = Builder.CreateIntCast(OffsetValue, IntPtrTy,
+                        /*isSigned*/true, "offsetcast");
+      PtrIntValue = Builder.CreateSub(PtrIntValue, OffsetValue, "offsetptr");
+    }
+
+    Value *Zero = llvm::ConstantInt::get(IntPtrTy, 0);
+    Value *MaskedPtr = Builder.CreateAnd(PtrIntValue, Mask, "maskedptr");
+    Value *InvCond = Builder.CreateICmpEQ(MaskedPtr, Zero, "maskcond");
+
+    Value *FnInvariant = CGM.getIntrinsic(Intrinsic::invariant);
+    Builder.CreateCall(FnInvariant, InvCond);
+    return RValue::get(PtrValue);
+  }
+  case Builtin::BI__assume:
+  case Builtin::BI__builtin_assume: {
+    Value *ArgValue = EmitScalarExpr(E->getArg(0));
+    Value *FnInvariant = CGM.getIntrinsic(Intrinsic::invariant);
+    return RValue::get(Builder.CreateCall(FnInvariant, ArgValue));
+  }
   case Builtin::BI__builtin_bswap16:
   case Builtin::BI__builtin_bswap32:
   case Builtin::BI__builtin_bswap64: {
     Value *ArgValue = EmitScalarExpr(E->getArg(0));
     llvm::Type *ArgType = ArgValue->getType();
     Value *F = CGM.getIntrinsic(Intrinsic::bswap, ArgType);
     return RValue::get(Builder.CreateCall(F, ArgValue));
   }

lib/Sema/SemaChecking.cpp

 #include "clang/Lex/Lexer.h" // TODO: Extract static functions to fix layering.
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/Sema.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/IR/Value.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/raw_ostream.h"
 #include <limits>
 using namespace clang;
 using namespace sema;
 
 SourceLocation Sema::getLocationOfStringLiteralByte(const StringLiteral *SL,
                                                     unsigned ByteNo) const {
Sema::CheckBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
   case Builtin::BI__builtin_shufflevector:
     return SemaBuiltinShuffleVector(TheCall);
     // TheCall will be freed by the smart pointer here, but that's fine, since
     // SemaBuiltinShuffleVector guts it, but then doesn't release it.
   case Builtin::BI__builtin_prefetch:
     if (SemaBuiltinPrefetch(TheCall))
       return ExprError();
     break;
+  case Builtin::BI__builtin_assume_aligned:
+    if (SemaBuiltinAssumeAligned(TheCall))
+      return ExprError();
+    break;
   case Builtin::BI__builtin_object_size:
     if (SemaBuiltinConstantArgRange(TheCall, 1, 0, 3))
       return ExprError();
     break;
   case Builtin::BI__builtin_longjmp:
     if (SemaBuiltinLongjmp(TheCall))
       return ExprError();
     break;
bool Sema::SemaBuiltinPrefetch(CallExpr *TheCall) {
   // constant integers.
   for (unsigned i = 1; i != NumArgs; ++i)
     if (SemaBuiltinConstantArgRange(TheCall, i, 0, i == 1 ? 1 : 3))
       return true;
 
   return false;
 }
 
+/// Handle __builtin_assume_aligned. This is declared
+/// as (const void*, size_t, ...) and can take one optional constant int arg.
+bool Sema::SemaBuiltinAssumeAligned(CallExpr *TheCall) {
+  unsigned NumArgs = TheCall->getNumArgs();
+
+  if (NumArgs > 3)
+    return Diag(TheCall->getLocEnd(),
+             diag::err_typecheck_call_too_many_args_at_most)
+             << 0 /*function call*/ << 3 << NumArgs
+             << TheCall->getSourceRange();
+
+  // Argument 0 is checked for us; the alignment must be a constant integer.
+  Expr *Arg = TheCall->getArg(1);
+
+  // We can't check the value of a dependent argument.
+  if (!Arg->isTypeDependent() && !Arg->isValueDependent()) {
+    llvm::APSInt Result;
+    if (SemaBuiltinConstantArg(TheCall, 1, Result))
+      return true;
+
+    if (Result.getLimitedValue() > +llvm::Value::MaximumAlignment ||
+        !Result.isUnsigned())
+      return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range)
+           << "0" << +llvm::Value::MaximumAlignment << Arg->getSourceRange();
+    if (!Result.isPowerOf2())
+      return Diag(TheCall->getLocStart(),
+                  diag::err_attribute_aligned_not_power_of_two)
+           << Arg->getSourceRange();
+  }
+
+  if (NumArgs > 2) {
+    Arg = TheCall->getArg(2);
+    QualType T = Arg->getType();
+
+    // Note: gcc specifies the prototype as taking a size_t, but LLVM can
+    // handle only 32-bit alignment values.
+    if (!T->isIntegralType(Context))
+      return Diag(TheCall->getLocStart(),
+               diag::err_typecheck_converted_constant_expression)
+          << T << "an integral type" << Arg->getSourceRange();
+  }
+
+  return false;
+}
+
 /// SemaBuiltinConstantArg - Handle a check if argument ArgNum of CallExpr
 /// TheCall is a constant expression.
 bool Sema::SemaBuiltinConstantArg(CallExpr *TheCall, int ArgNum,
                                   llvm::APSInt &Result) {
   Expr *Arg = TheCall->getArg(ArgNum);
   DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
   FunctionDecl *FDecl = cast<FunctionDecl>(DRE->getDecl());
   

test/CodeGen/builtin-assume-aligned.c

+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -o - %s | FileCheck %s
+
+// CHECK: @test1
+int test1(int *a) {
+// CHECK: %ptrint = ptrtoint
+// CHECK: %offsetptr = sub i64 %ptrint, 0
+// CHECK: %maskedptr = and i64 %offsetptr, 31
+// CHECK: %maskcond = icmp eq i64 %maskedptr, 0
+// CHECK: call void @llvm.invariant(i1 %maskcond)
+  a = __builtin_assume_aligned(a, 32, 0ull);
+  return a[0];
+}
+
+// CHECK: @test2
+int test2(int *a) {
+// CHECK: %ptrint = ptrtoint
+// CHECK: %offsetptr = sub i64 %ptrint, 0
+// CHECK: %maskedptr = and i64 %offsetptr, 31
+// CHECK: %maskcond = icmp eq i64 %maskedptr, 0
+// CHECK: call void @llvm.invariant(i1 %maskcond)
+  a = __builtin_assume_aligned(a, 32, 0);
+  return a[0];
+}
+
+// CHECK: @test3
+int test3(int *a) {
+// CHECK: %ptrint = ptrtoint
+// CHECK: %maskedptr = and i64 %ptrint, 31
+// CHECK: %maskcond = icmp eq i64 %maskedptr, 0
+// CHECK: call void @llvm.invariant(i1 %maskcond)
+  a = __builtin_assume_aligned(a, 32);
+  return a[0];
+}
+
+// CHECK: @test4
+int test4(int *a, int b) {
+// CHECK: %ptrint = ptrtoint
+// CHECK: %offsetcast = sext i32
+// CHECK: %offsetptr = sub i64 %ptrint, %offsetcast
+// CHECK: %maskedptr = and i64 %offsetptr, 31
+// CHECK: %maskcond = icmp eq i64 %maskedptr, 0
+// CHECK: call void @llvm.invariant(i1 %maskcond)
+  a = __builtin_assume_aligned(a, 32, b);
+  return a[0];
+}
+

test/CodeGen/builtin-assume.c

+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple i386-mingw32 -fms-extensions -emit-llvm -o - %s | FileCheck %s
+
+// CHECK: @test1
+int test1(int *a) {
+// CHECK: %0 = load i32** %a.addr
+// CHECK: %cmp = icmp ne i32* %0, null
+// CHECK: call void @llvm.invariant(i1 %cmp)
+#ifdef _MSC_VER
+  __assume(a != 0)
+#else
+  __builtin_assume(a != 0);
+#endif
+  return a[0];
+}
+

test/Sema/builtin-assume-aligned-tmpl.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<int z>
+int test9(int *a) {
+  a = (int *) __builtin_assume_aligned(a, z + 1); // expected-error {{requested alignment is not a power of 2}}
+  return a[0];
+}
+
+void test9i(int *a) {
+  test9<42>(a); // expected-note {{in instantiation of function template specialization 'test9<42>' requested here}}
+}
+
+template<typename T>
+int test10(int *a, T z) {
+  a = (int *) __builtin_assume_aligned(a, z + 1); // expected-error {{must be a constant integer}}
+  return a[0];
+}
+
+int test10i(int *a) {
+  return test10(a, 42); // expected-note {{in instantiation of function template specialization 'test10<int>' requested here}}
+}
+

test/Sema/builtin-assume-aligned.c

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+int test1(int *a) {
+  a = __builtin_assume_aligned(a, 32, 0ull);
+  return a[0];
+}
+
+int test2(int *a) {
+  a = __builtin_assume_aligned(a, 32, 0);
+  return a[0];
+}
+
+int test3(int *a) {
+  a = __builtin_assume_aligned(a, 32);
+  return a[0];
+}
+
+int test4(int *a) {
+  a = __builtin_assume_aligned(a, -32); // expected-error {{argument should be a value from 0 to 536870912}}
+  a = __builtin_assume_aligned(a, 1ULL << 63); // expected-error {{argument should be a value from 0 to 536870912}}
+  return a[0];
+}
+
+int test5(int *a, unsigned *b) {
+  a = __builtin_assume_aligned(a, 32, b); // expected-error {{value of type 'unsigned int *' is not implicitly convertible to an integral type}}
+  return a[0];
+}
+
+int test6(int *a) {
+  a = __builtin_assume_aligned(a, 32, 0, 0); // expected-error {{too many arguments to function call, expected at most 3, have 4}}
+  return a[0];
+}
+
+int test7(int *a) {
+  a = __builtin_assume_aligned(a, 31); // expected-error {{requested alignment is not a power of 2}}
+  return a[0];
+}
+
+int test8(int *a, int j) {
+  a = __builtin_assume_aligned(a, j); // expected-error {{must be a constant integer}}
+  return a[0];
+}
+