diff --git a/bridge/go-llvm-bfunction.cpp b/bridge/go-llvm-bfunction.cpp
index 7382331..e3fbe6b 100644
--- a/bridge/go-llvm-bfunction.cpp
+++ b/bridge/go-llvm-bfunction.cpp
@@ -81,6 +81,15 @@
   if (! name.empty())
     inst->setName(name);
   allocas_.push_back(inst);
+
+  // Immediately cast to address space
+  unsigned addressSpace = abiOracle_->tm()->addressSpace();
+  if (addressSpace != 0) {
+    llvm::Type *pt = llvm::PointerType::get(typ, addressSpace);
+    inst = new llvm::AddrSpaceCastInst(inst, pt);
+    allocas_.push_back(inst);
+  }
+
   return inst;
 }
 
@@ -251,8 +260,12 @@
   } else {
     inst = addAlloca(btype->type(), name);
   }
-  if (is_address_taken)
-    inst->setMetadata("go_addrtaken", llvm::MDNode::get(inst->getContext(), {}));
+  if (is_address_taken) {
+    llvm::Instruction *alloca = inst;
+    if (auto *ascast = llvm::dyn_cast<llvm::AddrSpaceCastInst>(alloca))
+      alloca = llvm::cast<llvm::Instruction>(ascast->getPointerOperand());
+    alloca->setMetadata("go_addrtaken", llvm::MDNode::get(inst->getContext(), {}));
+  }
   Bvariable *bv =
       new Bvariable(btype, location, name, LocalVar, is_address_taken, inst);
   localVariables_.push_back(bv);
@@ -468,7 +481,7 @@
 }
 
 void Bfunction::fixupProlog(llvm::BasicBlock *entry,
-                            const std::vector<llvm::AllocaInst *> &temps)
+                            const std::vector<llvm::Instruction *> &temps)
 {
   lazyAbiSetup();
   // If there are any "new" temporaries discovered during the control
@@ -477,8 +490,14 @@
   // (potentially) references to the alloca instructions themselves, so
   // we insert any new temps into the start of the block.
   if (! temps.empty())
-    for (auto ai : temps)
+    for (auto ai : temps) {
       entry->getInstList().push_front(ai);
+      if (auto *ascast = llvm::dyn_cast<llvm::AddrSpaceCastInst>(ai)) {
+        llvm::Value *op = ascast->getPointerOperand();
+        assert(llvm::isa<llvm::AllocaInst>(op));
+        entry->getInstList().push_front(llvm::cast<llvm::Instruction>(op));
+      }
+    }
 }
 
 llvm::Value *Bfunction::genReturnSequence(Bexpression *toRet,
diff --git a/bridge/go-llvm-bfunction.h b/bridge/go-llvm-bfunction.h
index f6d67e7..f83aafa 100644
--- a/bridge/go-llvm-bfunction.h
+++ b/bridge/go-llvm-bfunction.h
@@ -108,7 +108,7 @@
   // the the entry BB for the function, and "temps" is a set of temporary
   // variables that need to be adopted into the function.
   void fixupProlog(llvm::BasicBlock *entry,
-                   const std::vector<llvm::AllocaInst *> &temps);
+                   const std::vector<llvm::Instruction *> &temps);
 
   // Create code to return a function value from this fcn, following ABI rules.
   llvm::Value *genReturnSequence(Bexpression *toRet,
diff --git a/bridge/go-llvm-bnode.cpp b/bridge/go-llvm-bnode.cpp
index e0e6290..9e6fd9a 100644
--- a/bridge/go-llvm-bnode.cpp
+++ b/bridge/go-llvm-bnode.cpp
@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "go-llvm.h"
 #include "go-llvm-btype.h"
 #include "go-llvm-bnode.h"
 #include "go-llvm-bvariable.h"
@@ -372,6 +373,7 @@
 BnodeBuilder::BnodeBuilder(Llvm_backend *be)
     : integrityVisitor_(new IntegrityVisitor(be, TreeIntegCtl(DumpPointers, DontReportRepairableSharing, IncrementalMode)))
     , checkIntegrity_(true)
+    , addressSpace_(be->addressSpace())
 {
 }
 
@@ -398,14 +400,21 @@
       delete expr;
     }
   }
