Add support for non-zero null pointer for C and OpenCL

[yaxunl]

Summary

In amdgcn target, null pointers in global, constant, and generic address space take value 0 but null pointers in private and local address space take value -1. Currently LLVM assumes all null pointers take value 0, which results in incorrectly translated IR. To workaround this issue, instead of emit null pointers in local and private address space, a null pointer in generic address space is emitted and casted to local and private address space.

Tentative definition of global variables with non-zero initializer will have weak linkage instead of common linkage since common linkage requires zero initializer and does not have explicit section to hold the non-zero value.

Virtual member functions getNullPointer and performAddrSpaceCast are added to TargetCodeGenInfo which by default returns ConstantPointerNull and emitting addrspacecast instruction. A virtual member function getNullPointerValue is added to TargetInfo which by default returns 0. Each target can override these virtual functions to get target specific null pointer and the null pointer value for specific address space, and perform specific translations for addrspacecast.

Wrapper functions getNullPointer is added to CodegenModule and getTargetNullPointerValue is added to ASTContext to facilitate getting the target specific null pointers and their values.

This change has no effect on other targets except amdgcn target. Other targets can provide support of non-zero null pointer in a similar way.

This change only provides support for non-zero null pointer for C and OpenCL. Supporting for other languages will be added later incrementally.

[arsenm]

test/CodeGenOpenCL/amdgpu-nullptr.cl

31

Missing check-label

50

I think there need to be a lot more tests. A few I can think of:

• Tests that compare to NULL instead of 0
• Pointer compares without the explicit 0, i.e. if (p)/if(!p)
• Storage of a pointer value
• Calls with a pointer argument
• Set of tests with constant address space pointers
• Cast null to integer
• Compare of null with null
• Compare null in one address space with null in another

[arsenm]

lib/CodeGen/TargetInfo.cpp

6957–6958

I was thinking that addrspacecast (generic null) should be valid for all targets, but I guess this saves the trouble of needing to fold out the nulls for the address spaces where null is supposed to be 0

7038

The amdgcn check should be unnecessary

7039

Shouldn't the 0 be checking lang as::opencl_private?

[yaxunl]

Fixed translation of a pointer to bool. Added more tests.

[yaxunl]

lib/CodeGen/TargetInfo.cpp

7039

clang does not define enum for opencl_private.

[rjmccall]

I think there are a number of conceptual questions here, chiefly among them whether an llvm::ConstantPointerNull in an address-space type should have the correct representation for the target. If the decision for that is "no", then ok, we can produce an explicit representation in IRGen; however, we will need to update quite a bit of code in order to do so correctly.

In general, frontend address spaces don't necessarily correspond to IR address spaces. All of your address-space operations need to be parameterized with a frontend address space (or both a source and dest address space for conversions). The question you should be keeping in mind when designing these APIs is "what if there were an address space defined to be exactly the generic address space, only with a different null value?"

IRGen has primitive knowledge about null pointer representations that are encoded in a bunch of places. Among them are:

• Emitting zero-initialization. Fortunately, we already have this well-abstracted because of C++; search for isZeroInitializable.
• Converting from a literal 0, nullptr_t etc. to a given pointer type; this is CK_NullToPointer.
• Source-level conversions of a pointer type to boolean; this is CK_PointerToBoolean.
• Inherent null-checks of pointer values; you'll need to search for CK_DerivedToBase and CK_BaseToDerived.

You will also need to verify that the AST-level constant evaluator correctly distinguishes between CK_NullToPointer and CK_IntegerToPointer.

I think you need to provide three basic operations on CodeGenTargetInfo:

• Get a null pointer value in a given address space as an llvm::Constant.
• Test whether a value in a given address space is a null value.
• Convert a value from one address space to another. You'll need to make sure that everything in IRGen that does an address space conversion goes through this, and the default implementation should be the only thing that ever creates an LLVM addrspace cast.

[Anastasia]

My understanding of NULL constant in IR was that it doesn't assume any specific integer value (i.e. 0). And currently as I can see it is lowered very late in LLVM backend during the code selection phase.

Looking at the lowering code in LLVM, it seems like it shouldn't be too difficult to special case the NULL value based on the address space: http://llvm.org/docs/doxygen/html/SelectionDAGBuilder_8cpp_source.html#l01039 instead of using hard-coded 0 at it's done now.

My opinion is that we should try to lower the code as late as possible and Clang doesn't seem like an ideal place for this. Also this change adds extra overhead by adding extra addresspacecast instructions and complicates frontend implementation. I don't see immediate benefit in changing this in the frontend compared to changing LLVM code selection phase instead.

[• tstellarAMD]

In D26196#586723, @Anastasia wrote:

My understanding of NULL constant in IR was that it doesn't assume any specific integer value (i.e. 0). And currently as I can see it is lowered very late in LLVM backend during the code selection phase.

It is assumed to be zero in some places. For example:
https://github.com/llvm-mirror/llvm/blob/master/lib/IR/ConstantFold.cpp#L620
https://github.com/llvm-mirror/llvm/blob/master/lib/Analysis/ValueTracking.cpp#L1512

I should add though that I agree with you that lowering this late is the right thing to do in the long-term. It's just not clear how much the null == 0 assumption is baked into LLVM.

[arsenm]

In D26196#586433, @rjmccall wrote:

I think there are a number of conceptual questions here, chiefly among them whether an llvm::ConstantPointerNull in an address-space type should have the correct representation for the target. If the decision for that is "no", then ok, we can produce an explicit representation in IRGen; however, we will need to update quite a bit of code in order to do so correctly.

I think the answer for this is yes, but doing so would be a pretty involved project.

In D26196#586723, @Anastasia wrote:

My understanding of NULL constant in IR was that it doesn't assume any specific integer value (i.e. 0). And currently as I can see it is lowered very late in LLVM backend during the code selection phase.

Looking at the lowering code in LLVM, it seems like it shouldn't be too difficult to special case the NULL value based on the address space: http://llvm.org/docs/doxygen/html/SelectionDAGBuilder_8cpp_source.html#l01039 instead of using hard-coded 0 at it's done now.

My opinion is that we should try to lower the code as late as possible and Clang doesn't seem like an ideal place for this. Also this change adds extra overhead by adding extra addresspacecast instructions and complicates frontend implementation. I don't see immediate benefit in changing this in the frontend compared to changing LLVM code selection phase instead.

This is essentially moving the lowering of the constant to as late as possible by moving it to the addrspacecast lowering. I think it would be a pretty substantial project to add non-0 null pointer support, but would be better long term. It is treated as isNull, so computeKnownBits and other places already treat null as an alias for 0. Tracking down all of these would be a time consuming endeavor

[yaxunl]

In D26196#586433, @rjmccall wrote:

I think there are a number of conceptual questions here, chiefly among them whether an llvm::ConstantPointerNull in an address-space type should have the correct representation for the target. If the decision for that is "no", then ok, we can produce an explicit representation in IRGen; however, we will need to update quite a bit of code in order to do so correctly.

As Tom and Matt pointed out, llvm::ConstantPointerNull is the desired representation for a null pointer. However, currently LLVM assumes that it has 0 value extensively, and there is no plan to change that in a foreseeable future. This patch is intended to provide a workaround for this restriction by representing non-zero null pointer in an alternative way.

In general, frontend address spaces don't necessarily correspond to IR address spaces. All of your address-space operations need to be parameterized with a frontend address space (or both a source and dest address space for conversions). The question you should be keeping in mind when designing these APIs is "what if there were an address space defined to be exactly the generic address space, only with a different null value?"

Since non-zero null pointer is usually resulted from target restrictions (as in the case of amdgpu target), whether a null pointer needs a special representation only depends on the target or IR address space. Therefore we do not need to consider the address space in the source language. Hopefully this can simplify the implementation.

[rjmccall]

In D26196#587135, @yaxunl wrote:

In D26196#586433, @rjmccall wrote:

I think there are a number of conceptual questions here, chiefly among them whether an llvm::ConstantPointerNull in an address-space type should have the correct representation for the target. If the decision for that is "no", then ok, we can produce an explicit representation in IRGen; however, we will need to update quite a bit of code in order to do so correctly.

As Tom and Matt pointed out, llvm::ConstantPointerNull is the desired representation for a null pointer. However, currently LLVM assumes that it has 0 value extensively, and there is no plan to change that in a foreseeable future. This patch is intended to provide a workaround for this restriction by representing non-zero null pointer in an alternative way.

Yes, I understand the goal of this patch, and I am fine with working around the LLVM limitation in the frontend. I will, however, point out that Clang's assumptions about the representation of null are not necessarily any less extensive than LLVM's.

In general, frontend address spaces don't necessarily correspond to IR address spaces. All of your address-space operations need to be parameterized with a frontend address space (or both a source and dest address space for conversions). The question you should be keeping in mind when designing these APIs is "what if there were an address space defined to be exactly the generic address space, only with a different null value?"

Since non-zero null pointer is usually resulted from target restrictions (as in the case of amdgpu target), whether a null pointer needs a special representation only depends on the target or IR address space. Therefore we do not need to consider the address space in the source language. Hopefully this can simplify the implementation.

