Added support for linking against C global variables defined within Adept code from Adept code

Author: IsaacShelton

Diff for: src/llvm_backend/globals.rs

@@ -1,10 +1,11 @@
 use super::{backend_type::to_backend_type, ctx::BackendCtx, BackendError};
 use llvm_sys::{
     core::{
-        LLVMAddGlobal, LLVMGetUndef, LLVMSetExternallyInitialized, LLVMSetInitializer,
-        LLVMSetLinkage, LLVMSetThreadLocal,
+        LLVMAddGlobal, LLVMGetLinkage, LLVMGetNamedGlobal, LLVMGetThreadLocalMode, LLVMGetUndef,
+        LLVMIsExternallyInitialized, LLVMSetExternallyInitialized, LLVMSetInitializer,
+        LLVMSetLinkage, LLVMSetThreadLocalMode,
     },
-    LLVMLinkage,
+    LLVMLinkage, LLVMThreadLocalMode,
 };
 use std::ffi::CString;
 
@@ -13,9 +14,39 @@ pub unsafe fn create_globals(ctx: &mut BackendCtx) -> Result<(), BackendError> {
         let backend_type = to_backend_type(ctx.for_making_type(), &global.ir_type)?;
 
         let name = CString::new(global.mangled_name.as_bytes()).unwrap();
+        let existing = LLVMGetNamedGlobal(ctx.backend_module.get(), name.as_ptr());
+
+        if !existing.is_null() {
+            let existing_linkage = LLVMGetLinkage(existing);
+
+            if (global.exposure.is_exposed() || global.is_foreign)
+                && existing_linkage != LLVMLinkage::LLVMExternalLinkage
+            {
+                LLVMSetLinkage(existing, LLVMLinkage::LLVMExternalLinkage);
+            }
+
+            if global.is_thread_local
+                && LLVMGetThreadLocalMode(existing) == LLVMThreadLocalMode::LLVMNotThreadLocal
+            {
+                LLVMSetThreadLocalMode(existing, LLVMThreadLocalMode::LLVMGeneralDynamicTLSModel);
+            }
+
+            if LLVMIsExternallyInitialized(existing) == 0 && !global.is_foreign {
+                // In order to prevent aggressive optimizations from removing necessary internal global
+                // variables, we'll mark them as externally-initialized
+                LLVMSetExternallyInitialized(existing, true.into());
+                LLVMSetInitializer(existing, LLVMGetUndef(backend_type));
+            }
+
+            // NOTE: We assume the two global variables have the same type here,
+            // if they aren't, then we technically don't even to report it.
+            ctx.globals.insert(*global_ref, existing);
+            continue;
+        }
+
         let backend_global = LLVMAddGlobal(ctx.backend_module.get(), backend_type, name.as_ptr());
 
-        let linkage = if global.exposure.is_exposed() {
+        let linkage = if global.exposure.is_exposed() || global.is_foreign {
             LLVMLinkage::LLVMExternalLinkage
         } else {
             LLVMLinkage::LLVMInternalLinkage
@@ -24,7 +55,10 @@ pub unsafe fn create_globals(ctx: &mut BackendCtx) -> Result<(), BackendError> {
         LLVMSetLinkage(backend_global, linkage);
 
         if global.is_thread_local {
-            LLVMSetThreadLocal(backend_global, true.into());
+            LLVMSetThreadLocalMode(
+                backend_global,
+                LLVMThreadLocalMode::LLVMGeneralDynamicTLSModel,
+            );
         }
 
         if !global.is_foreign {

Diff for: tests/success/global_variables_exposed/_.adept

@@ -0,0 +1,14 @@
+
+pragma => adept("3.0")
+
+#[foreign]
+func printf(format ptr#char, ...) int
+
+#[foreign]
+special_value int
+
+func main {
+    special_value = 1234
+    printf(c"special_value = %d\n", special_value)
+}
+

Diff for: tests/success/global_variables_exposed/special_variable.adept

@@ -0,0 +1,4 @@
+
+#[private, exposed]
+special_value int
+