diff --git a/Manifest.toml b/Manifest.toml
index 41b661543..7ff48e787 100644
--- a/Manifest.toml
+++ b/Manifest.toml
@@ -49,11 +49,9 @@ version = "5.1.0"
 
 [[GPUCompiler]]
 deps = ["DataStructures", "InteractiveUtils", "LLVM", "Libdl", "TimerOutputs", "UUIDs"]
-git-tree-sha1 = "f0fdbfcd2bcd380aa50c43bdab753780f248581e"
-repo-rev = "master"
-repo-url = "https://github.com/JuliaGPU/GPUCompiler.jl.git"
+git-tree-sha1 = "10b1a3aa52de30e9219f3ed147cb09e72cf6d2e8"
 uuid = "61eb1bfa-7361-4325-ad38-22787b887f55"
-version = "0.6.0"
+version = "0.7.0"
 
 [[InteractiveUtils]]
 deps = ["Markdown"]
@@ -61,9 +59,9 @@ uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
 
 [[LLVM]]
 deps = ["CEnum", "Libdl", "Printf", "Unicode"]
-git-tree-sha1 = "a662366a5d485dee882077e8da3e1a95a86d097f"
+git-tree-sha1 = "d57affa9580f5e9fb44260e8f9366dc977f01a60"
 uuid = "929cbde3-209d-540e-8aea-75f648917ca0"
-version = "2.0.0"
+version = "3.0.0"
 
 [[Libdl]]
 uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
diff --git a/Project.toml b/Project.toml
index d848994ee..55699cabc 100644
--- a/Project.toml
+++ b/Project.toml
@@ -1,7 +1,7 @@
 name = "AMDGPU"
 uuid = "21141c5a-9bdb-4563-92ae-f87d6854732e"
 authors = ["Julian P Samaroo <jpsamaroo@jpsamaroo.me>"]
-version = "0.1.1"
+version = "0.1.2"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"
@@ -22,8 +22,8 @@ Adapt = "0.4, 1.0, 2.0"
 BinaryProvider = "0.5"
 CEnum = "0.2, 0.3, 0.4"
 GPUArrays = "2, 3, 4, 5"
-GPUCompiler = "0.4, 0.5, 0.6"
-LLVM = "2"
+GPUCompiler = "0.7"
+LLVM = "3"
 Requires = "1"
 Setfield = "0.5, 0.6, 0.7"
 julia = "1.4"
diff --git a/src/device/gcn/assertion.jl b/src/device/gcn/assertion.jl
index 8cdb7d939..cf695decb 100644
--- a/src/device/gcn/assertion.jl
+++ b/src/device/gcn/assertion.jl
@@ -37,38 +37,39 @@ end
 
 assert_counter = 0
 
-@generated function rocassert_fail(::Val{msg}, ::Val{file}, ::Val{line}) where
-                                 {msg, file, line}
-    T_void = LLVM.VoidType(JuliaContext())
-    T_int32 = LLVM.Int32Type(JuliaContext())
-    T_pint8 = LLVM.PointerType(LLVM.Int8Type(JuliaContext()))
+@generated function rocassert_fail(::Val{msg}, ::Val{file}, ::Val{line}) where {msg, file, line}
+    JuliaContext() do ctx
+        T_void = LLVM.VoidType(ctx)
+        T_int32 = LLVM.Int32Type(ctx)
+        T_pint8 = LLVM.PointerType(LLVM.Int8Type(ctx))
 
-    # create function
-    llvm_f, _ = create_function()
-    mod = LLVM.parent(llvm_f)
+        # create function
+        llvm_f, _ = create_function()
+        mod = LLVM.parent(llvm_f)
 
-    # generate IR
-    Builder(JuliaContext()) do builder
-        entry = BasicBlock(llvm_f, "entry", JuliaContext())
-        position!(builder, entry)
-        global assert_counter
-        assert_counter += 1
-        message = globalstring_ptr!(builder, String(msg), "assert_message_$(assert_counter)")
-        file = globalstring_ptr!(builder, String(file), "assert_file_$(assert_counter)")
-        line = ConstantInt(T_int32, line)
-        func = globalstring_ptr!(builder, "unknown", "assert_function_$(assert_counter)")
-        charSize = ConstantInt(Csize_t(1), JuliaContext())
+        # generate IR
+        Builder(ctx) do builder
+            entry = BasicBlock(llvm_f, "entry", ctx)
+            position!(builder, entry)
+            global assert_counter
+            assert_counter += 1
+            message = globalstring_ptr!(builder, String(msg), "assert_message_$(assert_counter)")
+            file = globalstring_ptr!(builder, String(file), "assert_file_$(assert_counter)")
+            line = ConstantInt(T_int32, line)
+            func = globalstring_ptr!(builder, "unknown", "assert_function_$(assert_counter)")
+            charSize = ConstantInt(Csize_t(1), ctx)
 
-        # invoke __assertfail and return
-        # TODO: mark noreturn since we don't use ptxas?
-        assertfail_typ =
-            LLVM.FunctionType(T_void,
-                             [T_pint8, T_pint8, T_int32, T_pint8, llvmtype(charSize)])
-        assertfail = LLVM.Function(mod, "__assertfail", assertfail_typ)
-        call!(builder, assertfail, [message, file, line, func, charSize])
-        ret!(builder)
-    end
+            # invoke __assertfail and return
+            # TODO: mark noreturn since we don't use ptxas?
+            assertfail_typ =
+                LLVM.FunctionType(T_void,
+                                 [T_pint8, T_pint8, T_int32, T_pint8, llvmtype(charSize)])
+            assertfail = LLVM.Function(mod, "__assertfail", assertfail_typ)
+            call!(builder, assertfail, [message, file, line, func, charSize])
+            ret!(builder)
+        end
 
-    call_function(llvm_f, Nothing, Tuple{})
+        call_function(llvm_f, Nothing, Tuple{})
+    end
 end
 
diff --git a/src/device/gcn/atomics.jl b/src/device/gcn/atomics.jl
index ed036fc34..ad38cc5b8 100644
--- a/src/device/gcn/atomics.jl
+++ b/src/device/gcn/atomics.jl
@@ -21,26 +21,28 @@
 # >   that points to either the global address space or the shared address space.
 
 @generated function llvm_atomic_op(::Val{binop}, ptr::DevicePtr{T,A}, val::T) where {binop, T, A}
-    T_val = convert(LLVMType, T)
-    T_ptr = convert(LLVMType, DevicePtr{T,A})
-    T_actual_ptr = LLVM.PointerType(T_val)
+    JuliaContext() do ctx
+        T_val = convert(LLVMType, T, ctx)
+        T_ptr = convert(LLVMType, DevicePtr{T,A}, ctx)
+        T_actual_ptr = LLVM.PointerType(T_val)
 
-    llvm_f, _ = create_function(T_val, [T_ptr, T_val])
+        llvm_f, _ = create_function(T_val, [T_ptr, T_val])
 
-    Builder(JuliaContext()) do builder
-        entry = BasicBlock(llvm_f, "entry", JuliaContext())
-        position!(builder, entry)
+        Builder(ctx) do builder
+            entry = BasicBlock(llvm_f, "entry", ctx)
+            position!(builder, entry)
 
-        actual_ptr = inttoptr!(builder, parameters(llvm_f)[1], T_actual_ptr)
+            actual_ptr = inttoptr!(builder, parameters(llvm_f)[1], T_actual_ptr)
 
