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

2112–2113

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

2126

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

Or would it get checked during template instantiation?

2131–2134

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

6095

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...

2069

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

2078–2081

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.

2084

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

2092–2093

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

2096

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

6095

Done.

lib/CodeGen/CGBuiltin.cpp

407

Done.

418

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

lib/Sema/SemaChecking.cpp

38

Removed.

2069

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

2078–2081

Good point.

2084

Renamed.

2092–2093

Fair enough.

2096

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 form of the expression provided as the argument and deduce from
+that information used to optimize the program. If the condition is violated
+during execution, the behavior is undefined. The argument itself is never
+evaluated, so any side effects of the expression will be discarded.
+
+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/Basic/DiagnosticSemaKinds.td

def warn_strncat_src_size : Warning<"size argument in 'strncat' call appears "
   "to be size of the source">, InGroup<StrncatSize>;
 def warn_strncat_wrong_size : Warning<
   "the value of the size argument to 'strncat' is wrong">, InGroup<StrncatSize>;
 def note_strncat_wrong_size : Note<
   "change the argument to be the free space in the destination buffer minus " 
   "the terminating null byte">;
 
 def warn_assume_side_effects : Warning<
-  "the argument to __assume has side effects that will be discarded">,
+  "the argument to %0 has side effects that will be discarded">,
   InGroup<DiagGroup<"assume">>;
 
 /// main()
 // static main() is not an error in C, just in C++.
 def warn_static_main : Warning<"'main' should not be declared static">,
     InGroup<Main>;
 def err_static_main : Error<"'main' is not allowed to be declared static">;
 def err_inline_main : Error<"'main' is not allowed to be declared inline">;
def err_anonymous_property: Error<
   "anonymous property is not supported">;
 def err_property_is_variably_modified : Error<
   "property %0 has a variably modified type">;
 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_attribute_aligned_not_power_of_two : Error<
+def err_alignment_not_power_of_two : Error<
   "requested alignment is not a power of 2">;
+
 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<DiagGroup<"inconsistent-dllimport">>;
 def warn_attribute_ignored : Warning<"%0 attribute ignored">,
   InGroup<IgnoredAttributes>;
 def warn_attribute_after_definition_ignored : Warning<

include/clang/Sema/Sema.h

public:
   ExprResult SemaBuiltinShuffleVector(CallExpr *TheCall);
   ExprResult SemaConvertVectorExpr(Expr *E, TypeSourceInfo *TInfo,
                                    SourceLocation BuiltinLoc,
                                    SourceLocation RParenLoc);
 
 private:
   bool SemaBuiltinPrefetch(CallExpr *TheCall);
   bool SemaBuiltinAssume(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))