-  for (auto inst : todel)
-    inst->deleteValue();
-  for (auto inst : deadInstructions_)
-    inst->deleteValue();
   for (auto ivpair : tempvars_) {
-    delete ivpair.first;
+    llvm::Instruction *inst = ivpair.first;
+    if (auto *ascast = llvm::dyn_cast<llvm::AddrSpaceCastInst>(inst)) {
+      inst = llvm::cast<llvm::Instruction>(ascast->getPointerOperand());
+      ascast->dropAllReferences();
+      todel.push_back(ascast);
+    }
+    assert(llvm::isa<llvm::AllocaInst>(inst));
+    todel.push_back(inst);
     delete ivpair.second;
   }
+  for (auto v : todel)
+    v->deleteValue();
+  for (auto inst : deadInstructions_)
+    inst->deleteValue();
 }
 
 void BnodeBuilder::freeStmts()
@@ -509,16 +518,24 @@
                                    const std::string &name)
 {
   assert(varType);
-  llvm::AllocaInst *inst = new llvm::AllocaInst(varType->type(), 0);
+  llvm::Type *typ = varType->type();
+  llvm::Instruction *inst = new llvm::AllocaInst(typ, 0);
   if (! name.empty())
     inst->setName(name);
+
+  // Immediately cast to address space
+  if (addressSpace_ != 0) {
+    llvm::Type *pt = llvm::PointerType::get(typ, addressSpace_);
+    inst = new llvm::AddrSpaceCastInst(inst, pt);
+  }
+
   Bvariable *tvar = new Bvariable(varType, loc, name, LocalVar, true, inst);
   tempvars_[inst] = tvar;
   tvar->markAsTemporary();
   return tvar;
 }
 
-Bvariable *BnodeBuilder::adoptTemporaryVariable(llvm::AllocaInst *alloca)
+Bvariable *BnodeBuilder::adoptTemporaryVariable(llvm::Instruction *alloca)
 {
   assert(alloca);
   auto mit = tempvars_.find(alloca);
@@ -729,6 +746,15 @@
   return archive(rval);
 }
 
+static bool isAlloca(llvm::Value *val)
+{
+  if (llvm::isa<llvm::AllocaInst>(val))
+    return true;
+  if (auto *ascast = llvm::dyn_cast<llvm::AddrSpaceCastInst>(val))
+    return llvm::isa<llvm::AllocaInst>(ascast->getPointerOperand());
+  return false;
+}
+
 Bexpression *BnodeBuilder::mkCall(Btype *btype,
                                   llvm::Value *val,
                                   Bfunction *caller,
@@ -751,7 +777,7 @@
       found = true;
     rval->appendInstruction(inst);
   }
-  if (!found && val && !llvm::isa<llvm::AllocaInst>(val))
+  if (!found && val && !isAlloca(val))
     appendInstIfNeeded(rval, val);
   rval->u.func = caller;
   return archive(rval);
diff --git a/bridge/go-llvm-bnode.h b/bridge/go-llvm-bnode.h
index 87a72be..ca63b7f 100644
--- a/bridge/go-llvm-bnode.h
+++ b/bridge/go-llvm-bnode.h
@@ -340,7 +340,7 @@
   // construction (via the mkTempVar method above). If so, the
   // variable is extracted from the builder's set and returned. If the
   // var is not an unadopted temp, then NULL is returned.
-  Bvariable *adoptTemporaryVariable(llvm::AllocaInst *alloca);
+  Bvariable *adoptTemporaryVariable(llvm::Instruction *alloca);
 
   // Free up this expr or stmt (it is garbage). Does not free up children.
   void freeNode(Bnode *node);
@@ -405,10 +405,11 @@
   std::vector<Bstatement *> sarchive_;
   std::vector<SwitchDescriptor*> swcases_;
   std::vector< std::vector<unsigned long> > indexvecs_;
-  std::unordered_map<llvm::AllocaInst*, Bvariable*> tempvars_;
+  std::unordered_map<llvm::Instruction*, Bvariable*> tempvars_;
   std::unique_ptr<IntegrityVisitor> integrityVisitor_;
   bool checkIntegrity_;
   std::vector<llvm::Instruction*> deadInstructions_;
+  unsigned addressSpace_;
 };
 
 // This class helps automate walking of a Bnode subtree; it invokes