Please do as I laid out and base this decision on the source-language address space. It will not significantly complicate the implementation.

[yaxunl]

This is work in progress. Revised by John's comments.

Refactored getNullPtr to add a QualType parameter for the original pointer type in source language.
Added support of non-zero null pointer in default initialization of global variables, including struct and array types.

[efriedma]

lib/CodeGen/CGExprConstant.cpp

1345

Consider code like the following:

int x = 0;
auto y1 = (__specialaddrspace int*)0;
auto y2 = (__specialaddrspace int*)((void)0, 0);
auto y3 = (__specialaddrspace int*)x;

How do you expect these three cases to behave? (The first case involves a C null pointer constant, the second and third cases are different ways of writing a general int->ptr conversion.)

[rjmccall]

lib/CodeGen/CGExprConstant.cpp

1345

Yeah, I think you probably need to fix APValue to be unambiguous about whether the value is a formal null pointer (CK_NullToPointer) or just a cast of an integer (CK_IntegralToPointer). It looks like PointerExprEvaluator will generate the exact same value for both.

[yaxunl]

lib/CodeGen/CGExprConstant.cpp

1345

It seems the current implementation generates the correct IR.

I tried the following sample and I saw correct IR generated.

private int* test_cast_0_to_ptr(void) {
  return (private int*)0;
}

private int* test_cast_int_to_ptr1(void) {
  return (private int*)((void)0, 0);
}

private int* test_cast_int_to_ptr2(void) {
  int x = 0;
  return (private int*)x;
}

The dumped AST is

