Make llvm.objectsize more conservative with null in non-zero address spaces

[george.burgess.iv]

Summary

NULL in non-zero address spaces is dereferenceable/etc, so we probably shouldn't be assuming that its objectsize is zero.

arsenm: pulling you in to confirm that this change isn't breaking code you care about somehow (re: the comment from you on https://reviews.llvm.org/D28494 ). If this does break something, I'm happy to try and find some middle-ground. I'm sort of assuming the intent of that comment was more along the lines of "if this is a gcc-compat hack, we should limit it to addrspace(0), which is presumably the only place where we care," though.

[nlopes]

LGTM

[george.burgess.iv]

Thanks!

(I'll go ahead and commit assuming my interpretation of arsenm's message was correct. Happy to revert or land follow-ups if not)

llvm/trunk/docs/LangRef.rst

 
 Arguments:
 """"""""""
 
 The ``llvm.objectsize`` intrinsic takes three arguments. The first argument is
 a pointer to or into the ``object``. The second argument determines whether
 ``llvm.objectsize`` returns 0 (if true) or -1 (if false) when the object size
 is unknown. The third argument controls how ``llvm.objectsize`` acts when
-``null`` is used as its pointer argument. If it's true and the pointer is in
-address space 0, ``null`` is treated as an opaque value with an unknown number
-of bytes. Otherwise, ``llvm.objectsize`` reports 0 bytes available when given
-``null``.
+``null`` in address space 0 is used as its pointer argument. If it's ``false``,
+``llvm.objectsize`` reports 0 bytes available when given ``null``. Otherwise, if
+the ``null`` is in a non-zero address space or if ``true`` is given for the
+third argument of ``llvm.objectsize``, we assume its size is unknown.
 
 The second and third arguments only accept constants.
 
 Semantics:
 """"""""""
 
 The ``llvm.objectsize`` intrinsic is lowered to a constant representing
 the size of the object concerned. If the size cannot be determined at

llvm/trunk/lib/Analysis/MemoryBuiltins.cpp

SizeOffsetType ObjectSizeOffsetVisitor::visitCallSite(CallSite CS) {
   // - strcat / strncat
   // - memcpy / memmove
   // - strcat / strncat
   // - memset
 }
 
 SizeOffsetType
 ObjectSizeOffsetVisitor::visitConstantPointerNull(ConstantPointerNull& CPN) {
-  if (Options.NullIsUnknownSize && CPN.getType()->getAddressSpace() == 0)
+  // If null is unknown, there's nothing we can do. Additionally, non-zero
+  // address spaces can make use of null, so we don't presume to know anything
+  // about that.
+  //
+  // TODO: How should this work with address space casts? We currently just drop
+  // them on the floor, but it's unclear what we should do when a NULL from
+  // addrspace(1) gets casted to addrspace(0) (or vice-versa).
+  if (Options.NullIsUnknownSize || CPN.getType()->getAddressSpace())
     return unknown();
   return std::make_pair(Zero, Zero);
 }
 
 SizeOffsetType
 ObjectSizeOffsetVisitor::visitExtractElementInst(ExtractElementInst&) {
   return unknown();
 }

llvm/trunk/test/Transforms/CodeGenPrepare/basic.ll

entry:
   ret i64 %0
 }
 
 ; Test foldable null pointers because we evaluate them with non-exact modes in
 ; CodeGenPrepare.
 ; CHECK-LABEL: @test_objectsize_null_flag_noas0(
 define i64 @test_objectsize_null_flag_noas0() {
 entry:
-  ; CHECK: ret i64 0
+  ; CHECK: ret i64 -1
   %0 = tail call i64 @llvm.objectsize.i64.p1i8(i8 addrspace(1)* null, i1 false,
                                                i1 true)
   ret i64 %0
 }
 
 ; CHECK-LABEL: @test_objectsize_null_flag_min_noas0(
 define i64 @test_objectsize_null_flag_min_noas0() {
 entry:
   ; CHECK: ret i64 0
   %0 = tail call i64 @llvm.objectsize.i64.p1i8(i8 addrspace(1)* null, i1 true,
                                                i1 true)
   ret i64 %0
 }
 
+; CHECK-LABEL: @test_objectsize_null_known_flag_noas0
+define i64 @test_objectsize_null_known_flag_noas0() {
+entry:
+  ; CHECK: ret i64 -1
+  %0 = tail call i64 @llvm.objectsize.i64.p1i8(i8 addrspace(1)* null, i1 false,
+                                               i1 false)
+  ret i64 %0
+}
+
+; CHECK-LABEL: @test_objectsize_null_known_flag_min_noas0
+define i64 @test_objectsize_null_known_flag_min_noas0() {
+entry:
+  ; CHECK: ret i64 0
+  %0 = tail call i64 @llvm.objectsize.i64.p1i8(i8 addrspace(1)* null, i1 true,
+                                               i1 false)
+  ret i64 %0
+}
+
 
 declare i64 @llvm.objectsize.i64(i8*, i1, i1) nounwind readonly
 declare i64 @llvm.objectsize.i64.p1i8(i8 addrspace(1)*, i1, i1) nounwind readonly
 
 declare void @llvm.trap() nounwind

llvm/trunk/test/Transforms/InstCombine/objsize.ll

 ; CHECK: llvm.objectsize
 define i32 @test23() {
   %1 = call i32 @llvm.objectsize.i32.p0i8(i8* null, i1 true, i1 true)
   ret i32 %1
 }
 
 ; 1 is an arbitrary non-zero address space.
 ; CHECK-LABEL: @test24(
-; CHECK: ret i32 0
+; CHECK: llvm.objectsize
 define i32 @test24() {
   %1 = call i32 @llvm.objectsize.i32.p1i8(i8 addrspace(1)* null, i1 false,
                                           i1 false)
   ret i32 %1
 }
 
 ; CHECK-LABEL: @test25(
-; CHECK: ret i32 0
+; CHECK: llvm.objectsize
 define i32 @test25() {
   %1 = call i32 @llvm.objectsize.i32.p1i8(i8 addrspace(1)* null, i1 true,
                                           i1 false)
   ret i32 %1
 }
 
 ; CHECK-LABEL: @test26(
-; CHECK: ret i32 0
+; CHECK: llvm.objectsize
 define i32 @test26() {
   %1 = call i32 @llvm.objectsize.i32.p1i8(i8 addrspace(1)* null, i1 false,
                                           i1 true)
   ret i32 %1
 }
 
 ; CHECK-LABEL: @test27(
-; CHECK: ret i32 0
+; CHECK: llvm.objectsize
 define i32 @test27() {
   %1 = call i32 @llvm.objectsize.i32.p1i8(i8 addrspace(1)* null, i1 true,
                                           i1 true)
   ret i32 %1
 }