diff --git a/bridge/go-llvm-materialize.cpp b/bridge/go-llvm-materialize.cpp
index b09a70e..49c6238 100644
--- a/bridge/go-llvm-materialize.cpp
+++ b/bridge/go-llvm-materialize.cpp
@@ -207,24 +207,45 @@
   // uintptr (as part of GC symbol initializer creation), and in other
   // places in FE-generated code (ex: array index checks).
   if (valType->isPointerTy() && toType == llvmIntegerType()) {
+    if (val->getType()->getPointerAddressSpace() != 0) {
+      // We are using non-integral pointer. Cast to address space 0
+      // before casting to int.
+      llvm::Type *et = val->getType()->getPointerElementType();
+      llvm::Type *pt = llvm::PointerType::get(et, 0);
+      std::string tname(namegen("ascast"));
+      val = builder.CreateAddrSpaceCast(val, pt, tname);
+      expr = nbuilder_.mkConversion(type, val, expr, location);
+    }
     std::string tname(namegen("pticast"));
     llvm::Value *pticast = builder.CreatePtrToInt(val, toType, tname);
     rval = nbuilder_.mkConversion(type, pticast, expr, location);
   }
 
-  // Pointer-sized-integer type pointer type. This comes up
+  // Pointer-sized-integer type to pointer type. This comes up
   // in type hash/compare functions.
   if (toType->isPointerTy() && valType == llvmIntegerType()) {
+    llvm::Type *pt = toType;
+    if (toType->getPointerAddressSpace() != 0) {
+      // We are using non-integral pointer. Cast to address space 0
+      // first.
+      llvm::Type *et = toType->getPointerElementType();
+      pt = llvm::PointerType::get(et, 0);
+    }
     std::string tname(namegen("itpcast"));
-    llvm::Value *itpcast = builder.CreateIntToPtr(val, toType, tname);
+    llvm::Value *itpcast = builder.CreateIntToPtr(val, pt, tname);
     rval = nbuilder_.mkConversion(type, itpcast, expr, location);
+    if (pt != toType) {
+      std::string tname(namegen("ascast"));
+      llvm::Value *ascast = builder.CreateAddrSpaceCast(itpcast, toType, tname);
+      rval = nbuilder_.mkConversion(type, ascast, rval, location);
+    }
   }
 
   // For pointer conversions (ex: *int32 => *int64) create an
   // appropriate bitcast.
   if (valType->isPointerTy() && toType->isPointerTy()) {
     std::string tag(namegen("cast"));
-    llvm::Value *bitcast = builder.CreateBitCast(val, toType, tag);
+    llvm::Value *bitcast = builder.CreatePointerBitCastOrAddrSpaceCast(val, toType, tag);
     rval = nbuilder_.mkConversion(type, bitcast, expr, location);
   }
 
@@ -1482,7 +1503,8 @@
   // descriptor. Allow this case.
   if (dstPtrToFD && srcFuncPtr) {
     std::string tag(namegen("cast"));
-    llvm::Value *bitcast = builder->CreateBitCast(srcVal, dstToType, tag);
+    llvm::Value *bitcast =
+        builder->CreatePointerBitCastOrAddrSpaceCast(srcVal, dstToType, tag);
     return bitcast;
   }
 
@@ -1523,7 +1545,7 @@
   if ((dstToType == llvmPtrType() && llvm::isa<llvm::PointerType>(srcType)) ||
       (srcType == llvmPtrType() && llvm::isa<llvm::PointerType>(dstToType))) {
     std::string tag(namegen("cast"));
-    llvm::Value *bitcast = builder->CreateBitCast(srcVal, dstToType, tag);
+    llvm::Value *bitcast = builder->CreatePointerBitCastOrAddrSpaceCast(srcVal, dstToType, tag);
     return bitcast;
   }
 
diff --git a/bridge/go-llvm-typemanager.cpp b/bridge/go-llvm-typemanager.cpp
index ee97280..7047684 100644
--- a/bridge/go-llvm-typemanager.cpp
+++ b/bridge/go-llvm-typemanager.cpp
@@ -22,11 +22,13 @@
 #include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/Type.h"
 
-TypeManager::TypeManager(llvm::LLVMContext &context, llvm::CallingConv::ID conv)
+TypeManager::TypeManager(llvm::LLVMContext &context,
+                         llvm::CallingConv::ID conv,
+                         unsigned addrspace)
     : context_(context)
     , datalayout_(nullptr)
     , cconv_(conv)