bool VisitCastExpr(const CastExpr *E) {
     }
   }
 
   bool VisitCallExpr(const CallExpr *E) {
     switch (E->getBuiltinCallee()) {
     default:
       return ExprEvaluatorBaseTy::VisitCallExpr(E);
     case Builtin::BI__assume:
+    case Builtin::BI__builtin_assume:
       // The argument is not evaluated!
       return true;
     }
   }
 };
 } // end anonymous namespace
 
 static bool EvaluateVoid(const Expr *E, EvalInfo &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 *OffsetValue =
+      (E->getNumArgs() > 2) ? EmitScalarExpr(E->getArg(2)) : nullptr;
+
+    Value *AlignmentValue = EmitScalarExpr(E->getArg(1));
+    ConstantInt *AlignmentCI = cast<ConstantInt>(AlignmentValue);
+    unsigned Alignment = (unsigned) AlignmentCI->getZExtValue();
+
+    EmitAlignmentAssumption(PtrValue, Alignment, OffsetValue);
+    return RValue::get(PtrValue);
+  }
+  case Builtin::BI__assume:
+  case Builtin::BI__builtin_assume: {
+    if (E->getArg(0)->HasSideEffects(getContext()))
+      return RValue::get(nullptr);
+
+    Value *ArgValue = EmitScalarExpr(E->getArg(0));
+    Value *FnAssume = CGM.getIntrinsic(Intrinsic::assume);
+    return RValue::get(Builder.CreateCall(FnAssume, 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));
   }
   case Builtin::BI__builtin_object_size: {
     // We rely on constant folding to deal with expressions with side effects.
     assert(!E->getArg(0)->HasSideEffects(getContext()) &&
            "should have been constant folded");
 
     // We pass this builtin onto the optimizer so that it can
     // figure out the object size in more complex cases.
case Builtin::BI__builtin_operator_new:
     return EmitBuiltinNewDeleteCall(FD->getType()->castAs<FunctionProtoType>(),
                                     E->getArg(0), false);
   case Builtin::BI__builtin_operator_delete:
     return EmitBuiltinNewDeleteCall(FD->getType()->castAs<FunctionProtoType>(),
                                     E->getArg(0), true);
   case Builtin::BI__noop:
     // __noop always evaluates to an integer literal zero.
     return RValue::get(ConstantInt::get(IntTy, 0));
-  case Builtin::BI__assume:
-    // Until LLVM supports assumptions at the IR level, this becomes nothing.
-    return RValue::get(nullptr);
   case Builtin::BI_InterlockedExchange:
   case Builtin::BI_InterlockedExchangePointer:
     return EmitBinaryAtomic(*this, llvm::AtomicRMWInst::Xchg, E);
   case Builtin::BI_InterlockedCompareExchangePointer: {
     llvm::Type *RTy;
     llvm::IntegerType *IntType =
       IntegerType::get(getLLVMContext(),
                        getContext().getTypeSize(E->getType()));

lib/CodeGen/CGExpr.cpp

EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV,
   // Store the updated result through the lvalue.
   EmitStoreOfComplex(IncVal, LV, /*init*/ false);
 
   // If this is a postinc, return the value read from memory, otherwise use the
   // updated value.
   return isPre ? IncVal : InVal;
 }
 
+void CodeGenFunction::EmitAlignmentAssumption(llvm::Value *PtrValue,
+                                              unsigned Alignment,
+                                              llvm::Value *OffsetValue) {
+  llvm::Value *PtrIntValue =
+    Builder.CreatePtrToInt(PtrValue, IntPtrTy, "ptrint");
+
+  llvm::Value *Mask = llvm::ConstantInt::get(IntPtrTy,
+    Alignment > 0 ? Alignment - 1 : 0);
+  if (OffsetValue) {
+    bool IsOffsetZero = false;
+    if (llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(OffsetValue))
+      IsOffsetZero = CI->isZero();
+
+    if (!IsOffsetZero) {
+      if (OffsetValue->getType() != IntPtrTy)
+        OffsetValue = Builder.CreateIntCast(OffsetValue, IntPtrTy,
+                        /*isSigned*/true, "offsetcast");
+      PtrIntValue = Builder.CreateSub(PtrIntValue, OffsetValue, "offsetptr");
+    }
+  }
+
+  llvm::Value *Zero = llvm::ConstantInt::get(IntPtrTy, 0);
+  llvm::Value *MaskedPtr = Builder.CreateAnd(PtrIntValue, Mask, "maskedptr");
+  llvm::Value *InvCond = Builder.CreateICmpEQ(MaskedPtr, Zero, "maskcond");
+
+  llvm::Value *FnAssume = CGM.getIntrinsic(llvm::Intrinsic::assume);
+  Builder.CreateCall(FnAssume, InvCond);
+}
 
 //===----------------------------------------------------------------------===//
 //                         LValue Expression Emission
 //===----------------------------------------------------------------------===//
 
 RValue CodeGenFunction::GetUndefRValue(QualType Ty) {
   if (Ty->isVoidType())
     return RValue::get(nullptr);

lib/CodeGen/CodeGenFunction.h

#endif
   /// this expression is used as an lvalue, for instance in "&Arr[Idx]".
   void EmitBoundsCheck(const Expr *E, const Expr *Base, llvm::Value *Index,
                        QualType IndexType, bool Accessed);
 
   llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
                                        bool isInc, bool isPre);
   ComplexPairTy EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV,
                                          bool isInc, bool isPre);