-        rv = atomic_rmw!(builder, binop,
-                         actual_ptr, parameters(llvm_f)[2],
-                         atomic_acquire_release, #=single_threaded=# false)
+            rv = atomic_rmw!(builder, binop,
+                             actual_ptr, parameters(llvm_f)[2],
+                             atomic_acquire_release, #=single_threaded=# false)
 
-        ret!(builder, rv)
-    end
+            ret!(builder, rv)
+        end
 
-    call_function(llvm_f, T, Tuple{DevicePtr{T,A}, T}, :((ptr,val)))
+        call_function(llvm_f, T, Tuple{DevicePtr{T,A}, T}, :((ptr,val)))
+    end
 end
 
 const binops = Dict(
@@ -82,28 +84,30 @@ for T in (Int32, Int64, UInt32, UInt64)
 end
 
 @generated function llvm_atomic_cas(ptr::DevicePtr{T,A}, cmp::T, val::T) where {T, A}
-    T_val = convert(LLVMType, T)
-    T_ptr = convert(LLVMType, DevicePtr{T,A})
-    T_actual_ptr = LLVM.PointerType(T_val)
+    JuliaContext() do ctx
+        T_val = convert(LLVMType, T, ctx)
+        T_ptr = convert(LLVMType, DevicePtr{T,A}, ctx)
+        T_actual_ptr = LLVM.PointerType(T_val)
 
-    llvm_f, _ = create_function(T_val, [T_ptr, T_val, T_val])
+        llvm_f, _ = create_function(T_val, [T_ptr, T_val, T_val])
 
-    Builder(JuliaContext()) do builder
-        entry = BasicBlock(llvm_f, "entry", JuliaContext())
-        position!(builder, entry)
+        Builder(ctx) do builder
+            entry = BasicBlock(llvm_f, "entry", ctx)
+            position!(builder, entry)
 
-        actual_ptr = inttoptr!(builder, parameters(llvm_f)[1], T_actual_ptr)
+            actual_ptr = inttoptr!(builder, parameters(llvm_f)[1], T_actual_ptr)
 
-        res = atomic_cmpxchg!(builder, actual_ptr, parameters(llvm_f)[2],
-                              parameters(llvm_f)[3], atomic_acquire_release, atomic_acquire,
-                              #=single threaded=# false)
+            res = atomic_cmpxchg!(builder, actual_ptr, parameters(llvm_f)[2],
+                                  parameters(llvm_f)[3], atomic_acquire_release, atomic_acquire,
+                                  #=single threaded=# false)
 
-        rv = extract_value!(builder, res, 0)
+            rv = extract_value!(builder, res, 0)
 
-        ret!(builder, rv)
-    end
+            ret!(builder, rv)
+        end
 
-    call_function(llvm_f, T, Tuple{DevicePtr{T,A}, T, T}, :((ptr,cmp,val)))
+        call_function(llvm_f, T, Tuple{DevicePtr{T,A}, T, T}, :((ptr,cmp,val)))
+    end
 end
 
 for T in (Int32, Int64, UInt32, UInt64)
diff --git a/src/device/gcn/execution_control.jl b/src/device/gcn/execution_control.jl
index 190cbcd04..cc0f833c6 100644
--- a/src/device/gcn/execution_control.jl
+++ b/src/device/gcn/execution_control.jl
@@ -3,34 +3,36 @@
 const completion_signal_base = _packet_offsets[findfirst(x->x==:completion_signal,_packet_names)]
 
 @generated function _completion_signal()
-    T_int8 = LLVM.Int8Type(JuliaContext())
-    T_int64 = LLVM.Int64Type(JuliaContext())
-    _as = convert(Int, AS.Constant)
-    T_ptr_i8 = LLVM.PointerType(T_int8, _as)
-    T_ptr_i64 = LLVM.PointerType(T_int64, _as)
-
-    # create function
-    llvm_f, _ = create_function(T_int64)
-    mod = LLVM.parent(llvm_f)
-
-    # generate IR
-    Builder(JuliaContext()) do builder
-        entry = BasicBlock(llvm_f, "entry", JuliaContext())
-        position!(builder, entry)
-
-        # get the kernel dispatch pointer
-        intr_typ = LLVM.FunctionType(T_ptr_i8)
-        intr = LLVM.Function(mod, "llvm.amdgcn.dispatch.ptr", intr_typ)
-        ptr = call!(builder, intr)
-
-        # load the index
-        signal_ptr_i8 = inbounds_gep!(builder, ptr, [ConstantInt(completion_signal_base, JuliaContext())])
-        signal_ptr = bitcast!(builder, signal_ptr_i8, T_ptr_i64)
-        signal = load!(builder, signal_ptr)
-        ret!(builder, signal)
+    JuliaContext() do ctx
+        T_int8 = LLVM.Int8Type(ctx)
+        T_int64 = LLVM.Int64Type(ctx)
+        _as = convert(Int, AS.Constant)
+        T_ptr_i8 = LLVM.PointerType(T_int8, _as)
+        T_ptr_i64 = LLVM.PointerType(T_int64, _as)
+
+        # create function
+        llvm_f, _ = create_function(T_int64)
+        mod = LLVM.parent(llvm_f)
+
+        # generate IR
+        Builder(ctx) do builder
+            entry = BasicBlock(llvm_f, "entry", ctx)
+            position!(builder, entry)
+
+            # get the kernel dispatch pointer
+            intr_typ = LLVM.FunctionType(T_ptr_i8)
+            intr = LLVM.Function(mod, "llvm.amdgcn.dispatch.ptr", intr_typ)
+            ptr = call!(builder, intr)
+
+            # load the index
+            signal_ptr_i8 = inbounds_gep!(builder, ptr, [ConstantInt(completion_signal_base, ctx)])
+            signal_ptr = bitcast!(builder, signal_ptr_i8, T_ptr_i64)
+            signal = load!(builder, signal_ptr)
+            ret!(builder, signal)
+        end
+
+        call_function(llvm_f, UInt64)
     end
-
-    call_function(llvm_f, UInt64)
 end
 
 signal_completion(value::Int64) = device_signal_store!(_completion_signal(), value)
diff --git a/src/device/gcn/hostcall.jl b/src/device/gcn/hostcall.jl
index d69a7908c..f8908bfd5 100644
--- a/src/device/gcn/hostcall.jl
+++ b/src/device/gcn/hostcall.jl
@@ -45,66 +45,70 @@ end
 ## device signal functions
 # TODO: device_signal_load, device_signal_add!, etc.
 @inline @generated function device_signal_store!(signal::UInt64, value::Int64)
-    T_nothing = convert(LLVMType, Nothing)
-    T_i32 = LLVM.Int32Type(JuliaContext())
-    T_i64 = LLVM.Int64Type(JuliaContext())
+    JuliaContext() do ctx
+        T_nothing = convert(LLVMType, Nothing, ctx)
+        T_i32 = LLVM.Int32Type(ctx)
+        T_i64 = LLVM.Int64Type(ctx)
 
-    # create a function
-    llvm_f, _ = create_function(T_nothing, [T_i64, T_i64])
-    mod = LLVM.parent(llvm_f)
+        # create a function
+        llvm_f, _ = create_function(T_nothing, [T_i64, T_i64])
+        mod = LLVM.parent(llvm_f)
 
-    # generate IR
-    Builder(JuliaContext()) do builder
-        entry = BasicBlock(llvm_f, "entry", JuliaContext())
-        position!(builder, entry)
+        # generate IR
+        Builder(ctx) do builder
+            entry = BasicBlock(llvm_f, "entry", ctx)
+            position!(builder, entry)
 
-        T_signal_store = LLVM.FunctionType(T_nothing, [T_i64, T_i64, T_i32])
-        signal_store = LLVM.Function(mod, "__ockl_hsa_signal_store", T_signal_store)
-        call!(builder, signal_store, [parameters(llvm_f)[1],
-                                      parameters(llvm_f)[2],
-                                      # __ATOMIC_RELEASE == 3
-                                      ConstantInt(Int32(3), JuliaContext())])
+            T_signal_store = LLVM.FunctionType(T_nothing, [T_i64, T_i64, T_i32])
+            signal_store = LLVM.Function(mod, "__ockl_hsa_signal_store", T_signal_store)
+            call!(builder, signal_store, [parameters(llvm_f)[1],
+                                          parameters(llvm_f)[2],
+                                          # __ATOMIC_RELEASE == 3
+                                          ConstantInt(Int32(3), ctx)])
 
-        ret!(builder)
-    end
+            ret!(builder)
+        end
 
-    call_function(llvm_f, Nothing, Tuple{UInt64,Int64}, :((signal,value)))
+        call_function(llvm_f, Nothing, Tuple{UInt64,Int64}, :((signal,value)))
+    end
 end
 @inline @generated function device_signal_wait(signal::UInt64, value::Int64)
-    T_nothing = convert(LLVMType, Nothing)
-    T_i32 = LLVM.Int32Type(JuliaContext())
-    T_i64 = LLVM.Int64Type(JuliaContext())
+    JuliaContext() do ctx
+        T_nothing = convert(LLVMType, Nothing, ctx)
+        T_i32 = LLVM.Int32Type(ctx)
+        T_i64 = LLVM.Int64Type(ctx)
 
-    # create a function
-    llvm_f, _ = create_function(T_nothing, [T_i64, T_i64])
-    mod = LLVM.parent(llvm_f)
+        # create a function
+        llvm_f, _ = create_function(T_nothing, [T_i64, T_i64])
+        mod = LLVM.parent(llvm_f)
 
-    # generate IR
-    Builder(JuliaContext()) do builder
-        entry = BasicBlock(llvm_f, "entry", JuliaContext())
-        signal_match = BasicBlock(llvm_f, "signal_match", JuliaContext())
-        signal_miss = BasicBlock(llvm_f, "signal_miss", JuliaContext())
+        # generate IR
+        Builder(ctx) do builder
+            entry = BasicBlock(llvm_f, "entry", ctx)
+            signal_match = BasicBlock(llvm_f, "signal_match", ctx)
+            signal_miss = BasicBlock(llvm_f, "signal_miss", ctx)
 
-        position!(builder, entry)
-        br!(builder, signal_miss)
+            position!(builder, entry)
+            br!(builder, signal_miss)
 
-        position!(builder, signal_miss)
-        T_sleep = LLVM.FunctionType(T_nothing, [T_i32])
-        sleep_f = LLVM.Function(mod, "llvm.amdgcn.s.sleep", T_sleep)
-        call!(builder, sleep_f, [ConstantInt(Int32(1), JuliaContext())])
-        T_signal_load = LLVM.FunctionType(T_i64, [T_i64, T_i32])
-        signal_load = LLVM.Function(mod, "__ockl_hsa_signal_load", T_signal_load)
-        loaded_value = call!(builder, signal_load, [parameters(llvm_f)[1],
-                                                    # __ATOMIC_ACQUIRE == 2
-                                                    ConstantInt(Int32(2), JuliaContext())])
-        cond = icmp!(builder, LLVM.API.LLVMIntEQ, loaded_value, parameters(llvm_f)[2])
-        br!(builder, cond, signal_match, signal_miss)
+            position!(builder, signal_miss)
+            T_sleep = LLVM.FunctionType(T_nothing, [T_i32])
+            sleep_f = LLVM.Function(mod, "llvm.amdgcn.s.sleep", T_sleep)
+            call!(builder, sleep_f, [ConstantInt(Int32(1), ctx)])
+            T_signal_load = LLVM.FunctionType(T_i64, [T_i64, T_i32])
+            signal_load = LLVM.Function(mod, "__ockl_hsa_signal_load", T_signal_load)
+            loaded_value = call!(builder, signal_load, [parameters(llvm_f)[1],
+                                                        # __ATOMIC_ACQUIRE == 2
+                                                        ConstantInt(Int32(2), ctx)])
+            cond = icmp!(builder, LLVM.API.LLVMIntEQ, loaded_value, parameters(llvm_f)[2])
+            br!(builder, cond, signal_match, signal_miss)
 
-        position!(builder, signal_match)
-        ret!(builder)
-    end
+            position!(builder, signal_match)
+            ret!(builder)
+        end
 
-    call_function(llvm_f, Nothing, Tuple{UInt64,Int64}, :((signal,value)))
+        call_function(llvm_f, Nothing, Tuple{UInt64,Int64}, :((signal,value)))
+    end
 end
 "Calls the host function stored in `hc` with arguments `args`."
 @inline @generated function hostcall!(hc::HostCall{UInt64,RT,AT}, args...) where {RT,AT}
diff --git a/src/device/gcn/indexing.jl b/src/device/gcn/indexing.jl
index 9935802e7..fad70e9b1 100644
--- a/src/device/gcn/indexing.jl
+++ b/src/device/gcn/indexing.jl
@@ -3,71 +3,75 @@ export workitemIdx, workgroupIdx, workgroupDim, gridDim, gridDimWG
 export threadIdx, blockIdx, blockDim
 
 @generated function _index(::Val{fname}, ::Val{name}, ::Val{range}) where {fname, name, range}
-    T_int32 = LLVM.Int32Type(JuliaContext())
-
-    # create function
-    llvm_f, _ = create_function(T_int32)
-    mod = LLVM.parent(llvm_f)
-
-    # generate IR
-    Builder(JuliaContext()) do builder
-        entry = BasicBlock(llvm_f, "entry", JuliaContext())
-        position!(builder, entry)
-
-        # call the indexing intrinsic
-        intr_typ = LLVM.FunctionType(T_int32)
-        intr = LLVM.Function(mod, "llvm.amdgcn.$fname.id.$name", intr_typ)
-        idx = call!(builder, intr)
-
-        # attach range metadata
-        range_metadata = MDNode([ConstantInt(Int32(range.start), JuliaContext()),
-                                 ConstantInt(Int32(range.stop), JuliaContext())],
-                                JuliaContext())
-        metadata(idx)[LLVM.MD_range] = range_metadata
-        ret!(builder, idx)
+    JuliaContext() do ctx
+        T_int32 = LLVM.Int32Type(ctx)
+
+        # create function
+        llvm_f, _ = create_function(T_int32)
+        mod = LLVM.parent(llvm_f)
+
+        # generate IR
+        Builder(ctx) do builder
+            entry = BasicBlock(llvm_f, "entry", ctx)
+            position!(builder, entry)
+
+            # call the indexing intrinsic
+            intr_typ = LLVM.FunctionType(T_int32)
+            intr = LLVM.Function(mod, "llvm.amdgcn.$fname.id.$name", intr_typ)
+            idx = call!(builder, intr)
+
+            # attach range metadata
+            range_metadata = MDNode([ConstantInt(Int32(range.start), ctx),
+                                     ConstantInt(Int32(range.stop), ctx)],
+                                    ctx)
+            metadata(idx)[LLVM.MD_range] = range_metadata
+            ret!(builder, idx)
+        end
+
+        call_function(llvm_f, UInt32)
     end
-
-    call_function(llvm_f, UInt32)
 end
 
 @generated function _dim(::Val{base}, ::Val{off}, ::Val{range}, ::Type{T}) where {base, off, range, T}
-    T_int8 = LLVM.Int8Type(JuliaContext())
-    T_int32 = LLVM.Int32Type(JuliaContext())
-    _as = convert(Int, AS.Constant)
-    T_ptr_i8 = LLVM.PointerType(T_int8, _as)
-    T_ptr_i32 = LLVM.PointerType(T_int32, _as)
-    T_ptr_T = LLVM.PointerType(convert(LLVMType, T), _as)
-
-    # create function
-    llvm_f, _ = create_function(T_int32)
-    mod = LLVM.parent(llvm_f)
-
-    # generate IR
-    Builder(JuliaContext()) do builder
-        entry = BasicBlock(llvm_f, "entry", JuliaContext())
-        position!(builder, entry)
-
-        # get the kernel dispatch pointer
-        intr_typ = LLVM.FunctionType(T_ptr_i8)
-        intr = LLVM.Function(mod, "llvm.amdgcn.dispatch.ptr", intr_typ)
-        ptr = call!(builder, intr)
-
-        # load the index
-        offset = base+((off-1)*sizeof(T))
-        idx_ptr_i8 = inbounds_gep!(builder, ptr, [ConstantInt(offset,JuliaContext())])
-        idx_ptr_T = bitcast!(builder, idx_ptr_i8, T_ptr_T)
-        idx_T = load!(builder, idx_ptr_T)
-        idx = zext!(builder, idx_T, T_int32)
-
-        # attach range metadata
-        range_metadata = MDNode([ConstantInt(T(range.start), JuliaContext()),
-                                 ConstantInt(T(range.stop), JuliaContext())],
-                                JuliaContext())
-        metadata(idx_T)[LLVM.MD_range] = range_metadata
-        ret!(builder, idx)
+    JuliaContext() do ctx
+        T_int8 = LLVM.Int8Type(ctx)
+        T_int32 = LLVM.Int32Type(ctx)
+        _as = convert(Int, AS.Constant)
+        T_ptr_i8 = LLVM.PointerType(T_int8, _as)
+        T_ptr_i32 = LLVM.PointerType(T_int32, _as)
+        T_ptr_T = LLVM.PointerType(convert(LLVMType, T, ctx), _as)
+
+        # create function
+        llvm_f, _ = create_function(T_int32)
+        mod = LLVM.parent(llvm_f)
+
+        # generate IR
+        Builder(ctx) do builder
+            entry = BasicBlock(llvm_f, "entry", ctx)
+            position!(builder, entry)
+
+            # get the kernel dispatch pointer
+            intr_typ = LLVM.FunctionType(T_ptr_i8)
+            intr = LLVM.Function(mod, "llvm.amdgcn.dispatch.ptr", intr_typ)
+            ptr = call!(builder, intr)
+
+            # load the index
+            offset = base+((off-1)*sizeof(T))
+            idx_ptr_i8 = inbounds_gep!(builder, ptr, [ConstantInt(offset,ctx)])
+            idx_ptr_T = bitcast!(builder, idx_ptr_i8, T_ptr_T)
+            idx_T = load!(builder, idx_ptr_T)
+            idx = zext!(builder, idx_T, T_int32)
+
+            # attach range metadata
+            range_metadata = MDNode([ConstantInt(T(range.start), ctx),
+                                     ConstantInt(T(range.stop), ctx)],
+                                    ctx)
+            metadata(idx_T)[LLVM.MD_range] = range_metadata
+            ret!(builder, idx)
+        end
+
+        call_function(llvm_f, UInt32)
     end
-
-    call_function(llvm_f, UInt32)
 end
 
 # TODO: look these up for the current agent/queue
diff --git a/src/device/gcn/math.jl b/src/device/gcn/math.jl
index e05311ead..62cbdc2fe 100644
--- a/src/device/gcn/math.jl
+++ b/src/device/gcn/math.jl
@@ -1,26 +1,28 @@
 @generated function _intr(::Val{fname}, out_arg, inp_args...) where {fname,}
-    inp_exprs = [:( inp_args[$i] ) for i in 1:length(inp_args)]
-    inp_types = [inp_args...]
-    out_type = convert(LLVMType, out_arg.parameters[1])
+    JuliaContext() do ctx
+        inp_exprs = [:( inp_args[$i] ) for i in 1:length(inp_args)]
+        inp_types = [inp_args...]
+        out_type = convert(LLVMType, out_arg.parameters[1], ctx)
 
-    # create function
-    param_types = LLVMType[convert.(LLVMType, inp_types)...]
-    llvm_f, _ = create_function(out_type, param_types)
-    mod = LLVM.parent(llvm_f)
+        # create function
+        param_types = LLVMType[convert.(LLVMType, inp_types, Ref(ctx))...]
+        llvm_f, _ = create_function(out_type, param_types)
+        mod = LLVM.parent(llvm_f)
 
-    # generate IR
-    Builder(JuliaContext()) do builder
-        entry = BasicBlock(llvm_f, "entry", JuliaContext())
-        position!(builder, entry)
+        # generate IR
+        Builder(ctx) do builder
+            entry = BasicBlock(llvm_f, "entry", ctx)
+            position!(builder, entry)
 
-        # call the intrinsic
-        intr_typ = LLVM.FunctionType(out_type, param_types)
-        intr = LLVM.Function(mod, string(fname), intr_typ)
-        value = call!(builder, intr, [parameters(llvm_f)...])
-        ret!(builder, value)
-    end
+            # call the intrinsic
+            intr_typ = LLVM.FunctionType(out_type, param_types)
+            intr = LLVM.Function(mod, string(fname), intr_typ)
+            value = call!(builder, intr, [parameters(llvm_f)...])
+            ret!(builder, value)
+        end
 
-    call_function(llvm_f, out_arg.parameters[1], Tuple{inp_args...}, Expr(:tuple, inp_exprs...))
+        call_function(llvm_f, out_arg.parameters[1], Tuple{inp_args...}, Expr(:tuple, inp_exprs...))
+    end
 end
 
 struct GCNIntrinsic
diff --git a/src/device/gcn/memory_static.jl b/src/device/gcn/memory_static.jl
index 0769b7730..f66036151 100644
--- a/src/device/gcn/memory_static.jl
+++ b/src/device/gcn/memory_static.jl
@@ -2,119 +2,127 @@ export alloc_special, alloc_local
 
 "Allocates on-device memory statically from the specified address space."
 @generated function alloc_special(::Val{id}, ::Type{T}, ::Val{as}, ::Val{len}) where {id,T,as,len}
-    eltyp = convert(LLVMType, T)
+    JuliaContext() do ctx
+        eltyp = convert(LLVMType, T, ctx)
 
-    # old versions of GPUArrays invoke _shmem with an integer id; make sure those are unique
-    if !isa(id, String) || !isa(id, Symbol)
-        id = "alloc_special_$id"
-    end
+        # old versions of GPUArrays invoke _shmem with an integer id; make sure those are unique
+        if !isa(id, String) || !isa(id, Symbol)
+            id = "alloc_special_$id"
+        end
 
-    T_ptr = convert(LLVMType, DevicePtr{T,as})
+        T_ptr = convert(LLVMType, DevicePtr{T,as}, ctx)
 
-    # create a function
-    llvm_f, _ = create_function(T_ptr)
+        # create a function
+        llvm_f, _ = create_function(T_ptr)
 
-    # create the global variable
-    mod = LLVM.parent(llvm_f)
-    gv_typ = LLVM.ArrayType(eltyp, len)
-    gv = GlobalVariable(mod, gv_typ, string(id), convert(Int, as))
-    if len > 0
-        linkage!(gv, LLVM.API.LLVMInternalLinkage)
-        #initializer!(gv, null(gv_typ))
-    end
+        # create the global variable
+        mod = LLVM.parent(llvm_f)
+        gv_typ = LLVM.ArrayType(eltyp, len)
+        gv = GlobalVariable(mod, gv_typ, string(id), convert(Int, as))
+        if len > 0
+            linkage!(gv, LLVM.API.LLVMInternalLinkage)
+            #initializer!(gv, null(gv_typ))
+        end
 
-    # by requesting a larger-than-datatype alignment, we might be able to vectorize.
-    # TODO: Make the alignment configurable
-    alignment!(gv, Base.max(32, Base.datatype_alignment(T)))
+        # by requesting a larger-than-datatype alignment, we might be able to vectorize.
+        # TODO: Make the alignment configurable
+        alignment!(gv, Base.max(32, Base.datatype_alignment(T)))
 
-    # generate IR
-    Builder(JuliaContext()) do builder
-        entry = BasicBlock(llvm_f, "entry", JuliaContext())
-        position!(builder, entry)
+        # generate IR
+        Builder(ctx) do builder
+            entry = BasicBlock(llvm_f, "entry", ctx)
+            position!(builder, entry)
 
-        ptr_with_as = gep!(builder, gv, [ConstantInt(0, JuliaContext()),
-                                         ConstantInt(0, JuliaContext())])
+            ptr_with_as = gep!(builder, gv, [ConstantInt(0, ctx),
+                                             ConstantInt(0, ctx)])
 
-        val = ptrtoint!(builder, ptr_with_as, T_ptr)
-        ret!(builder, val)
-    end
+            val = ptrtoint!(builder, ptr_with_as, T_ptr)
+            ret!(builder, val)
+        end
 
-    call_function(llvm_f, DevicePtr{T,as})
+        call_function(llvm_f, DevicePtr{T,as})
+    end
 end
 
 @inline alloc_local(id, T, len) = alloc_special(Val(id), Val(T), Val(AS.Local), Val(len))
 
 @inline @generated function alloc_string(::Val{str}) where str
-    T_pint8_generic = LLVM.PointerType(LLVM.Int8Type(JuliaContext()), convert(Int, AS.Generic))
-    llvm_f, _ = create_function(LLVM.Int64Type(JuliaContext()))
-    Builder(JuliaContext()) do builder
-        entry = BasicBlock(llvm_f, "entry", JuliaContext())
-        position!(builder, entry)
-        str_ptr = globalstring_ptr!(builder, String(str))
-        str_ptr_i64 = ptrtoint!(builder, str_ptr, LLVM.Int64Type(JuliaContext()))
-        ret!(builder, str_ptr_i64)
+    JuliaContext() do ctx
+        T_pint8_generic = LLVM.PointerType(LLVM.Int8Type(ctx), convert(Int, AS.Generic))
+        llvm_f, _ = create_function(LLVM.Int64Type(ctx))
+        Builder(ctx) do builder
+            entry = BasicBlock(llvm_f, "entry", ctx)
+            position!(builder, entry)
+            str_ptr = globalstring_ptr!(builder, String(str))
+            str_ptr_i64 = ptrtoint!(builder, str_ptr, LLVM.Int64Type(ctx))
+            ret!(builder, str_ptr_i64)
+        end
+        call_function(llvm_f, DevicePtr{UInt8,AS.Generic})
     end
-    call_function(llvm_f, DevicePtr{UInt8,AS.Generic})
 end
 
 # TODO: Support various types of len
 @inline @generated function memcpy!(dest_ptr::DevicePtr{UInt8,DestAS}, src_ptr::DevicePtr{UInt8,SrcAS}, len::LT) where {DestAS,SrcAS,LT<:Union{Int64,UInt64}}
-    T_nothing = LLVM.VoidType(JuliaContext())
-    dest_as = convert(Int, DestAS)
-    src_as = convert(Int, SrcAS)
-    T_int8 = LLVM.Int8Type(JuliaContext())
-    T_int64 = LLVM.Int64Type(JuliaContext())
-    T_pint8_dest = LLVM.PointerType(T_int8, dest_as)
-    T_pint64_dest = LLVM.PointerType(T_int64, dest_as)
-    T_pint8_src = LLVM.PointerType(T_int8, src_as)
-    T_pint64_src = LLVM.PointerType(T_int64, src_as)
-    T_int1 = LLVM.Int1Type(JuliaContext())
-
-    llvm_f, _ = create_function(T_nothing, [T_int64, T_int64, T_int64])
-    mod = LLVM.parent(llvm_f)
-    T_intr = LLVM.FunctionType(T_nothing, [T_pint8_dest, T_pint8_src, T_int64, T_int1])
-    intr = LLVM.Function(mod, "llvm.memcpy.p$(dest_as)i8.p$(src_as)i8.i64", T_intr)
-    Builder(JuliaContext()) do builder
-        entry = BasicBlock(llvm_f, "entry", JuliaContext())
-        position!(builder, entry)
-
-        dest_ptr_i64 = inttoptr!(builder, parameters(llvm_f)[1], T_pint64_dest)
-        dest_ptr_i8 = bitcast!(builder, dest_ptr_i64, T_pint8_dest)
-
-        src_ptr_i64 = inttoptr!(builder, parameters(llvm_f)[2], T_pint64_src)
-        src_ptr_i8 = bitcast!(builder, src_ptr_i64, T_pint8_src)
-
-        call!(builder, intr, [dest_ptr_i8, src_ptr_i8, parameters(llvm_f)[3], ConstantInt(T_int1, 0)])
-        ret!(builder)
+    JuliaContext() do ctx
+        T_nothing = LLVM.VoidType(ctx)
+        dest_as = convert(Int, DestAS)
+        src_as = convert(Int, SrcAS)
+        T_int8 = LLVM.Int8Type(ctx)
+        T_int64 = LLVM.Int64Type(ctx)
+        T_pint8_dest = LLVM.PointerType(T_int8, dest_as)
+        T_pint64_dest = LLVM.PointerType(T_int64, dest_as)
+        T_pint8_src = LLVM.PointerType(T_int8, src_as)
+        T_pint64_src = LLVM.PointerType(T_int64, src_as)
+        T_int1 = LLVM.Int1Type(ctx)
+
+        llvm_f, _ = create_function(T_nothing, [T_int64, T_int64, T_int64])
+        mod = LLVM.parent(llvm_f)
+        T_intr = LLVM.FunctionType(T_nothing, [T_pint8_dest, T_pint8_src, T_int64, T_int1])
+        intr = LLVM.Function(mod, "llvm.memcpy.p$(dest_as)i8.p$(src_as)i8.i64", T_intr)
+        Builder(ctx) do builder
+            entry = BasicBlock(llvm_f, "entry", ctx)
+            position!(builder, entry)
+
+            dest_ptr_i64 = inttoptr!(builder, parameters(llvm_f)[1], T_pint64_dest)
+            dest_ptr_i8 = bitcast!(builder, dest_ptr_i64, T_pint8_dest)
+
+            src_ptr_i64 = inttoptr!(builder, parameters(llvm_f)[2], T_pint64_src)
+            src_ptr_i8 = bitcast!(builder, src_ptr_i64, T_pint8_src)
+
+            call!(builder, intr, [dest_ptr_i8, src_ptr_i8, parameters(llvm_f)[3], ConstantInt(T_int1, 0)])
+            ret!(builder)
+        end
+        call_function(llvm_f, Nothing, Tuple{DevicePtr{UInt8,DestAS},DevicePtr{UInt8,SrcAS},LT}, :((dest_ptr, src_ptr, len)))
     end
-    call_function(llvm_f, Nothing, Tuple{DevicePtr{UInt8,DestAS},DevicePtr{UInt8,SrcAS},LT}, :((dest_ptr, src_ptr, len)))
 end
 memcpy!(dest_ptr::DevicePtr{T,DestAS}, src_ptr::DevicePtr{T,SrcAS}, len::Integer) where {T,DestAS,SrcAS} =
     memcpy!(convert(DevicePtr{UInt8,DestAS}, dest_ptr), convert(DevicePtr{UInt8,SrcAS}, src_ptr), UInt64(len))
 @inline @generated function memset!(dest_ptr::DevicePtr{UInt8,DestAS}, value::UInt8, len::LT) where {DestAS,LT<:Union{Int64,UInt64}}
-    T_nothing = LLVM.VoidType(JuliaContext())
-    dest_as = convert(Int, DestAS)
-    T_int8 = LLVM.Int8Type(JuliaContext())
-    T_int64 = LLVM.Int64Type(JuliaContext())
-    T_pint8_dest = LLVM.PointerType(T_int8, dest_as)
-    T_pint64_dest = LLVM.PointerType(T_int64, dest_as)
-    T_int1 = LLVM.Int1Type(JuliaContext())
-
-    llvm_f, _ = create_function(T_nothing, [T_int64, T_int8, T_int64])
-    mod = LLVM.parent(llvm_f)
-    T_intr = LLVM.FunctionType(T_nothing, [T_pint8_dest, T_int8, T_int64, T_int1])
-    intr = LLVM.Function(mod, "llvm.memset.p$(dest_as)i8.i64", T_intr)
-    Builder(JuliaContext()) do builder
-        entry = BasicBlock(llvm_f, "entry", JuliaContext())
-        position!(builder, entry)
-
-        dest_ptr_i64 = inttoptr!(builder, parameters(llvm_f)[1], T_pint64_dest)
-        dest_ptr_i8 = bitcast!(builder, dest_ptr_i64, T_pint8_dest)
-
-        call!(builder, intr, [dest_ptr_i8, parameters(llvm_f)[2], parameters(llvm_f)[3], ConstantInt(T_int1, 0)])
-        ret!(builder)
+    JuliaContext() do ctx
+        T_nothing = LLVM.VoidType(ctx)
+        dest_as = convert(Int, DestAS)
+        T_int8 = LLVM.Int8Type(ctx)
+        T_int64 = LLVM.Int64Type(ctx)
+        T_pint8_dest = LLVM.PointerType(T_int8, dest_as)
+        T_pint64_dest = LLVM.PointerType(T_int64, dest_as)
+        T_int1 = LLVM.Int1Type(ctx)
+
+        llvm_f, _ = create_function(T_nothing, [T_int64, T_int8, T_int64])
+        mod = LLVM.parent(llvm_f)
+        T_intr = LLVM.FunctionType(T_nothing, [T_pint8_dest, T_int8, T_int64, T_int1])
+        intr = LLVM.Function(mod, "llvm.memset.p$(dest_as)i8.i64", T_intr)
+        Builder(ctx) do builder
+            entry = BasicBlock(llvm_f, "entry", ctx)
+            position!(builder, entry)
+
+            dest_ptr_i64 = inttoptr!(builder, parameters(llvm_f)[1], T_pint64_dest)
+            dest_ptr_i8 = bitcast!(builder, dest_ptr_i64, T_pint8_dest)
+
+            call!(builder, intr, [dest_ptr_i8, parameters(llvm_f)[2], parameters(llvm_f)[3], ConstantInt(T_int1, 0)])
+            ret!(builder)
+        end
+        call_function(llvm_f, Nothing, Tuple{DevicePtr{UInt8,DestAS},UInt8,LT}, :((dest_ptr, value, len)))
     end
-    call_function(llvm_f, Nothing, Tuple{DevicePtr{UInt8,DestAS},UInt8,LT}, :((dest_ptr, value, len)))
 end
 memset!(dest_ptr::DevicePtr{T,DestAS}, value::UInt8, len::Integer) where {T,DestAS} =
     memset!(convert(DevicePtr{UInt8,DestAS}, dest_ptr), value, UInt64(len))
diff --git a/src/device/globals.jl b/src/device/globals.jl
index cf13a04a7..ca52a9ed8 100644
--- a/src/device/globals.jl
+++ b/src/device/globals.jl
@@ -4,39 +4,41 @@
 # does not exist yet, then it is declared in the global memory address
 # space.
 @generated function get_global_pointer(::Val{global_name}, ::Type{T})::AMDGPU.DevicePtr{T} where {global_name, T}
-    T_global = convert(LLVMType, T)
-    T_result = convert(LLVMType, Ptr{T})
+    JuliaContext() do ctx
+        T_global = convert(LLVMType, T, ctx)
+        T_result = convert(LLVMType, Ptr{T}, ctx)
 
-    # Create a thunk that computes a pointer to the global.
-    llvm_f, _ = create_function(T_result)
-    mod = LLVM.parent(llvm_f)
+        # Create a thunk that computes a pointer to the global.
+        llvm_f, _ = create_function(T_result)
+        mod = LLVM.parent(llvm_f)
 
-    # Figure out if the global has been defined already.
-    global_set = LLVM.globals(mod)
-    global_name_string = String(global_name)
-    if haskey(global_set, global_name_string)
-        global_var = global_set[global_name_string]
-    else
-        # If the global hasn't been defined already, then we'll define
-        # it in the global address space, i.e., address space one.
-        global_var = GlobalVariable(mod, T_global, global_name_string, 1)
-        linkage!(global_var, LLVM.API.LLVMExternalLinkage)
-        extinit!(global_var, true)
-        set_used!(mod, global_var)
-    end
+        # Figure out if the global has been defined already.
+        global_set = LLVM.globals(mod)
+        global_name_string = String(global_name)
+        if haskey(global_set, global_name_string)
+            global_var = global_set[global_name_string]
+        else
+            # If the global hasn't been defined already, then we'll define
+            # it in the global address space, i.e., address space one.
+            global_var = GlobalVariable(mod, T_global, global_name_string, 1)
+            linkage!(global_var, LLVM.API.LLVMExternalLinkage)
+            extinit!(global_var, true)
+            set_used!(mod, global_var)
+        end
 
-    # Generate IR that computes the global's address.
-    Builder(JuliaContext()) do builder
-        entry = BasicBlock(llvm_f, "entry", JuliaContext())
-        position!(builder, entry)
+        # Generate IR that computes the global's address.
+        Builder(ctx) do builder
+            entry = BasicBlock(llvm_f, "entry", ctx)
+            position!(builder, entry)
 
-        # Cast the global variable's type to the result type.
-        result = ptrtoint!(builder, global_var, T_result)
-        ret!(builder, result)
-    end
+            # Cast the global variable's type to the result type.
+            result = ptrtoint!(builder, global_var, T_result)
+            ret!(builder, result)
+        end
 
-    # Call the function.
-    quote
-        AMDGPU.DevicePtr{T, AMDGPU.AS.Global}(convert(Csize_t, $(call_function(llvm_f, Ptr{T}))))
+        # Call the function.
+        quote
+            AMDGPU.DevicePtr{T, AMDGPU.AS.Global}(convert(Csize_t, $(call_function(llvm_f, Ptr{T}))))
+        end
     end
 end
diff --git a/src/device/pointer.jl b/src/device/pointer.jl
index 1371f42a3..7b76dbacc 100644
--- a/src/device/pointer.jl
+++ b/src/device/pointer.jl
@@ -114,69 +114,72 @@ function tbaa_make_child(name::String, constant::Bool=false; ctx::LLVM.Context=J
     return tbaa_access_tag
 end
 
-tbaa_addrspace(as::Type{<:AddressSpace}) = tbaa_make_child(lowercase(String(as.name.name)))
+tbaa_addrspace(as::Type{<:AddressSpace}, ctx) = tbaa_make_child(lowercase(String(as.name.name)); ctx=ctx)
 
 @generated function Base.unsafe_load(p::DevicePtr{T,A}, i::Integer=1,
                                      ::Val{align}=Val(1)) where {T,A,align}
-    eltyp = convert(LLVMType, T)
-    T_int = convert(LLVMType, Int)
-    T_ptr = convert(LLVMType, DevicePtr{T,A})
-    T_actual_ptr = LLVM.PointerType(eltyp, convert(Int, A))
-
-    # create a function
-    param_types = [T_ptr, T_int]
-    llvm_f, _ = create_function(eltyp, param_types)
-
-    # generate IR
-    Builder(JuliaContext()) do builder
-        entry = BasicBlock(llvm_f, "entry", JuliaContext())
-        position!(builder, entry)
-
-        ptr = inttoptr!(builder, parameters(llvm_f)[1], T_actual_ptr)
-        ptr = gep!(builder, ptr, [parameters(llvm_f)[2]])
-        ld = load!(builder, ptr)
-
-        if A != AS.Generic
-            metadata(ld)[LLVM.MD_tbaa] = tbaa_addrspace(A)
+    JuliaContext() do ctx
+        eltyp = convert(LLVMType, T, ctx)
+        T_int = convert(LLVMType, Int, ctx)
+        T_ptr = convert(LLVMType, DevicePtr{T,A}, ctx)
+        T_actual_ptr = LLVM.PointerType(eltyp, convert(Int, A))
+
+        # create a function
+        param_types = [T_ptr, T_int]
+        llvm_f, _ = create_function(eltyp, param_types)
+
+        # generate IR
+        Builder(ctx) do builder
+            entry = BasicBlock(llvm_f, "entry", ctx)
+            position!(builder, entry)
+
+            ptr = inttoptr!(builder, parameters(llvm_f)[1], T_actual_ptr)
+            ptr = gep!(builder, ptr, [parameters(llvm_f)[2]])
+            ld = load!(builder, ptr)
+
+            if A != AS.Generic
+                metadata(ld)[LLVM.MD_tbaa] = tbaa_addrspace(A, ctx)
+            end
+
+            alignment!(ld, align)
+            ret!(builder, ld)
         end
 
-        alignment!(ld, align)
-        ret!(builder, ld)
+        call_function(llvm_f, T, Tuple{DevicePtr{T,A}, Int}, :((p, Int(i-one(i)))))
     end
-
-    call_function(llvm_f, T, Tuple{DevicePtr{T,A}, Int}, :((p, Int(i-one(i)))))
 end
 
 @generated function Base.unsafe_store!(p::DevicePtr{T,A}, x, i::Integer=1,
                                        ::Val{align}=Val(1)) where {T,A,align}
-    eltyp = convert(LLVMType, T)
-    T_int = convert(LLVMType, Int)
-    T_ptr = convert(LLVMType, DevicePtr{T,A})
-    T_actual_ptr = LLVM.PointerType(eltyp, convert(Int, A))
-
-    # create a function
-    param_types = [T_ptr, eltyp, T_int]
-    llvm_f, _ = create_function(LLVM.VoidType(JuliaContext()), param_types)
-
-    # generate IR
-    Builder(JuliaContext()) do builder
-        entry = BasicBlock(llvm_f, "entry", JuliaContext())
-        position!(builder, entry)
-
-        ptr = inttoptr!(builder, parameters(llvm_f)[1], T_actual_ptr)
-        ptr = gep!(builder, ptr, [parameters(llvm_f)[3]])
-        val = parameters(llvm_f)[2]
-        st = store!(builder, val, ptr)
-
-        if A != AS.Generic
-            metadata(st)[LLVM.MD_tbaa] = tbaa_addrspace(A)
+    JuliaContext() do ctx
+        eltyp = convert(LLVMType, T, ctx)
+        T_int = convert(LLVMType, Int, ctx)
+        T_ptr = convert(LLVMType, DevicePtr{T,A}, ctx)
+        T_actual_ptr = LLVM.PointerType(eltyp, convert(Int, A))
+
+        # create a function
+        param_types = [T_ptr, eltyp, T_int]
+        llvm_f, _ = create_function(LLVM.VoidType(ctx), param_types)
+
+        # generate IR
+        Builder(ctx) do builder
+            entry = BasicBlock(llvm_f, "entry", ctx)
+            position!(builder, entry)
+
+            ptr = inttoptr!(builder, parameters(llvm_f)[1], T_actual_ptr)
+            ptr = gep!(builder, ptr, [parameters(llvm_f)[3]])
+            val = parameters(llvm_f)[2]
+            st = store!(builder, val, ptr)
+
+            if A != AS.Generic
+                metadata(st)[LLVM.MD_tbaa] = tbaa_addrspace(A, ctx)
+            end
+
+            alignment!(st, align)
+            ret!(builder)
         end
 
-        alignment!(st, align)
-        ret!(builder)
+        call_function(llvm_f, Cvoid, Tuple{DevicePtr{T,A}, T, Int},
+                      :((p, convert(T,x), Int(i-one(i)))))
     end
-
-    call_function(llvm_f, Cvoid, Tuple{DevicePtr{T,A}, T, Int},
-                  :((p, convert(T,x), Int(i-one(i)))))
 end
-
diff --git a/src/device/runtime.jl b/src/device/runtime.jl
index 84abcd6f2..6385aa5c9 100644
--- a/src/device/runtime.jl
+++ b/src/device/runtime.jl
@@ -92,16 +92,18 @@ function load_device_libs(dev_isa)
         "ocml.amdgcn.bc",
     )
 
-    for file in bitcode_files
-        ispath(joinpath(device_libs_path, file)) || continue
-        name, ext = splitext(file)
-        lib = get!(libcache, name) do
-            file_path = joinpath(device_libs_path, file)
-            open(file_path) do io
-                parse(LLVM.Module, read(file_path), JuliaContext())
+    JuliaContext() do ctx
+        for file in bitcode_files
+            ispath(joinpath(device_libs_path, file)) || continue
+            name, ext = splitext(file)
+            lib = get!(libcache, name) do
+                file_path = joinpath(device_libs_path, file)
+                open(file_path) do io
+                    parse(LLVM.Module, read(file_path), ctx)
+                end
             end
+            push!(device_libs, lib)
         end
-        push!(device_libs, lib)
     end
 
     @assert !isempty(device_libs) "No device libs detected!"
@@ -114,7 +116,8 @@ function link_device_libs!(mod::LLVM.Module, dev_isa::String, undefined_fns)
     ufns = undefined_fns
     # TODO: only link if used
     # TODO: make these globally/locally configurable
-    link_oclc_defaults!(mod, dev_isa)
+    ctx = LLVM.context(mod)
+    link_oclc_defaults!(mod, dev_isa, ctx)
     for lib in libs
         # override libdevice's triple and datalayout to avoid warnings
         triple!(lib, triple(mod))
@@ -124,7 +127,7 @@ function link_device_libs!(mod::LLVM.Module, dev_isa::String, undefined_fns)
     GPUCompiler.link_library!(mod, libs)
 end
 
-function link_oclc_defaults!(mod::LLVM.Module, dev_isa::String; finite_only=false,
+function link_oclc_defaults!(mod::LLVM.Module, dev_isa::String, ctx; finite_only=false,
                              unsafe_math=false, correctly_rounded_sqrt=true, daz=false)
     # link in some defaults for OCLC knobs, to prevent undefined variable errors
     lib = LLVM.Module("OCLC")
@@ -138,9 +141,9 @@ function link_oclc_defaults!(mod::LLVM.Module, dev_isa::String; finite_only=fals
             "__oclc_unsafe_math_opt"=>Int32(unsafe_math),
             "__oclc_correctly_rounded_sqrt32"=>Int32(correctly_rounded_sqrt),
             "__oclc_daz_opt"=>Int32(daz))
-        gvtype = convert(LLVMType, typeof(value))
+        gvtype = convert(LLVMType, typeof(value), ctx)
         gv = GlobalVariable(lib, gvtype, name, 4)
-        init = ConstantInt(Int32(0), JuliaContext())
+        init = ConstantInt(Int32(0), ctx)
         initializer!(gv, init)
         unnamed_addr!(gv, true)
         constant!(gv, true)
diff --git a/src/device/tools.jl b/src/device/tools.jl
index df055bb24..a6d0fe824 100644
--- a/src/device/tools.jl
+++ b/src/device/tools.jl
@@ -144,24 +144,26 @@ end
 end
 
 @generated function extract_value(val, ::Type{sub}, ::Val{offset}) where {sub, offset}
-    T_val = convert(LLVMType, val)
-    T_sub = convert(LLVMType, sub)
-    bytes = Core.sizeof(val)
-    T_int = LLVM.IntType(8*bytes, JuliaContext())
-
-    # create function
-    llvm_f, _ = create_function(T_sub, [T_val])
-    mod = LLVM.parent(llvm_f)
-
-    # generate IR
-    Builder(JuliaContext()) do builder
-        entry = BasicBlock(llvm_f, "entry", JuliaContext())
-        position!(builder, entry)
-        equiv = bitcast!(builder, parameters(llvm_f)[1], T_int)
-        shifted = lshr!(builder, equiv, LLVM.ConstantInt(T_int, offset))
-        # extracted = and!(builder, shifted, 2^32-1)
-        extracted = trunc!(builder, shifted, T_sub)
-        ret!(builder, extracted)
+    JuliaContext() do ctx
+        T_val = convert(LLVMType, val, ctx)
+        T_sub = convert(LLVMType, sub, ctx)
+        bytes = Core.sizeof(val)
+        T_int = LLVM.IntType(8*bytes, ctx)
+
+        # create function
+        llvm_f, _ = create_function(T_sub, [T_val])
+        mod = LLVM.parent(llvm_f)
+
+        # generate IR
+        Builder(ctx) do builder
+            entry = BasicBlock(llvm_f, "entry", ctx)
+            position!(builder, entry)
+            equiv = bitcast!(builder, parameters(llvm_f)[1], T_int)
+            shifted = lshr!(builder, equiv, LLVM.ConstantInt(T_int, offset))
+            # extracted = and!(builder, shifted, 2^32-1)
+            extracted = trunc!(builder, shifted, T_sub)
+            ret!(builder, extracted)
+        end
     end
 
     call_function(llvm_f, UInt32, Tuple{val}, :( (val,) ))
@@ -173,25 +175,27 @@ end
 end
 
 @generated function insert_value(val, sub, ::Val{offset}) where {offset}
-    T_val = convert(LLVMType, val)
-    T_sub = convert(LLVMType, sub)
-    bytes = Core.sizeof(val)
-    T_out_int = LLVM.IntType(8*bytes, JuliaContext())
-
-    # create function
-    llvm_f, _ = create_function(T_val, [T_val, T_sub])
-    mod = LLVM.parent(llvm_f)
-
-    # generate IR
-    Builder(JuliaContext()) do builder
-        entry = BasicBlock(llvm_f, "entry", JuliaContext())
-        position!(builder, entry)
-        equiv = bitcast!(builder, parameters(llvm_f)[1], T_out_int)
-        ext = zext!(builder, parameters(llvm_f)[2], T_out_int)
-        shifted = shl!(builder, ext, LLVM.ConstantInt(T_out_int, offset))
-        inserted = or!(builder, equiv, shifted)
-        orig = bitcast!(builder, inserted, T_val)
-        ret!(builder, orig)
+    JuliaContext() do ctx
+        T_val = convert(LLVMType, val, ctx)
+        T_sub = convert(LLVMType, sub, ctx)
+        bytes = Core.sizeof(val)
+        T_out_int = LLVM.IntType(8*bytes, ctx)
+
+        # create function
+        llvm_f, _ = create_function(T_val, [T_val, T_sub])
+        mod = LLVM.parent(llvm_f)
+
+        # generate IR
+        Builder(ctx) do builder
+            entry = BasicBlock(llvm_f, "entry", ctx)
+            position!(builder, entry)
+            equiv = bitcast!(builder, parameters(llvm_f)[1], T_out_int)
+            ext = zext!(builder, parameters(llvm_f)[2], T_out_int)
+            shifted = shl!(builder, ext, LLVM.ConstantInt(T_out_int, offset))
+            inserted = or!(builder, equiv, shifted)
+            orig = bitcast!(builder, inserted, T_val)
+            ret!(builder, orig)
+        end
     end
 
     call_function(llvm_f, val, Tuple{val, sub}, :( (val, sub) ))
@@ -338,34 +342,36 @@ llvmsize(ty::LLVM.ArrayType) = length(ty)*llvmsize(eltype(ty))
 llvmsize(ty) = error("Unknown size for type: $ty, typeof: $(typeof(ty))")
 
 @generated function string_length(ex)
-    T_ex = convert(LLVMType, ex)
-    T_ex_ptr = LLVM.PointerType(T_ex)
-    T_i8_ptr = LLVM.PointerType(LLVM.Int8Type(JuliaContext()))
-    T_i64 = LLVM.Int64Type(JuliaContext())
-    llvm_f, _ = create_function(T_i64, [T_ex])
-    mod = LLVM.parent(llvm_f)
-    Builder(JuliaContext()) do builder
-        entry = BasicBlock(llvm_f, "entry", JuliaContext())
-        check = BasicBlock(llvm_f, "check", JuliaContext())
-        done = BasicBlock(llvm_f, "done", JuliaContext())
-
-        position!(builder, entry)
-        init_offset = ConstantInt(0, JuliaContext())
-        input_ptr = inttoptr!(builder, parameters(llvm_f)[1], T_ex_ptr)
-        input_ptr = bitcast!(builder, input_ptr, T_i8_ptr)
-        br!(builder, check)
-
-        position!(builder, check)
-        offset = phi!(builder, T_i64)
-        next_offset = add!(builder, offset, ConstantInt(1, JuliaContext()))
-        append!(LLVM.incoming(offset), [(init_offset, entry), (next_offset, check)])
-        ptr = gep!(builder, input_ptr, [offset])
-        value = load!(builder, ptr)
-        cond = icmp!(builder, LLVM.API.LLVMIntEQ, value, ConstantInt(0x0, JuliaContext()))
-        br!(builder, cond, done, check)
-
-        position!(builder, done)
-        ret!(builder, offset)
+    JuliaContext() do ctx
+        T_ex = convert(LLVMType, ex, ctx)
+        T_ex_ptr = LLVM.PointerType(T_ex)
+        T_i8_ptr = LLVM.PointerType(LLVM.Int8Type(ctx))
+        T_i64 = LLVM.Int64Type(ctx)
+        llvm_f, _ = create_function(T_i64, [T_ex])
+        mod = LLVM.parent(llvm_f)
+        Builder(ctx) do builder
+            entry = BasicBlock(llvm_f, "entry", ctx)
+            check = BasicBlock(llvm_f, "check", ctx)
+            done = BasicBlock(llvm_f, "done", ctx)
+
+            position!(builder, entry)
+            init_offset = ConstantInt(0, ctx)
+            input_ptr = inttoptr!(builder, parameters(llvm_f)[1], T_ex_ptr)
+            input_ptr = bitcast!(builder, input_ptr, T_i8_ptr)
+            br!(builder, check)
+
+            position!(builder, check)
+            offset = phi!(builder, T_i64)
+            next_offset = add!(builder, offset, ConstantInt(1, ctx))
+            append!(LLVM.incoming(offset), [(init_offset, entry), (next_offset, check)])
+            ptr = gep!(builder, input_ptr, [offset])
+            value = load!(builder, ptr)
+            cond = icmp!(builder, LLVM.API.LLVMIntEQ, value, ConstantInt(0x0, ctx))
+            br!(builder, cond, done, check)
+
+            position!(builder, done)
+            ret!(builder, offset)
+        end
+        call_function(llvm_f, Csize_t, Tuple{ex}, :((ex,)))
     end
-    return call_function(llvm_f, Csize_t, Tuple{ex}, :((ex,)))
 end
diff --git a/src/exceptions.jl b/src/exceptions.jl
index 3cff70300..b8f7fb4c2 100644
--- a/src/exceptions.jl
+++ b/src/exceptions.jl
@@ -31,27 +31,28 @@ ExceptionEntry() = ExceptionEntry(0)
 function emit_exception_user!(mod::LLVM.Module)
     # add a fake user for __ockl_hsa_signal_store and __ockl_hsa_signal_load
     if !haskey(LLVM.functions(mod), "__fake_global_exception_flag_user")
-        ctx = JuliaContext()
-        ft = LLVM.FunctionType(LLVM.VoidType(ctx))
-        fn = LLVM.Function(mod, "__fake_global_exception_flag_user", ft)
-        Builder(ctx) do builder
-            entry = BasicBlock(fn, "entry", ctx)
-            position!(builder, entry)
-            T_nothing = LLVM.VoidType(ctx)
-            T_i32 = LLVM.Int32Type(ctx)
-            T_i64 = LLVM.Int64Type(ctx)
-            T_signal_store = LLVM.FunctionType(T_nothing, [T_i64, T_i64, T_i32])
-            signal_store = LLVM.Function(mod, "__ockl_hsa_signal_store", T_signal_store)
-            call!(builder, signal_store, [ConstantInt(0,ctx),
-                                          ConstantInt(0,ctx),
-                                          # __ATOMIC_RELEASE == 3
-                                          ConstantInt(Int32(3), JuliaContext())])
-            T_signal_load = LLVM.FunctionType(T_i64, [T_i64, T_i32])
-            signal_load = LLVM.Function(mod, "__ockl_hsa_signal_load", T_signal_load)
-            loaded_value = call!(builder, signal_load, [ConstantInt(0,ctx),
-                                                        # __ATOMIC_ACQUIRE == 2
-                                                        ConstantInt(Int32(2), JuliaContext())])
-            ret!(builder)
+        JuliaContext() do ctx
+            ft = LLVM.FunctionType(LLVM.VoidType(ctx))
+            fn = LLVM.Function(mod, "__fake_global_exception_flag_user", ft)
+            Builder(ctx) do builder
+                entry = BasicBlock(fn, "entry", ctx)
+                position!(builder, entry)
+                T_nothing = LLVM.VoidType(ctx)
+                T_i32 = LLVM.Int32Type(ctx)
+                T_i64 = LLVM.Int64Type(ctx)
+                T_signal_store = LLVM.FunctionType(T_nothing, [T_i64, T_i64, T_i32])
+                signal_store = LLVM.Function(mod, "__ockl_hsa_signal_store", T_signal_store)
+                call!(builder, signal_store, [ConstantInt(0,ctx),
+                                              ConstantInt(0,ctx),
+                                              # __ATOMIC_RELEASE == 3
+                                              ConstantInt(Int32(3), ctx)])
+                T_signal_load = LLVM.FunctionType(T_i64, [T_i64, T_i32])
+                signal_load = LLVM.Function(mod, "__ockl_hsa_signal_load", T_signal_load)
+                loaded_value = call!(builder, signal_load, [ConstantInt(0,ctx),
+                                                            # __ATOMIC_ACQUIRE == 2
+                                                            ConstantInt(Int32(2), ctx)])
+                ret!(builder)
+            end
         end
     end
     @assert haskey(LLVM.functions(mod), "__fake_global_exception_flag_user")
diff --git a/test/hsa/memory.jl b/test/hsa/memory.jl
index 64b314ac9..f3ee95e98 100644
--- a/test/hsa/memory.jl
+++ b/test/hsa/memory.jl
@@ -64,13 +64,13 @@ end
     N = 1024
     a = rand(N)
     b = Mem.alloc(default_agent, N)
-    
+
     ptrinfo_host = Mem.pointerinfo(a)
     ptrinfo_hsa = Mem.pointerinfo(b)
 
     @test ptrinfo_host.type == HSA.POINTER_TYPE_UNKNOWN
     @test ptrinfo_hsa.type == HSA.POINTER_TYPE_HSA
-    @test ptrinfo_hsa.agentOwner.handle == default_agent.agent.handle
+    @test_skip ptrinfo_hsa.agentOwner.handle == default_agent.agent.handle
 
     Mem.free(b)
 end