-    , addressSpace_(0)
+    , addressSpace_(addrspace)
     , traceLevel_(0)
     , nametags_(nullptr)
     , errorExpression_(nullptr)
@@ -36,6 +38,7 @@
     , llvmVoidType_(nullptr)
     , llvmBoolType_(nullptr)
     , llvmPtrType_(nullptr)
+    , llvmPtr0Type_(nullptr)
     , llvmSizeType_(nullptr)
     , llvmIntegerType_(nullptr)
     , llvmInt8Type_(nullptr)
@@ -56,6 +59,8 @@
   llvmPtrType_ =
       llvm::PointerType::get(llvm::IntegerType::get(context_, 8),
                              addressSpace_);
+  llvmPtr0Type_ =
+      llvm::PointerType::get(llvm::IntegerType::get(context_, 8), 0);
 
   // Assorted pre-computer types for use in builtin function creation
   llvmVoidType_ = llvm::Type::getVoidTy(context_);
@@ -483,6 +488,11 @@
 
 Btype *TypeManager::pointerType(Btype *toType)
 {
+  return addrSpacePointerType(toType, addressSpace_);
+}
+
+Btype *TypeManager::addrSpacePointerType(Btype *toType, unsigned addressSpace)
+{
   if (toType == errorType_)
     return errorType_;
 
@@ -491,7 +501,7 @@
   // as pointer to char.
   llvm::Type *lltot =
       (toType->type() == llvmVoidType_ ? llvmInt8Type_ : toType->type());
-  llvm::Type *llpt = llvm::PointerType::get(lltot, addressSpace_);
+  llvm::Type *llpt = llvm::PointerType::get(lltot, addressSpace);
 
   // Check for and return existing anon type if we have one already
   Location loc;
@@ -1340,7 +1350,7 @@
 llvm::Type *TypeManager::landingPadExceptionType()
 {
   llvm::SmallVector<llvm::Type *, 2> elems(2);
-  elems[0] = llvmPtrType();
+  elems[0] = llvmPtr0Type();
   elems[1] = llvmInt32Type();
   return llvm::StructType::get(context_, elems);
 }
diff --git a/bridge/go-llvm-typemanager.h b/bridge/go-llvm-typemanager.h
index c3e0b1b..8eca95e 100644
--- a/bridge/go-llvm-typemanager.h
+++ b/bridge/go-llvm-typemanager.h
@@ -42,7 +42,9 @@
 
 class TypeManager {
  public:
-  TypeManager(llvm::LLVMContext &context, llvm::CallingConv::ID cconv);
+  TypeManager(llvm::LLVMContext &context,
+              llvm::CallingConv::ID cconv,
+              unsigned addrspace);
   ~TypeManager();
 
   // These methods are intended to match up with the similarly
@@ -114,6 +116,7 @@
   llvm::Type *llvmVoidType() const { return llvmVoidType_; }
   llvm::Type *llvmBoolType() const { return llvmBoolType_; }
   llvm::Type *llvmPtrType() const { return llvmPtrType_; }
+  llvm::Type *llvmPtr0Type() const { return llvmPtr0Type_; } // pointer in address space 0
   llvm::Type *llvmInt8Type() const { return llvmInt8Type_; }
   llvm::Type *llvmInt32Type() const { return llvmInt32Type_; }
   llvm::Type *llvmInt64Type() const { return llvmInt64Type_; }
@@ -147,6 +150,9 @@
   llvm::LLVMContext &context() const { return context_; }
   unsigned addressSpace() const { return addressSpace_; }
 
+  // Same as pointerType, but explicitly specify address space.
+  Btype *addrSpacePointerType(Btype *toType, unsigned addressSpace);
+
   // Go string type
   Btype *stringType() const { return stringType_; }
 
@@ -357,6 +363,7 @@
   llvm::Type *llvmVoidType_;
   llvm::Type *llvmBoolType_;
   llvm::Type *llvmPtrType_;
+  llvm::Type *llvmPtr0Type_;
   llvm::Type *llvmSizeType_;
   llvm::Type *llvmIntegerType_;
   llvm::Type *llvmInt8Type_;
diff --git a/bridge/go-llvm.cpp b/bridge/go-llvm.cpp
index 3751410..ac6eafb 100644
--- a/bridge/go-llvm.cpp
+++ b/bridge/go-llvm.cpp
@@ -42,14 +42,15 @@
 
 Llvm_backend::Llvm_backend(llvm::LLVMContext &context,
                            llvm::Module *module,
-                           Llvm_linemap *linemap)
-    : TypeManager(context, llvm::CallingConv::X86_64_SysV)
+                           Llvm_linemap *linemap,
+                           unsigned addrspace)
+    : TypeManager(context, llvm::CallingConv::X86_64_SysV, addrspace)
     , context_(context)
     , module_(module)
     , datalayout_(module ? &module->getDataLayout() : nullptr)
     , nbuilder_(this)
     , linemap_(linemap)
-    , addressSpace_(0)
+    , addressSpace_(addrspace)
     , traceLevel_(0)
     , noInline_(false)
     , noFpElim_(false)
@@ -747,7 +748,7 @@
   // apply a bitcast to perform the conversion.
   LIRBuilder builder(context_, llvm::ConstantFolder());
   if (! isToComposite) {
-    llvm::Value *bitcast = builder.CreateBitCast(fromVal, llToType);
+    llvm::Value *bitcast = builder.CreatePointerBitCastOrAddrSpaceCast(fromVal, llToType);
     assert(llvm::isa<llvm::Constant>(bitcast));
     llvm::Constant *constCast = llvm::cast<llvm::Constant>(bitcast);
     return constCast;
@@ -1432,13 +1433,16 @@
   if (bfunc == errorFunction_.get())
     return errorExpression();
 
-  // Look up pointer-to-function type
-  Btype *fpBtype = pointer_type(bfunc->fcnType());
+  // Look up pointer-to-function type.
+  // Function is always in address space 0.
+  Btype *fpBtype = addrSpacePointerType(bfunc->fcnType(), 0);
+
+  llvm::Constant *fpval = bfunc->fcnValue();
 
   // Create an address-of-function expr
-  Bexpression *fexpr = nbuilder_.mkFcnAddress(fpBtype, bfunc->fcnValue(),
+  Bexpression *fexpr = nbuilder_.mkFcnAddress(fpBtype, fpval,
                                               bfunc, location);
-  return makeGlobalExpression(fexpr, bfunc->fcnValue(), fpBtype, location);
+  return makeGlobalExpression(fexpr, fpval, fpBtype, location);
 }
 
 // Return an expression for the field at INDEX in BSTRUCT.
@@ -2128,9 +2132,12 @@
     }
   }
 