+
+  void EmitAlignmentAssumption(llvm::Value *PtrValue, unsigned Alignment,
+                               llvm::Value *OffsetValue = nullptr);
+
   //===--------------------------------------------------------------------===//
   //                            Declaration Emission
   //===--------------------------------------------------------------------===//
 
   /// EmitDecl - Emit a declaration.
   ///
   /// This function can be called with a null (unreachable) insert point.
   void EmitDecl(const Decl &D);

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/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 {
   return SL->getLocationOfByte(ByteNo, getSourceManager(), LangOpts,
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__assume:
+  case Builtin::BI__builtin_assume:
     if (SemaBuiltinAssume(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;

 // __assume does not evaluate its arguments, and should warn if its argument
 // has side effects.
 bool Sema::SemaBuiltinAssume(CallExpr *TheCall) {
   Expr *Arg = TheCall->getArg(0);
   if (Arg->isInstantiationDependent()) return false;
 
   if (Arg->HasSideEffects(Context))
     return Diag(Arg->getLocStart(), diag::warn_assume_side_effects)
+      << Arg->getSourceRange()
+      << cast<FunctionDecl>(TheCall->getCalleeDecl())->getIdentifier();
+
+  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();
+
+  // 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.isPowerOf2())
+      return Diag(TheCall->getLocStart(),
+                  diag::err_alignment_not_power_of_two)
            << Arg->getSourceRange();
+  }
+
+  if (NumArgs > 2) {
+    ExprResult Arg(TheCall->getArg(2));
+    InitializedEntity Entity = InitializedEntity::InitializeParameter(Context,
+      Context.getSizeType(), false);
+    Arg = PerformCopyInitialization(Entity, SourceLocation(), Arg);
+    if (Arg.isInvalid()) return true;
+    TheCall->setArg(2, Arg.get());
+  }
 
   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());
   
   if (Arg->isTypeDependent() || Arg->isValueDependent()) return false;
   
   if (!Arg->isIntegerConstantExpr(Result, Context))
     return Diag(TheCall->getLocStart(), diag::err_constant_integer_arg_type)
                 << FDecl->getDeclName() <<  Arg->getSourceRange();
   
   return false;
 }
 
 /// SemaBuiltinConstantArgRange - Handle a check if argument ArgNum of CallExpr
 /// TheCall is a constant expression in the range [Low, High].
 bool Sema::SemaBuiltinConstantArgRange(CallExpr *TheCall, int ArgNum,
                                        int Low, int High) {
   llvm::APSInt Result;
 
   // We can't check the value of a dependent argument.
   Expr *Arg = TheCall->getArg(ArgNum);
   if (Arg->isTypeDependent() || Arg->isValueDependent())
     return false;
 
   // Check constant-ness first.
   if (SemaBuiltinConstantArg(TheCall, ArgNum, Result))
     return true;
 

lib/Sema/SemaDeclAttr.cpp

void Sema::AddAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E,
 
   // C++11 [dcl.align]p2:
   //   -- if the constant expression evaluates to zero, the alignment
   //      specifier shall have no effect
   // C11 6.7.5p6:
   //   An alignment specification of zero has no effect.
   if (!(TmpAttr.isAlignas() && !Alignment) &&
       !llvm::isPowerOf2_64(Alignment.getZExtValue())) {
-    Diag(AttrLoc, diag::err_attribute_aligned_not_power_of_two)
+    Diag(AttrLoc, diag::err_alignment_not_power_of_two)
       << E->getSourceRange();
     return;
   }
 
   // Alignment calculations can wrap around if it's greater than 2**28.
   unsigned MaxValidAlignment = TmpAttr.isDeclspec() ? 8192 : 268435456;
   if (Alignment.getZExtValue() > MaxValidAlignment) {
     Diag(AttrLoc, diag::err_attribute_aligned_too_great) << MaxValidAlignment

test/CodeGen/builtin-assume-aligned.c

+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -o - %s | FileCheck %s
+
+// CHECK-LABEL: @test1
+int test1(int *a) {
+// CHECK: %ptrint = ptrtoint
+// CHECK: %maskedptr = and i64 %ptrint, 31
+// CHECK: %maskcond = icmp eq i64 %maskedptr, 0
+// CHECK: call void @llvm.assume(i1 %maskcond)
+  a = __builtin_assume_aligned(a, 32, 0ull);
+  return a[0];
+}
+
+// CHECK-LABEL: @test2
+int test2(int *a) {
+// CHECK: %ptrint = ptrtoint
+// CHECK: %maskedptr = and i64 %ptrint, 31
+// CHECK: %maskcond = icmp eq i64 %maskedptr, 0
+// CHECK: call void @llvm.assume(i1 %maskcond)
+  a = __builtin_assume_aligned(a, 32, 0);
+  return a[0];
+}
+
+// CHECK-LABEL: @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.assume(i1 %maskcond)
+  a = __builtin_assume_aligned(a, 32);
+  return a[0];
+}
+
+// CHECK-LABEL: @test4
+int test4(int *a, int b) {
+// CHECK-DAG: %ptrint = ptrtoint
+// CHECK-DAG: %conv = sext i32
+// CHECK: %offsetptr = sub i64 %ptrint, %conv
+// CHECK: %maskedptr = and i64 %offsetptr, 31
+// CHECK: %maskcond = icmp eq i64 %maskedptr, 0
+// CHECK: call void @llvm.assume(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-LABEL: @test1
-int test1(int *a) {
-  __assume(a != 0);
+int test1(int *a, int i) {
+// CHECK: %0 = load i32** %a.addr
+// CHECK: %cmp = icmp ne i32* %0, null
+// CHECK: call void @llvm.assume(i1 %cmp)
+#ifdef _MSC_VER
+  __assume(a != 0)
+#else
+  __builtin_assume(a != 0);
+#endif
+
+// Nothing is generated for an assume with side effects...
+// CHECK-NOT: load i32** %i.addr
+// CHECK-NOT: call void @llvm.assume
+#ifdef _MSC_VER
+  __assume(++i != 0)
+#else
+  __builtin_assume(++i != 0);
+#endif
+
   return a[0];
 }
 

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 {{requested alignment is not a power of 2}}
+  a = __builtin_assume_aligned(a, 1ULL << 63);
+  return a[0];
+}
+
+int test5(int *a, unsigned *b) {
+  a = __builtin_assume_aligned(a, 32, b); // expected-warning {{incompatible pointer to integer conversion passing 'unsigned int *' to parameter of 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];
+}
+

test/Sema/builtin-assume.c

 // RUN: %clang_cc1 -triple i386-mingw32 -fms-extensions -fsyntax-only -verify %s
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fsyntax-only -verify %s
 
 int foo(int *a, int i) {
+#ifdef _MSC_VER
   __assume(i != 4);
-  __assume(++i > 2); //expected-warning {{the argument to __assume has side effects that will be discarded}}
+  __assume(++i > 2); //expected-warning {{the argument to '__assume' has side effects that will be discarded}}
 
   int test = sizeof(struct{char qq[(__assume(i != 5), 7)];});
+#else
+  __builtin_assume(i != 4);
+  __builtin_assume(++i > 2); //expected-warning {{the argument to '__builtin_assume' has side effects that will be discarded}}
 
+  int test = sizeof(struct{char qq[(__builtin_assume(i != 5), 7)];});
+#endif
   return a[i];
 }
 

test/SemaCXX/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}}
+}
+