Remove offset size check in nullptr arithmetic handling

[andrew.w.kaylor]

Summary

This patch amends the changes that were committed from D37042 to remove the offset size check in the idiom identification routine.

That check was behaving inconsistently (from target to target) because the offset was implicitly promoted to an integer before the idiom identification routine was called. The result was that when a smaller-than-int offset was added to a nullptr, the idiom was reported as having been matched on platforms where the int size is the same as the pointer size but the idiom was reported as not having been matched on platforms where the int size and the pointer size were different.

Because this check adds little value, and because the behavior of nullptr arithmetic is undefined in all cases (and therefore at our discretion to implement as we choose), it seems best to remove this check in order to guarantee consistent behavior across all platforms.

[efriedma]

LGTM

[andrew.w.kaylor]

This was committed as r313784. I put the wrong differential revision number in the comment for that check-in.

lib/AST/Expr.cpp

if (!PExp->IgnoreParenCasts()
           ->isNullPointerConstant(Ctx, Expr::NPC_ValueDependentIsNotNull))
     return false;
 
   // Check that the pointee type is char-sized.
   const PointerType *PTy = PExp->getType()->getAs<PointerType>();
   if (!PTy || !PTy->getPointeeType()->isCharType())
     return false;
 
-  // Check that the integer type is pointer-sized.
-  if (Ctx.getTypeSize(IExp->getType()) != Ctx.getTypeSize(PExp->getType()))
-    return false;
-
   return true;
 }
 InitListExpr::InitListExpr(const ASTContext &C, SourceLocation lbraceloc,
                            ArrayRef<Expr*> initExprs, SourceLocation rbraceloc)
   : Expr(InitListExprClass, QualType(), VK_RValue, OK_Ordinary, false, false,
          false, false),
     InitExprs(C, initExprs.size()),
     LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), AltForm(nullptr, true)

test/CodeGen/nullptr-arithmetic.c

 // RUN: %clang_cc1 -S %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -S %s -emit-llvm -triple i686-unknown-unknown -o - | FileCheck %s
+// RUN: %clang_cc1 -S %s -emit-llvm -triple x86_64-unknown-unknown -o - | FileCheck %s
 
 #include <stdint.h>
 
 // This test is meant to verify code that handles the 'p = nullptr + n' idiom
 // used by some versions of glibc and gcc.  This is undefined behavior but
 // it is intended there to act like a conversion from a pointer-sized integer
 // to a pointer, and we would like to tolerate that.
 

 
 // This doesn't meet the idiom because the offset is subtracted.
 int8_t* test3(intptr_t n) {
   return NULLPTRI8 - n;
 }
 // CHECK-LABEL: test3
 // CHECK: getelementptr
 // CHECK-NOT: inttoptr
+
+// This checks the case where the offset isn't pointer-sized.
+// The front end will implicitly cast the offset to an integer, so we need to
+// make sure that doesn't cause problems on targets where integers and pointers
+// are not the same size.
+int8_t *test4(int8_t b) {
+  return NULLPTRI8 + b;
+}
+// CHECK-LABEL: test4
+// CHECK: inttoptr
+// CHECK-NOT: getelementptr

test/Sema/pointer-addition.c

 // RUN: %clang_cc1 %s -fsyntax-only -verify -pedantic -Wextra -std=c11
+// RUN: %clang_cc1 %s -fsyntax-only -triple i686-unknown-unknown -verify -pedantic -Wextra -std=c11
+// RUN: %clang_cc1 %s -fsyntax-only -triple x86_64-unknown-unknown -verify -pedantic -Wextra -std=c11
 
 #include <stdint.h>
 
 typedef struct S S; // expected-note 4 {{forward declaration of 'struct S'}}
 extern _Atomic(S*) e;
 void a(S* b, void* c) {
   void (*fp)(int) = 0;
   b++;       // expected-error {{arithmetic on a pointer to an incomplete type}}

test/SemaCXX/nullptr-arithmetic.cpp

 // RUN: %clang_cc1 %s -fsyntax-only -verify -pedantic -Wextra -std=c++11
+// RUN: %clang_cc1 %s -fsyntax-only -triple i686-unknown-unknown -verify -pedantic -Wextra -std=c++11
+// RUN: %clang_cc1 %s -fsyntax-only -triple x86_64-unknown-unknown -verify -pedantic -Wextra -std=c++11
 
 #include <stdint.h>
 
 void f(intptr_t offset) {
   // A zero offset from a nullptr is OK.
   char *f = (char*)nullptr + 0;
   int *g = (int*)0 + 0;
   f = (char*)nullptr - 0;