+  llvm::GlobalValue::ThreadLocalMode threadlocal =
+      llvm::GlobalValue::NotThreadLocal;
   glob = new llvm::GlobalVariable(module(), underlyingType->type(),
                                   isConstant == MV_Constant,
-                                  linkage, init, gname);
+                                  linkage, init, gname, nullptr,
+                                  threadlocal, addressSpace_);
 
   if (alignment)
     glob->setAlignment(alignment);
@@ -2454,8 +2461,11 @@
   llvm::GlobalValue::LinkageTypes linkage = llvm::GlobalValue::ExternalLinkage;
   bool isConstant = true;
   llvm::Constant *init = nullptr;
+  llvm::GlobalValue::ThreadLocalMode threadlocal =
+      llvm::GlobalValue::NotThreadLocal;
   glob = new llvm::GlobalVariable(module(), btype->type(), isConstant,
-                                  linkage, init, gname);
+                                  linkage, init, gname, nullptr,
+                                  threadlocal, addressSpace_);
 
   Bvariable *bv =
       new Bvariable(btype, location, name, GlobalVar, false, glob);
@@ -2769,8 +2779,8 @@
   std::vector<Bblock *> blockStack_;
   std::map<LabelId, llvm::BasicBlock *> labelmap_;
   std::vector<llvm::BasicBlock*> padBlockStack_;
-  std::set<llvm::AllocaInst *> temporariesDiscovered_;
-  std::vector<llvm::AllocaInst *> newTemporaries_;
+  std::set<llvm::Instruction *> temporariesDiscovered_;
+  std::vector<llvm::Instruction *> newTemporaries_;
   llvm::BasicBlock *finallyBlock_;
   Bstatement *cachedReturn_;
 };
@@ -2829,6 +2839,8 @@
   else
     builder.SetInsertPoint(curBlock);
 
