Reimplement globalstring to provide addrspace control. (#479)

Author: maleadt

src/core/value/constant.jl

@@ -599,12 +599,12 @@ const_fcmp(Predicate::API.LLVMRealPredicate, lhs::Constant, rhs::Constant) =
 const_shl(lhs::Constant, rhs::Constant) =
     Value(API.LLVMConstShl(lhs, rhs))
 
-function const_gep(val::Constant, Ty::LLVMType, Indices::Vector{<:Constant})
-    Value(API.LLVMConstGEP2(val, Ty, Indices, length(Indices)))
+function const_gep(Ty::LLVMType, val::Constant, Indices::Vector{<:Constant})
+    Value(API.LLVMConstGEP2(Ty, val, Indices, length(Indices)))
 end
 
-function const_inbounds_gep(val::Constant, Ty::LLVMType, Indices::Vector{<:Constant})
-    Value(API.LLVMConstInBoundsGEP2(val, Ty, Indices, length(Indices)))
+function const_inbounds_gep(Ty::LLVMType, val::Constant, Indices::Vector{<:Constant})
+    Value(API.LLVMConstInBoundsGEP2(Ty, val, Indices, length(Indices)))
 end
 
 const_trunc(val::Constant, ToType::LLVMType) =

src/irbuilder.jl

@@ -518,11 +518,41 @@ not!(builder::IRBuilder, V::Value, Name::String="") =
 
 # other build methods
 
-globalstring!(builder::IRBuilder, Str::String, Name::String="") =
-    Value(API.LLVMBuildGlobalString(builder, Str, Name))
+#globalstring!(builder::IRBuilder, Str::String, Name::String="") =
+#    Value(API.LLVMBuildGlobalString(builder, Str, Name))
+
+# re-implementation for flexibility (exposing addrspace, add_null)
+function globalstring!(mod::LLVM.Module, str::String, name::String="";
+                       addrspace::Integer=0, add_null::Bool=true)
+    bytes = Vector{UInt8}(str)
+    if add_null
+        push!(bytes, 0x00)
+    end
+    constant = ConstantDataArray(bytes)
+
+    gv = GlobalVariable(mod, value_type(constant), name, addrspace)
+    alignment!(gv, 1)
+    unnamed_addr!(gv, true)
+    initializer!(gv, constant)
+    constant!(gv, true)
+    linkage!(gv, LLVM.API.LLVMPrivateLinkage)
 
-globalstring_ptr!(builder::IRBuilder, Str::String, Name::String="") =
-    Value(API.LLVMBuildGlobalStringPtr(builder, Str, Name))
+    return gv
+end
+function globalstring!(builder::IRBuilder, args...; kwargs...)
+    mod = parent(parent(position(builder)))
+    globalstring!(mod, args...; kwargs...)
+end
+
+#globalstring_ptr!(builder::IRBuilder, Str::String, Name::String="") =
+#    Value(API.LLVMBuildGlobalStringPtr(builder, Str, Name))
+
+function globalstring_ptr!(args...; kwargs...)
+    gv = globalstring!(args...; kwargs...)
+    zero = LLVM.ConstantInt(LLVM.IntType(32), 0)
+    indices = [zero, zero]
+    const_inbounds_gep(global_value_type(gv), gv, indices)
+end
 
 isnull!(builder::IRBuilder, Val::Value, Name::String="") =
     Value(API.LLVMBuildIsNull(builder, Val, Name))

test/instructions_tests.jl

@@ -389,13 +389,16 @@
     strinst = globalstring!(builder, "foobar")
     @check_ir strinst "private unnamed_addr constant [7 x i8] c\"foobar\\00\""
 
+    str2inst = globalstring!(builder, "foobar"; addrspace=2, add_null=false)
+    @check_ir str2inst "private unnamed_addr addrspace(2) constant [6 x i8] c\"foobar\""
+
     strptrinst = globalstring_ptr!(builder, "foobar")
     if supports_typed_pointers(ctx)
-        @check_ir strptrinst "i8* getelementptr inbounds ([7 x i8], [7 x i8]* @1, i32 0, i32 0)"
+        @check_ir strptrinst "i8* getelementptr inbounds ([7 x i8], [7 x i8]* @2, i32 0, i32 0)"
     elseif LLVM.version() < v"15"
         # globalstring_ptr! returns a i8* ptr instead of a ptr to an i8 array.
         # that difference is moot when we have opaque pointers...
-        @check_ir strptrinst "ptr getelementptr inbounds ([7 x i8], ptr @1, i32 0, i32 0)"
+        @check_ir strptrinst "ptr getelementptr inbounds ([7 x i8], ptr @2, i32 0, i32 0)"
     else
         # ... so it is folded away now.
         @check_ir strptrinst "private unnamed_addr constant [7 x i8] c\"foobar\\00\""