|-FunctionDecl 0x95fdc88 <ptr.cl:3:1, line:5:1> line:3:14 test_cast_0_to_ptr 'int *(void)'
| `-CompoundStmt 0x95fdde8 <col:39, line:5:1>
|   `-ReturnStmt 0x95fddd0 <line:4:3, col:24>
|     `-CStyleCastExpr 0x95fdda8 <col:10, col:24> 'int *' <NullToPointer>
|       `-IntegerLiteral 0x95fdd70 <col:24> 'int' 0
|-FunctionDecl 0x95fdea0 <line:13:1, line:15:1> line:13:14 test_cast_int_to_ptr1 'int *(void)'
| `-CompoundStmt 0x95fe098 <col:42, line:15:1>
|   `-ReturnStmt 0x95fe080 <line:14:3, col:35>
|     `-CStyleCastExpr 0x95fe058 <col:10, col:35> 'int *' <IntegralToPointer>
|       `-ParenExpr 0x95fe038 <col:24, col:35> 'int'
|         `-BinaryOperator 0x95fe010 <col:25, col:34> 'int' ','
|           |-CStyleCastExpr 0x95fdf78 <col:25, col:31> 'void' <ToVoid>
|           | `-IntegerLiteral 0x95fdf48 <col:31> 'int' 0
|           `-IntegerLiteral 0x95fdfa0 <col:34> 'int' 0
`-FunctionDecl 0x95fe150 <line:19:1, line:22:1> line:19:14 test_cast_int_to_ptr2 'int *(void)'
  `-CompoundStmt 0x9620130 <col:42, line:22:1>
    |-DeclStmt 0x9620080 <line:20:3, col:12>
    | `-VarDecl 0x95fe210 <col:3, col:11> col:7 used x 'int' cinit
    |   `-IntegerLiteral 0x9620060 <col:11> 'int' 0
    `-ReturnStmt 0x9620118 <line:21:3, col:24>
      `-CStyleCastExpr 0x96200f0 <col:10, col:24> 'int *' <IntegralToPointer>

Since only CK_NullToPointer is translated to null pointer through getNullPtr, CK_IntegralToPointer will result in either zero-valued pointer or inttoptr, the generated IR is correct.

[yaxunl]

Fixed list initialization of large struct which are mostly initialized by 0 through memset.
Added tests for casting literal 0 and non-literal integer to pointer.

There are many more places need to be changed. I am wondering if it makes sense to split this feature into multiple pieces, e.g. for C and OpenCL, C++, Objective-C, OpenMP, incrementally.

[tony-tye]

lib/CodeGen/CodeGenTypes.cpp

743

Is this correct if the target does not represent a NULL pointer as the address with value 0? Or should this be asking the target if this null pointer is represented by an address value of 0?

[yaxunl]

lib/CodeGen/CodeGenTypes.cpp

743

Currently this is correct even if the target does not represent a null pointer as address with value 0. The purpose of this line is to check if NullPtr has zero value at compile time. In LLVM checking whether a pointer having zero value at compile time is by checking if it is ConstantPointerNull.

However, if in the future LLVM no longer assumes ConstantPointerNull having zero value, then this will become incorrect. To be future proof, I think I'd better add a member function isPtrZero to TargetCodeGenInfo and use it to check if a pointer has zero value.

[yaxunl]

Added isNullPtrZero to TargetCodeGenInfo.

[yaxunl]

lib/CodeGen/CGExprConstant.cpp

1345

Basically in the second and third case the destination type is not pointer, so they do not need to be emitted as null pointer. If a literal 0 is casted to a pointer type, then it should be emitted as a null pointer.

[efriedma]

lib/CodeGen/CGExprConstant.cpp

1345

What happens in the following case?

static private int* x = (private int*)((void)0, 0);

[yaxunl]

lib/CodeGen/CGExprConstant.cpp

1345

You are right. This needs to be fixed.

[rjmccall]

lib/CodeGen/CGExprConstant.cpp

1345

Another straightforward test case would be reinterpret_cast<private void*>(0), or (private void*) (1-1) in C++11.

[rjmccall]

In D26196#589493, @yaxunl wrote:

Fixed list initialization of large struct which are mostly initialized by 0 through memset.
Added tests for casting literal 0 and non-literal integer to pointer.

There are many more places need to be changed. I am wondering if it makes sense to split this feature into multiple pieces, e.g. for C and OpenCL, C++, Objective-C, OpenMP, incrementally.

It's fine to split it up. Note that at least some of the Objective-C code doesn't need to be updated, because Objective-C object pointers can't be in an alternate address space.

lib/CodeGen/CGExprConstant.cpp

1645

The cast<> here is now unnecessary.

lib/CodeGen/CodeGenModule.h

1159

This can just take QT; it's not optimized by taking T as well, and in some cases you wouldn't otherwise need to compute that.

lib/CodeGen/TargetInfo.cpp

7040

This check is definitely not correct; this function needs to return true when AS == 0, right?

Also, you should really just be checking QT.getAddressSpace().

[yaxunl]

lib/CodeGen/TargetInfo.cpp

7040

The null pointer of amdgpu target in addr space 0 does not have zero value.

I will change it use QT.getAddressSpace() though.

[yaxunl]

Changed APValue to differentiate with null pointer and pointers casted from integer. Fixed casting integer to pointer.

Refactored isNullPtrZero to use just QualType as parameter.

Added tests for casting integer to pointer, initialization of static and function-scope variable, and cast pointer to bool.

[rjmccall]

lib/CodeGen/TargetInfo.cpp

7040

Oh, if the *default* address space — the address space of the stack — has a non-zero null pointer value, that will definitely change a lot of things, and LLVM will probably be deeply unhappy with you. I feel like that's a much bigger and more problematic change. This is still the right approach for working around it in Clang, but... it's concerning.

And that does mean you'll have to fix a bunch of the other languages that in principle you could otherwise have avoided.

[yaxunl]

Hi John,

It seems the casting from a pointer to different address space is not affected by this change. When a null pointer is casted to different address space, it is casted the same way as an ordinary pointer, e.g. by addrspacecast.

I think this patch covers most of the changes that is needed for supporting non-zero null pointer in C and OpenCL. Is there anything else missing?

Thanks.

[rjmccall]

In D26196#592823, @yaxunl wrote:

Hi John,

It seems the casting from a pointer to different address space is not affected by this change. When a null pointer is casted to different address space, it is casted the same way as an ordinary pointer, e.g. by addrspacecast.

You mean, the code-generation for that knows about your special null pointer representation? That is confusing.

[yaxunl]

It seems the casting from a pointer to different address space is not affected by this change. When a null pointer is casted to different address space, it is casted the same way as an ordinary pointer, e.g. by addrspacecast.

You mean, the code-generation for that knows about your special null pointer representation? That is confusing.

The null pointer is represented in a new way, but the new representation has the same type as before. For example, a null pointer in addr space 0 used to be i8 *null, now it becomes addrspacecast i8 addrspace(4)* null to i8*. It is still of type i8*, so nothing is changed about casting a pointer to a different address space.

[yaxunl]

It seems the casting from a pointer to different address space is not affected by this change. When a null pointer is casted to different address space, it is casted the same way as an ordinary pointer, e.g. by addrspacecast.

You mean, the code-generation for that knows about your special null pointer representation? That is confusing.

Do you mean if a null pointer in one address space is casted to another address space, we should use the specific null pointer representation in the new address space, instead of a simple addrspacecast?

[rjmccall]

In D26196#593741, @yaxunl wrote:

It seems the casting from a pointer to different address space is not affected by this change. When a null pointer is casted to different address space, it is casted the same way as an ordinary pointer, e.g. by addrspacecast.

You mean, the code-generation for that knows about your special null pointer representation? That is confusing.

Do you mean if a null pointer in one address space is casted to another address space, we should use the specific null pointer representation in the new address space, instead of a simple addrspacecast?

That's the general user expectation, yes: a null pointer should be converted to a null pointer. Technically, whether this required is up to the appropriate language standard.

The standard rules for address spaces are laid out by Embedded C (ISO/IEC TR 18037), which has this to say in 5.1.3p4:

A non-null pointer into an address space A can be cast to a pointer into another address space B, but such a cast is undefined if the source pointer does not point to a location in B. Note that if A is a subset of B, the cast is always valid; however, if B is a subset of A, the cast is valid only if the source pointer refers to a location in B. A null pointer into one address space can be cast to a null pointer into any overlapping address space.

The wording could be better, but I think this is fairly clearly saying that you do need to map null to null.

Now, my understanding is that you're not actually implementing Embedded C, you're implementing Open CL. The Open CL specification that I have on hand (v1.1) says that global, local, constant, and private are disjoint and that casts between address spaces are illegal. So this might not actually matter to you.

But if you do need to support these conversions for some reason, the correct behavior is to ensure that null is mapped to null.

[yaxunl]

But if you do need to support these conversions for some reason, the correct behavior is to ensure that null is mapped to null.

I only need to do this for constant folding, right? I found that the current implementation is already able to cast null pointer to the correct representation of null pointer in another address space for constant expression. e.g. file-scope variables

generic char *gen = (global char*)(generic char*)(private char*)0;
private char *priv = (private char*)(generic char*)(global char*)0;
global char *glob = (global char*)(generic char*)(global char*)0;

are translated to

@gen = addrspace(1) global i8 addrspace(4)* null, align 4
@priv = addrspace(1) global i8* addrspacecast (i8 addrspace(4)* null to i8*), align 4
@glob = addrspace(1) global i8 addrspace(1)* null, align 4

This is because null pointers are handled in APValue and PointerExprEvaluator::VisitCastExpr. Once a null pointer is identified, it can survive passing through addrspacecast and bitcast. When it gets folded, it becomes the target-specific null pointer representation in the target address space.

However, if an addrspacecast is not going through constant folding, it will be translated to LLVM addrspacecast, e.g.

void test_cast(void) {
  global char* glob = (global char*)(generic char*)0;
 }

Since the initializer of the function-scope variable does not go through constant folding, it is not translated to target-specific null pointer representation in the target address space. Instead, it is simply an addrspacecast of the original null pointer:

define void @test_cast() #0 {
entry:
  %glob = alloca i8 addrspace(1)*, align 4
  store i8 addrspace(1)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(1)*), i8 addrspace(1)** %glob, align 4
  ret void
}

This is still correct translation, since backend should be able to understand addrspacecast of null pointer.

Do you think in the last case I should try to fold the addrspacecast?

Thanks.

[rjmccall]

In D26196#602660, @yaxunl wrote:

But if you do need to support these conversions for some reason, the correct behavior is to ensure that null is mapped to null.

I only need to do this for constant folding, right? I found that the current implementation is already able to cast null pointer to the correct representation of null pointer in another address space for constant expression. e.g. file-scope variables

generic char *gen = (global char*)(generic char*)(private char*)0;
private char *priv = (private char*)(generic char*)(global char*)0;
global char *glob = (global char*)(generic char*)(global char*)0;

are translated to

@gen = addrspace(1) global i8 addrspace(4)* null, align 4
@priv = addrspace(1) global i8* addrspacecast (i8 addrspace(4)* null to i8*), align 4
@glob = addrspace(1) global i8 addrspace(1)* null, align 4

This is because null pointers are handled in APValue and PointerExprEvaluator::VisitCastExpr. Once a null pointer is identified, it can survive passing through addrspacecast and bitcast. When it gets folded, it becomes the target-specific null pointer representation in the target address space.

However, if an addrspacecast is not going through constant folding, it will be translated to LLVM addrspacecast, e.g.

void test_cast(void) {
  global char* glob = (global char*)(generic char*)0;
 }

Since the initializer of the function-scope variable does not go through constant folding, it is not translated to target-specific null pointer representation in the target address space. Instead, it is simply an addrspacecast of the original null pointer:

define void @test_cast() #0 {
entry:
  %glob = alloca i8 addrspace(1)*, align 4
  store i8 addrspace(1)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(1)*), i8 addrspace(1)** %glob, align 4
  ret void
}

This is still correct translation, since backend should be able to understand addrspacecast of null pointer.

Do you think in the last case I should try to fold the addrspacecast?

Yes. I think it would be wrong for an addrspacecast of a literal llvm::ConstantPointerNull to have different semantics from an addrspacecast of an opaque value that happens to be an llvm::ConstantPointerNull.

[yaxunl]

Revised by John's comments.

Emit null pointer in target-specific representation in folded constant expressions.
Fix casting null pointer to integer in constant expressions.

[yaxunl]

ping

[rjmccall]

include/clang/Basic/TargetInfo.h

306 ↗

(On Diff #79406)

We normally spell out "Pointer", I think.

lib/AST/APValue.cpp

585 ↗

(On Diff #79406)

Seems reasonable to assert isLValue() here.

lib/CodeGen/CGExprAgg.cpp

1054

This is probably a common enough case that it's worth "inlining", i.e. adding a isPointerZeroInitializable() method that asserts that it's been given a pointer type and does the right thing with it.

lib/CodeGen/CGExprScalar.cpp

1401

As discussed, please also delegate addrspace conversions into TargetCodeGenInfo. You don't have to implement them for your target if you don't want, but please do the delegation correctly.

Also, even if you decide not to implement the actual dynamic comparison logic, you should at least teach your target's implementation to recognize when the original pointer is a constant null pointer and just produce the correct new constant. That should eliminate the need for this special case here, as well as fixing the case where E is a null pointer with side effects like (foo(), NULL).

1526

Why is this necessary? ptrtoint on the recursively-emitted null pointer should do this automatically.

lib/CodeGen/CodeGenModule.h

1156

Like above, this should be getNullPointer. Also, please document which type QT is: the pointer type or the pointee type.

lib/CodeGen/TargetInfo.h

228

Same as the comment on getNullPtr above.

[yaxunl]

lib/CodeGen/CGExprScalar.cpp

1526

Since the target knows the value in the null pointers, it can fold a null pointer to integer literal directly.

The above code does that, e.g.

void test_cast_null_pointer_to_sizet_calee(size_t arg_private,
                                           size_t arg_local,
                                           size_t arg_global,
                                           size_t arg_constant,
                                           size_t arg_generic);

// CHECK-LABEL: test_cast_null_pointer_to_sizet
// CHECK: call void @test_cast_null_pointer_to_sizet_calee(i64 -1, i64 -1, i64 0, i64 0, i64 0)
void test_cast_null_pointer_to_sizet(void) {
  test_cast_null_pointer_to_sizet_calee((size_t)((private char*)0),
                                        (size_t)((local char*)0),
                                        (size_t)((global char*)0),
                                        (size_t)((constant char*)0),
                                        (size_t)((generic char*)0));
}

Without the above code, we only get ptrtoint instructions.

[yaxunl]

Revised by John's comments.

Changed Ptr in function names to Pointer.
Added TargetCodeGenInfo::performAddrSpaceCast.
Fixed folding addrspacecast of null pointer with side effect and added a test.

[yaxunl]

Fix some missed function name and remove accidentally added #if 0.

[rjmccall]

include/clang/AST/APValue.h

379 ↗

(On Diff #80488)

Typo.

lib/AST/ExprConstant.cpp

1153 ↗

(On Diff #80488)

Hmm. I think the code would be clearer overall if this were conditionalized in the callers instead of here.

lib/CodeGen/CGExprScalar.cpp

1526

Oh, does the constant folder not know how to fold ptrtoint(inttoptr(X)) -> X? I guess that's probably LLVM's nominal target-independence rearing its head.

Is getting a slightly LLVM constant actually important here? I would prefer to avoid this complexity (and unnecessary recursive walk) if possible.

lib/CodeGen/TargetInfo.h

236

This should just take a Value* and the source and dest types.

[yaxunl]

lib/CodeGen/CGExprScalar.cpp

1526

Since it's target dependent, it won't be constant folded by the target agnostic passes until very late in the backend, which may lose optimization opportunities. I think it's better folded by FE like other constants.

[yaxunl]

Revised by John's comments.

Fixed typos.
Changed parameter of performAddrSpaceCast.
Fixed constant folding of ptrtoint with side effect and added a test.

[rjmccall]

lib/CodeGen/CGExprScalar.cpp

1526

Are you sure? All of my attempts to produce these constants in LLVM seem to get instantly folded, even without a target set in the IR:

i32 ptrtoint (i8* inttoptr (i32 -1 to i8*) to i32)
i64 ptrtoint (i8* inttoptr (i64 -1 to i8*) to i64)

This folding literally occurs within ConstantExpr::getPtrToInt, without any passes running, and it seems to happen regardless of the pointer having an addrspace.

I suspect that the problem is that you additionally have an addrspacecast constant in place, which almost certainly does block the constant folder. The right fix for that is to ensure that your target's implementation of performAddrSpaceCast makes an effort to peephole casts of Constants.

lib/CodeGen/TargetInfo.h

236

Please also pass the source QualType. The QualType is necessary to determine the source-language address space, which is how an implementation can correctly determine the null-pointer representation in the source type.

[yaxunl]

lib/CodeGen/CGExprScalar.cpp

1526

In amdgpu target, null pointer in addr space 0 is represented as addrspacecast int addrspace(4)* null to int* instead of inttoptr i32 -1 to i8*. As addrspacecast is opaque to target-independent LLVM passes, they don't know how to fold it. Only the backend knows how to fold it.

This could be a general situation, i.e., the non-zero null pointer is represented in some target specific form which LLVM does not know how to fold.

[yaxunl]

Revised by John's comments.

Added source QualType parameter to performAddrSpaceCast.
Changed linkage of tentative definition of global var with non-zero initializer to weak linkage since common linkage requires zero initializer.

[rjmccall]

lib/CodeGen/CGExprScalar.cpp

1526

LLVM has deeply-baked-in assumptions that null is a zero bit pattern. It is really, really not a good idea to assume that LLVM will never make any assumptions about the behavior of addrspacecasts in its target-independent code.

Also, it is almost certainly possible to validly produce that constant with the expectation that it will have value 0, and thus you special-case lowering in the backend would be a miscompile.

I understand that you probably got into this situation by trying to give null a non-zero representation in the backend and then slowly realized that you needed frontend changes to avoid miscompiles. That is totally understandable. Please understand that what are you actually doing now with this patch is fundamentally changing where you lower null pointers, so that it's now only the frontend which knows about the representation of null pointers, and the backend just treats ConstantPointerNull as a special way of spelling the valid, semantically non-null zero representation of a pointer.

[yaxunl]

lib/CodeGen/CGExprScalar.cpp

1526

Thanks John. I think your concern is valid. Actually I have fixed some issues in LLVM about incorrect assumptions about addrspacecast'ed bits. Personally I prefer using inttoptr -1 instead of addrspacecast null to represent non-zero null pointer, but I need to discuss with my team before making the change.

For now, I will drop the above code for constant folding of ptrtoint of non-zero null pointer.

[yaxunl]

Revised by John's comments.

Dropped constant folding of ptrtoint of non-zero null pointer.

[rjmccall]

Okay. With that resolved, this LGTM.

lib/CodeGen/CGDecl.cpp

if (capturedByInit) {
       // We can use a simple GEP for this because it can't have been
       // moved yet.
       tempLV.setAddress(emitBlockByrefAddress(tempLV.getAddress(),
                                               cast<VarDecl>(D),
                                               /*follow*/ false));
     }
 
     auto ty = cast<llvm::PointerType>(tempLV.getAddress().getElementType());
-    llvm::Value *zero = llvm::ConstantPointerNull::get(ty);
+    llvm::Value *zero = CGM.getNullPtr(ty, tempLV.getType());
 
     // If __weak, we want to use a barrier under certain conditions.
     if (lifetime == Qualifiers::OCL_Weak)
       EmitARCInitWeak(tempLV.getAddress(), zero);
 
     // Otherwise just do a simple store.
     else
       EmitStoreOfScalar(zero, tempLV, /* isInitialization */ true);

lib/CodeGen/CGExprAgg.cpp

   if (const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(E))
     return FL->getValue().isPosZero();
   // int()
   if ((isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) &&
       CGF.getTypes().isZeroInitializable(E->getType()))
     return true;
   // (int*)0 - Null pointer expressions.
   if (const CastExpr *ICE = dyn_cast<CastExpr>(E))
-    return ICE->getCastKind() == CK_NullToPointer;
+    return ICE->getCastKind() == CK_NullToPointer &&
+        CGF.getTypes().isZeroInitializable(E->getType());
   // '\0'
   if (const CharacterLiteral *CL = dyn_cast<CharacterLiteral>(E))
     return CL->getValue() == 0;
   
   // Otherwise, hard case: conservatively return false.
   return false;
 }
 

lib/CodeGen/CGExprConstant.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "CodeGenFunction.h"
 #include "CGCXXABI.h"
 #include "CGObjCRuntime.h"
 #include "CGRecordLayout.h"
 #include "CodeGenModule.h"
+#include "TargetInfo.h"
 #include "clang/AST/APValue.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/RecordLayout.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/Basic/Builtins.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Function.h"
llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E,
 
   if (C && C->getType()->isIntegerTy(1)) {
     llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType());
     C = llvm::ConstantExpr::getZExt(C, BoolTy);
   }
   return C;
 }
 
+llvm::Constant *CodeGenModule::getNullPtr(llvm::PointerType *T, QualType QT) {
+  return getTargetCodeGenInfo().getNullPtr(*this, T, QT);
+}
+
+bool CodeGenModule::isNullPtrZero(llvm::PointerType *T, QualType QT) {
+  return getTargetCodeGenInfo().isNullPtrZero(*this, T, QT);
+}
+
+
 llvm::Constant *CodeGenModule::EmitConstantValue(const APValue &Value,
                                                  QualType DestType,
                                                  CodeGenFunction *CGF) {
   // For an _Atomic-qualified constant, we may need to add tail padding.
   if (auto *AT = DestType->getAs<AtomicType>()) {
     QualType InnerType = AT->getValueType();
     auto *Inner = EmitConstantValue(Value, InnerType, CGF);
 
if (APValue::LValueBase LVBase = Value.getLValueBase()) {
         return llvm::ConstantExpr::getPointerCast(C, DestTy);
 
       return llvm::ConstantExpr::getPtrToInt(C, DestTy);
     } else {
       C = Offset;
 
       // Convert to the appropriate type; this could be an lvalue for
       // an integer.
-      if (isa<llvm::PointerType>(DestTy)) {
+      if (auto PT = dyn_cast<llvm::PointerType>(DestTy)) {
         // Convert the integer to a pointer-sized integer before converting it
         // to a pointer.
         C = llvm::ConstantExpr::getIntegerCast(
             C, getDataLayout().getIntPtrType(DestTy),
             /*isSigned=*/false);
-        return llvm::ConstantExpr::getIntToPtr(C, DestTy);
+        C = llvm::ConstantExpr::getIntToPtr(C, DestTy);
+        if (!isa<llvm::ConstantPointerNull>(C))
+          return C;
+        return getNullPtr(PT, DestType);
       }
 
       // If the types don't match this should only be a truncate.
       if (C->getType() != DestTy)
         return llvm::ConstantExpr::getTrunc(C, DestTy);
 
       return C;
     }
CodeGenModule::getMemberPointerConstant(const UnaryOperator *uo) {
   return getCXXABI().EmitMemberDataPointer(type, chars);
 }
 
 static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM,
                                                llvm::Type *baseType,
                                                const CXXRecordDecl *base);
 
 static llvm::Constant *EmitNullConstant(CodeGenModule &CGM,
-                                        const CXXRecordDecl *record,
+                                        const RecordDecl *record,
                                         bool asCompleteObject) {
   const CGRecordLayout &layout = CGM.getTypes().getCGRecordLayout(record);
   llvm::StructType *structure =
     (asCompleteObject ? layout.getLLVMType()
                       : layout.getBaseSubobjectLLVMType());
 
   unsigned numElements = structure->getNumElements();
   std::vector<llvm::Constant *> elements(numElements);
 
+  auto CXXR = dyn_cast<CXXRecordDecl>(record);
   // Fill in all the bases.
-  for (const auto &I : record->bases()) {
+  if (CXXR) {
+    for (const auto &I : CXXR->bases()) {
       if (I.isVirtual()) {
         // Ignore virtual bases; if we're laying out for a complete
         // object, we'll lay these out later.
         continue;
       }
 
-    const CXXRecordDecl *base = 
+      const CXXRecordDecl *base =
         cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
 
       // Ignore empty bases.
       if (base->isEmpty() ||
-        CGM.getContext().getASTRecordLayout(base).getNonVirtualSize().isZero())
+          CGM.getContext().getASTRecordLayout(base).getNonVirtualSize()
+              .isZero())
         continue;
-    
       unsigned fieldIndex = layout.getNonVirtualBaseLLVMFieldNo(base);
       llvm::Type *baseType = structure->getElementType(fieldIndex);
       elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base);
     }
+  }
 
   // Fill in all the fields.
   for (const auto *Field : record->fields()) {
     // Fill in non-bitfields. (Bitfields always use a zero pattern, which we
     // will fill in later.)
     if (!Field->isBitField()) {
       unsigned fieldIndex = layout.getLLVMFieldNo(Field);
       elements[fieldIndex] = CGM.EmitNullConstant(Field->getType());
     }
 
     // For unions, stop after the first named field.
     if (record->isUnion()) {
       if (Field->getIdentifier())
         break;
       if (const auto *FieldRD =
               dyn_cast_or_null<RecordDecl>(Field->getType()->getAsTagDecl()))
         if (FieldRD->findFirstNamedDataMember())
           break;
     }
   }
 
   // Fill in the virtual bases, if we're working with the complete object.
-  if (asCompleteObject) {
-    for (const auto &I : record->vbases()) {
+  if (CXXR && asCompleteObject) {
+    for (const auto &I : CXXR->vbases()) {
       const CXXRecordDecl *base = 
         cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
 
       // Ignore empty bases.
       if (base->isEmpty())
         continue;
 
       unsigned fieldIndex = layout.getVirtualBaseIndex(base);
static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM,
   if (baseLayout.isZeroInitializableAsBase())
     return llvm::Constant::getNullValue(baseType);
 
   // Otherwise, we can just use its null constant.
   return EmitNullConstant(CGM, base, /*asCompleteObject=*/false);
 }
 
 llvm::Constant *CodeGenModule::EmitNullConstant(QualType T) {
+  if (auto PT = T->getAs<PointerType>())
+    return getNullPtr(cast<llvm::PointerType>(getTypes().ConvertTypeForMem(T)),
+                      T);
+
   if (getTypes().isZeroInitializable(T))
     return llvm::Constant::getNullValue(getTypes().ConvertTypeForMem(T));
     
   if (const ConstantArrayType *CAT = Context.getAsConstantArrayType(T)) {
     llvm::ArrayType *ATy =
       cast<llvm::ArrayType>(getTypes().ConvertTypeForMem(T));
 
     QualType ElementTy = CAT->getElementType();
 
     llvm::Constant *Element = EmitNullConstant(ElementTy);
     unsigned NumElements = CAT->getSize().getZExtValue();
     SmallVector<llvm::Constant *, 8> Array(NumElements, Element);
     return llvm::ConstantArray::get(ATy, Array);
   }
 
   if (const RecordType *RT = T->getAs<RecordType>()) {
-    const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
+    const RecordDecl *RD = cast<RecordDecl>(RT->getDecl());
     return ::EmitNullConstant(*this, RD, /*complete object*/ true);
   }
 
   assert(T->isMemberDataPointerType() &&
          "Should only see pointers to data members here!");
 
   return getCXXABI().EmitNullMemberPointer(T->castAs<MemberPointerType>());
 }
 
 llvm::Constant *
 CodeGenModule::EmitNullConstantForBase(const CXXRecordDecl *Record) {
   return ::EmitNullConstant(*this, Record, false);
 }

lib/CodeGen/CGExprScalar.cpp

public:
   /// EmitFloatToBoolConversion - Perform an FP to boolean conversion.
   Value *EmitFloatToBoolConversion(Value *V) {
     // Compare against 0.0 for fp scalars.
     llvm::Value *Zero = llvm::Constant::getNullValue(V->getType());
     return Builder.CreateFCmpUNE(V, Zero, "tobool");
   }
 
   /// EmitPointerToBoolConversion - Perform a pointer to boolean conversion.
-  Value *EmitPointerToBoolConversion(Value *V) {
-    Value *Zero = llvm::ConstantPointerNull::get(
-                                      cast<llvm::PointerType>(V->getType()));
+  Value *EmitPointerToBoolConversion(Value *V, QualType QT) {
+    Value *Zero = CGF.CGM.getNullPtr(cast<llvm::PointerType>(V->getType()), QT);
+
     return Builder.CreateICmpNE(V, Zero, "tobool");
   }
 
   Value *EmitIntToBoolConversion(Value *V) {
     // Because of the type rules of C, we often end up computing a
     // logical value, then zero extending it to int, then wanting it
     // as a logical value again.  Optimize this common case.
     if (llvm::ZExtInst *ZI = dyn_cast<llvm::ZExtInst>(V)) {
Value *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) {
 
   assert((SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType())) &&
          "Unknown scalar type to convert");
 
   if (isa<llvm::IntegerType>(Src->getType()))
     return EmitIntToBoolConversion(Src);
 
   assert(isa<llvm::PointerType>(Src->getType()));
-  return EmitPointerToBoolConversion(Src);
+  return EmitPointerToBoolConversion(Src, SrcType);
 }
 
 void ScalarExprEmitter::EmitFloatConversionCheck(
     Value *OrigSrc, QualType OrigSrcType, Value *Src, QualType SrcType,
     QualType DstType, llvm::Type *DstTy, SourceLocation Loc) {
   CodeGenFunction::SanitizerScope SanScope(&CGF);
   using llvm::APFloat;
   using llvm::APSInt;
case CK_BitCast: {
 
     return Builder.CreateBitCast(Src, DstTy);
   }
   case CK_AddressSpaceConversion: {
     Value *Src = Visit(const_cast<Expr*>(E));
     // Since target may map different address spaces in AST to the same address
     // space, an address space conversion may end up as a bitcast.
     return Builder.CreatePointerBitCastOrAddrSpaceCast(Src,
                                                        ConvertType(DestTy));
   }
   case CK_AtomicToNonAtomic:
   case CK_NonAtomicToAtomic:
   case CK_NoOp:
   case CK_UserDefinedConversion:
     return Visit(const_cast<Expr*>(E));
 
   case CK_BaseToDerived: {
case CK_ArrayToPointerDecay:
     return CGF.EmitArrayToPointerDecay(E).getPointer();
   case CK_FunctionToPointerDecay:
     return EmitLValue(E).getPointer();
 
   case CK_NullToPointer:
     if (MustVisitNullValue(E))
       (void) Visit(E);
 
-    return llvm::ConstantPointerNull::get(
-                               cast<llvm::PointerType>(ConvertType(DestTy)));
+    return CGF.CGM.getNullPtr(cast<llvm::PointerType>(ConvertType(DestTy)),
+                              DestTy);
 
   case CK_NullToMemberPointer: {
     if (MustVisitNullValue(E))
       (void) Visit(E);
 
     const MemberPointerType *MPT = CE->getType()->getAs<MemberPointerType>();
     return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT);
   }
case CK_IntegralToPointer: {
 
     return Builder.CreateIntToPtr(IntResult, DestLLVMTy);
   }
   case CK_PointerToIntegral:
     assert(!DestTy->isBooleanType() && "bool should use PointerToBool");
     return Builder.CreatePtrToInt(Visit(E), ConvertType(DestTy));
 
   case CK_ToVoid: {
     CGF.EmitIgnoredExpr(E);
     return nullptr;
   }
   case CK_VectorSplat: {
     llvm::Type *DstTy = ConvertType(DestTy);
     Value *Elt = Visit(const_cast<Expr*>(E));
     // Splat the element across to all elements
     unsigned NumElements = DstTy->getVectorNumElements();
     return Builder.CreateVectorSplat(NumElements, Elt, "splat");
   }
 
   case CK_IntegralCast:
   case CK_IntegralToFloating:
   case CK_FloatingToIntegral:
   case CK_FloatingCast:
     return EmitScalarConversion(Visit(E), E->getType(), DestTy,
                                 CE->getExprLoc());
   case CK_BooleanToSignedIntegral:
     return EmitScalarConversion(Visit(E), E->getType(), DestTy,
                                 CE->getExprLoc(),
                                 /*TreatBooleanAsSigned=*/true);
   case CK_IntegralToBoolean:
     return EmitIntToBoolConversion(Visit(E));
   case CK_PointerToBoolean:
-    return EmitPointerToBoolConversion(Visit(E));
+    return EmitPointerToBoolConversion(Visit(E), E->getType());
   case CK_FloatingToBoolean:
     return EmitFloatToBoolConversion(Visit(E));
   case CK_MemberPointerToBoolean: {
     llvm::Value *MemPtr = Visit(E);
     const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>();
     return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, MemPtr, MPT);
   }
 

lib/CodeGen/CodeGenModule.h

   /// \breif Get the declaration of std::terminate for the platform.
   llvm::Constant *getTerminateFn();
 
   llvm::SanitizerStatReport &getSanStats();
 
   llvm::Value *
   createOpenCLIntToSamplerConversion(const Expr *E, CodeGenFunction &CGF);
 
+  /// Get target specific null pointer.
+  llvm::Constant *getNullPtr(llvm::PointerType *T, QualType QT);
+
+  /// Does null pointer have zero value.
+  bool isNullPtrZero(llvm::PointerType *T, QualType QT);
+
 private:
   llvm::Constant *
   GetOrCreateLLVMFunction(StringRef MangledName, llvm::Type *Ty, GlobalDecl D,
                           bool ForVTable, bool DontDefer = false,
                           bool IsThunk = false,
                           llvm::AttributeSet ExtraAttrs = llvm::AttributeSet(),
                           bool IsForDefinition = false);
 

   /// delayed until the end of the translation unit. This is relevant for
   /// definitions whose linkage can change, e.g. implicit function instantions
   /// which may later be explicitly instantiated.
   bool MayBeEmittedEagerly(const ValueDecl *D);
 
   /// Check whether we can use a "simpler", more core exceptions personality
   /// function.
   void SimplifyPersonality();
+
 };
 }  // end namespace CodeGen
 }  // end namespace clang
 
 #endif // LLVM_CLANG_LIB_CODEGEN_CODEGENMODULE_H

lib/CodeGen/CodeGenTypes.cpp

if (!Layout) {
     Layout = CGRecordLayouts.lookup(Key);
   }
 
   assert(Layout && "Unable to find record layout information for type");
   return *Layout;
 }
 
 bool CodeGenTypes::isZeroInitializable(QualType T) {
-  // No need to check for member pointers when not compiling C++.
-  if (!Context.getLangOpts().CPlusPlus)
-    return true;
+  if (auto PT = T->getAs<PointerType>()) {
+    auto LLPT = cast<llvm::PointerType>(ConvertType(T));
+    return CGM.isNullPtrZero(LLPT, T);
+  }
 
   if (const auto *AT = Context.getAsArrayType(T)) {
     if (isa<IncompleteArrayType>(AT))
       return true;
     if (const auto *CAT = dyn_cast<ConstantArrayType>(AT))
       if (Context.getConstantArrayElementCount(CAT) == 0)
         return true;
     T = Context.getBaseElementType(T);
   }
 
   // Records are non-zero-initializable if they contain any
   // non-zero-initializable subobjects.
   if (const RecordType *RT = T->getAs<RecordType>()) {
-    const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
+    auto RD = cast<RecordDecl>(RT->getDecl());
     return isZeroInitializable(RD);
   }
 
   // We have to ask the ABI about member pointers.
   if (const MemberPointerType *MPT = T->getAs<MemberPointerType>())
     return getCXXABI().isZeroInitializable(MPT);
   
   // Everything else is okay.
   return true;
 }
 
 bool CodeGenTypes::isZeroInitializable(const RecordDecl *RD) {
   return getCGRecordLayout(RD).isZeroInitializable();
 }

lib/CodeGen/TargetInfo.h

public:
   /// Gets the linker options necessary to detect object file mismatches on
   /// this platform.
   virtual void getDetectMismatchOption(llvm::StringRef Name,
                                        llvm::StringRef Value,
                                        llvm::SmallString<32> &Opt) const {}
 
   /// Get LLVM calling convention for OpenCL kernel.
   virtual unsigned getOpenCLKernelCallingConv() const;
+
+  /// Get target specific null pointer.
+  /// \return ConstantPointerNull with the given type \p T.
+  /// Each target can override it to return its own desired constant value.
+  virtual llvm::Constant *getNullPtr(const CodeGen::CodeGenModule &CGM,
+      llvm::PointerType *T, QualType QT) const;
+
+  /// Does null pointer have zero value.
+  virtual bool isNullPtrZero(const CodeGen::CodeGenModule &CGM,
+      llvm::PointerType *T, QualType QT) const {
+    return true;
+  }
 };
 
 } // namespace CodeGen
 } // namespace clang
 
 #endif // LLVM_CLANG_LIB_CODEGEN_TARGETINFO_H

lib/CodeGen/TargetInfo.cpp

   Opt = "-l";
   Opt += Lib;
 }
 
 unsigned TargetCodeGenInfo::getOpenCLKernelCallingConv() const {
   return llvm::CallingConv::C;
 }
 
+llvm::Constant *TargetCodeGenInfo::getNullPtr(const CodeGen::CodeGenModule &CGM,
+    llvm::PointerType *T, QualType QT) const {
+  return llvm::ConstantPointerNull::get(T);
+}
+
 static bool isEmptyRecord(ASTContext &Context, QualType T, bool AllowArrays);
 
 /// isEmptyField - Return true iff a the field is "empty", that is it
 /// is an unnamed bit-field or an (array of) empty record(s).
 static bool isEmptyField(ASTContext &Context, const FieldDecl *FD,
                          bool AllowArrays) {
   if (FD->isUnnamedBitfield())
     return true;

   // individual elements, which confuses the Clover OpenCL backend; therefore we
   // have to set it to false here. Other args of getDirect() are just defaults.
   return ABIArgInfo::getDirect(nullptr, 0, nullptr, false);
 }
 
 class AMDGPUTargetCodeGenInfo : public TargetCodeGenInfo {
 public:
   AMDGPUTargetCodeGenInfo(CodeGenTypes &CGT)
     : TargetCodeGenInfo(new AMDGPUABIInfo(CGT)) {}
   void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
                            CodeGen::CodeGenModule &M) const override;
   unsigned getOpenCLKernelCallingConv() const override;
+
+  llvm::Constant *getNullPtr(const CodeGen::CodeGenModule &CGM,
+      llvm::PointerType *T, QualType QT) const override;
+
+  bool isNullPtrZero(const CodeGen::CodeGenModule &CGM,
+      llvm::PointerType *T, QualType QT) const override;
 };
 
 }
 
 static void appendOpenCLVersionMD (CodeGen::CodeGenModule &CGM);
 
 void AMDGPUTargetCodeGenInfo::setTargetAttributes(
     const Decl *D,

 
   appendOpenCLVersionMD(M);
 }
 
 unsigned AMDGPUTargetCodeGenInfo::getOpenCLKernelCallingConv() const {
   return llvm::CallingConv::AMDGPU_KERNEL;
 }
 
+// In amdgcn target the null pointer in global, constant, and generic
+// address space has value 0 but in private and local address space has
+// value -1.
+bool AMDGPUTargetCodeGenInfo::isNullPtrZero(
+   const CodeGen::CodeGenModule &CGM, llvm::PointerType *PT,
+   QualType QT) const {
+ auto &Ctx = CGM.getContext();
+ auto AS = PT->getAddressSpace();
+ return AS != Ctx.getTargetAddressSpace(LangAS::opencl_local) && AS != 0;
+}
+
+// Currently LLVM assumes null pointers always have value 0,
+// which results in incorrectly transformed IR. Therefore, instead of
+// emitting null pointers in private and local address spaces, a null
+// pointer in generic address space is emitted which is casted to a
+// pointer in local or private address space.
+llvm::Constant *AMDGPUTargetCodeGenInfo::getNullPtr(
+    const CodeGen::CodeGenModule &CGM, llvm::PointerType *PT,
+    QualType QT) const {
+  if (isNullPtrZero(CGM, PT, QT))
+    return llvm::ConstantPointerNull::get(PT);
+
+  auto &Ctx = CGM.getContext();
+  auto NPT = llvm::PointerType::get(PT->getElementType(),
+      Ctx.getTargetAddressSpace(LangAS::opencl_generic));
+  return llvm::ConstantExpr::getAddrSpaceCast(
+      llvm::ConstantPointerNull::get(NPT), PT);
+}
+
 //===----------------------------------------------------------------------===//
 // SPARC v8 ABI Implementation.
 // Based on the SPARC Compliance Definition version 2.4.1.
 //
 // Ensures that complex values are passed in registers.
 //
 namespace {
 class SparcV8ABIInfo : public DefaultABIInfo {

test/CodeGenOpenCL/amdgpu-nullptr.cl

+// RUN: %clang_cc1 %s -cl-std=CL2.0 -include opencl-c.h -triple amdgcn -fno-common -emit-llvm -o - | FileCheck %s
+
+// LLVM requests global variable with common linkage to be initialized with zeroinitializer, therefore use -fno-common
+// to suppress common linkage for tentative definition.
+
+// Test 0 as initializer.
+
+// CHECK: @private_p = local_unnamed_addr addrspace(1) global i8* addrspacecast (i8 addrspace(4)* null to i8*), align 4
+private char *private_p = 0;
+
+// CHECK: @local_p = local_unnamed_addr addrspace(1) global i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*), align 4
+local char *local_p = 0;
+
+// CHECK: @global_p = local_unnamed_addr addrspace(1) global i8 addrspace(1)* null, align 4
+global char *global_p = 0;
+
+// CHECK: @constant_p = local_unnamed_addr addrspace(1) global i8 addrspace(2)* null, align 4
+constant char *constant_p = 0;
+
+// CHECK: @generic_p = local_unnamed_addr addrspace(1) global i8 addrspace(4)* null, align 4
+generic char *generic_p = 0;
+
+// Test NULL as initializer.
+
+// CHECK: @private_p_NULL = local_unnamed_addr addrspace(1) global i8* addrspacecast (i8 addrspace(4)* null to i8*), align 4
+private char *private_p_NULL = NULL;
+
+// CHECK: @local_p_NULL = local_unnamed_addr addrspace(1) global i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*), align 4
+local char *local_p_NULL = NULL;
+
+// CHECK: @global_p_NULL = local_unnamed_addr addrspace(1) global i8 addrspace(1)* null, align 4
+global char *global_p_NULL = NULL;
+
+// CHECK: @constant_p_NULL = local_unnamed_addr addrspace(1) global i8 addrspace(2)* null, align 4
+constant char *constant_p_NULL = NULL;
+
+// CHECK: @generic_p_NULL = local_unnamed_addr addrspace(1) global i8 addrspace(4)* null, align 4
+generic char *generic_p_NULL = NULL;
+
+// Test default initialization of pointers.
+
+// CHECK: @p1 = local_unnamed_addr addrspace(1) global i8* addrspacecast (i8 addrspace(4)* null to i8*), align 4
+private char *p1;
+
+// CHECK: @p2 = local_unnamed_addr addrspace(1) global i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*), align 4
+local char *p2;
+
+// CHECK: @p3 = local_unnamed_addr addrspace(1) global i8 addrspace(2)* null, align 4
+constant char *p3;
+
+// CHECK: @p4 = local_unnamed_addr addrspace(1) global i8 addrspace(1)* null, align 4
+global char *p4;
+
+// CHECK: @p5 = local_unnamed_addr addrspace(1) global i8 addrspace(4)* null, align 4
+generic char *p5;
+
+// Test default initialization of sturcture.
+typedef struct {
+  private char *p1;
+  local char *p2;
+  constant char *p3;
+  global char *p4;
+  generic char *p5;
+} StructTy1;
+
+// CHECK: @S1 = local_unnamed_addr addrspace(1) global %struct.StructTy1 { i8* addrspacecast (i8 addrspace(4)* null to i8*), i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*), i8 addrspace(2)* null, i8 addrspace(1)* null, i8 addrspace(4)* null }, align 4
+StructTy1 S1;
+
+typedef struct {
+  constant char *p3;
+  global char *p4;
+  generic char *p5;
+} StructTy2;
+
+// CHECK: @S2 = local_unnamed_addr addrspace(1) global %struct.StructTy2 zeroinitializer, align 4
+StructTy2 S2;
+
+// Test default initialization of array.
+// CHECK: @A1 = local_unnamed_addr addrspace(1) global [2 x %struct.StructTy1] [%struct.StructTy1 { i8* addrspacecast (i8 addrspace(4)* null to i8*), i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*), i8 addrspace(2)* null, i8 addrspace(1)* null, i8 addrspace(4)* null }, %struct.StructTy1 { i8* addrspacecast (i8 addrspace(4)* null to i8*), i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*), i8 addrspace(2)* null, i8 addrspace(1)* null, i8 addrspace(4)* null }], align 4
+StructTy1 A1[2];
+
+// CHECK: @A2 = local_unnamed_addr addrspace(1) global [2 x %struct.StructTy2] zeroinitializer, align 4
+StructTy2 A2[2];
+
+// Test comparison with 0.
+
+// CHECK-LABEL: cmp_private
+// CHECK: icmp eq i8* %p, addrspacecast (i8 addrspace(4)* null to i8*)
+void cmp_private(private char* p) {
+  if (p != 0)
+    *p = 0;
+}
+
+// CHECK-LABEL: cmp_local
+// CHECK: icmp eq i8 addrspace(3)* %p, addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*)
+void cmp_local(local char* p) {
+  if (p != 0)
+    *p = 0;
+}
+
+// CHECK-LABEL: cmp_global
+// CHECK: icmp eq i8 addrspace(1)* %p, null
+void cmp_global(global char* p) {
+  if (p != 0)
+    *p = 0;
+}
+
+// CHECK-LABEL: cmp_constant
+// CHECK: icmp eq i8 addrspace(2)* %p, null
+char cmp_constant(constant char* p) {
+  if (p != 0)
+    return *p;
+  else
+    return 0;
+}
+
+// CHECK-LABEL: cmp_generic
+// CHECK: icmp eq i8 addrspace(4)* %p, null
+void cmp_generic(generic char* p) {
+  if (p != 0)
+    *p = 0;
+}
+
+// Test comparison with NULL.
+
+// CHECK-LABEL: cmp_NULL_private
+// CHECK: icmp eq i8* %p, addrspacecast (i8 addrspace(4)* null to i8*)
+void cmp_NULL_private(private char* p) {
+  if (p != NULL)
+    *p = 0;
+}
+
+// CHECK-LABEL: cmp_NULL_local
+// CHECK: icmp eq i8 addrspace(3)* %p, addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*)
+void cmp_NULL_local(local char* p) {
+  if (p != NULL)
+    *p = 0;
+}
+
+// CHECK-LABEL: cmp_NULL_global
+// CHECK: icmp eq i8 addrspace(1)* %p, addrspacecast (i8 addrspace(4)* null to i8 addrspace(1)*)
+void cmp_NULL_global(global char* p) {
+  if (p != NULL)
+    *p = 0;
+}
+
+// CHECK-LABEL: cmp_NULL_constant
+// CHECK: icmp eq i8 addrspace(2)* %p, addrspacecast (i8 addrspace(4)* null to i8 addrspace(2)*)
+char cmp_NULL_constant(constant char* p) {
+  if (p != NULL)
+    return *p;
+  else
+    return 0;
+}
+
+// CHECK-LABEL: cmp_NULL_generic
+// CHECK: icmp eq i8 addrspace(4)* %p, null
+void cmp_NULL_generic(generic char* p) {
+  if (p != NULL)
+    *p = 0;
+}
+
+// Test storage 0 as null pointer.
+// CHECK-LABEL: test_storage_null_pointer
+// CHECK: store i8* addrspacecast (i8 addrspace(4)* null to i8*), i8* addrspace(4)* %arg_private
+// CHECK: store i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*), i8 addrspace(3)* addrspace(4)* %arg_local
+// CHECK: store i8 addrspace(1)* null, i8 addrspace(1)* addrspace(4)* %arg_global
+// CHECK: store i8 addrspace(2)* null, i8 addrspace(2)* addrspace(4)* %arg_constant
+// CHECK: store i8 addrspace(4)* null, i8 addrspace(4)* addrspace(4)* %arg_generic
+void test_storage_null_pointer(private char** arg_private,
+                               local char** arg_local,
+                               global char** arg_global,
+                               constant char** arg_constant,
+                               generic char** arg_generic) {
+   *arg_private = 0;
+   *arg_local = 0;
+   *arg_global = 0;
+   *arg_constant = 0;
+   *arg_generic = 0;
+}
+
+// Test storage NULL as null pointer.
+// CHECK-LABEL: test_storage_null_pointer_NULL
+// CHECK: store i8* addrspacecast (i8 addrspace(4)* null to i8*), i8* addrspace(4)* %arg_private
+// CHECK: store i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*), i8 addrspace(3)* addrspace(4)* %arg_local
+// CHECK: store i8 addrspace(1)* null, i8 addrspace(1)* addrspace(4)* %arg_global
+// CHECK: store i8 addrspace(2)* null, i8 addrspace(2)* addrspace(4)* %arg_constant
+// CHECK: store i8 addrspace(4)* null, i8 addrspace(4)* addrspace(4)* %arg_generic
+void test_storage_null_pointer_NULL(private char** arg_private,
+                                    local char** arg_local,
+                                    global char** arg_global,
+                                    constant char** arg_constant,
+                                    generic char** arg_generic) {
+   *arg_private = NULL;
+   *arg_local = NULL;
+   *arg_global = NULL;
+   *arg_constant = NULL;
+   *arg_generic = NULL;
+}
+
+// Test pass null pointer to function as argument.
+void test_pass_null_pointer_arg_calee(private char* arg_private,
+                                      local char* arg_local,
+                                      global char* arg_global,
+                                      constant char* arg_constant,
+                                      generic char* arg_generic);
+
+// CHECK-LABEL: test_pass_null_pointer_arg
+// CHECK: call void @test_pass_null_pointer_arg_calee(i8* addrspacecast (i8 addrspace(4)* null to i8*), i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*), i8 addrspace(1)* null, i8 addrspace(2)* null, i8 addrspace(4)* null)
+// CHECK: call void @test_pass_null_pointer_arg_calee(i8* addrspacecast (i8 addrspace(4)* null to i8*), i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*), i8 addrspace(1)* null, i8 addrspace(2)* null, i8 addrspace(4)* null)
+void test_pass_null_pointer_arg(void) {
+  test_pass_null_pointer_arg_calee(0, 0, 0, 0, 0);
+  test_pass_null_pointer_arg_calee(NULL, NULL, NULL, NULL, NULL);
+}
+
+// Test cast null pointer to size_t.
+void test_cast_null_pointer_to_sizet_calee(size_t arg_private,
+                                           size_t arg_local,
+                                           size_t arg_global,
+                                           size_t arg_constant,
+                                           size_t arg_generic);
+
+// CHECK-LABEL: test_cast_null_pointer_to_sizet
+// CHECK: call void @test_cast_null_pointer_to_sizet_calee(i64 ptrtoint (i8* addrspacecast (i8 addrspace(4)* null to i8*) to i64), i64 ptrtoint (i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*) to i64), i64 0, i64 0, i64 0)
+// CHeCK: call void @test_cast_null_pointer_to_sizet_calee(i64 ptrtoint (i8* addrspacecast (i8 addrspace(4)* null to i8*) to i64), i64 ptrtoint (i8 addrspace(3)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*) to i64), i64 ptrtoint (i8 addrspace(1)* addrspacecast (i8 addrspace(4)* null to i8 addrspace(1)*) to i64), i64 0, i64 0)
+void test_cast_null_pointer_to_sizet(void) {
+  test_cast_null_pointer_to_sizet_calee((size_t)((private char*)0),
+                                        (size_t)((local char*)0),
+                                        (size_t)((global char*)0),
+                                        (size_t)((constant char*)0),
+                                        (size_t)((generic char*)0));
+  test_cast_null_pointer_to_sizet_calee((size_t)((private char*)NULL),
+                                        (size_t)((local char*)NULL),
+                                        (size_t)((global char*)NULL),
+                                        (size_t)((constant char*)0), // NULL cannot be casted to constant pointer since it is defined as a generic pointer
+                                        (size_t)((generic char*)NULL));
+}
+
+// Test comparision between null pointers.
+#define TEST_EQ00(addr1, addr2) int test_eq00_##addr1##_##addr2(void) { return (addr1 char*)0 == (addr2 char*)0; }
+#define TEST_EQ0N(addr1, addr2) int test_eq0N_##addr1##_##addr2(void) { return (addr1 char*)0 == (addr2 char*)NULL; }
+#define TEST_EQN0(addr1, addr2) int test_eqN0_##addr1##_##addr2(void) { return (addr1 char*)NULL == (addr2 char*)0; }
+#define TEST_EQNN(addr1, addr2) int test_eqNN_##addr1##_##addr2(void) { return (addr1 char*)0 == (addr2 char*)NULL; }
+#define TEST_NE00(addr1, addr2) int test_ne00_##addr1##_##addr2(void) { return (addr1 char*)0 != (addr2 char*)0; }
+#define TEST_NE0N(addr1, addr2) int test_ne0N_##addr1##_##addr2(void) { return (addr1 char*)0 != (addr2 char*)NULL; }
+#define TEST_NEN0(addr1, addr2) int test_neN0_##addr1##_##addr2(void) { return (addr1 char*)NULL != (addr2 char*)0; }
+#define TEST_NENN(addr1, addr2) int test_neNN_##addr1##_##addr2(void) { return (addr1 char*)0 != (addr2 char*)NULL; }
+#define TEST(addr1, addr2) \
+        TEST_EQ00(addr1, addr2) \
+        TEST_EQ0N(addr1, addr2) \
+        TEST_EQN0(addr1, addr2) \
+        TEST_EQNN(addr1, addr2) \
+        TEST_NE00(addr1, addr2) \
+        TEST_NE0N(addr1, addr2) \
+        TEST_NEN0(addr1, addr2) \
+        TEST_NENN(addr1, addr2)
+
+// CHECK-LABEL: test_eq00_generic_private
+// CHECK: ret i32 1
+// CHECK-LABEL: test_eq0N_generic_private
+// CHECK: ret i32 1
+// CHECK-LABEL: test_eqN0_generic_private
+// CHECK: ret i32 1
+// CHECK-LABEL: test_eqNN_generic_private
+// CHECK: ret i32 1
+// CHECK-LABEL: test_ne00_generic_private
+// CHECK: ret i32 0
+// CHECK-LABEL: test_ne0N_generic_private
+// CHECK: ret i32 0
+// CHECK-LABEL: test_neN0_generic_private
+// CHECK: ret i32 0
+// CHECK-LABEL: test_neNN_generic_private
+// CHECK: ret i32 0
+TEST(generic, private)
+
+// CHECK-LABEL: test_eq00_generic_local
+// CHECK: ret i32 1
+// CHECK-LABEL: test_eq0N_generic_local
+// CHECK: ret i32 1
+// CHECK-LABEL: test_eqN0_generic_local
+// CHECK: ret i32 1
+// CHECK-LABEL: test_eqNN_generic_local
+// CHECK: ret i32 1
+// CHECK-LABEL: test_ne00_generic_local
+// CHECK: ret i32 0
+// CHECK-LABEL: test_ne0N_generic_local
+// CHECK: ret i32 0
+// CHECK-LABEL: test_neN0_generic_local
+// CHECK: ret i32 0
+// CHECK-LABEL: test_neNN_generic_local
+// CHECK: ret i32 0
+TEST(generic, local)
+
+// CHECK-LABEL: test_eq00_generic_global
+// CHECK: ret i32 zext (i1 icmp eq (i8 addrspace(4)* addrspacecast (i8 addrspace(1)* null to i8 addrspace(4)*), i8 addrspace(4)* null) to i32)
+// CHECK-LABEL: test_eq0N_generic_global
+// CHECK: ret i32 1
+// CHECK-LABEL: test_eqN0_generic_global
+// CHECK: ret i32 zext (i1 icmp eq (i8 addrspace(4)* addrspacecast (i8 addrspace(1)* null to i8 addrspace(4)*), i8 addrspace(4)* null) to i32)
+// CHECK-LABEL: test_eqNN_generic_global
+// CHECK: ret i32 1
+// CHECK-LABEL: test_ne00_generic_global
+// CHECK: ret i32 zext (i1 icmp ne (i8 addrspace(4)* addrspacecast (i8 addrspace(1)* null to i8 addrspace(4)*), i8 addrspace(4)* null) to i32)
+// CHECK-LABEL: test_ne0N_generic_global
+// CHECK: ret i32 0
+// CHECK-LABEL: test_neN0_generic_global
+// CHECK: ret i32 zext (i1 icmp ne (i8 addrspace(4)* addrspacecast (i8 addrspace(1)* null to i8 addrspace(4)*), i8 addrspace(4)* null) to i32)
+// CHECK-LABEL: test_neNN_generic_global
+// CHECK: ret i32 0
+TEST(generic, global)
+
+// CHECK-LABEL: test_eq00_generic_generic
+// CHECK: ret i32 1
+// CHECK-LABEL: test_eq0N_generic_generic
+// CHECK: ret i32 1
+// CHECK-LABEL: test_eqN0_generic_generic
+// CHECK: ret i32 1
+// CHECK-LABEL: test_eqNN_generic_generic
+// CHECK: ret i32 1
+// CHECK-LABEL: test_ne00_generic_generic
+// CHECK: ret i32 0
+// CHECK-LABEL: test_ne0N_generic_generic
+// CHECK: ret i32 0
+// CHECK-LABEL: test_neN0_generic_generic
+// CHECK: ret i32 0
+// CHECK-LABEL: test_neNN_generic_generic
+// CHECK: ret i32 0
+TEST(generic, generic)
+
+// CHECK-LABEL: test_eq00_constant_constant
+// CHECK: ret i32 1
+TEST_EQ00(constant, constant)
+
+// Test cast to bool.
+
+// CHECK-LABEL: cast_bool_private
+// CHECK: icmp eq i8* %p, addrspacecast (i8 addrspace(4)* null to i8*)
+void cast_bool_private(private char* p) {
+  if (p)
+    *p = 0;
+}
+
+// CHECK-LABEL: cast_bool_local
+// CHECK: icmp eq i8 addrspace(3)* %p, addrspacecast (i8 addrspace(4)* null to i8 addrspace(3)*)
+void cast_bool_local(local char* p) {
+  if (p)
+    *p = 0;
+}
+
+// CHECK-LABEL: cast_bool_global
+// CHECK: icmp eq i8 addrspace(1)* %p, null
+void cast_bool_global(global char* p) {
+  if (p)
+    *p = 0;
+}
+
+// CHECK-LABEL: cast_bool_constant
+// CHECK: icmp eq i8 addrspace(2)* %p, null
+char cast_bool_constant(constant char* p) {
+  if (p)
+    return *p;
+  else
+    return 0;
+}
+
+// CHECK-LABEL: cast_bool_generic
+// CHECK: icmp eq i8 addrspace(4)* %p, null
+void cast_bool_generic(generic char* p) {
+  if (p)
+    *p = 0;
+}
+
+// Test initialize a struct using memset.
+// For large structures which is mostly zero, clang generats llvm.memset for
+// the zero part and store for non-zero members.
+typedef struct {
+  long a, b, c, d;
+  private char *p;
+} StructTy3;
+
+// CHECK-LABEL: test_memset
+// CHECK: call void @llvm.memset.p0i8.i64(i8* {{.*}}, i8 0, i64 32, i32 8, i1 false)
+// CHECK: store i8* addrspacecast (i8 addrspace(4)* null to i8*), i8** {{.*}}
+StructTy3 test_memset(void) {
+  StructTy3 S3 = {0, 0, 0, 0, 0};
+  return S3;
+}
+
+// Test casting literal 0 to pointer.
+// A 0 literal casted to pointer should become a null pointer.
+
+// CHECK-LABEL: test_cast_0_to_ptr
+// CHECK: ret i32* addrspacecast (i32 addrspace(4)* null to i32*)
+private int* test_cast_0_to_ptr(void) {
+  return (private int*)0;
+}
+
+// Test casting non-literal integer with 0 value to pointer.
+// A non-literal integer expression with 0 value is casted to a pointer with
+// zero value. 
+
+// CHECK-LABEL: test_cast_int_to_ptr1
+// CHECK: ret i32* null
+private int* test_cast_int_to_ptr1(void) {
+  return (private int*)((void)0, 0);
+}
+
+// CHECK-LABEL: test_cast_int_to_ptr2
+// CHECK: ret i32* null
+private int* test_cast_int_to_ptr2(void) {
+  int x = 0;
+  return (private int*)x;
+}
+