+  if (auto *ascast = llvm::dyn_cast<llvm::AddrSpaceCastInst>(alloca))
+    alloca = ascast->getPointerOperand();
   llvm::AllocaInst *ai = llvm::cast<llvm::AllocaInst>(alloca);
 
   // expect array size of 1 given how we constructed it
@@ -2970,8 +2982,9 @@
 {
   for (llvm::Instruction::op_iterator oi = inst->op_begin(),
            oe = inst->op_end(); oi != oe; ++oi) {
-    if (llvm::isa<llvm::AllocaInst>(*oi)) {
-      llvm::AllocaInst *ai = llvm::cast<llvm::AllocaInst>(*oi);
+    if (llvm::isa<llvm::AllocaInst>(*oi) ||
+        llvm::isa<llvm::AddrSpaceCastInst>(*oi)) {
+      llvm::Instruction *ai = llvm::cast<llvm::Instruction>(*oi);
 
       // If this alloca is associated with a temporary variable
       // that was manufactured at some point during IR construction,
@@ -3366,7 +3379,7 @@
 
   // Create temporary into which caught result will be stored
   std::string tag(be_->namegen("ehtmp"));
-  llvm::AllocaInst *ai = new llvm::AllocaInst(eht, 0, tag);
+  llvm::Instruction *ai = new llvm::AllocaInst(eht, 0, tag);
   temporariesDiscovered_.insert(ai);
   newTemporaries_.push_back(ai);
 
@@ -3854,5 +3867,5 @@
 // Return a new backend generator.
 
 Backend *go_get_backend(llvm::LLVMContext &context) {
-  return new Llvm_backend(context, nullptr, nullptr);
+  return new Llvm_backend(context, nullptr, nullptr, 0);
 }
diff --git a/bridge/go-llvm.h b/bridge/go-llvm.h
index 67ac52b..382934c 100644
--- a/bridge/go-llvm.h
+++ b/bridge/go-llvm.h
@@ -78,7 +78,8 @@
 public:
   Llvm_backend(llvm::LLVMContext &context,
                llvm::Module *module,
-               Llvm_linemap *linemap);
+               Llvm_linemap *linemap,
+               unsigned addrspace);
   ~Llvm_backend();
 
   // Types.
diff --git a/driver/CompileGo.cpp b/driver/CompileGo.cpp
index 62ddfd6..23fc08c 100644
--- a/driver/CompileGo.cpp
+++ b/driver/CompileGo.cpp
@@ -462,19 +462,30 @@
   context_.setDiagnosticHandler(
       llvm::make_unique<BEDiagnosticHandler>(&this->hasError_));
 
+  llvm::Optional<unsigned> enable_gc =
+      driver_.getLastArgAsInteger(gollvm::options::OPT_enable_gc_EQ, 0u);
+  enable_gc_ = enable_gc && *enable_gc;
+
   // Construct linemap and module
   linemap_.reset(new Llvm_linemap());
   module_.reset(new llvm::Module("gomodule", context_));
 
   // Add the target data from the target machine, if it exists
   module_->setTargetTriple(triple_.getTriple());
-  module_->setDataLayout(target_->createDataLayout());
+
+  // Data layout.
+  std::string dlstr = target_->createDataLayout().getStringRepresentation();
+  if (enable_gc_)
+    dlstr += "-ni:1"; // non-integral pointer in address space 1
+  module_->setDataLayout(dlstr);
+
   module_->setPICLevel(driver_.getPicLevel());
   if (driver_.picIsPIE())
     module_->setPIELevel(driver_.getPieLevel());
 
   // Now construct Llvm_backend helper.
-  bridge_.reset(new Llvm_backend(context_, module_.get(), linemap_.get()));
+  unsigned addrspace = enable_gc_ ? 1 : 0;
+  bridge_.reset(new Llvm_backend(context_, module_.get(), linemap_.get(), addrspace));
 
   // Honor inline, tracelevel cmd line options
   llvm::Optional<unsigned> tl =
@@ -504,14 +515,13 @@
   for (const auto &arg : driver_.args().getAllArgValues(gollvm::options::OPT_fdebug_prefix_map_EQ))
     bridge_->addDebugPrefix(llvm::StringRef(arg).split('='));
 
-  llvm::Optional<unsigned> enable_gc =
-      driver_.getLastArgAsInteger(gollvm::options::OPT_enable_gc_EQ, 0u);
-  if (enable_gc && *enable_gc) {
-    enable_gc_ = true;
+  // GC support.
+  if (enable_gc_) {
     bridge_->setGCStrategy("go");
     linkGoGC();
     linkGoGCPrinter();
   }
+
   // Support -fgo-dump-ast
   if (args_.hasArg(gollvm::options::OPT_fgo_dump_ast))
     go_enable_dump("ast");
@@ -753,8 +763,10 @@
 
   // Add statepoint insertion pass to the end of optimization pipeline,
   // right before lowering to machine IR.
-  if (enable_gc_)
+  if (enable_gc_) {
     modulePasses.add(createGoStatepointsLegacyPass());
+    modulePasses.add(createRemoveAddrSpacePass(target_->createDataLayout()));
+  }
 
   legacy::PassManager codeGenPasses;
   bool noverify = args_.hasArg(gollvm::options::OPT_noverify);
diff --git a/passes/CMakeLists.txt b/passes/CMakeLists.txt
index 2919b57..1a65572 100644
--- a/passes/CMakeLists.txt
+++ b/passes/CMakeLists.txt
@@ -10,5 +10,6 @@
   GC.cpp
   GoAnnotation.cpp
   GoStatepoints.cpp
+  RemoveAddrSpace.cpp
   Util.cpp
 )
diff --git a/passes/GollvmPasses.h b/passes/GollvmPasses.h
index 2691c67..e388b1f 100644
--- a/passes/GollvmPasses.h
+++ b/passes/GollvmPasses.h
@@ -22,9 +22,11 @@
 
 void initializeGoAnnotationPass(PassRegistry&);
 void initializeGoStatepointsLegacyPassPass(PassRegistry&);
+void initializeRemoveAddrSpacePassPass(PassRegistry&);
 
 FunctionPass *createGoAnnotationPass();
 ModulePass *createGoStatepointsLegacyPass();
+ModulePass *createRemoveAddrSpacePass(const DataLayout&);
 
 void linkGoGC();
 void linkGoGCPrinter();
diff --git a/passes/RemoveAddrSpace.cpp b/passes/RemoveAddrSpace.cpp
new file mode 100644
index 0000000..e31e9ac
--- /dev/null
+++ b/passes/RemoveAddrSpace.cpp
@@ -0,0 +1,99 @@
+//===--- GoStackMap.cpp ---------------------------------------------------===//
+//
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+//
+//===----------------------------------------------------------------------===//
+//
+// LLVM backend pass to remove addrspacecast instructions
+// in static initializers (because codegen cannot handle
+// them).
+//
+//===----------------------------------------------------------------------===//
+
+#include "GollvmPasses.h"
+
+#include "llvm/ADT/DenseSet.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/DataLayout.h"
+#include "llvm/IR/GlobalVariable.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/Type.h"
+#include "llvm/Pass.h"
+#include "llvm/PassRegistry.h"
+
+using namespace llvm;
+
+namespace {
+
+class RemoveAddrSpacePass : public ModulePass {
+ public:
+  static char ID;
+
+  RemoveAddrSpacePass() : ModulePass(ID), DL("") {}
+
+  RemoveAddrSpacePass(const DataLayout &DL) : ModulePass(ID), DL(DL) {
+    initializeRemoveAddrSpacePassPass(
+        *PassRegistry::getPassRegistry());
+  }
+
+  bool runOnModule(Module &M) override;
+
+ private:
+  Type *IntTy; // type of uintptr_t, used to cast pointer to/from integer
+  DataLayout DL; // data layout without non-integral pointer, passed in from the driver
+  DenseSet<Constant*> Visited; // handle circular references
+
+  // Replace addrspacecast in static initializer C with a pair
+  // of ptr-to-int and int-to-ptr casts, as codegen cannot handle
+  // addrspacecast in static initializer.
+  void removeAddrSpaceCast(Constant *C);
+};
+
+} // namespace
+
+char RemoveAddrSpacePass::ID = 0;
+INITIALIZE_PASS(RemoveAddrSpacePass, "remove-addrspacecast",
+                "Remove addrspacecast instructions", false,
+                false)
+ModulePass *llvm::createRemoveAddrSpacePass(const DataLayout &DL) {
+  return new RemoveAddrSpacePass(DL);
+}
+
+void
+RemoveAddrSpacePass::removeAddrSpaceCast(Constant *C) {
+  if (Visited.count(C))
+    return;
+  Visited.insert(C);
+
+  ConstantExpr *CE = dyn_cast<ConstantExpr>(C);
+  if (CE && CE->getOpcode() == Instruction::AddrSpaceCast) {
+    Constant *Op = CE->getOperand(0);
+    Constant *New = ConstantExpr::getIntToPtr(
+        ConstantExpr::getPtrToInt(Op, IntTy), CE->getType());
+    CE->replaceAllUsesWith(New);
+    Visited.erase(CE);
+    CE->destroyConstant();
+    C = New;
+  }
+
+  unsigned N = C->getNumOperands();
+  for (unsigned Idx = 0; Idx < N; Idx++) {
+    Constant *Op = cast<Constant>(C->getOperand(Idx));
+    removeAddrSpaceCast(Op);
+  }
+}
+
+bool
+RemoveAddrSpacePass::runOnModule(Module &M) {
+  // At this point we no longer need non-integral pointers.
+  // Set data layout back to default.
+  M.setDataLayout(DL);
+
+  IntTy = Type::getInt64Ty(M.getContext());
+  for (GlobalVariable &GV : M.globals())
+    if (GV.hasInitializer())
+      removeAddrSpaceCast(GV.getInitializer());
+  return true;
+}
diff --git a/unittests/BackendCore/BackendCABIOracleTests.cpp b/unittests/BackendCore/BackendCABIOracleTests.cpp
index 29ff26b..99f8108 100644
--- a/unittests/BackendCore/BackendCABIOracleTests.cpp
+++ b/unittests/BackendCore/BackendCABIOracleTests.cpp
@@ -20,7 +20,7 @@
 
 TEST(BackendCABIOracleTests, Basic) {
   LLVMContext C;
-  std::unique_ptr<Llvm_backend> bep(new Llvm_backend(C, nullptr, nullptr));
+  std::unique_ptr<Llvm_backend> bep(new Llvm_backend(C, nullptr, nullptr, 0));
   Llvm_backend *be = bep.get();
 
   Btype *bi8t = be->integer_type(false, 8);
@@ -58,7 +58,7 @@
 
 TEST(BackendCABIOracleTests, Extended) {
   LLVMContext C;
-  std::unique_ptr<Llvm_backend> bep(new Llvm_backend(C, nullptr, nullptr));
+  std::unique_ptr<Llvm_backend> bep(new Llvm_backend(C, nullptr, nullptr, 0));
   Llvm_backend *be = bep.get();
 
   Btype *bi8t = be->integer_type(false, 8);
diff --git a/unittests/BackendCore/BackendTreeIntegrity.cpp b/unittests/BackendCore/BackendTreeIntegrity.cpp
index c82ef1f..5beec52 100644
--- a/unittests/BackendCore/BackendTreeIntegrity.cpp
+++ b/unittests/BackendCore/BackendTreeIntegrity.cpp
@@ -64,7 +64,7 @@
 
   // Add the same Expression to more than one statement
   LLVMContext C;
-  std::unique_ptr<Llvm_backend> be(new Llvm_backend(C, nullptr, nullptr));
+  std::unique_ptr<Llvm_backend> be(new Llvm_backend(C, nullptr, nullptr, 0));
   be->disableIntegrityChecks();
 
   Location loc;
@@ -101,7 +101,7 @@
 
   // Same statement with more than one parent.
   LLVMContext C;
-  std::unique_ptr<Llvm_backend> be(new Llvm_backend(C, nullptr, nullptr));
+  std::unique_ptr<Llvm_backend> be(new Llvm_backend(C, nullptr, nullptr, 0));
   be->disableIntegrityChecks();
   Location loc;
   Bfunction *func = mkFunci32o64(be.get(), "foo");
diff --git a/unittests/BackendCore/TestUtils.cpp b/unittests/BackendCore/TestUtils.cpp
index 9bff12a..4f2c41e 100644
--- a/unittests/BackendCore/TestUtils.cpp
+++ b/unittests/BackendCore/TestUtils.cpp
@@ -374,7 +374,7 @@
 
 FcnTestHarness::FcnTestHarness(const char *fcnName)
     : context_()
-    , be_(new Llvm_backend(context_, nullptr, nullptr))
+    , be_(new Llvm_backend(context_, nullptr, nullptr, 0))
     , func_(nullptr)
     , entryBlock_(nullptr)
     , curBlock_(nullptr)