[C++2a] Add __builtin_bit_cast, used to implement std::bit_cast

[erik.pilkington]

Summary

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0476r2.html

This adds a new (pseudo) builtin, __builtin_bit_cast(T, v), which performs a bit_cast from a value v to a type T. This expression can be evaluated at compile time under specific circumstances. The compile time evaluation currently doesn't support bit-fields, but I'm planning on fixing this in a follow up (some of the logic for figuring this out is in CodeGen).

rdar://44987528

Thanks for taking a look!

[jfb]

clang/include/clang/Basic/DiagnosticSemaKinds.td

9716 ↗

(On Diff #202804)

Drop the "a".

9718 ↗

(On Diff #202804)

What does "match" mean? Can this be clearer?

clang/lib/AST/ExprConstant.cpp

5364 ↗

(On Diff #202804)

Use an enum class instead of a bool.

5368 ↗

(On Diff #202804)

nodiscard seems useful here.

5377 ↗

(On Diff #202804)

Similar to this, you probably want to assert that CHAR_BIT == whatever we use to denote target bitwidth.

[jfb]

clang/lib/AST/ExprConstant.cpp

5459 ↗

(On Diff #202804)

Does this properly fail when there's a vtable?

[rsmith]

Can we also use the same bit reader/writer implementation to generalize the current implementation of __builtin_memcpy and friends? (I don't think we can remove the existing implementation, sadly, since we allow copying arrays of the same trivially-copyable type today even if it contains pointers and unions and such.)

clang/include/clang/AST/OperationKinds.def

69–72 ↗

(On Diff #202804)

I'm not sure I understand why we don't just use CK_BitCast for this. What's the difference? (The CastKind just specifies how to do the conversion, and doesn't have anything to do with the semantic requirements -- those should be checked by whatever code builds the cast.)

clang/include/clang/Basic/DiagnosticASTKinds.td

219 ↗

(On Diff #202804)

Typo: in -> is

clang/include/clang/Basic/DiagnosticSemaKinds.td

9715–9718 ↗

(On Diff #202804)

If these diagnostics are going to be produced by instantiations of std::bit_cast, it'd be more user-friendly to avoid mentioning __builtin_bit_cast at all (we'll presumably have a diagnostic pointing at it). So maybe s/__builtin_bit_cast/bit cast/?

clang/include/clang/Basic/Features.def

252 ↗

(On Diff #202804)

Should we identify this with __has_builtin instead of __has_extension? (We already list some of our keyword-shaped __builtin_*s there.)

clang/include/clang/Parse/Parser.h

3062–3064 ↗

(On Diff #202804)

Please put this somewhere better in the class definition rather than at the end. Maybe with the other named cast expression parsing?

clang/lib/AST/Expr.cpp

3454–3456 ↗

(On Diff #202804)

Maybe just add this as another case to the list of *CastExprClass cases above? If we're going to make this a CastExpr, we should at least get some benefit from that... :)

clang/lib/AST/ExprClassification.cpp

423–424 ↗

(On Diff #202804)

Likewise here, list this with the other CastExprs.

clang/lib/AST/ExprConstant.cpp

5359 ↗

(On Diff #202804)

This only works if unsigned char is large enough to hold one CharUnit, which is theoretically not guaranteed to be the case. Maybe we can defer handling that until we support bit-fields here (or beyond; this is far from the only place in Clang that's not yet ready for char being anything other than 8 bits) but we should at least have a FIXME.

5421–5423 ↗

(On Diff #202804)

APValue::None means "outside lifetime", not "uninitialized".

5434–5436 ↗

(On Diff #202804)

We should at some point support complex, vector, and fixed point here. Please add a FIXME.

5447 ↗

(On Diff #202804)

This will permit bitcasts from nullptr_t, providing a zero value. I think that's wrong; the bit representation of nullptr_t is notionally uninitialized (despite strangely having pointer size and alignment).

I think this is a specification bug: bit_cast<intptr_t>(nullptr) should be non-constant (it won't necessarily be 0 at runtime) but the current wording doesn't seem to permit us to treat it as non-constant.

5486 ↗

(On Diff #202804)

Please don't use a literal 8 to encode the target char width; use Info.Context.getCharWidth() instead.

5489 ↗

(On Diff #202804)

Use Context.toCharUnitsFromBits here.

5505 ↗

(On Diff #202804)

Expanding the array seems unnecessary (and isn't const-correct and might be modifying an actually-const temporary); it doesn't seem hard to use the array filler from here for elements past the last initialized one.

5657 ↗

(On Diff #202804)

You support reading atomic types but not writing them. Is that intentional?

6197–6204 ↗

(On Diff #202804)

Assuming we switch to using CK_BitCast for all forms of bitcast, we should produce a CCEDiag if the cast expression is not a BuiltinBitCastExpr here.

clang/lib/Sema/SemaCast.cpp

355 ↗

(On Diff #202804)

This if condition is redundant with the corresponding check in CheckBitCast.

2801–2802 ↗

(On Diff #202804)

Should we be performing the default lvalue conversions here too? Or maybe materializing a temporary? (Are we expecting a glvalue or prvalue as the operand of bit_cast? It seems unnecessarily complex for the AST representation to allow either.)

2805 ↗

(On Diff #202804)

isValueDependent is irrelevant here, since you're not going to constant-evaluate SrcExpr.

2831 ↗

(On Diff #202804)

If SrcType and DestType are the same (other than cv-qualifiers), we should use CK_NoOp here.

clang/lib/Sema/SemaExceptionSpec.cpp

1207 ↗

(On Diff #202804)

List this with the other casts.

clang/lib/Sema/TreeTransform.h

10259–10260 ↗

(On Diff #202804)

Please add a RebuildBuiltinBitCastExpr function to TreeTransform and call it here, following the pattern used for other Expr subclasses.

clang/lib/StaticAnalyzer/Core/ExprEngine.cpp

1292 ↗

(On Diff #202804)

This should be listed with the other CastExprs.

clang/test/CodeGenCXX/builtin-bit-cast.cpp

8–15 ↗

(On Diff #202804)

This seems like an unnecessarily-complex lowering. Bitcasting via memory seems fine, but we don't need two separate allocas here -- using only one would seem preferable (especially at -O0), we just need to make sure we don't emit any TBAA metadata for one side of the load/store pair. (Maybe in practice getting CodeGen to do that is too hard and it's not worth it though?)

[jfb]

clang/lib/AST/ExprConstant.cpp

5447 ↗

(On Diff #202804)

You brought this up in ABQ, the outcome was... poor notes so I have no idea what Core decided...

[rsmith]

clang/lib/AST/ExprConstant.cpp

5447 ↗

(On Diff #202804)

It looks like we never actually resolved what happens in this case ;-(

5549 ↗

(On Diff #202804)

Support for bitcasting to nullptr_t seems to be missing.

[jfb]

clang/lib/AST/ExprConstant.cpp

5447 ↗

(On Diff #202804)

IIRC we discussed having the same-ish issue with bool, or any other indeterminate bit pattern. Realistically it's zero...

[rjmccall]

In what sense is the bit-pattern of a null pointer indeterminate? It's implementation-specified, but the compiler is certainly required to be able to produce that value during the constant initialization phase. If the language committee wants to make this non-constant out of some sort of portability concern, that's its business, but it's certainly implementable even if the target has non-zero null pointers or even different null pointer patterns for different types (though of course nullptr_t uses void*'s pattern).

[rsmith]

In D62825#1542247, @rjmccall wrote:

In what sense is the bit-pattern of a null pointer indeterminate?

The problem is not null pointers, it's nullptr_t, which is required to have the same size and alignment as void* but which comprises only padding bits. (Loads of nullptr_t are not even permitted to touch memory...).

[rjmccall]

In D62825#1542301, @rsmith wrote:

In D62825#1542247, @rjmccall wrote:

In what sense is the bit-pattern of a null pointer indeterminate?

The problem is not null pointers, it's nullptr_t, which is required to have the same size and alignment as void* but which comprises only padding bits. (Loads of nullptr_t are not even permitted to touch memory...).

I mean, I know this is C++ and the committee loves tying itself in knots to make the language unnecessarily unusable, but surely the semantics of bitcasting an r-value of type nullptr_t are intended to be equivalent to bitcasting an r-value of type void* that happens to be a null pointer.

[rsmith]

In D62825#1542309, @rjmccall wrote:

In D62825#1542301, @rsmith wrote:

In D62825#1542247, @rjmccall wrote:

In what sense is the bit-pattern of a null pointer indeterminate?

The problem is not null pointers, it's nullptr_t, which is required to have the same size and alignment as void* but which comprises only padding bits. (Loads of nullptr_t are not even permitted to touch memory...).

I mean, I know this is C++ and the committee loves tying itself in knots to make the language unnecessarily unusable, but surely the semantics of bitcasting an r-value of type nullptr_t are intended to be equivalent to bitcasting an r-value of type void* that happens to be a null pointer.

I don't follow -- why would they be? bit_cast reads the object representation, which for nullptr_t is likely to be uninitialized, because the type contains only padding bits. (Note that there is formally no such thing as "bitcasting an rvalue". bit_cast takes an lvalue, and reinterprets its storage.)

nullptr_t is modeled roughly as if:

struct alignas(void*) nullptr_t {
  template<typename T> operator T*() { return nullptr; }
}

and as with that struct type,bit_cast of nullptr_t to some other type should (presumably) result in an uninitialized value.

[rsmith]

(You might argue that it's ridiculous to require that nullptr_t have the same size and alignment as void* but not have the same storage representation as a null void*. I'd agree, and I've raised this in committee before, but without success)

[jfb]

In D62825#1542377, @rsmith wrote:

(You might argue that it's ridiculous to require that nullptr_t have the same size and alignment as void* but not have the same storage representation as a null void*. I'd agree, and I've raised this in committee before, but without success)

We could open a DR for bit_cast<void*>(nullptr_t{}), with proposed resolution that the void* returned is a null void*. Approaching the same problem from a different angle to confuse the prey.

[erik.pilkington]

Address review comments.

[erik.pilkington]

In D62825#1528329, @rsmith wrote:

Can we also use the same bit reader/writer implementation to generalize the current implementation of __builtin_memcpy and friends? (I don't think we can remove the existing implementation, sadly, since we allow copying arrays of the same trivially-copyable type today even if it contains pointers and unions and such.)

Yeah, I think we could support that. Sounds like follow-up stuff though :)

clang/include/clang/AST/OperationKinds.def

69–72 ↗

(On Diff #202804)

Sure, new patch just folds this into CK_BitCast.

clang/include/clang/Basic/DiagnosticSemaKinds.td

9715–9718 ↗

(On Diff #202804)

An invalid __builtin_bit_cast should never really be created, since std::bit_cast guards this with a SFINAE check, so I think its more appropriate to use the __builtin spelling. I just included these diagnostics for completeness, I don't think anyone would actually run into them.

9718 ↗

(On Diff #202804)

Sure, "does not match" -> "does not equal".

clang/include/clang/Basic/Features.def

252 ↗

(On Diff #202804)

Sure, that makes more sense.

clang/lib/AST/ExprConstant.cpp

5359 ↗

(On Diff #202804)

Sure, I added a FIXME.

5364 ↗

(On Diff #202804)

Why? Doesn't seem like it would be any more clear, and all the other endian values we're comparing against are bools, which would mean awkwardly translating from an bool -> enum -> bool whenever we want to use it. (i.e. llvm::sys::IsLittleEndianHost, TargetInfo::isLittleEndian() are both booleans)

5377 ↗

(On Diff #202804)

Sure, I added an assert down in handleBitCast (which has access to that information).

5421–5423 ↗

(On Diff #202804)

New patch updates the diagnostic.

5447 ↗

(On Diff #202804)

The new patch writing anything (including an indeterminate value) to nullptr_t, and reading nullptr_t results in indeterminate bytes.

5459 ↗

(On Diff #202804)

A virtual function would mean that the record isn't trivially copyable, so that case will be handled in Sema, or even in the SFINAE check. Added a test.

5505 ↗

(On Diff #202804)

Yeah, good point. I use the filler in the new patch.

5657 ↗

(On Diff #202804)

I haven't considered it until now, but its kinda a moot point, _Atomic types aren't trivially copyable, so a BuiltinBitCastExpr over an atomic type will never be created.

clang/lib/Sema/SemaCast.cpp

2801–2802 ↗

(On Diff #202804)

Okay, new patch filters the expression through DefaultLvalueConversion (which deals with placeholders too).

clang/test/CodeGenCXX/builtin-bit-cast.cpp

8–15 ↗

(On Diff #202804)

The reason I did the double alloca was TBAA concerns, but it looks like convincing CodeGen to suppress it isn't that hard, so the new patch just does that. We also need to use the max(alignof(dest), alignof(src)) for the alloca.

[rjmccall]

In D62825#1542374, @rsmith wrote:

In D62825#1542309, @rjmccall wrote:

In D62825#1542301, @rsmith wrote:

In D62825#1542247, @rjmccall wrote:

In what sense is the bit-pattern of a null pointer indeterminate?

The problem is not null pointers, it's nullptr_t, which is required to have the same size and alignment as void* but which comprises only padding bits. (Loads of nullptr_t are not even permitted to touch memory...).

I mean, I know this is C++ and the committee loves tying itself in knots to make the language unnecessarily unusable, but surely the semantics of bitcasting an r-value of type nullptr_t are intended to be equivalent to bitcasting an r-value of type void* that happens to be a null pointer.

I don't follow -- why would they be? bit_cast reads the object representation, which for nullptr_t is likely to be uninitialized, because the type contains only padding bits. (Note that there is formally no such thing as "bitcasting an rvalue". bit_cast takes an lvalue, and reinterprets its storage.)

I agree that the problem is that the object representation of nullptr_t is wrong, but it seems absurd to me that we're going to bake in an absurd special case (from the user's perspective) to bit_cast because we consider that representation unfixable.

[rsmith]

clang/lib/AST/ExprConstant.cpp

5360 ↗

(On Diff #204609)

A static_assert(std::numeric_limits<unsigned char>::digits >= 8); would be nice.

5461–5469 ↗

(On Diff #204609)

This looks wrong: bitcasting a pointer should not dereference the pointer and store its pointee! (Likewise for a reference member.) But I think this should actually simply be unreachable: we already checked for pointers and reference members in checkBitCastConstexprEligibilityType.

(However, I think it currently *is* reached, because there's also some cases where the operand of the bitcast is an lvalue, and the resulting lvalue gets misinterpreted as a value of the underlying type, landing us here. See below.)

5761–5764 ↗

(On Diff #204609)

The spec for bit_cast also asks us to check for members of reference type. That can't happen because a type with reference members can never be trivially-copyable, but please include an assert here to demonstrate to a reader that we've thought about and handled that case.

7098–7099 ↗

(On Diff #204609)

I think this is reversed from the way I'd think about it: casts to void* are modeled as bit-casts, and so need special handling here. (Theoretically it'd be preferable to call the base class function for all other kinds of bitcast we encounter, but it turns out to not matter because only bitcasts to nullptr_t are ever evaluatable currently. In future we might want to support bit-casts between integers and pointers (for constant folding only), and then it might matter.)

clang/lib/Sema/SemaCast.cpp

2801–2802 ↗

(On Diff #202804)

Hmm, sorry, on reflection I think I've led you down the wrong path here.

I think we really do want the operand of the bitcast here to be a glvalue. In the case where the operand is of class type, it will be an lvalue even after DefaultLvalueConversion, because there's no such thing as a CK_LValueToRValue conversion on class type in C++. (For example, this is why you currently need the code in BitCastReader that deals with APValue::LValue -- when bitcasting a class type, you get an lvalue denoting the object rather than the object itself.)

Also, forming an lvalue-to-rvalue conversion here is at least theoretically wrong, because that conversion (notionally) discards the values of padding bits in the "from" object, whereas std::bit_cast requires those values to be preserved into the destination if they are defined in the source object.

Perhaps we should also have different cast kinds for an lvalue-to-rvalue bitcast (this new thing) versus an rvalue-to-rvalue bitcast (CK_BitCast).

clang/test/CodeGenCXX/builtin-bit-cast.cpp

100–112 ↗

(On Diff #204609)

If we remove the DefaultLvalueConversion from building the bitcast expression, we should be able to avoid the unnecessary extra alloca here, and instead memcpy directly from ary to the unsigned long. (This is the most important testcase in this file, since it's the only one that gives __builtin_bit_cast an lvalue operand, which is what std::bit_cast will do.)

clang/test/SemaCXX/constexpr-builtin-bit-cast.cpp

1 ↗

(On Diff #204609)

Please add a test that structs with reference members are rejected, along with the other cases from [bit.cast]/2.4-2.8.

[rsmith]

In D62825#1542597, @rjmccall wrote:

In D62825#1542374, @rsmith wrote:

In D62825#1542309, @rjmccall wrote:

In D62825#1542301, @rsmith wrote:

In D62825#1542247, @rjmccall wrote:

In what sense is the bit-pattern of a null pointer indeterminate?

The problem is not null pointers, it's nullptr_t, which is required to have the same size and alignment as void* but which comprises only padding bits. (Loads of nullptr_t are not even permitted to touch memory...).

I mean, I know this is C++ and the committee loves tying itself in knots to make the language unnecessarily unusable, but surely the semantics of bitcasting an r-value of type nullptr_t are intended to be equivalent to bitcasting an r-value of type void* that happens to be a null pointer.

I don't follow -- why would they be? bit_cast reads the object representation, which for nullptr_t is likely to be uninitialized, because the type contains only padding bits. (Note that there is formally no such thing as "bitcasting an rvalue". bit_cast takes an lvalue, and reinterprets its storage.)

I agree that the problem is that the object representation of nullptr_t is wrong, but it seems absurd to me that we're going to bake in an absurd special case (from the user's perspective) to bit_cast because we consider that representation unfixable.

Note that bit_cast supports casting not just from fundamental types but also from aggregates (which might contain a nullptr_t). At runtime, we're going to memcpy from the source object, which will leave the bits in the destination corresponding to nullptr_t subobjects in the source uninitialized (if they were in fact uninitialized in the source object, which they might be). It would be unreasonable to initialize the bits in the bit_cast result during compile-time evaluation but not during runtime evaluation -- compile-time evaluation is supposed to diagnose cases that would be undefined at runtime, not define them.

In my view, the mistake was specifying nullptr_t to have the same size and alignment as void*; it should instead be an empty type. Only confusion results from making it "look like" a pointer type rather than just being an empty tag type.

[rjmccall]

In D62825#1542639, @rsmith wrote:

In D62825#1542597, @rjmccall wrote:

In D62825#1542374, @rsmith wrote:

In D62825#1542309, @rjmccall wrote:

In D62825#1542301, @rsmith wrote:

In D62825#1542247, @rjmccall wrote:

In what sense is the bit-pattern of a null pointer indeterminate?

The problem is not null pointers, it's nullptr_t, which is required to have the same size and alignment as void* but which comprises only padding bits. (Loads of nullptr_t are not even permitted to touch memory...).

I mean, I know this is C++ and the committee loves tying itself in knots to make the language unnecessarily unusable, but surely the semantics of bitcasting an r-value of type nullptr_t are intended to be equivalent to bitcasting an r-value of type void* that happens to be a null pointer.

I don't follow -- why would they be? bit_cast reads the object representation, which for nullptr_t is likely to be uninitialized, because the type contains only padding bits. (Note that there is formally no such thing as "bitcasting an rvalue". bit_cast takes an lvalue, and reinterprets its storage.)

I agree that the problem is that the object representation of nullptr_t is wrong, but it seems absurd to me that we're going to bake in an absurd special case (from the user's perspective) to bit_cast because we consider that representation unfixable.

Note that bit_cast supports casting not just from fundamental types but also from aggregates (which might contain a nullptr_t). At runtime, we're going to memcpy from the source object, which will leave the bits in the destination corresponding to nullptr_t subobjects in the source uninitialized (if they were in fact uninitialized in the source object, which they might be). It would be unreasonable to initialize the bits in the bit_cast result during compile-time evaluation but not during runtime evaluation -- compile-time evaluation is supposed to diagnose cases that would be undefined at runtime, not define them.

In my view, the mistake was specifying nullptr_t to have the same size and alignment as void*; it should instead be an empty type. Only confusion results from making it "look like" a pointer type rather than just being an empty tag type.

Perhaps, but that's clearly unfixable without breaking ABI, whereas the object-representation issue is fixable by, at most, requiring a few stores that might be difficult to eliminate in some fanciful situations.

[rsmith]

In D62825#1542662, @rjmccall wrote:

In D62825#1542639, @rsmith wrote:

In my view, the mistake was specifying nullptr_t to have the same size and alignment as void*; it should instead be an empty type. Only confusion results from making it "look like" a pointer type rather than just being an empty tag type.

Perhaps, but that's clearly unfixable without breaking ABI, whereas the object-representation issue is fixable by, at most, requiring a few stores that might be difficult to eliminate in some fanciful situations.

Requiring initialization of, or assignment to, an object of type nullptr_t to actually store a null pointer value is also an ABI break. (Eg, void f() { decltype(nullptr) n; g(&n); } does not initialize n today in GCC, Clang, or EDG, but would need to do so under the new rule.)

In any case, I've started a discussion on the core reflector. We'll see where that goes.

[erik.pilkington]

Address review comments, thanks!

clang/lib/AST/ExprConstant.cpp

5461–5469 ↗

(On Diff #204609)

Okay, the new patch moves the read to handleBitCast. I added an unreachable here.

5761–5764 ↗

(On Diff #204609)

Oh, it looks like the old patch crashed in this case! Turns out structs with reference members are trivially copyable.

7098–7099 ↗

(On Diff #204609)

The new patch creates a special cast kind for this, so no changes here are necessary here.

clang/test/CodeGenCXX/builtin-bit-cast.cpp

100–112 ↗

(On Diff #204609)

ScalarExprEmitter::VisitCastExpr has to return a Value of type i32 here though, so we don't know where to memcpy the array to when emitting the cast. I guess we could bitcast the pointer and load from it if the alignments are compatible, and fall back to a temporary otherwise (such as this case, where alignof(ary) is 4, but alignof(unsigned long) is 8). I think its more in the spirit of clang CodeGen to just emit simple code that always works though, then leave any optimizations to, well, the optimizer (assuming the -O0 output isn't too horrible). We can use this CodeGen strategy for aggregate destinations, which the new patch does.

This is the most important testcase in this file, since it's the only one that gives __builtin_bit_cast an lvalue operand

Yeah, good point. New patch gives lvalue operands to the other calls.

[rsmith]

clang/include/clang/Basic/DiagnosticASTKinds.td

223 ↗

(On Diff #205713)

"constexpr evaluate" doesn't really mean anything. Also, the "struct with a reference member type X" case seems a bit strangely phrased (and it need not be a struct anyway...).

Maybe "cannot bit_cast {from|to}0 a {|type with a}1 {union|pointer|member pointer|volatile|reference}2 {type|member}1 in a constant expression"?

clang/include/clang/Basic/DiagnosticSemaKinds.td

9732 ↗

(On Diff #205713)

We would usually use vs rather than and here.

clang/lib/AST/ExprConstant.cpp

5454–5457 ↗

(On Diff #205713)

I've checked the intent on the reflectors, and we should drop both this and the APValue::None check here. Bits corresponding to uninitialized or out-of-lifetime subobjects should just be left uninitialized (exactly like padding bits).

Example:

struct X { char c; int n; };
struct Y { char data[sizeof(X)]; };
constexpr bool test() {
  X x = {1, 2};
  Y y = __builtin_bit_cast(Y, x); // OK, y.data[1] - y.data[3] are APValue::Indeterminate
  X z = __builtin_bit_cast(X, y); // OK, both members are initialized
  return x.c == z.c && x.n == z.n;
}
static_assert(test());

5614–5615 ↗

(On Diff #205713)

This should fail with a diagnostic if T is not a byte-like type (an unsigned narrow character type or std::byte), due to [basic.indet]p2.

clang/lib/CodeGen/CGExprComplex.cpp

472–475 ↗

(On Diff #205713)

This seems to unnecessarily force an extra round-trip through memory. Op is an lvalue, so it already describes a value in memory, and you should be able to use EmitLValue(Op) to get the lvalue you want to load from.

clang/lib/CodeGen/CGExprScalar.cpp

2045–2048 ↗

(On Diff #205713)

Likewise here.

[• Quuxplusone]

clang/include/clang/Basic/DiagnosticASTKinds.td

223 ↗

(On Diff #205713)

Peanut gallery says: Surely wherever this message comes from should use the same wording as other similar messages: "(this construction) is not allowed in a constant expression". That is, the diagnostics for

constexpr int *foo(void *p) { return reinterpret_cast<int*>(p); }
constexpr int *bar(void *p) { return std::bit_cast<int*>(p); }

should be word-for-word identical except for the kind of cast they're complaining about.

(And if I had my pedantic druthers, every such message would say "...does not produce a constant expression" instead of "...is not allowed in a constant expression." But that's way out of scope for this patch.)

[erik.pilkington]

Address review comments.

clang/include/clang/Basic/DiagnosticASTKinds.td

223 ↗

(On Diff #205713)

Sure, that seems more consistent.

clang/lib/AST/ExprConstant.cpp

5454–5457 ↗

(On Diff #205713)

You mean:

- struct Y { char data[sizeof(X)]; };
+ struct Y { unsigned char data[sizeof(X)]; };

...right? I added this test to the constexpr-builtin-bit-cast.cpp (as well of some of your other cases from the reflector).

[rsmith]

LG with a few tweaks.

clang/include/clang/Basic/DiagnosticASTKinds.td

228–230 ↗

(On Diff #206304)

This is incorrect; you can also bitcast to char if it's unsigned (under -funsigned-char). Use getLangOpts().CharIsSigned to detect whether we're in that mode.

clang/lib/AST/ExprConstant.cpp

5380 ↗

(On Diff #206304)

I don't think there's really anything "arbitrary-precision" about this APBuffer. (It's a bad name for APValue and a worse name here.) Maybe BitCastBuffer would be better?

5430 ↗

(On Diff #206304)

Every time I come back to this patch I find these class names confusing -- the reader writes to the buffer, and the writer reads from it. I think more explicit names would help: APValueToAPBufferConverter and APBufferToAPValueConverter maybe?

clang/lib/CodeGen/CGExprComplex.cpp

474–476 ↗

(On Diff #206304)

Do we need to change the alignment here at all? The alignment on DestLV should already be taken from Addr (whose alignment in turn is taken from SourceLVal), and should be the alignment computed when emitting the source lvalue expression, which seems like the right alignment to use for the load. The natural alignment of the destination type (or the source type for that matter) doesn't seem relevant.

clang/lib/CodeGen/CGExprScalar.cpp

2043–2045 ↗

(On Diff #206304)

Likewise here, I think we should not be changing the alignment.

clang/test/CodeGenCXX/builtin-bit-cast.cpp

18–20 ↗

(On Diff #206304)

Change the return type to unsigned long and return __builtin_bit_cast(...) so that future improvements to discarded value expression lowering don't invalidate your test. (That'll also better mirror the expected use in std::bit_cast.)

clang/test/SemaCXX/builtin-bit-cast.cpp

35 ↗

(On Diff #206304)

Please also explicitly test __builtin_bit_cast to a reference type. (Reference types aren't trivially-copyable, but this seems like an important enough special case to be worth calling out in the tests -- usually, casting to a reference is the same thing as casting the address of the operand to a pointer and dereferencing, but not here.)

clang/test/SemaCXX/constexpr-builtin-bit-cast.cpp

30 ↗

(On Diff #206304)

Return bool here rather than int.

230 ↗

(On Diff #206304)

Please also test bitcasting from uninitialized and out of lifetime objects to nullptr_t.

cfe/trunk/include/clang-c/Index.h

enum CXCursorKind {
   /** OpenMP target teams distribute parallel for simd directive.
    */
   CXCursor_OMPTargetTeamsDistributeParallelForSimdDirective = 278,
 
   /** OpenMP target teams distribute simd directive.
    */
   CXCursor_OMPTargetTeamsDistributeSimdDirective = 279,
 
-  CXCursor_LastStmt = CXCursor_OMPTargetTeamsDistributeSimdDirective,
+  /** C++2a std::bit_cast expression.
+   */
+  CXCursor_BuiltinBitCastExpr = 280,
+
+  CXCursor_LastStmt = CXCursor_BuiltinBitCastExpr,
 
   /**
    * Cursor that represents the translation unit itself.
    *
    * The translation unit cursor exists primarily to act as the root
    * cursor for traversing the contents of a translation unit.
    */
   CXCursor_TranslationUnit               = 300,

cfe/trunk/include/clang/AST/ExprCXX.h

Expr *getOperand() const {
     return getCommonExpr();
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == CoyieldExprClass;
   }
 };
 
+/// Represents a C++2a __builtin_bit_cast(T, v) expression. Used to implement
+/// std::bit_cast. These can sometimes be evaluated as part of a constant
+/// expression, but otherwise CodeGen to a simple memcpy in general.
+class BuiltinBitCastExpr final
+    : public ExplicitCastExpr,
+      private llvm::TrailingObjects<BuiltinBitCastExpr, CXXBaseSpecifier *> {
+  friend class ASTStmtReader;
+  friend class CastExpr;
+  friend class TrailingObjects;
+
+  SourceLocation KWLoc;
+  SourceLocation RParenLoc;
+
+public:
+  BuiltinBitCastExpr(QualType T, ExprValueKind VK, CastKind CK, Expr *SrcExpr,
+                     TypeSourceInfo *DstType, SourceLocation KWLoc,
+                     SourceLocation RParenLoc)
+      : ExplicitCastExpr(BuiltinBitCastExprClass, T, VK, CK, SrcExpr, 0,
+                         DstType),
+        KWLoc(KWLoc), RParenLoc(RParenLoc) {}
+
+  SourceLocation getBeginLoc() const LLVM_READONLY { return KWLoc; }
+  SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == BuiltinBitCastExprClass;
+  }
+};
+
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_EXPRCXX_H

cfe/trunk/include/clang/AST/OperationKinds.def

 CAST_OPERATION(BitCast)
 
 /// CK_LValueBitCast - A conversion which reinterprets the address of
 /// an l-value as an l-value of a different kind.  Used for
 /// reinterpret_casts of l-value expressions to reference types.
 ///    bool b; reinterpret_cast<char&>(b) = 'a';
 CAST_OPERATION(LValueBitCast)
 
+/// CK_LValueToRValueBitCast - A conversion that causes us to reinterpret an
+/// lvalue as an rvalue of a different type. Created by __builtin_bit_cast.
+CAST_OPERATION(LValueToRValueBitCast)
+
 /// CK_LValueToRValue - A conversion which causes the extraction of
 /// an r-value from the operand gl-value.  The result of an r-value
 /// conversion is always unqualified.
 CAST_OPERATION(LValueToRValue)
 
 /// CK_NoOp - A conversion which does not affect the type other than
 /// (possibly) adding qualifiers.
 ///   int    -> int

cfe/trunk/include/clang/AST/RecursiveASTVisitor.h

 DEF_TRAVERSE_STMT(CXXReinterpretCastExpr, {
   TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
 })
 
 DEF_TRAVERSE_STMT(CXXStaticCastExpr, {
   TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
 })
 
+DEF_TRAVERSE_STMT(BuiltinBitCastExpr, {
+  TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
+})
+
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseSynOrSemInitListExpr(
     InitListExpr *S, DataRecursionQueue *Queue) {
   if (S) {
     // Skip this if we traverse postorder. We will visit it later
     // in PostVisitStmt.
     if (!getDerived().shouldTraversePostOrder())
       TRY_TO(WalkUpFromInitListExpr(S));

cfe/trunk/include/clang/Basic/DiagnosticASTKinds.td

 def note_constexpr_memcpy_overlap : Note<
   "'%select{memcpy|wmemcpy}0' between overlapping memory regions">;
 def note_constexpr_memcpy_unsupported : Note<
   "'%select{%select{memcpy|wmemcpy}1|%select{memmove|wmemmove}1}0' "
   "not supported: %select{"
   "size to copy (%4) is not a multiple of size of element type %3 (%5)|"
   "source is not a contiguous array of at least %4 elements of type %3|"
   "destination is not a contiguous array of at least %4 elements of type %3}2">;
+def note_constexpr_bit_cast_unsupported_type : Note<
+  "constexpr bit_cast involving type %0 is not yet supported">;
+def note_constexpr_bit_cast_unsupported_bitfield : Note<
+  "constexpr bit_cast involving bit-field is not yet supported">;
+def note_constexpr_bit_cast_invalid_type : Note<
+  "bit_cast %select{from|to}0 a %select{|type with a }1"
+  "%select{union|pointer|member pointer|volatile|reference}2 "
+  "%select{type|member}1 is not allowed in a constant expression">;
+def note_constexpr_bit_cast_invalid_subtype : Note<
+  "invalid type %0 is a %select{member|base}1 of %2">;
+def note_constexpr_bit_cast_indet_dest : Note<
+  "indeterminate value can only initialize an object of type 'unsigned char'"
+  "%select{, 'char',|}1 or 'std::byte'; %0 is invalid">;
 
 def warn_integer_constant_overflow : Warning<
   "overflow in expression; result is %0 with type %1">,
   InGroup<DiagGroup<"integer-overflow">>;
 
 // This is a temporary diagnostic, and shall be removed once our
 // implementation is complete, and like the preceding constexpr notes belongs
 // in Sema.

cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td

def warn_noderef_on_non_pointer_or_array : Warning<
   "'noderef' can only be used on an array or pointer type">, InGroup<IgnoredAttributes>;
 def warn_noderef_to_dereferenceable_pointer : Warning<
   "casting to dereferenceable pointer removes 'noderef' attribute">, InGroup<NoDeref>;
 
 def err_builtin_launder_invalid_arg : Error<
   "%select{non-pointer|function pointer|void pointer}0 argument to "
   "'__builtin_launder' is not allowed">;
 
+def err_bit_cast_non_trivially_copyable : Error<
+  "__builtin_bit_cast %select{source|destination}0 type must be trivially copyable">;
+def err_bit_cast_type_size_mismatch : Error<
+  "__builtin_bit_cast source size does not equal destination size (%0 vs %1)">;
 } // end of sema component.

cfe/trunk/include/clang/Basic/StmtNodes.td

 def CUDAKernelCallExpr : DStmt<CallExpr>;
 
 // Clang Extensions.
 def ShuffleVectorExpr : DStmt<Expr>;
 def ConvertVectorExpr : DStmt<Expr>;
 def BlockExpr : DStmt<Expr>;
 def OpaqueValueExpr : DStmt<Expr>;
 def TypoExpr : DStmt<Expr>;
+def BuiltinBitCastExpr : DStmt<ExplicitCastExpr>;
 
 // Microsoft Extensions.
 def MSPropertyRefExpr : DStmt<Expr>;
 def MSPropertySubscriptExpr : DStmt<Expr>;
 def CXXUuidofExpr : DStmt<Expr>;
 def SEHTryStmt : Stmt;
 def SEHExceptStmt : Stmt;
 def SEHFinallyStmt : Stmt;

cfe/trunk/include/clang/Basic/TokenKinds.def

 
 // Borland Extensions which should be disabled in strict conformance mode.
 ALIAS("_pascal"      , __pascal   , KEYBORLAND)
 
 // Clang Extensions.
 KEYWORD(__builtin_convertvector   , KEYALL)
 ALIAS("__char16_t"   , char16_t   , KEYCXX)
 ALIAS("__char32_t"   , char32_t   , KEYCXX)
-
+KEYWORD(__builtin_bit_cast        , KEYALL)
 KEYWORD(__builtin_available       , KEYALL)
 
 // Clang-specific keywords enabled only in testing.
 TESTING_KEYWORD(__unknown_anytype , KEYALL)
 
 
 //===----------------------------------------------------------------------===//
 // Objective-C @-preceded keywords.

cfe/trunk/include/clang/Parse/Parser.h

private:
   ParseLambdaIntroducer(LambdaIntroducer &Intro,
                         LambdaIntroducerTentativeParse *Tentative = nullptr);
   ExprResult ParseLambdaExpressionAfterIntroducer(LambdaIntroducer &Intro);
 
   //===--------------------------------------------------------------------===//
   // C++ 5.2p1: C++ Casts
   ExprResult ParseCXXCasts();
 
+  /// Parse a __builtin_bit_cast(T, E), used to implement C++2a std::bit_cast.
+  ExprResult ParseBuiltinBitCast();
+
   //===--------------------------------------------------------------------===//
   // C++ 5.2p1: C++ Type Identification
   ExprResult ParseCXXTypeid();
 
   //===--------------------------------------------------------------------===//
   //  C++ : Microsoft __uuidof Expression
   ExprResult ParseCXXUuidof();
 

cfe/trunk/include/clang/Sema/Sema.h

public:
 
   ExprResult BuildCXXNamedCast(SourceLocation OpLoc,
                                tok::TokenKind Kind,
                                TypeSourceInfo *Ty,
                                Expr *E,
                                SourceRange AngleBrackets,
                                SourceRange Parens);
 
+  ExprResult ActOnBuiltinBitCastExpr(SourceLocation KWLoc, Declarator &Dcl,
+                                     ExprResult Operand,
+                                     SourceLocation RParenLoc);
+
+  ExprResult BuildBuiltinBitCastExpr(SourceLocation KWLoc, TypeSourceInfo *TSI,
+                                     Expr *Operand, SourceLocation RParenLoc);
+
   ExprResult BuildCXXTypeId(QualType TypeInfoType,
                             SourceLocation TypeidLoc,
                             TypeSourceInfo *Operand,
                             SourceLocation RParenLoc);
   ExprResult BuildCXXTypeId(QualType TypeInfoType,
                             SourceLocation TypeidLoc,
                             Expr *Operand,
                             SourceLocation RParenLoc);

cfe/trunk/lib/AST/Expr.cpp

bool CastExpr::CastConsistency() const {
   case CK_NonAtomicToAtomic:
   case CK_PointerToBoolean:
   case CK_IntegralToBoolean:
   case CK_FloatingToBoolean:
   case CK_MemberPointerToBoolean:
   case CK_FloatingComplexToBoolean:
   case CK_IntegralComplexToBoolean:
   case CK_LValueBitCast:            // -> bool&
+  case CK_LValueToRValueBitCast:
   case CK_UserDefinedConversion:    // operator bool()
   case CK_BuiltinFnToFnPtr:
   case CK_FixedPointToBoolean:
   CheckNoBasePath:
     assert(path_empty() && "Cast kind should not have a base path!");
     break;
   }
   return true;
if (DCE->getTypeAsWritten()->isReferenceType() &&
       return true;
     }
     LLVM_FALLTHROUGH;
   case ImplicitCastExprClass:
   case CStyleCastExprClass:
   case CXXStaticCastExprClass:
   case CXXReinterpretCastExprClass:
   case CXXConstCastExprClass:
-  case CXXFunctionalCastExprClass: {
+  case CXXFunctionalCastExprClass:
+  case BuiltinBitCastExprClass: {
     // While volatile reads are side-effecting in both C and C++, we treat them
     // as having possible (not definite) side-effects. This allows idiomatic
     // code to behave without warning, such as sizeof(*v) for a volatile-
     // qualified pointer.
     if (!IncludePossibleEffects)
       break;
 
     const CastExpr *CE = cast<CastExpr>(this);

cfe/trunk/lib/AST/ExprClassification.cpp

case Expr::ExprWithCleanupsClass:
     // Casts depend completely on the target type. All casts work the same.
   case Expr::CStyleCastExprClass:
   case Expr::CXXFunctionalCastExprClass:
   case Expr::CXXStaticCastExprClass:
   case Expr::CXXDynamicCastExprClass:
   case Expr::CXXReinterpretCastExprClass:
   case Expr::CXXConstCastExprClass:
   case Expr::ObjCBridgedCastExprClass:
+  case Expr::BuiltinBitCastExprClass:
     // Only in C++ can casts be interesting at all.
     if (!Lang.CPlusPlus) return Cl::CL_PRValue;
     return ClassifyUnnamed(Ctx, cast<ExplicitCastExpr>(E)->getTypeAsWritten());
 
   case Expr::CXXUnresolvedConstructExprClass:
     return ClassifyUnnamed(Ctx,
                       cast<CXXUnresolvedConstructExpr>(E)->getTypeAsWritten());
 

cfe/trunk/lib/AST/ExprConstant.cpp

 #include "clang/AST/Expr.h"
 #include "clang/AST/OSLog.h"
 #include "clang/AST/RecordLayout.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/FixedPoint.h"
 #include "clang/Basic/TargetInfo.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/Support/SaveAndRestore.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstring>
 #include <functional>
 
 #define DEBUG_TYPE "exprconstant"
 
 using namespace clang;
+using llvm::APInt;
 using llvm::APSInt;
 using llvm::APFloat;
+using llvm::Optional;
 
 static bool IsGlobalLValue(APValue::LValueBase B);
 
 namespace {
   struct LValue;
   struct CallStackFrame;
   struct EvalInfo;
 
if (Imag) {
     if (!HandleSizeof(Info, E->getExprLoc(), EltTy, SizeOfComponent))
       return false;
     LVal.Offset += SizeOfComponent;
   }
   LVal.addComplex(Info, E, EltTy, Imag);
   return true;
 }
 
-static bool handleLValueToRValueConversion(EvalInfo &Info, const Expr *Conv,
-                                           QualType Type, const LValue &LVal,
-                                           APValue &RVal);
-
 /// Try to evaluate the initializer for a variable declaration.
 ///
 /// \param Info   Information about the ongoing evaluation.
 /// \param E      An expression to be used when printing diagnostics.
 /// \param VD     The variable whose initializer should be obtained.
 /// \param Frame  The frame in which the variable was created. Must be null
 ///               if this variable is not local to the evaluation.
 /// \param Result Filled in with a pointer to the value of the variable.
return HandleConstructorCall(E, This, ArgValues.data(), Definition,
                                Info, Result);
 }
 
 //===----------------------------------------------------------------------===//
 // Generic Evaluation
 //===----------------------------------------------------------------------===//
 namespace {
 
+class BitCastBuffer {
+  // FIXME: We're going to need bit-level granularity when we support
+  // bit-fields.
+  // FIXME: Its possible under the C++ standard for 'char' to not be 8 bits, but
+  // we don't support a host or target where that is the case. Still, we should
+  // use a more generic type in case we ever do.
+  SmallVector<Optional<unsigned char>, 32> Bytes;
+
+  static_assert(std::numeric_limits<unsigned char>::digits >= 8,
+                "Need at least 8 bit unsigned char");
+
+  bool TargetIsLittleEndian;
+
+public:
+  BitCastBuffer(CharUnits Width, bool TargetIsLittleEndian)
+      : Bytes(Width.getQuantity()),
+        TargetIsLittleEndian(TargetIsLittleEndian) {}
+
+  LLVM_NODISCARD
+  bool readObject(CharUnits Offset, CharUnits Width,
+                  SmallVectorImpl<unsigned char> &Output) const {
+    for (CharUnits I = Offset, E = Offset + Width; I != E; ++I) {
+      // If a byte of an integer is uninitialized, then the whole integer is
+      // uninitalized.
+      if (!Bytes[I.getQuantity()])
+        return false;
+      Output.push_back(*Bytes[I.getQuantity()]);
+    }
+    if (llvm::sys::IsLittleEndianHost != TargetIsLittleEndian)
+      std::reverse(Output.begin(), Output.end());
+    return true;
+  }
+
+  void writeObject(CharUnits Offset, SmallVectorImpl<unsigned char> &Input) {
+    if (llvm::sys::IsLittleEndianHost != TargetIsLittleEndian)
+      std::reverse(Input.begin(), Input.end());
+
+    size_t Index = 0;
+    for (unsigned char Byte : Input) {
+      assert(!Bytes[Offset.getQuantity() + Index] && "overwriting a byte?");
+      Bytes[Offset.getQuantity() + Index] = Byte;
+      ++Index;
+    }
+  }
+
+  size_t size() { return Bytes.size(); }
+};
+
+/// Traverse an APValue to produce an BitCastBuffer, emulating how the current
+/// target would represent the value at runtime.
+class APValueToBufferConverter {
+  EvalInfo &Info;
+  BitCastBuffer Buffer;
+  const CastExpr *BCE;
+
+  APValueToBufferConverter(EvalInfo &Info, CharUnits ObjectWidth,
+                           const CastExpr *BCE)
+      : Info(Info),
+        Buffer(ObjectWidth, Info.Ctx.getTargetInfo().isLittleEndian()),
+        BCE(BCE) {}
+
+  bool visit(const APValue &Val, QualType Ty) {
+    return visit(Val, Ty, CharUnits::fromQuantity(0));
+  }
+
+  // Write out Val with type Ty into Buffer starting at Offset.
+  bool visit(const APValue &Val, QualType Ty, CharUnits Offset) {
+    assert((size_t)Offset.getQuantity() <= Buffer.size());
+
+    // As a special case, nullptr_t has an indeterminate value.
+    if (Ty->isNullPtrType())
+      return true;
+
+    // Dig through Src to find the byte at SrcOffset.
+    switch (Val.getKind()) {
+    case APValue::Indeterminate:
+    case APValue::None:
+      return true;
+
+    case APValue::Int:
+      return visitInt(Val.getInt(), Ty, Offset);
+    case APValue::Float:
+      return visitFloat(Val.getFloat(), Ty, Offset);
+    case APValue::Array:
+      return visitArray(Val, Ty, Offset);
+    case APValue::Struct:
+      return visitRecord(Val, Ty, Offset);
+
+    case APValue::ComplexInt:
+    case APValue::ComplexFloat:
+    case APValue::Vector:
+    case APValue::FixedPoint:
+      // FIXME: We should support these.
+
+    case APValue::Union:
+    case APValue::MemberPointer:
+    case APValue::AddrLabelDiff: {
+      Info.FFDiag(BCE->getBeginLoc(),
+                  diag::note_constexpr_bit_cast_unsupported_type)
+          << Ty;
+      return false;
+    }
+
+    case APValue::LValue:
+      llvm_unreachable("LValue subobject in bit_cast?");
+    }
+  }
+
+  bool visitRecord(const APValue &Val, QualType Ty, CharUnits Offset) {
+    const RecordDecl *RD = Ty->getAsRecordDecl();
+    const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
+
+    // Visit the base classes.
+    if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
+      for (size_t I = 0, E = CXXRD->getNumBases(); I != E; ++I) {
+        const CXXBaseSpecifier &BS = CXXRD->bases_begin()[I];
+        CXXRecordDecl *BaseDecl = BS.getType()->getAsCXXRecordDecl();
+
+        if (!visitRecord(Val.getStructBase(I), BS.getType(),
+                         Layout.getBaseClassOffset(BaseDecl) + Offset))
+          return false;
+      }
+    }
+
+    // Visit the fields.
+    unsigned FieldIdx = 0;
+    for (FieldDecl *FD : RD->fields()) {
+      if (FD->isBitField()) {
+        Info.FFDiag(BCE->getBeginLoc(),
+                    diag::note_constexpr_bit_cast_unsupported_bitfield);
+        return false;
+      }
+
+      uint64_t FieldOffsetBits = Layout.getFieldOffset(FieldIdx);
+
+      assert(FieldOffsetBits % Info.Ctx.getCharWidth() == 0 &&
+             "only bit-fields can have sub-char alignment");
+      CharUnits FieldOffset =
+          Info.Ctx.toCharUnitsFromBits(FieldOffsetBits) + Offset;
+      QualType FieldTy = FD->getType();
+      if (!visit(Val.getStructField(FieldIdx), FieldTy, FieldOffset))
+        return false;
+      ++FieldIdx;
+    }
+
+    return true;
+  }
+
+  bool visitArray(const APValue &Val, QualType Ty, CharUnits Offset) {
+    const auto *CAT =
+        dyn_cast_or_null<ConstantArrayType>(Ty->getAsArrayTypeUnsafe());
+    if (!CAT)
+      return false;
+
+    CharUnits ElemWidth = Info.Ctx.getTypeSizeInChars(CAT->getElementType());
+    unsigned NumInitializedElts = Val.getArrayInitializedElts();
+    unsigned ArraySize = Val.getArraySize();
+    // First, initialize the initialized elements.
+    for (unsigned I = 0; I != NumInitializedElts; ++I) {
+      const APValue &SubObj = Val.getArrayInitializedElt(I);
+      if (!visit(SubObj, CAT->getElementType(), Offset + I * ElemWidth))
+        return false;
+    }
+
+    // Next, initialize the rest of the array using the filler.
+    if (Val.hasArrayFiller()) {
+      const APValue &Filler = Val.getArrayFiller();
+      for (unsigned I = NumInitializedElts; I != ArraySize; ++I) {
+        if (!visit(Filler, CAT->getElementType(), Offset + I * ElemWidth))
+          return false;
+      }
+    }
+
+    return true;
+  }
+
+  bool visitInt(const APSInt &Val, QualType Ty, CharUnits Offset) {
+    CharUnits Width = Info.Ctx.getTypeSizeInChars(Ty);
+    SmallVector<unsigned char, 8> Bytes(Width.getQuantity());
+    llvm::StoreIntToMemory(Val, &*Bytes.begin(), Width.getQuantity());
+    Buffer.writeObject(Offset, Bytes);
+    return true;
+  }
+
+  bool visitFloat(const APFloat &Val, QualType Ty, CharUnits Offset) {
+    APSInt AsInt(Val.bitcastToAPInt());
+    return visitInt(AsInt, Ty, Offset);
+  }
+
+public:
+  static Optional<BitCastBuffer> convert(EvalInfo &Info, const APValue &Src,
+                                         const CastExpr *BCE) {
+    CharUnits DstSize = Info.Ctx.getTypeSizeInChars(BCE->getType());
+    APValueToBufferConverter Converter(Info, DstSize, BCE);
+    if (!Converter.visit(Src, BCE->getSubExpr()->getType()))
+      return None;
+    return Converter.Buffer;
+  }
+};
+
+/// Write an BitCastBuffer into an APValue.
+class BufferToAPValueConverter {
+  EvalInfo &Info;
+  const BitCastBuffer &Buffer;
+  const CastExpr *BCE;
+
+  BufferToAPValueConverter(EvalInfo &Info, const BitCastBuffer &Buffer,
+                           const CastExpr *BCE)
+      : Info(Info), Buffer(Buffer), BCE(BCE) {}
+
+  // Emit an unsupported bit_cast type error. Sema refuses to build a bit_cast
+  // with an invalid type, so anything left is a deficiency on our part (FIXME).
+  // Ideally this will be unreachable.
+  llvm::NoneType unsupportedType(QualType Ty) {
+    Info.FFDiag(BCE->getBeginLoc(),
+                diag::note_constexpr_bit_cast_unsupported_type)
+        << Ty;
+    return None;
+  }
+
+  Optional<APValue> visit(const BuiltinType *T, CharUnits Offset,
+                          const EnumType *EnumSugar = nullptr) {
+    if (T->isNullPtrType()) {
+      uint64_t NullValue = Info.Ctx.getTargetNullPointerValue(QualType(T, 0));
+      return APValue((Expr *)nullptr,
+                     /*Offset=*/CharUnits::fromQuantity(NullValue),
+                     APValue::NoLValuePath{}, /*IsNullPtr=*/true);
+    }
+
+    CharUnits SizeOf = Info.Ctx.getTypeSizeInChars(T);
+    SmallVector<uint8_t, 8> Bytes;
+    if (!Buffer.readObject(Offset, SizeOf, Bytes)) {
+      // If this is std::byte or unsigned char, then its okay to store an
+      // indeterminate value.
+      bool IsStdByte = EnumSugar && EnumSugar->isStdByteType();
+      bool IsUChar =
+          !EnumSugar && (T->isSpecificBuiltinType(BuiltinType::UChar) ||
+                         T->isSpecificBuiltinType(BuiltinType::Char_U));
+      if (!IsStdByte && !IsUChar) {
+        QualType DisplayType(EnumSugar ? (Type *)EnumSugar : T, 0);
+        Info.FFDiag(BCE->getExprLoc(),
+                    diag::note_constexpr_bit_cast_indet_dest)
+            << DisplayType << Info.Ctx.getLangOpts().CharIsSigned;
+        return None;
+      }
+
+      return APValue::IndeterminateValue();
+    }
+
+    APSInt Val(SizeOf.getQuantity() * Info.Ctx.getCharWidth(), true);
+    llvm::LoadIntFromMemory(Val, &*Bytes.begin(), Bytes.size());
+
+    if (T->isIntegralOrEnumerationType()) {
+      Val.setIsSigned(T->isSignedIntegerOrEnumerationType());
+      return APValue(Val);
+    }
+
+    if (T->isRealFloatingType()) {
+      const llvm::fltSemantics &Semantics =
+          Info.Ctx.getFloatTypeSemantics(QualType(T, 0));
+      return APValue(APFloat(Semantics, Val));
+    }
+
+    return unsupportedType(QualType(T, 0));
+  }
+
+  Optional<APValue> visit(const RecordType *RTy, CharUnits Offset) {
+    const RecordDecl *RD = RTy->getAsRecordDecl();
+    const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
+
+    unsigned NumBases = 0;
+    if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
+      NumBases = CXXRD->getNumBases();
+
+    APValue ResultVal(APValue::UninitStruct(), NumBases,
+                      std::distance(RD->field_begin(), RD->field_end()));
+
+    // Visit the base classes.
+    if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
+      for (size_t I = 0, E = CXXRD->getNumBases(); I != E; ++I) {
+        const CXXBaseSpecifier &BS = CXXRD->bases_begin()[I];
+        CXXRecordDecl *BaseDecl = BS.getType()->getAsCXXRecordDecl();
+        if (BaseDecl->isEmpty() ||
+            Info.Ctx.getASTRecordLayout(BaseDecl).getNonVirtualSize().isZero())
+          continue;
+
+        Optional<APValue> SubObj = visitType(
+            BS.getType(), Layout.getBaseClassOffset(BaseDecl) + Offset);
+        if (!SubObj)
+          return None;
+        ResultVal.getStructBase(I) = *SubObj;
+      }
+    }
+
+    // Visit the fields.
+    unsigned FieldIdx = 0;
+    for (FieldDecl *FD : RD->fields()) {
+      // FIXME: We don't currently support bit-fields. A lot of the logic for
+      // this is in CodeGen, so we need to factor it around.
+      if (FD->isBitField()) {
+        Info.FFDiag(BCE->getBeginLoc(),
+                    diag::note_constexpr_bit_cast_unsupported_bitfield);
+        return None;
+      }
+
+      uint64_t FieldOffsetBits = Layout.getFieldOffset(FieldIdx);
+      assert(FieldOffsetBits % Info.Ctx.getCharWidth() == 0);
+
+      CharUnits FieldOffset =
+          CharUnits::fromQuantity(FieldOffsetBits / Info.Ctx.getCharWidth()) +
+          Offset;
+      QualType FieldTy = FD->getType();
+      Optional<APValue> SubObj = visitType(FieldTy, FieldOffset);
+      if (!SubObj)
+        return None;
+      ResultVal.getStructField(FieldIdx) = *SubObj;
+      ++FieldIdx;
+    }
+
+    return ResultVal;
+  }
+
+  Optional<APValue> visit(const EnumType *Ty, CharUnits Offset) {
+    QualType RepresentationType = Ty->getDecl()->getIntegerType();
+    assert(!RepresentationType.isNull() &&
+           "enum forward decl should be caught by Sema");
+    const BuiltinType *AsBuiltin =
+        RepresentationType.getCanonicalType()->getAs<BuiltinType>();
+    assert(AsBuiltin && "non-integral enum underlying type?");
+    // Recurse into the underlying type. Treat std::byte transparently as
+    // unsigned char.
+    return visit(AsBuiltin, Offset, /*EnumTy=*/Ty);
+  }
+
+  Optional<APValue> visit(const ConstantArrayType *Ty, CharUnits Offset) {
+    size_t Size = Ty->getSize().getLimitedValue();
+    CharUnits ElementWidth = Info.Ctx.getTypeSizeInChars(Ty->getElementType());
+
+    APValue ArrayValue(APValue::UninitArray(), Size, Size);
+    for (size_t I = 0; I != Size; ++I) {
+      Optional<APValue> ElementValue =
+          visitType(Ty->getElementType(), Offset + I * ElementWidth);
+      if (!ElementValue)
+        return None;
+      ArrayValue.getArrayInitializedElt(I) = std::move(*ElementValue);
+    }
+
+    return ArrayValue;
+  }
+
+  Optional<APValue> visit(const Type *Ty, CharUnits Offset) {
+    return unsupportedType(QualType(Ty, 0));
+  }
+
+  Optional<APValue> visitType(QualType Ty, CharUnits Offset) {
+    QualType Can = Ty.getCanonicalType();
+
+    switch (Can->getTypeClass()) {
+#define TYPE(Class, Base)                                                      \
+  case Type::Class:                                                            \
+    return visit(cast<Class##Type>(Can.getTypePtr()), Offset);
+#define ABSTRACT_TYPE(Class, Base)
+#define NON_CANONICAL_TYPE(Class, Base)                                        \
+  case Type::Class:                                                            \
+    llvm_unreachable("non-canonical type should be impossible!");
+#define DEPENDENT_TYPE(Class, Base)                                            \
+  case Type::Class:                                                            \
+    llvm_unreachable(                                                          \
+        "dependent types aren't supported in the constant evaluator!");
+#define NON_CANONICAL_UNLESS_DEPENDENT(Class, Base)                            \
+  case Type::Class:                                                            \
+    llvm_unreachable("either dependent or not canonical!");
+#include "clang/AST/TypeNodes.def"
+    }
+  }
+
+public:
+  // Pull out a full value of type DstType.
+  static Optional<APValue> convert(EvalInfo &Info, BitCastBuffer &Buffer,
+                                   const CastExpr *BCE) {
+    BufferToAPValueConverter Converter(Info, Buffer, BCE);
+    return Converter.visitType(BCE->getType(), CharUnits::fromQuantity(0));
+  }
+};
+
+static bool checkBitCastConstexprEligibilityType(SourceLocation Loc,
+                                                 QualType Ty, EvalInfo *Info,
+                                                 const ASTContext &Ctx,
+                                                 bool CheckingDest) {
+  Ty = Ty.getCanonicalType();
+
+  auto diag = [&](int Reason) {
+    if (Info)
+      Info->FFDiag(Loc, diag::note_constexpr_bit_cast_invalid_type)
+          << CheckingDest << (Reason == 4) << Reason;
+    return false;
+  };
+  auto note = [&](int Construct, QualType NoteTy, SourceLocation NoteLoc) {
+    if (Info)
+      Info->Note(NoteLoc, diag::note_constexpr_bit_cast_invalid_subtype)
+          << NoteTy << Construct << Ty;
+    return false;
+  };
+
+  if (Ty->isUnionType())
+    return diag(0);
+  if (Ty->isPointerType())
+    return diag(1);
+  if (Ty->isMemberPointerType())
+    return diag(2);
+  if (Ty.isVolatileQualified())
+    return diag(3);
+
+  if (RecordDecl *Record = Ty->getAsRecordDecl()) {
+    if (auto *CXXRD = dyn_cast<CXXRecordDecl>(Record)) {
+      for (CXXBaseSpecifier &BS : CXXRD->bases())
+        if (!checkBitCastConstexprEligibilityType(Loc, BS.getType(), Info, Ctx,
+                                                  CheckingDest))
+          return note(1, BS.getType(), BS.getBeginLoc());
+    }
+    for (FieldDecl *FD : Record->fields()) {
+      if (FD->getType()->isReferenceType())
+        return diag(4);
+      if (!checkBitCastConstexprEligibilityType(Loc, FD->getType(), Info, Ctx,
+                                                CheckingDest))
+        return note(0, FD->getType(), FD->getBeginLoc());
+    }
+  }
+
+  if (Ty->isArrayType() &&
+      !checkBitCastConstexprEligibilityType(Loc, Ctx.getBaseElementType(Ty),
+                                            Info, Ctx, CheckingDest))
+    return false;
+
+  return true;
+}
+
+static bool checkBitCastConstexprEligibility(EvalInfo *Info,
+                                             const ASTContext &Ctx,
+                                             const CastExpr *BCE) {
+  bool DestOK = checkBitCastConstexprEligibilityType(
+      BCE->getBeginLoc(), BCE->getType(), Info, Ctx, true);
+  bool SourceOK = DestOK && checkBitCastConstexprEligibilityType(
+                                BCE->getBeginLoc(),
+                                BCE->getSubExpr()->getType(), Info, Ctx, false);
+  return SourceOK;
+}
+
+static bool handleLValueToRValueBitCast(EvalInfo &Info, APValue &DestValue,
+                                        APValue &SourceValue,
+                                        const CastExpr *BCE) {
+  assert(CHAR_BIT == 8 && Info.Ctx.getTargetInfo().getCharWidth() == 8 &&
+         "no host or target supports non 8-bit chars");
+  assert(SourceValue.isLValue() &&
+         "LValueToRValueBitcast requires an lvalue operand!");
+
+  if (!checkBitCastConstexprEligibility(&Info, Info.Ctx, BCE))
+    return false;
+
+  LValue SourceLValue;
+  APValue SourceRValue;
+  SourceLValue.setFrom(Info.Ctx, SourceValue);
+  if (!handleLValueToRValueConversion(Info, BCE,
+                                      BCE->getSubExpr()->getType().withConst(),
+                                      SourceLValue, SourceRValue))
+    return false;
+
+  // Read out SourceValue into a char buffer.
+  Optional<BitCastBuffer> Buffer =
+      APValueToBufferConverter::convert(Info, SourceRValue, BCE);
+  if (!Buffer)
+    return false;
+
+  // Write out the buffer into a new APValue.
+  Optional<APValue> MaybeDestValue =
+      BufferToAPValueConverter::convert(Info, *Buffer, BCE);
+  if (!MaybeDestValue)
+    return false;
+
+  DestValue = std::move(*MaybeDestValue);
+  return true;
+}
+
 template <class Derived>
 class ExprEvaluatorBase
   : public ConstStmtVisitor<Derived, bool> {
 private:
   Derived &getDerived() { return static_cast<Derived&>(*this); }
   bool DerivedSuccess(const APValue &V, const Expr *E) {
     return getDerived().Success(V, E);
   }
bool VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *E) {
     CCEDiag(E, diag::note_constexpr_invalid_cast) << 0;
     return static_cast<Derived*>(this)->VisitCastExpr(E);
   }
   bool VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *E) {
     if (!Info.Ctx.getLangOpts().CPlusPlus2a)
       CCEDiag(E, diag::note_constexpr_invalid_cast) << 1;
     return static_cast<Derived*>(this)->VisitCastExpr(E);
   }
+  bool VisitBuiltinBitCastExpr(const BuiltinBitCastExpr *E) {
+    return static_cast<Derived*>(this)->VisitCastExpr(E);
+  }
 
   bool VisitBinaryOperator(const BinaryOperator *E) {
     switch (E->getOpcode()) {
     default:
       return Error(E);
 
     case BO_Comma:
       VisitIgnoredValue(E->getLHS());
case CK_LValueToRValue: {
         return false;
       APValue RVal;
       // Note, we use the subexpression's type in order to retain cv-qualifiers.
       if (!handleLValueToRValueConversion(Info, E, E->getSubExpr()->getType(),
                                           LVal, RVal))
         return false;
       return DerivedSuccess(RVal, E);
     }
+    case CK_LValueToRValueBitCast: {
+      APValue DestValue, SourceValue;
+      if (!Evaluate(SourceValue, Info, E->getSubExpr()))
+        return false;
+      if (!handleLValueToRValueBitCast(Info, DestValue, SourceValue, E))
+        return false;
+      return DerivedSuccess(DestValue, E);
+    }
     }
 
     return Error(E);
   }
 
   bool VisitUnaryPostInc(const UnaryOperator *UO) {
     return VisitUnaryPostIncDec(UO);
   }

 }
 
 bool PointerExprEvaluator::VisitCastExpr(const CastExpr *E) {
   const Expr *SubExpr = E->getSubExpr();
 
   switch (E->getCastKind()) {
   default:
     break;
-
   case CK_BitCast:
   case CK_CPointerToObjCPointerCast:
   case CK_BlockPointerToObjCPointerCast:
   case CK_AnyPointerToBlockPointerCast:
   case CK_AddressSpaceConversion:
     if (!Visit(SubExpr))
       return false;
     // Bitcasts to cv void* are static_casts, not reinterpret_casts, so are
bool Success(uint64_t Value, const Expr *E) {
     return Success(Value, E, Result);
   }
 
   bool Success(CharUnits Size, const Expr *E) {
     return Success(Size.getQuantity(), E);
   }
 
   bool Success(const APValue &V, const Expr *E) {
-    if (V.isLValue() || V.isAddrLabelDiff()) {
+    if (V.isLValue() || V.isAddrLabelDiff() || V.isIndeterminate()) {
       Result = V;
       return true;
     }
     return Success(V.getInt(), E);
   }
 
   bool ZeroInitialization(const Expr *E) { return Success(0, E); }
 
bool IntExprEvaluator::VisitCastExpr(const CastExpr *E) {
   case CK_ARCExtendBlockObject:
   case CK_CopyAndAutoreleaseBlockObject:
     return Error(E);
 
   case CK_UserDefinedConversion:
   case CK_LValueToRValue:
   case CK_AtomicToNonAtomic:
   case CK_NoOp:
+  case CK_LValueToRValueBitCast:
     return ExprEvaluatorBaseTy::VisitCastExpr(E);
 
   case CK_MemberPointerToBoolean:
   case CK_PointerToBoolean:
   case CK_IntegralToBoolean:
   case CK_FloatingToBoolean:
   case CK_BooleanToSignedIntegral:
   case CK_FloatingComplexToBoolean:
bool ComplexExprEvaluator::VisitCastExpr(const CastExpr *E) {
   case CK_FixedPointToBoolean:
   case CK_FixedPointToIntegral:
   case CK_IntegralToFixedPoint:
     llvm_unreachable("invalid cast kind for complex value");
 
   case CK_LValueToRValue:
   case CK_AtomicToNonAtomic:
   case CK_NoOp:
+  case CK_LValueToRValueBitCast:
     return ExprEvaluatorBaseTy::VisitCastExpr(E);
 
   case CK_Dependent:
   case CK_LValueBitCast:
   case CK_UserDefinedConversion:
     return Error(E);
 
   case CK_FloatingRealToComplex: {
#include "clang/AST/StmtNodes.inc"
   }
   case Expr::CXXDefaultArgExprClass:
     return CheckICE(cast<CXXDefaultArgExpr>(E)->getExpr(), Ctx);
   case Expr::CXXDefaultInitExprClass:
     return CheckICE(cast<CXXDefaultInitExpr>(E)->getExpr(), Ctx);
   case Expr::ChooseExprClass: {
     return CheckICE(cast<ChooseExpr>(E)->getChosenSubExpr(), Ctx);
   }
+  case Expr::BuiltinBitCastExprClass: {
+    if (!checkBitCastConstexprEligibility(nullptr, Ctx, cast<CastExpr>(E)))
+      return ICEDiag(IK_NotICE, E->getBeginLoc());
+    return CheckICE(cast<CastExpr>(E)->getSubExpr(), Ctx);
+  }
   }
 
   llvm_unreachable("Invalid StmtClass!");
 }
 
 /// Evaluate an expression as a C++11 integral constant expression.
 static bool EvaluateCPlusPlus11IntegralConstantExpr(const ASTContext &Ctx,
                                                     const Expr *E,

cfe/trunk/lib/AST/ItaniumMangle.cpp

#include "clang/AST/StmtNodes.inc"
   case Expr::ExpressionTraitExprClass:
   case Expr::VAArgExprClass:
   case Expr::CUDAKernelCallExprClass:
   case Expr::AsTypeExprClass:
   case Expr::PseudoObjectExprClass:
   case Expr::AtomicExprClass:
   case Expr::SourceLocExprClass:
   case Expr::FixedPointLiteralClass:
+  case Expr::BuiltinBitCastExprClass:
   {
     if (!NullOut) {
       // As bad as this diagnostic is, it's better than crashing.
       DiagnosticsEngine &Diags = Context.getDiags();
       unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
                                        "cannot yet mangle expression type %0");
       Diags.Report(E->getExprLoc(), DiagID)
         << E->getStmtClassName() << E->getSourceRange();

cfe/trunk/lib/AST/StmtPrinter.cpp

 void StmtPrinter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *Node) {
   VisitCXXNamedCastExpr(Node);
 }
 
 void StmtPrinter::VisitCXXConstCastExpr(CXXConstCastExpr *Node) {
   VisitCXXNamedCastExpr(Node);
 }
 
+void StmtPrinter::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *Node) {
+  OS << "__builtin_bit_cast(";
+  Node->getTypeInfoAsWritten()->getType().print(OS, Policy);
+  OS << ", ";
+  PrintExpr(Node->getSubExpr());
+  OS << ")";
+}
+
 void StmtPrinter::VisitCXXTypeidExpr(CXXTypeidExpr *Node) {
   OS << "typeid(";
   if (Node->isTypeOperand()) {
     Node->getTypeOperandSourceInfo()->getType().print(OS, Policy);
   } else {
     PrintExpr(Node->getExprOperand());
   }
   OS << ")";

cfe/trunk/lib/AST/StmtProfile.cpp

 StmtProfiler::VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *S) {
   VisitCXXNamedCastExpr(S);
 }
 
 void StmtProfiler::VisitCXXConstCastExpr(const CXXConstCastExpr *S) {
   VisitCXXNamedCastExpr(S);
 }
 
+void StmtProfiler::VisitBuiltinBitCastExpr(const BuiltinBitCastExpr *S) {
+  VisitExpr(S);
+  VisitType(S->getTypeInfoAsWritten()->getType());
+}
+
 void StmtProfiler::VisitUserDefinedLiteral(const UserDefinedLiteral *S) {
   VisitCallExpr(S);
 }
 
 void StmtProfiler::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *S) {
   VisitExpr(S);
   ID.AddBoolean(S->getValue());
 }

cfe/trunk/lib/CodeGen/CGExpr.cpp

 /// then it must mean that we need the address of an aggregate in order to
 /// access one of its members.  This can happen for all the reasons that casts
 /// are permitted with aggregate result, including noop aggregate casts, and
 /// cast from scalar to union.
 LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) {
   switch (E->getCastKind()) {
   case CK_ToVoid:
   case CK_BitCast:
+  case CK_LValueToRValueBitCast:
   case CK_ArrayToPointerDecay:
   case CK_FunctionToPointerDecay:
   case CK_NullToMemberPointer:
   case CK_NullToPointer:
   case CK_IntegralToPointer:
   case CK_PointerToIntegral:
   case CK_PointerToBoolean:
   case CK_VectorSplat:

cfe/trunk/lib/CodeGen/CGExprAgg.cpp

case CK_ToUnion: {
     QualType Ty = E->getSubExpr()->getType();
     Address CastPtr =
       Builder.CreateElementBitCast(Dest.getAddress(), CGF.ConvertType(Ty));
     EmitInitializationToLValue(E->getSubExpr(),
                                CGF.MakeAddrLValue(CastPtr, Ty));
     break;
   }
 
+  case CK_LValueToRValueBitCast: {
+    if (Dest.isIgnored()) {
+      CGF.EmitAnyExpr(E->getSubExpr(), AggValueSlot::ignored(),
+                      /*ignoreResult=*/true);
+      break;
+    }
+
+    LValue SourceLV = CGF.EmitLValue(E->getSubExpr());
+    Address SourceAddress =
+        Builder.CreateElementBitCast(SourceLV.getAddress(), CGF.Int8Ty);
+    Address DestAddress =
+        Builder.CreateElementBitCast(Dest.getAddress(), CGF.Int8Ty);
+    llvm::Value *SizeVal = llvm::ConstantInt::get(
+        CGF.SizeTy,
+        CGF.getContext().getTypeSizeInChars(E->getType()).getQuantity());
+    Builder.CreateMemCpy(DestAddress, SourceAddress, SizeVal);
+    break;
+  }
+
   case CK_DerivedToBase:
   case CK_BaseToDerived:
   case CK_UncheckedDerivedToBase: {
     llvm_unreachable("cannot perform hierarchy conversion in EmitAggExpr: "
                 "should have been unpacked before we got here");
   }
 
   case CK_NonAtomicToAtomic:

cfe/trunk/lib/CodeGen/CGExprComplex.cpp

ComplexPairTy ComplexExprEmitter::EmitCast(CastKind CK, Expr *Op,
 
   case CK_LValueBitCast: {
     LValue origLV = CGF.EmitLValue(Op);
     Address V = origLV.getAddress();
     V = Builder.CreateElementBitCast(V, CGF.ConvertType(DestTy));
     return EmitLoadOfLValue(CGF.MakeAddrLValue(V, DestTy), Op->getExprLoc());
   }
 
+  case CK_LValueToRValueBitCast: {
+    LValue SourceLVal = CGF.EmitLValue(Op);
+    Address Addr = Builder.CreateElementBitCast(SourceLVal.getAddress(),
+                                                CGF.ConvertTypeForMem(DestTy));
+    LValue DestLV = CGF.MakeAddrLValue(Addr, DestTy);
+    DestLV.setTBAAInfo(TBAAAccessInfo::getMayAliasInfo());
+    return EmitLoadOfLValue(DestLV, Op->getExprLoc());
+  }
+
   case CK_BitCast:
   case CK_BaseToDerived:
   case CK_DerivedToBase:
   case CK_UncheckedDerivedToBase:
   case CK_Dynamic:
   case CK_ToUnion:
   case CK_ArrayToPointerDecay:
   case CK_FunctionToPointerDecay:

cfe/trunk/lib/CodeGen/CGExprConstant.cpp

case CK_CopyAndAutoreleaseBlockObject:
       return nullptr;
 
     // These don't need to be handled here because Evaluate knows how to
     // evaluate them in the cases where they can be folded.
     case CK_BitCast:
     case CK_ToVoid:
     case CK_Dynamic:
     case CK_LValueBitCast:
+    case CK_LValueToRValueBitCast:
     case CK_NullToMemberPointer:
     case CK_UserDefinedConversion:
     case CK_CPointerToObjCPointerCast:
     case CK_BlockPointerToObjCPointerCast:
     case CK_AnyPointerToBlockPointerCast:
     case CK_ArrayToPointerDecay:
     case CK_FunctionToPointerDecay:
     case CK_BaseToDerived:

cfe/trunk/lib/CodeGen/CGExprScalar.cpp

Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) {
   case CK_LValueBitCast:
   case CK_ObjCObjectLValueCast: {
     Address Addr = EmitLValue(E).getAddress();
     Addr = Builder.CreateElementBitCast(Addr, CGF.ConvertTypeForMem(DestTy));
     LValue LV = CGF.MakeAddrLValue(Addr, DestTy);
     return EmitLoadOfLValue(LV, CE->getExprLoc());
   }
 
+  case CK_LValueToRValueBitCast: {
+    LValue SourceLVal = CGF.EmitLValue(E);
+    Address Addr = Builder.CreateElementBitCast(SourceLVal.getAddress(),
+                                                CGF.ConvertTypeForMem(DestTy));
+    LValue DestLV = CGF.MakeAddrLValue(Addr, DestTy);
+    DestLV.setTBAAInfo(TBAAAccessInfo::getMayAliasInfo());
+    return EmitLoadOfLValue(DestLV, CE->getExprLoc());
+  }
+
   case CK_CPointerToObjCPointerCast:
   case CK_BlockPointerToObjCPointerCast:
   case CK_AnyPointerToBlockPointerCast:
   case CK_BitCast: {
     Value *Src = Visit(const_cast<Expr*>(E));
     llvm::Type *SrcTy = Src->getType();
     llvm::Type *DstTy = ConvertType(DestTy);
     if (SrcTy->isPtrOrPtrVectorTy() && DstTy->isPtrOrPtrVectorTy() &&

cfe/trunk/lib/Edit/RewriteObjCFoundationAPI.cpp

if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
     case CK_AtomicToNonAtomic:
     case CK_AddressSpaceConversion:
       needsCast = true;
       break;
 
     case CK_Dependent:
     case CK_BitCast:
     case CK_LValueBitCast:
+    case CK_LValueToRValueBitCast:
     case CK_BaseToDerived:
     case CK_DerivedToBase:
     case CK_UncheckedDerivedToBase:
     case CK_Dynamic:
     case CK_ToUnion:
     case CK_ArrayToPointerDecay:
     case CK_FunctionToPointerDecay:
     case CK_NullToPointer:

cfe/trunk/lib/Lex/PPMacroExpansion.cpp

EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
                       .Case("__is_target_arch", true)
                       .Case("__is_target_vendor", true)
                       .Case("__is_target_os", true)
                       .Case("__is_target_environment", true)
                       .Case("__builtin_LINE", true)
                       .Case("__builtin_FILE", true)
                       .Case("__builtin_FUNCTION", true)
                       .Case("__builtin_COLUMN", true)
+                      .Case("__builtin_bit_cast", true)
                       .Default(false);
         }
       });
   } else if (II == Ident__is_identifier) {
     EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
       [](Token &Tok, bool &HasLexedNextToken) -> int {
         return Tok.is(tok::identifier);
       });

cfe/trunk/lib/Parse/ParseExpr.cpp

case tok::ampamp: {      // unary-expression: '&&' identifier
     return Res;
   }
   case tok::kw_const_cast:
   case tok::kw_dynamic_cast:
   case tok::kw_reinterpret_cast:
   case tok::kw_static_cast:
     Res = ParseCXXCasts();
     break;
+  case tok::kw___builtin_bit_cast:
+    Res = ParseBuiltinBitCast();
+    break;
   case tok::kw_typeid:
     Res = ParseCXXTypeid();
     break;
   case tok::kw___uuidof:
     Res = ParseCXXUuidof();
     break;
   case tok::kw_this:
     Res = ParseCXXThis();

cfe/trunk/lib/Parse/ParseExprCXX.cpp

Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,
   }
 
   Tracker.consumeClose();
   // Consume EOF marker for Toks buffer.
   assert(Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData());
   ConsumeAnyToken();
   return Result;
 }
+
+/// Parse a __builtin_bit_cast(T, E).
+ExprResult Parser::ParseBuiltinBitCast() {
+  SourceLocation KWLoc = ConsumeToken();
+
+  BalancedDelimiterTracker T(*this, tok::l_paren);
+  if (T.expectAndConsume(diag::err_expected_lparen_after, "__builtin_bit_cast"))
+    return ExprError();
+
+  // Parse the common declaration-specifiers piece.
+  DeclSpec DS(AttrFactory);
+  ParseSpecifierQualifierList(DS);
+
+  // Parse the abstract-declarator, if present.
+  Declarator DeclaratorInfo(DS, DeclaratorContext::TypeNameContext);
+  ParseDeclarator(DeclaratorInfo);
+
+  if (ExpectAndConsume(tok::comma)) {
+    Diag(Tok.getLocation(), diag::err_expected) << tok::comma;
+    SkipUntil(tok::r_paren, StopAtSemi);
+    return ExprError();
+  }
+
+  ExprResult Operand = ParseExpression();
+
+  if (T.consumeClose())
+    return ExprError();
+
+  if (Operand.isInvalid() || DeclaratorInfo.isInvalidType())
+    return ExprError();
+
+  return Actions.ActOnBuiltinBitCastExpr(KWLoc, DeclaratorInfo, Operand,
+                                         T.getCloseLocation());
+}

cfe/trunk/lib/Sema/SemaCast.cpp

struct CastOperation {
 
     // Top-level semantics-checking routines.
     void CheckConstCast();
     void CheckReinterpretCast();
     void CheckStaticCast();
     void CheckDynamicCast();
     void CheckCXXCStyleCast(bool FunctionalCast, bool ListInitialization);
     void CheckCStyleCast();
+    void CheckBuiltinBitCast();
 
     void updatePartOfExplicitCastFlags(CastExpr *CE) {
       // Walk down from the CE to the OrigSrcExpr, and mark all immediate
       // ImplicitCastExpr's as being part of ExplicitCastExpr. The original CE
       // (which is a ExplicitCastExpr), and the OrigSrcExpr are not touched.
       for (; auto *ICE = dyn_cast<ImplicitCastExpr>(CE->getSubExpr()); CE = ICE)
         ICE->setIsPartOfExplicitCast(true);
     }
return Op.complete(CXXStaticCastExpr::Create(Context, Op.ResultType,
                                    Op.ValueKind, Op.Kind, Op.SrcExpr.get(),
                                                  &Op.BasePath, DestTInfo,
                                                  OpLoc, Parens.getEnd(),
                                                  AngleBrackets));
   }
   }
 }
 
+ExprResult Sema::ActOnBuiltinBitCastExpr(SourceLocation KWLoc, Declarator &D,
+                                         ExprResult Operand,
+                                         SourceLocation RParenLoc) {
+  assert(!D.isInvalidType());
+
+  TypeSourceInfo *TInfo = GetTypeForDeclaratorCast(D, Operand.get()->getType());
+  if (D.isInvalidType())
+    return ExprError();
+
+  return BuildBuiltinBitCastExpr(KWLoc, TInfo, Operand.get(), RParenLoc);
+}
+
+ExprResult Sema::BuildBuiltinBitCastExpr(SourceLocation KWLoc,
+                                         TypeSourceInfo *TSI, Expr *Operand,
+                                         SourceLocation RParenLoc) {
+  CastOperation Op(*this, TSI->getType(), Operand);
+  Op.OpRange = SourceRange(KWLoc, RParenLoc);
+  TypeLoc TL = TSI->getTypeLoc();
+  Op.DestRange = SourceRange(TL.getBeginLoc(), TL.getEndLoc());
+
+  if (!Operand->isTypeDependent() && !TSI->getType()->isDependentType()) {
+    Op.CheckBuiltinBitCast();
+    if (Op.SrcExpr.isInvalid())
+      return ExprError();
+  }
+
+  BuiltinBitCastExpr *BCE =
+      new (Context) BuiltinBitCastExpr(Op.ResultType, Op.ValueKind, Op.Kind,
+                                       Op.SrcExpr.get(), TSI, KWLoc, RParenLoc);
+  return Op.complete(BCE);
+}
+
 /// Try to diagnose a failed overloaded cast.  Returns true if
 /// diagnostics were emitted.
 static bool tryDiagnoseOverloadedCast(Sema &S, CastType CT,
                                       SourceRange range, Expr *src,
                                       QualType destType,
                                       bool listInitialization) {
   switch (CT) {
   // These cast kinds don't consider user-defined conversions.
void CastOperation::CheckCStyleCast() {
   Kind = Self.PrepareScalarCast(SrcExpr, DestType);
   if (SrcExpr.isInvalid())
     return;
 
   if (Kind == CK_BitCast)
     checkCastAlign();
 }
 
+void CastOperation::CheckBuiltinBitCast() {
+  QualType SrcType = SrcExpr.get()->getType();
+  if (SrcExpr.get()->isRValue())
+    SrcExpr = Self.CreateMaterializeTemporaryExpr(SrcType, SrcExpr.get(),
+                                                  /*IsLValueReference=*/false);
+
+  CharUnits DestSize = Self.Context.getTypeSizeInChars(DestType);
+  CharUnits SourceSize = Self.Context.getTypeSizeInChars(SrcType);
+  if (DestSize != SourceSize) {
+    Self.Diag(OpRange.getBegin(), diag::err_bit_cast_type_size_mismatch)
+        << (int)SourceSize.getQuantity() << (int)DestSize.getQuantity();
+    SrcExpr = ExprError();
+    return;
+  }
+
+  if (!DestType.isTriviallyCopyableType(Self.Context)) {
+    Self.Diag(OpRange.getBegin(), diag::err_bit_cast_non_trivially_copyable)
+        << 1;
+    SrcExpr = ExprError();
+    return;
+  }
+
+  if (!SrcType.isTriviallyCopyableType(Self.Context)) {
+    Self.Diag(OpRange.getBegin(), diag::err_bit_cast_non_trivially_copyable)
+        << 0;
+    SrcExpr = ExprError();
+    return;
+  }
+
+  if (Self.Context.hasSameUnqualifiedType(DestType, SrcType)) {
+    Kind = CK_NoOp;
+    return;
+  }
+
+  Kind = CK_LValueToRValueBitCast;
+}
+
 /// DiagnoseCastQual - Warn whenever casts discards a qualifiers, be it either
 /// const, volatile or both.
 static void DiagnoseCastQual(Sema &Self, const ExprResult &SrcExpr,
                              QualType DestType) {
   if (SrcExpr.isInvalid())
     return;
 
   QualType SrcType = SrcExpr.get()->getType();

cfe/trunk/lib/Sema/SemaExceptionSpec.cpp

case Expr::ObjCBoxedExprClass:
     // Many other things have subexpressions, so we have to test those.
     // Some are simple:
   case Expr::CoawaitExprClass:
   case Expr::ConditionalOperatorClass:
   case Expr::CompoundLiteralExprClass:
   case Expr::CoyieldExprClass:
   case Expr::CXXConstCastExprClass:
   case Expr::CXXReinterpretCastExprClass:
+  case Expr::BuiltinBitCastExprClass:
   case Expr::CXXStdInitializerListExprClass:
   case Expr::DesignatedInitExprClass:
   case Expr::DesignatedInitUpdateExprClass:
   case Expr::ExprWithCleanupsClass:
   case Expr::ExtVectorElementExprClass:
   case Expr::InitListExprClass:
   case Expr::ArrayInitLoopExprClass:
   case Expr::MemberExprClass:

cfe/trunk/lib/Sema/TreeTransform.h

ExprResult RebuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo,
                                           Expr *Sub,
                                           SourceLocation RParenLoc,
                                           bool ListInitialization) {
     return getSema().BuildCXXTypeConstructExpr(TInfo, LParenLoc,
                                                MultiExprArg(&Sub, 1), RParenLoc,
                                                ListInitialization);
   }
 
+  /// Build a new C++ __builtin_bit_cast expression.
+  ///
+  /// By default, performs semantic analysis to build the new expression.
+  /// Subclasses may override this routine to provide different behavior.
+  ExprResult RebuildBuiltinBitCastExpr(SourceLocation KWLoc,
+                                       TypeSourceInfo *TSI, Expr *Sub,
+                                       SourceLocation RParenLoc) {
+    return getSema().BuildBuiltinBitCastExpr(KWLoc, TSI, Sub, RParenLoc);
+  }
+
   /// Build a new C++ typeid(type) expression.
   ///
   /// By default, performs semantic analysis to build the new expression.
   /// Subclasses may override this routine to provide different behavior.
   ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
                                         SourceLocation TypeidLoc,
                                         TypeSourceInfo *Operand,
                                         SourceLocation RParenLoc) {
return getDerived().RebuildCXXNamedCastExpr(
       E->getOperatorLoc(), E->getStmtClass(), E->getAngleBrackets().getBegin(),
       Type, E->getAngleBrackets().getEnd(),
       // FIXME. this should be '(' location
       E->getAngleBrackets().getEnd(), SubExpr.get(), E->getRParenLoc());
 }
 
 template<typename Derived>
 ExprResult
+TreeTransform<Derived>::TransformBuiltinBitCastExpr(BuiltinBitCastExpr *BCE) {
+  TypeSourceInfo *TSI =
+      getDerived().TransformType(BCE->getTypeInfoAsWritten());
+  if (!TSI)
+    return ExprError();
+
+  ExprResult Sub = getDerived().TransformExpr(BCE->getSubExpr());
+  if (Sub.isInvalid())
+    return ExprError();
+
+  return getDerived().RebuildBuiltinBitCastExpr(BCE->getBeginLoc(), TSI,
+                                                Sub.get(), BCE->getEndLoc());
+}
+
+template<typename Derived>
+ExprResult
 TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) {
   return getDerived().TransformCXXNamedCastExpr(E);
 }
 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
   return getDerived().TransformCXXNamedCastExpr(E);

cfe/trunk/lib/Serialization/ASTReaderStmt.cpp

 }
 
 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
   VisitExplicitCastExpr(E);
   E->setLParenLoc(ReadSourceLocation());
   E->setRParenLoc(ReadSourceLocation());
 }
 
+void ASTStmtReader::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) {
+  VisitExplicitCastExpr(E);
+  E->KWLoc = ReadSourceLocation();
+  E->RParenLoc = ReadSourceLocation();
+}
+
 void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
   VisitCallExpr(E);
   E->UDSuffixLoc = ReadSourceLocation();
 }
 
 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
   VisitExpr(E);
   E->setValue(Record.readInt());

cfe/trunk/lib/Serialization/ASTWriterStmt.cpp

 
 void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
   VisitExplicitCastExpr(E);
   Record.AddSourceLocation(E->getLParenLoc());
   Record.AddSourceLocation(E->getRParenLoc());
   Code = serialization::EXPR_CXX_FUNCTIONAL_CAST;
 }
 
+void ASTStmtWriter::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) {
+  VisitExplicitCastExpr(E);
+  Record.AddSourceLocation(E->getBeginLoc());
+  Record.AddSourceLocation(E->getEndLoc());
+}
+
 void ASTStmtWriter::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
   VisitCallExpr(E);
   Record.AddSourceLocation(E->UDSuffixLoc);
   Code = serialization::EXPR_USER_DEFINED_LITERAL;
 }
 
 void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
   VisitExpr(E);

cfe/trunk/lib/StaticAnalyzer/Core/ExprEngine.cpp

switch (S->getStmtClass()) {
 
     case Stmt::ImplicitCastExprClass:
     case Stmt::CStyleCastExprClass:
     case Stmt::CXXStaticCastExprClass:
     case Stmt::CXXDynamicCastExprClass:
     case Stmt::CXXReinterpretCastExprClass:
     case Stmt::CXXConstCastExprClass:
     case Stmt::CXXFunctionalCastExprClass:
+    case Stmt::BuiltinBitCastExprClass:
     case Stmt::ObjCBridgedCastExprClass: {
       Bldr.takeNodes(Pred);
       const auto *C = cast<CastExpr>(S);
       ExplodedNodeSet dstExpr;
       VisitCast(C, C->getSubExpr(), Pred, dstExpr);
 
       // Handle the postvisit checks.
       getCheckerManager().runCheckersForPostStmt(Dst, dstExpr, C, *this);

cfe/trunk/lib/StaticAnalyzer/Core/ExprEngineC.cpp

switch (CastE->getCastKind()) {
         // Explicitly proceed with default handler for this case cascade.
         state =
             handleLValueBitCast(state, Ex, LCtx, T, ExTy, CastE, Bldr, Pred);
         continue;
       }
       case CK_Dependent:
       case CK_ArrayToPointerDecay:
       case CK_BitCast:
+      case CK_LValueToRValueBitCast:
       case CK_AddressSpaceConversion:
       case CK_BooleanToSignedIntegral:
       case CK_IntegralToPointer:
       case CK_PointerToIntegral: {
         SVal V = state->getSVal(Ex, LCtx);
         if (V.getAs<nonloc::PointerToMember>()) {
           state = state->BindExpr(CastE, LCtx, UnknownVal());
           Bldr.generateNode(CastE, Pred, state);

cfe/trunk/test/CodeGenCXX/builtin-bit-cast-no-tbaa.cpp

+// RUN: %clang_cc1 -O3 -std=c++2a -S -emit-llvm -o - -disable-llvm-passes -triple x86_64-apple-macos10.14 %s | FileCheck %s
+
+void test_scalar() {
+  // CHECK-LABEL: define void @_Z11test_scalarv
+  __builtin_bit_cast(float, 42);
+
+  // CHECK: load float, float* {{.*}}, align 4, !tbaa ![[MAY_ALIAS_TBAA:.*]]
+}
+
+void test_scalar2() {
+  // CHECK-LABEL: define void @_Z12test_scalar2v
+  struct S {int m;};
+  __builtin_bit_cast(int, S{42});
+
+  // CHECK: load i32, i32* {{.*}}, align 4, !tbaa ![[MAY_ALIAS_TBAA]]
+}
+
+// CHECK: ![[CHAR_TBAA:.*]] = !{!"omnipotent char", {{.*}}, i64 0}
+// CHECK: ![[MAY_ALIAS_TBAA]] = !{![[CHAR_TBAA]], ![[CHAR_TBAA]], i64 0}

cfe/trunk/test/CodeGenCXX/builtin-bit-cast.cpp

+// RUN: %clang_cc1 -std=c++2a -S -emit-llvm -o - -disable-llvm-passes -triple x86_64-apple-macos10.14 %s | FileCheck %s
+
+void test_scalar(int &oper) {
+  // CHECK-LABEL: define void @_Z11test_scalarRi
+  __builtin_bit_cast(float, oper);
+
+  // CHECK: [[OPER:%.*]] = alloca i32*
+  // CHECK: [[REF:%.*]] = load i32*, i32**
+  // CHECK-NEXT: [[CASTED:%.*]] = bitcast i32* [[REF]] to float*
+  // CHECK-NEXT: load float, float* [[CASTED]]
+}
+
+struct two_ints {
+  int x;
+  int y;
+};
+
+unsigned long test_aggregate_to_scalar(two_ints &ti) {
+  // CHECK-LABEL: define i64 @_Z24test_aggregate_to_scalarR8two_ints
+  return __builtin_bit_cast(unsigned long, ti);
+
+  // CHECK: [[TI_ADDR:%.*]] = alloca %struct.two_ints*, align 8
+  // CHECK: [[TI_LOAD:%.*]] = load %struct.two_ints*, %struct.two_ints** [[TI_ADDR]]
+  // CHECK-NEXT: [[CASTED:%.*]] = bitcast %struct.two_ints* [[TI_LOAD]] to i64*
+  // CHECK-NEXT: load i64, i64* [[CASTED]]
+}
+
+struct two_floats {
+  float x;
+  float y;
+};
+
+two_floats test_aggregate_record(two_ints& ti) {
+  // CHECK-LABEL: define <2 x float> @_Z21test_aggregate_recordR8two_int
+   return __builtin_bit_cast(two_floats, ti);
+
+  // CHECK: [[RETVAL:%.*]] = alloca %struct.two_floats, align 4
+  // CHECK: [[TI:%.*]] = alloca %struct.two_ints*, align 8
+
+  // CHECK: [[LOAD_TI:%.*]] = load %struct.two_ints*, %struct.two_ints** [[TI]]
+  // CHECK: [[MEMCPY_SRC:%.*]] = bitcast %struct.two_ints* [[LOAD_TI]] to i8*
+  // CHECK: [[MEMCPY_DST:%.*]] = bitcast %struct.two_floats* [[RETVAL]] to i8*
+  // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 [[MEMCPY_DST]], i8* align 4 [[MEMCPY_SRC]]
+}
+
+two_floats test_aggregate_array(int (&ary)[2]) {
+  // CHECK-LABEL: define <2 x float> @_Z20test_aggregate_arrayRA2_i
+  return __builtin_bit_cast(two_floats, ary);
+
+  // CHECK: [[RETVAL:%.*]] = alloca %struct.two_floats, align 4
+  // CHECK: [[ARY:%.*]] = alloca [2 x i32]*, align 8
+
+  // CHECK: [[LOAD_ARY:%.*]] = load [2 x i32]*, [2 x i32]** [[ARY]]
+  // CHECK: [[MEMCPY_SRC:%.*]] = bitcast [2 x i32]* [[LOAD_ARY]] to i8*
+  // CHECK: [[MEMCPY_DST:%.*]] = bitcast %struct.two_floats* [[RETVAL]] to i8*
+  // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 [[MEMCPY_DST]], i8* align 4 [[MEMCPY_SRC]]
+}
+
+two_ints test_scalar_to_aggregate(unsigned long ul) {
+  // CHECK-LABEL: define i64 @_Z24test_scalar_to_aggregatem
+  return __builtin_bit_cast(two_ints, ul);
+
+  // CHECK: [[TI:%.*]] = alloca %struct.two_ints, align 4
+  // CHECK: [[TITMP:%.*]] = bitcast %struct.two_ints* [[TI]] to i8*
+  // CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 [[TITMP]]
+}
+
+unsigned long test_complex(_Complex unsigned &cu) {
+  // CHECK-LABEL: define i64 @_Z12test_complexRCj
+  return __builtin_bit_cast(unsigned long, cu);
+
+  // CHECK: [[REF_ALLOCA:%.*]] = alloca { i32, i32 }*, align 8
+  // CHECK-NEXT: store { i32, i32 }* {{.*}}, { i32, i32 }** [[REF_ALLOCA]]
+  // CHECK-NEXT: [[REF:%.*]] = load { i32, i32 }*, { i32, i32 }** [[REF_ALLOCA]]
+  // CHECK-NEXT: [[CASTED:%.*]] = bitcast { i32, i32 }* [[REF]] to i64*
+  // CHECK-NEXT: load i64, i64* [[CASTED]], align 4
+}
+
+_Complex unsigned test_to_complex(unsigned long &ul) {
+  // CHECK-LABEL: define i64 @_Z15test_to_complexRm
+
+  return __builtin_bit_cast(_Complex unsigned, ul);
+
+  // CHECK: [[REF:%.*]] = alloca i64*
+  // CHECK: [[LOAD_REF:%.*]] = load i64*, i64** [[REF]]
+  // CHECK: [[CASTED:%.*]] = bitcast i64* [[LOAD_REF]] to { i32, i32 }*
+}
+
+unsigned long test_array(int (&ary)[2]) {
+  // CHECK-LABEL: define i64 @_Z10test_arrayRA2_i
+  return __builtin_bit_cast(unsigned long, ary);
+
+  // CHECK: [[REF_ALLOCA:%.*]] = alloca [2 x i32]*
+  // CHECK: [[LOAD_REF:%.*]] = load [2 x i32]*, [2 x i32]** [[REF_ALLOCA]]
+  // CHECK: [[CASTED:%.*]] = bitcast [2 x i32]* [[LOAD_REF]] to i64*
+  // CHECK: load i64, i64* [[CASTED]], align 4
+}
+
+two_ints test_rvalue_aggregate() {
+  // CHECK-LABEL: define i64 @_Z21test_rvalue_aggregate
+  return __builtin_bit_cast(two_ints, 42ul);
+
+  // CHECK: [[TI:%.*]] = alloca %struct.two_ints, align 4
+  // CHECK: [[CASTED:%.*]] = bitcast %struct.two_ints* [[TI]] to i8*
+  // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 [[CASTED]]
+}

cfe/trunk/test/SemaCXX/builtin-bit-cast.cpp

+// RUN: %clang_cc1 -verify -std=c++2a -fsyntax-only -triple x86_64-apple-macosx10.14.0 %s
+// RUN: %clang_cc1 -verify -std=c++2a -fsyntax-only -triple x86_64-apple-macosx10.14.0 %s -fno-signed-char
+
+#if !__has_builtin(__builtin_bit_cast)
+#error
+#endif
+
+template <class T, T v>
+T instantiate() {
+  return __builtin_bit_cast(T, v);
+}
+
+int x = instantiate<int, 32>();
+
+struct secret_ctor {
+  char member;
+
+private: secret_ctor() = default;
+};
+
+void test1() {
+  secret_ctor c = __builtin_bit_cast(secret_ctor, (char)0);
+}
+
+void test2() {
+  constexpr int i = 0;
+  // expected-error@+1{{__builtin_bit_cast source size does not equal destination size (4 vs 1)}}
+  constexpr char c = __builtin_bit_cast(char, i);
+}
+
+struct not_trivially_copyable {
+  virtual void foo() {}
+};
+
+// expected-error@+1{{__builtin_bit_cast source type must be trivially copyable}}
+constexpr unsigned long ul = __builtin_bit_cast(unsigned long, not_trivially_copyable{});
+
+// expected-error@+1 {{__builtin_bit_cast destination type must be trivially copyable}}
+constexpr long us = __builtin_bit_cast(unsigned long &, 0L);

cfe/trunk/test/SemaCXX/constexpr-builtin-bit-cast.cpp

+// RUN: %clang_cc1 -verify -std=c++2a -fsyntax-only -triple x86_64-apple-macosx10.14.0 %s
+// RUN: %clang_cc1 -verify -std=c++2a -fsyntax-only -triple x86_64-apple-macosx10.14.0 %s -fno-signed-char
+// RUN: %clang_cc1 -verify -std=c++2a -fsyntax-only -triple aarch64_be-linux-gnu %s
+
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#  define LITTLE_END 1
+#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#  define LITTLE_END 0
+#else
+#  error "huh?"
+#endif
+
+template <class T, class V> struct is_same {
+  static constexpr bool value = false;
+};
+template <class T> struct is_same<T, T> {
+  static constexpr bool value = true;
+};
+
+static_assert(sizeof(int) == 4);
+static_assert(sizeof(long long) == 8);
+
+template <class To, class From>
+constexpr To bit_cast(const From &from) {
+  static_assert(sizeof(To) == sizeof(From));
+#ifdef __CHAR_UNSIGNED__
+  // expected-note@+4 2 {{indeterminate value can only initialize an object of type 'unsigned char', 'char', or 'std::byte'; 'signed char' is invalid}}
+#else
+  // expected-note@+2 2 {{indeterminate value can only initialize an object of type 'unsigned char' or 'std::byte'; 'signed char' is invalid}}
+#endif
+  return __builtin_bit_cast(To, from);
+}
+
+template <class Intermediate, class Init>
+constexpr bool round_trip(const Init &init) {
+  return bit_cast<Init>(bit_cast<Intermediate>(init)) == init;
+}
+
+void test_int() {
+  static_assert(round_trip<unsigned>((int)-1));
+  static_assert(round_trip<unsigned>((int)0x12345678));
+  static_assert(round_trip<unsigned>((int)0x87654321));
+  static_assert(round_trip<unsigned>((int)0x0C05FEFE));
+}
+
+void test_array() {
+  constexpr unsigned char input[] = {0xCA, 0xFE, 0xBA, 0xBE};
+  constexpr unsigned expected = LITTLE_END ? 0xBEBAFECA : 0xCAFEBABE;
+  static_assert(bit_cast<unsigned>(input) == expected);
+}
+
+void test_record() {
+  struct int_splicer {
+    unsigned x;
+    unsigned y;
+
+    constexpr bool operator==(const int_splicer &other) const {
+      return other.x == x && other.y == y;
+    }
+  };
+
+  constexpr int_splicer splice{0x0C05FEFE, 0xCAFEBABE};
+
+  static_assert(bit_cast<unsigned long long>(splice) == LITTLE_END
+                ? 0xCAFEBABE0C05FEFE
+                : 0x0C05FEFECAFEBABE);
+
+  static_assert(bit_cast<int_splicer>(0xCAFEBABE0C05FEFE).x == LITTLE_END
+                ? 0x0C05FEFE
+                : 0xCAFEBABE);
+
+  static_assert(round_trip<unsigned long long>(splice));
+  static_assert(round_trip<long long>(splice));
+
+  struct base2 {
+  };
+
+  struct base3 {
+    unsigned z;
+  };
+
+  struct bases : int_splicer, base2, base3 {
+    unsigned doublez;
+  };
+
+  struct tuple4 {
+    unsigned x, y, z, doublez;
+
+    constexpr bool operator==(tuple4 const &other) const {
+      return x == other.x && y == other.y &&
+             z == other.z && doublez == other.doublez;
+    }
+  };
+  constexpr bases b = {{1, 2}, {}, {3}, 4};
+  constexpr tuple4 t4 = bit_cast<tuple4>(b);
+  static_assert(t4 == tuple4{1, 2, 3, 4});
+  static_assert(round_trip<tuple4>(b));
+}
+
+void test_partially_initialized() {
+  struct pad {
+    signed char x;
+    int y;
+  };
+
+  struct no_pad {
+    signed char x;
+    signed char p1, p2, p3;
+    int y;
+  };
+
+  static_assert(sizeof(pad) == sizeof(no_pad));
+
+  constexpr pad pir{4, 4};
+  // expected-error@+2 {{constexpr variable 'piw' must be initialized by a constant expression}}
+  // expected-note@+1 {{in call to 'bit_cast(pir)'}}
+  constexpr int piw = bit_cast<no_pad>(pir).x;
+
+  // expected-error@+2 {{constexpr variable 'bad' must be initialized by a constant expression}}
+  // expected-note@+1 {{in call to 'bit_cast(pir)'}}
+  constexpr no_pad bad = bit_cast<no_pad>(pir);
+
+  constexpr pad fine = bit_cast<pad>(no_pad{1, 2, 3, 4, 5});
+  static_assert(fine.x == 1 && fine.y == 5);
+}
+
+void no_bitfields() {
+  // FIXME!
+  struct S {
+    unsigned char x : 8;
+  };
+
+  struct G {
+    unsigned char x : 8;
+  };
+
+  constexpr S s{0};
+  // expected-error@+2 {{constexpr variable 'g' must be initialized by a constant expression}}
+  // expected-note@+1 {{constexpr bit_cast involving bit-field is not yet supported}}
+  constexpr G g = __builtin_bit_cast(G, s);
+}
+
+void array_members() {
+  struct S {
+    int ar[3];
+
+    constexpr bool operator==(const S &rhs) {
+      return ar[0] == rhs.ar[0] && ar[1] == rhs.ar[1] && ar[2] == rhs.ar[2];
+    }
+  };
+
+  struct G {
+    int a, b, c;
+
+    constexpr bool operator==(const G &rhs) {
+      return a == rhs.a && b == rhs.b && c == rhs.c;
+    }
+  };
+
+  constexpr S s{{1, 2, 3}};
+  constexpr G g = bit_cast<G>(s);
+  static_assert(g.a == 1 && g.b == 2 && g.c == 3);
+
+  static_assert(round_trip<G>(s));
+  static_assert(round_trip<S>(g));
+}
+
+void bad_types() {
+  union X {
+    int x;
+  };
+
+  struct G {
+    int g;
+  };
+  // expected-error@+2 {{constexpr variable 'g' must be initialized by a constant expression}}
+  // expected-note@+1 {{bit_cast from a union type is not allowed in a constant expression}}
+  constexpr G g = __builtin_bit_cast(G, X{0});
+  // expected-error@+2 {{constexpr variable 'x' must be initialized by a constant expression}}
+  // expected-note@+1 {{bit_cast to a union type is not allowed in a constant expression}}
+  constexpr X x = __builtin_bit_cast(X, G{0});
+
+  struct has_pointer {
+    // expected-note@+1 2 {{invalid type 'int *' is a member of 'has_pointer'}}
+    int *ptr;
+  };
+
+  // expected-error@+2 {{constexpr variable 'ptr' must be initialized by a constant expression}}
+  // expected-note@+1 {{bit_cast from a pointer type is not allowed in a constant expression}}
+  constexpr unsigned long ptr = __builtin_bit_cast(unsigned long, has_pointer{0});
+  // expected-error@+2 {{constexpr variable 'hptr' must be initialized by a constant expression}}
+  // expected-note@+1 {{bit_cast to a pointer type is not allowed in a constant expression}}
+  constexpr has_pointer hptr =  __builtin_bit_cast(has_pointer, 0ul);
+}
+
+void backtrace() {
+  struct A {
+    // expected-note@+1 {{invalid type 'int *' is a member of 'A'}}
+    int *ptr;
+  };
+
+  struct B {
+    // expected-note@+1 {{invalid type 'A [10]' is a member of 'B'}}
+    A as[10];
+  };
+
+  // expected-note@+1 {{invalid type 'B' is a base of 'C'}}
+  struct C : B {
+  };
+
+  struct E {
+    unsigned long ar[10];
+  };
+
+  // expected-error@+2 {{constexpr variable 'e' must be initialized by a constant expression}}
+  // expected-note@+1 {{bit_cast from a pointer type is not allowed in a constant expression}}
+  constexpr E e = __builtin_bit_cast(E, C{});
+}
+
+void test_array_fill() {
+  constexpr unsigned char a[4] = {1, 2};
+  constexpr unsigned int i = bit_cast<unsigned int>(a);
+  static_assert(i == LITTLE_END ? 0x00000201 : 0x01020000, "");
+}
+
+typedef decltype(nullptr) nullptr_t;
+
+#ifdef __CHAR_UNSIGNED__
+// expected-note@+5 {{indeterminate value can only initialize an object of type 'unsigned char', 'char', or 'std::byte'; 'unsigned long' is invalid}}
+#else
+// expected-note@+3 {{indeterminate value can only initialize an object of type 'unsigned char' or 'std::byte'; 'unsigned long' is invalid}}
+#endif
+// expected-error@+1 {{constexpr variable 'test_from_nullptr' must be initialized by a constant expression}}
+constexpr unsigned long test_from_nullptr = __builtin_bit_cast(unsigned long, nullptr);
+
+constexpr int test_from_nullptr_pass = (__builtin_bit_cast(unsigned char[8], nullptr), 0);
+
+constexpr int test_to_nullptr() {
+  nullptr_t npt = __builtin_bit_cast(nullptr_t, 0ul);
+
+  struct indet_mem {
+    unsigned char data[sizeof(void *)];
+  };
+  indet_mem im = __builtin_bit_cast(indet_mem, nullptr);
+  nullptr_t npt2 = __builtin_bit_cast(nullptr_t, im);
+
+  return 0;
+}
+
+constexpr int ttn = test_to_nullptr();
+
+// expected-warning@+2 {{returning reference to local temporary object}}
+// expected-note@+1 {{temporary created here}}
+constexpr const long &returns_local() { return 0L; }
+
+// expected-error@+2 {{constexpr variable 'test_nullptr_bad' must be initialized by a constant expression}}
+// expected-note@+1 {{read of temporary whose lifetime has ended}}
+constexpr nullptr_t test_nullptr_bad = __builtin_bit_cast(nullptr_t, returns_local());
+
+constexpr int test_indeterminate(bool read_indet) {
+  struct pad {
+    char a;
+    int b;
+  };
+
+  struct no_pad {
+    char a;
+    unsigned char p1, p2, p3;
+    int b;
+  };
+
+  pad p{1, 2};
+  no_pad np = bit_cast<no_pad>(p);
+
+  int tmp = np.a + np.b;
+
+  unsigned char& indet_ref = np.p1;
+
+  if (read_indet) {
+    // expected-note@+1 {{read of uninitialized object is not allowed in a constant expression}}
+    tmp = indet_ref;
+  }
+
+  indet_ref = 0;
+
+  return 0;
+}
+
+constexpr int run_test_indeterminate = test_indeterminate(false);
+// expected-error@+2 {{constexpr variable 'run_test_indeterminate2' must be initialized by a constant expression}}
+// expected-note@+1 {{in call to 'test_indeterminate(true)'}}
+constexpr int run_test_indeterminate2 = test_indeterminate(true);
+
+struct ref_mem {
+  const int &rm;
+};
+
+constexpr int global_int = 0;
+
+// expected-error@+2 {{constexpr variable 'run_ref_mem' must be initialized by a constant expression}}
+// expected-note@+1 {{bit_cast from a type with a reference member is not allowed in a constant expression}}
+constexpr unsigned long run_ref_mem = __builtin_bit_cast(
+    unsigned long, ref_mem{global_int});
+
+union u {
+  int im;
+};
+
+// expected-error@+2 {{constexpr variable 'run_u' must be initialized by a constant expression}}
+// expected-note@+1 {{bit_cast from a union type is not allowed in a constant expression}}
+constexpr int run_u = __builtin_bit_cast(int, u{32});
+
+struct vol_mem {
+  volatile int x;
+};
+
+// expected-error@+2 {{constexpr variable 'run_vol_mem' must be initialized by a constant expression}}
+// expected-note@+1 {{non-literal type 'vol_mem' cannot be used in a constant expression}}
+constexpr int run_vol_mem = __builtin_bit_cast(int, vol_mem{43});
+
+struct mem_ptr {
+  int vol_mem::*x; // expected-note{{invalid type 'int vol_mem::*' is a member of 'mem_ptr'}}
+};
+// expected-error@+2 {{constexpr variable 'run_mem_ptr' must be initialized by a constant expression}}
+// expected-note@+1 {{bit_cast from a member pointer type is not allowed in a constant expression}}
+constexpr int run_mem_ptr = __builtin_bit_cast(unsigned long, mem_ptr{nullptr});
+
+struct A { char c; /* char padding : 8; */ short s; };
+struct B { unsigned char x[4]; };
+
+constexpr B one() {
+  A a = {1, 2};
+  return bit_cast<B>(a);
+}
+constexpr char good_one = one().x[0] + one().x[2] + one().x[3];
+// expected-error@+2 {{constexpr variable 'bad_one' must be initialized by a constant expression}}
+// expected-note@+1 {{read of uninitialized object is not allowed in a constant expression}}
+constexpr char bad_one = one().x[1];
+
+constexpr A two() {
+  B b = one(); // b.x[1] is indeterminate.
+  b.x[0] = 'a';
+  b.x[2] = 1;
+  b.x[3] = 2;
+  return bit_cast<A>(b);
+}
+constexpr short good_two = two().c + two().s;
+
+namespace std {
+enum byte : unsigned char {};
+}
+
+enum my_byte : unsigned char {};
+
+struct pad {
+  char a;
+  int b;
+};
+
+constexpr int ok_byte = (__builtin_bit_cast(std::byte[8], pad{1, 2}), 0);
+constexpr int ok_uchar = (__builtin_bit_cast(unsigned char[8], pad{1, 2}), 0);
+
+#ifdef __CHAR_UNSIGNED__
+// expected-note@+5 {{indeterminate value can only initialize an object of type 'unsigned char', 'char', or 'std::byte'; 'my_byte' is invalid}}}}
+#else
+// expected-note@+3 {{indeterminate value can only initialize an object of type 'unsigned char' or 'std::byte'; 'my_byte' is invalid}}
+#endif
+// expected-error@+1 {{constexpr variable 'bad_my_byte' must be initialized by a constant expression}}
+constexpr int bad_my_byte = (__builtin_bit_cast(my_byte[8], pad{1, 2}), 0);
+#ifndef __CHAR_UNSIGNED__
+// expected-error@+3 {{constexpr variable 'bad_char' must be initialized by a constant expression}}
+// expected-note@+2 {{indeterminate value can only initialize an object of type 'unsigned char' or 'std::byte'; 'char' is invalid}}
+#endif
+constexpr int bad_char =  (__builtin_bit_cast(char[8], pad{1, 2}), 0);
+
+struct pad_buffer { unsigned char data[sizeof(pad)]; };
+constexpr bool test_pad_buffer() {
+  pad x = {1, 2};
+  pad_buffer y = __builtin_bit_cast(pad_buffer, x);
+  pad z = __builtin_bit_cast(pad, y);
+  return x.a == z.a && x.b == z.b;
+}
+static_assert(test_pad_buffer());

cfe/trunk/tools/libclang/CIndex.cpp

CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) {
   case CXCursor_DeclRefExpr:
       return cxstring::createRef("DeclRefExpr");
   case CXCursor_MemberRefExpr:
       return cxstring::createRef("MemberRefExpr");
   case CXCursor_CallExpr:
       return cxstring::createRef("CallExpr");
   case CXCursor_ObjCMessageExpr:
       return cxstring::createRef("ObjCMessageExpr");
+  case CXCursor_BuiltinBitCastExpr:
+    return cxstring::createRef("BuiltinBitCastExpr");
   case CXCursor_UnexposedStmt:
       return cxstring::createRef("UnexposedStmt");
   case CXCursor_DeclStmt:
       return cxstring::createRef("DeclStmt");
   case CXCursor_LabelStmt:
       return cxstring::createRef("LabelStmt");
   case CXCursor_CompoundStmt:
       return cxstring::createRef("CompoundStmt");

cfe/trunk/tools/libclang/CXCursor.cpp

case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
     K = CXCursor_OMPTargetTeamsDistributeParallelForDirective;
     break;
   case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
     K = CXCursor_OMPTargetTeamsDistributeParallelForSimdDirective;
     break;
   case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
     K = CXCursor_OMPTargetTeamsDistributeSimdDirective;
     break;
+  case Stmt::BuiltinBitCastExprClass:
+    K = CXCursor_BuiltinBitCastExpr;
   }
 
   CXCursor C = { K, 0, { Parent, S, TU } };
   return C;
 }
 
 CXCursor cxcursor::MakeCursorObjCSuperClassRef(ObjCInterfaceDecl *Super, 
                                                SourceLocation Loc, 

llvm/trunk/include/llvm/ADT/APInt.h

 /// coefficients.
 Optional<APInt> SolveQuadraticEquationWrap(APInt A, APInt B, APInt C,
                                            unsigned RangeWidth);
 } // End of APIntOps namespace
 
 // See friend declaration above. This additional declaration is required in
 // order to compile LLVM with IBM xlC compiler.
 hash_code hash_value(const APInt &Arg);
-} // End of llvm namespace
+
+/// StoreIntToMemory - Fills the StoreBytes bytes of memory starting from Dst
+/// with the integer held in IntVal.
+void StoreIntToMemory(const APInt &IntVal, uint8_t *Dst, unsigned StoreBytes);
+
+/// LoadIntFromMemory - Loads the integer stored in the LoadBytes bytes starting
+/// from Src into IntVal, which is assumed to be wide enough and to hold zero.
+void LoadIntFromMemory(APInt &IntVal, uint8_t *Src, unsigned LoadBytes);
+
+} // namespace llvm
 
 #endif

llvm/trunk/lib/ExecutionEngine/ExecutionEngine.cpp

default:
     raw_svector_ostream OS(Msg);
     OS << "ERROR: Constant unimplemented for type: " << *C->getType();
     report_fatal_error(OS.str());
   }
 
   return Result;
 }
 
-/// StoreIntToMemory - Fills the StoreBytes bytes of memory starting from Dst
-/// with the integer held in IntVal.
-static void StoreIntToMemory(const APInt &IntVal, uint8_t *Dst,
-                             unsigned StoreBytes) {
-  assert((IntVal.getBitWidth()+7)/8 >= StoreBytes && "Integer too small!");
-  const uint8_t *Src = (const uint8_t *)IntVal.getRawData();
-
-  if (sys::IsLittleEndianHost) {
-    // Little-endian host - the source is ordered from LSB to MSB.  Order the
-    // destination from LSB to MSB: Do a straight copy.
-    memcpy(Dst, Src, StoreBytes);
-  } else {
-    // Big-endian host - the source is an array of 64 bit words ordered from
-    // LSW to MSW.  Each word is ordered from MSB to LSB.  Order the destination
-    // from MSB to LSB: Reverse the word order, but not the bytes in a word.
-    while (StoreBytes > sizeof(uint64_t)) {
-      StoreBytes -= sizeof(uint64_t);
-      // May not be aligned so use memcpy.
-      memcpy(Dst + StoreBytes, Src, sizeof(uint64_t));
-      Src += sizeof(uint64_t);
-    }
-
-    memcpy(Dst, Src + sizeof(uint64_t) - StoreBytes, StoreBytes);
-  }
-}
-
 void ExecutionEngine::StoreValueToMemory(const GenericValue &Val,
                                          GenericValue *Ptr, Type *Ty) {
   const unsigned StoreBytes = getDataLayout().getTypeStoreSize(Ty);
 
   switch (Ty->getTypeID()) {
   default:
     dbgs() << "Cannot store value of type " << *Ty << "!\n";
     break;
case Type::VectorTyID:
     break;
   }
 
   if (sys::IsLittleEndianHost != getDataLayout().isLittleEndian())
     // Host and target are different endian - reverse the stored bytes.
     std::reverse((uint8_t*)Ptr, StoreBytes + (uint8_t*)Ptr);
 }
 
-/// LoadIntFromMemory - Loads the integer stored in the LoadBytes bytes starting
-/// from Src into IntVal, which is assumed to be wide enough and to hold zero.
-static void LoadIntFromMemory(APInt &IntVal, uint8_t *Src, unsigned LoadBytes) {
-  assert((IntVal.getBitWidth()+7)/8 >= LoadBytes && "Integer too small!");
-  uint8_t *Dst = reinterpret_cast<uint8_t *>(
-                   const_cast<uint64_t *>(IntVal.getRawData()));
-
-  if (sys::IsLittleEndianHost)
-    // Little-endian host - the destination must be ordered from LSB to MSB.
-    // The source is ordered from LSB to MSB: Do a straight copy.
-    memcpy(Dst, Src, LoadBytes);
-  else {
-    // Big-endian - the destination is an array of 64 bit words ordered from
-    // LSW to MSW.  Each word must be ordered from MSB to LSB.  The source is
-    // ordered from MSB to LSB: Reverse the word order, but not the bytes in
-    // a word.
-    while (LoadBytes > sizeof(uint64_t)) {
-      LoadBytes -= sizeof(uint64_t);
-      // May not be aligned so use memcpy.
-      memcpy(Dst, Src + LoadBytes, sizeof(uint64_t));
-      Dst += sizeof(uint64_t);
-    }
-
-    memcpy(Dst + sizeof(uint64_t) - LoadBytes, Src, LoadBytes);
-  }
-}
-
 /// FIXME: document
 ///
 void ExecutionEngine::LoadValueFromMemory(GenericValue &Result,
                                           GenericValue *Ptr,
                                           Type *Ty) {
   const unsigned LoadBytes = getDataLayout().getTypeStoreSize(Ty);
 
   switch (Ty->getTypeID()) {

llvm/trunk/lib/Support/APInt.cpp

if (!SignChange) {
     LLVM_DEBUG(dbgs() << __func__ << ": no valid solution\n");
     return None;
   }
 
   X += 1;
   LLVM_DEBUG(dbgs() << __func__ << ": solution (wrap): " << X << '\n');
   return X;
 }
+
+/// StoreIntToMemory - Fills the StoreBytes bytes of memory starting from Dst
+/// with the integer held in IntVal.
+void llvm::StoreIntToMemory(const APInt &IntVal, uint8_t *Dst,
+                            unsigned StoreBytes) {
+  assert((IntVal.getBitWidth()+7)/8 >= StoreBytes && "Integer too small!");
+  const uint8_t *Src = (const uint8_t *)IntVal.getRawData();
+
+  if (sys::IsLittleEndianHost) {
+    // Little-endian host - the source is ordered from LSB to MSB.  Order the
+    // destination from LSB to MSB: Do a straight copy.
+    memcpy(Dst, Src, StoreBytes);
+  } else {
+    // Big-endian host - the source is an array of 64 bit words ordered from
+    // LSW to MSW.  Each word is ordered from MSB to LSB.  Order the destination
+    // from MSB to LSB: Reverse the word order, but not the bytes in a word.
+    while (StoreBytes > sizeof(uint64_t)) {
+      StoreBytes -= sizeof(uint64_t);
+      // May not be aligned so use memcpy.
+      memcpy(Dst + StoreBytes, Src, sizeof(uint64_t));
+      Src += sizeof(uint64_t);
+    }
+
+    memcpy(Dst, Src + sizeof(uint64_t) - StoreBytes, StoreBytes);
+  }
+}
+
+/// LoadIntFromMemory - Loads the integer stored in the LoadBytes bytes starting
+/// from Src into IntVal, which is assumed to be wide enough and to hold zero.
+void llvm::LoadIntFromMemory(APInt &IntVal, uint8_t *Src, unsigned LoadBytes) {
+  assert((IntVal.getBitWidth()+7)/8 >= LoadBytes && "Integer too small!");
+  uint8_t *Dst = reinterpret_cast<uint8_t *>(
+                   const_cast<uint64_t *>(IntVal.getRawData()));
+
+  if (sys::IsLittleEndianHost)
+    // Little-endian host - the destination must be ordered from LSB to MSB.
+    // The source is ordered from LSB to MSB: Do a straight copy.
+    memcpy(Dst, Src, LoadBytes);
+  else {
+    // Big-endian - the destination is an array of 64 bit words ordered from
+    // LSW to MSW.  Each word must be ordered from MSB to LSB.  The source is
+    // ordered from MSB to LSB: Reverse the word order, but not the bytes in
+    // a word.
+    while (LoadBytes > sizeof(uint64_t)) {
+      LoadBytes -= sizeof(uint64_t);
+      // May not be aligned so use memcpy.
+      memcpy(Dst, Src + LoadBytes, sizeof(uint64_t));
+      Dst += sizeof(uint64_t);
+    }
+
+    memcpy(Dst + sizeof(uint64_t) - LoadBytes, Src, LoadBytes);
+  }
+}