gollvm: update to LLVM mainline Patch switches to mainline LLVM which implies following changes in gollvm: - Use of new pass manager - Use of opaque pointers and implementing type tracking based on Btype instead of llvm::Type - Use of debug records instead of intrinsics - Fix gollvm unit tests Change-Id: I3b8e3fe4820158a06fd1754ba2e1e0515d65ecca Reviewed-on: https://go-review.googlesource.com/c/gollvm/+/642655 Reviewed-by: Carlos Amedee <carlos@golang.org> Reviewed-by: Than McIntosh <thanm@golang.org> Reviewed-by: Anton Korobeynikov <anton@korobeynikov.info> Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2561f8b..f5b8baa 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt

@@ -114,6 +114,16 @@
   set(gocdep llvm-goc-token)
 endif()
 
+if(CXX_SUPPORTS_SUGGEST_OVERRIDE_FLAG)
+  add_definitions("-Wno-suggest-override")
+  set_target_properties(gollvm PROPERTIES INTERFACE_COMPILE_OPTIONS "-Wno-suggest-override")
+endif()
+
+if(CXX_SUPPORTS_COVERED_SWITCH_DEFAULT_FLAG)
+  add_definitions("-Wno-covered-switch-default")
+  set_target_properties(gollvm PROPERTIES INTERFACE_COMPILE_OPTIONS "-Wno-covered-switch-default")
+endif()
+
 # Root of gollvm source code.
 set(GOLLVM_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 

diff --git a/bridge/go-llvm-bexpression.cpp b/bridge/go-llvm-bexpression.cpp
index 1b97168..1b0ff3a 100644
--- a/bridge/go-llvm-bexpression.cpp
+++ b/bridge/go-llvm-bexpression.cpp

@@ -118,12 +118,6 @@
   if (!llvm::isa<llvm::Constant>(value_))
     return false;
 
-  // Not a constant if there is a pending load
-  if (value_->getType()->isPointerTy() &&
-      value_->getType()->getPointerElementType() ==
-        btype()->type())
-    return false;
-
   // In some cases, even the underlying value is an
   // llvm::Constant, the expression may be not. For
   // example, a var expression for a global variable,

diff --git a/bridge/go-llvm-bexpression.h b/bridge/go-llvm-bexpression.h
index 767ac47..9f4be88 100644
--- a/bridge/go-llvm-bexpression.h
+++ b/bridge/go-llvm-bexpression.h

@@ -83,10 +83,6 @@
   VarContext() : addrLevel_(0), lvalue_(false), pending_(false) { }
   VarContext(bool lvalue, unsigned addrLevel)
       : addrLevel_(addrLevel), lvalue_(lvalue), pending_(true) { }
-  explicit VarContext(const VarContext &src)
-      : addrLevel_(src.addrLevel_), lvalue_(src.lvalue_),
-        pending_(src.pending_)
-  { }
 
   bool pending() const { return pending_; }
   unsigned addrLevel() const { return addrLevel_; }

diff --git a/bridge/go-llvm-bfunction.cpp b/bridge/go-llvm-bfunction.cpp
index 20aed84..e4b741f 100644
--- a/bridge/go-llvm-bfunction.cpp
+++ b/bridge/go-llvm-bfunction.cpp

@@ -74,10 +74,9 @@
   return abiOracle_->tm()->tnamegen(tag);
 }
 
-llvm::Instruction *Bfunction::addAlloca(llvm::Type *typ,
-                                        const std::string &name)
-{
+llvm::Instruction *Bfunction::addAlloca(Btype *bty, const std::string &name) {
   llvm::Instruction *insBefore = nullptr;
+  llvm::Type *typ = bty->type();
   TypeManager *tm = abiOracle_->tm();
   llvm::Align aaAlign = tm->datalayout()->getABITypeAlign(typ);
   llvm::Value *aaSize = nullptr;
@@ -131,8 +130,7 @@
         // Seems weird to create a zero-sized alloca(), but it should
         // simplify things in that we can avoid having a Bvariable with a
         // null value.
-        llvm::Type *llpt = paramTypes[idx]->type();
-        llvm::Instruction *inst = addAlloca(llpt, "");
+        llvm::Instruction *inst = addAlloca(paramTypes[idx], "");
         paramValues_.push_back(inst);
         break;
       }
@@ -148,8 +146,7 @@
         break;
       }
       case ParmDirect: {
-        llvm::Type *llpt = paramTypes[idx]->type();
-        llvm::Instruction *inst = addAlloca(llpt, "");
+        llvm::Instruction *inst = addAlloca(paramTypes[idx], "");
         paramValues_.push_back(inst);
         if (paramInfo.attr() == AttrSext)
           arguments_[argIdx]->addAttr(llvm::Attribute::SExt);
@@ -229,7 +226,7 @@
   // Create the spill slot for the param.
   std::string spname(name);
   spname += ".addr";
-  llvm::Instruction *inst = addAlloca(btype->type(), spname);
+  llvm::Instruction *inst = addAlloca(btype, spname);
   assert(chainVal_);
   assert(llvm::isa<llvm::Argument>(chainVal_));
   chainVal_ = inst;
@@ -260,7 +257,7 @@
     // to share the same alloca instruction.
     inst = llvm::cast<llvm::Instruction>(declVar->value());
   } else {
-    inst = addAlloca(btype->type(), name);
+    inst = addAlloca(btype, name);
   }
   if (is_address_taken) {
     llvm::Instruction *alloca = inst;
@@ -285,12 +282,7 @@
 
 llvm::Value *Bfunction::createTemporary(Btype *btype, const std::string &tag)
 {
-  return createTemporary(btype->type(), tag);
-}
-
-llvm::Value *Bfunction::createTemporary(llvm::Type *typ, const std::string &tag)
-{
-  return addAlloca(typ, tag);
+  return addAlloca(btype, tag);
 }
 
 // This implementation uses an alloca instruction as a placeholder
@@ -378,13 +370,6 @@
     llvm::Argument *arg = arguments_[paramInfo.sigOffset()];
     assert(sploc->getType()->isPointerTy());
     llvm::PointerType *llpt = llvm::cast<llvm::PointerType>(sploc->getType());
-    if (paramInfo.abiType()->isVectorTy() ||
-        arg->getType() != llpt->getElementType()) {
-      std::string tag(namegen("cast"));
-      llvm::Type *ptv = llvm::PointerType::get(paramInfo.abiType(), 0);
-      llvm::Value *bitcast = builder.CreateBitCast(sploc, ptv, tag);
-      sploc = bitcast;
-    }
     llvm::Instruction *si = builder.CreateStore(arg, sploc);
     paramVar->setInitializer(si);
     spillInstructions->appendInstructions(builder.instructions());
@@ -398,16 +383,13 @@
   llvm::Type *llst = paramInfo.computeABIStructType(tm);
   llvm::Type *ptst = llvm::PointerType::get(llst, 0);
 
-  // Cast the spill location to a pointer to the struct created above.
-  std::string tag(namegen("cast"));
-  llvm::Value *bitcast = builder.CreateBitCast(sploc, ptst, tag);
   llvm::Instruction *stinst = nullptr;
 
   // Generate a store to each field.
   for (unsigned i = 0; i < paramInfo.abiTypes().size(); ++i) {
     std::string tag(namegen("field" + std::to_string(i)));
     llvm::Value *fieldgep =
-        builder.CreateConstInBoundsGEP2_32(llst, bitcast, 0, i, tag);
+        builder.CreateConstInBoundsGEP2_32(llst, sploc, 0, i, tag);
     llvm::Value *argChunk = arguments_[paramInfo.sigOffset() + i];
     stinst = builder.CreateStore(argChunk, fieldgep);
   }
@@ -457,11 +439,11 @@
   // Append allocas for local variables
   // FIXME: create lifetime annotations
   for (auto aa : allocas_)
-    entry->getInstList().push_back(aa);
+    aa->insertBefore(*entry, entry->end());
 
   // Param spills
   for (auto sp : spills.instructions())
-    entry->getInstList().push_back(sp);
+    sp->insertBefore(*entry, entry->end());
 
   // Debug meta-data generation needs to know the position at which a
   // parameter variable is available for inspection -- this is
@@ -496,11 +478,11 @@
   // we insert any new temps into the start of the block.
   if (! temps.empty())
     for (auto ai : temps) {
-      entry->getInstList().push_front(ai);
+      ai->insertInto(entry, entry->begin());
       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::cast<llvm::Instruction>(op)->insertInto(entry, entry->begin());
       }
     }
 }
@@ -547,10 +529,8 @@
                       returnInfo.abiType());
   llvm::Type *ptst = llvm::PointerType::get(llrt, 0);
   BlockLIRBuilder builder(function(), inamegen);
-  std::string castname(namegen("cast"));
-  llvm::Value *bitcast = builder.CreateBitCast(toRet->value(), ptst, castname);
   std::string loadname(namegen("ld"));
-  llvm::Instruction *ldinst = builder.CreateLoad(llrt, bitcast, loadname);
+  llvm::Instruction *ldinst = builder.CreateLoad(llrt, toRet->value(), loadname);
   retInstrs->appendInstructions(builder.instructions());
   return ldinst;
 }

diff --git a/bridge/go-llvm-bfunction.h b/bridge/go-llvm-bfunction.h
index f83aafa..e51cb91 100644
--- a/bridge/go-llvm-bfunction.h
+++ b/bridge/go-llvm-bfunction.h

@@ -124,7 +124,6 @@
 
   // Return an alloca temporary of the specified type.
   llvm::Value *createTemporary(Btype *btype, const std::string &tag);
-  llvm::Value *createTemporary(llvm::Type *type, const std::string &tag);
 
   // If the function return value is passing via memory instead of
   // directly, this function returns the location into which the
@@ -155,7 +154,7 @@
 
   // Create an alloca with the specified type. The alloca is recorded
   // in a list so that it can be picked up during prolog generation.
-  llvm::Instruction *addAlloca(llvm::Type *vtyp, const std::string &name);
+  llvm::Instruction *addAlloca(Btype *typ, const std::string &name);
 
   // Given an LLVM value, return the Bvariable we created to wrap it (either
   // local var or parameter var).

diff --git a/bridge/go-llvm-builtins.cpp b/bridge/go-llvm-builtins.cpp
index 8e7224a..606d02d 100644
--- a/bridge/go-llvm-builtins.cpp
+++ b/bridge/go-llvm-builtins.cpp

@@ -535,14 +535,13 @@
   return builder->CreateOr(old, args[1]);
 }
 
-static llvm::Value *atomicCasMaker(llvm::SmallVectorImpl<llvm::Value*> &args,
-                                   BlockLIRBuilder *builder,
-                                   Llvm_backend *be)
-{
+static llvm::Value *atomicCasMaker(llvm::SmallVectorImpl<llvm::Value *> &args,
+                                   BlockLIRBuilder *builder, Llvm_backend *be,
+                                   llvm::Type *elemTy) {
   assert(args.size() == 6);
   // GCC __atomic_compare_exchange_n takes a pointer to the old value.
   // We need to load it.
-  llvm::Value *old = builder->CreateLoad(args[1]->getType()->getPointerElementType(), args[1]);
+  llvm::Value *old = builder->CreateLoad(elemTy, args[1]);
   // FIXME: see atomicLoadMaker, but default to SequentiallyConsistent
   // for success order, Monotonic (i.e. relaxed) for failed order,
   // and false for weak.
@@ -566,6 +565,18 @@
   return builder->CreateZExt(ret, be->llvmInt8Type());
 }
 
+static llvm::Value *atomicCasMaker4(llvm::SmallVectorImpl<llvm::Value *> &args,
+                                    BlockLIRBuilder *builder,
+                                    Llvm_backend *be) {
+  return atomicCasMaker(args, builder, be, be->llvmInt32Type());
+}
+
+static llvm::Value *atomicCasMaker8(llvm::SmallVectorImpl<llvm::Value *> &args,
+                                    BlockLIRBuilder *builder,
+                                    Llvm_backend *be) {
+  return atomicCasMaker(args, builder, be, be->llvmInt64Type());
+}
+
 void BuiltinTable::defineExprBuiltins()
 {
   Btype *boolType = tman_->boolType();
@@ -655,13 +666,13 @@
   {
     BuiltinEntryTypeVec typeVec = {boolType, uint32PtrType, uint32PtrType, uint32Type,
                                    boolType, int32Type, int32Type};
-    registerExprBuiltin("__atomic_compare_exchange_4", nullptr,
-                        typeVec, atomicCasMaker);
+    registerExprBuiltin("__atomic_compare_exchange_4", nullptr, typeVec,
+                        atomicCasMaker4);
   }
   {
     BuiltinEntryTypeVec typeVec = {boolType, uint64PtrType, uint64PtrType, uint64Type,
                                    boolType, int32Type, int32Type};
-    registerExprBuiltin("__atomic_compare_exchange_8", nullptr,
-                        typeVec, atomicCasMaker);
+    registerExprBuiltin("__atomic_compare_exchange_8", nullptr, typeVec,
+                        atomicCasMaker8);
   }
 }

diff --git a/bridge/go-llvm-dibuildhelper.cpp b/bridge/go-llvm-dibuildhelper.cpp
index 777b8d9..de94946 100644
--- a/bridge/go-llvm-dibuildhelper.cpp
+++ b/bridge/go-llvm-dibuildhelper.cpp

@@ -156,13 +156,7 @@
   if(var->initializer() && !var->initializerInstruction()->getParent())
     return;
 
-  // Create the declare instruction, giving it an initial position at
-  // the end of the entry block (the insertDeclare call below doesn't
-  // allow a NULL insert location, so we pick end-of-block arbitrarily).
   assert(entryBlock_);
-  llvm::Instruction *decl =
-      dibuilder().insertDeclare(var->value(), dilv, expr, vloc, entryBlock_);
-  decl->removeFromParent();
 
   // Extract the decl from the end of the entry block and reposition
   // it according to the var properties.
@@ -173,7 +167,11 @@
   } else if (var->flavor() == ParamVar) {
     // parameters passing by reference may have no initializers.
     // declare them at function entry.
-    entryBlock_->getInstList().push_front(decl);
+    if (!entryBlock_->empty())
+      dibuilder().insertDeclare(var->value(), dilv, expr, vloc,
+                                &entryBlock_->front());
+    else
+      dibuilder().insertDeclare(var->value(), dilv, expr, vloc, entryBlock_);
     return;
   } else {
     // locals with no initializer should only be zero-sized vars.
@@ -185,7 +183,12 @@
 
   assert(! llvm::isa<llvm::BranchInst>(insertionPoint));
   assert(insertionPoint != insertionPoint->getParent()->getTerminator());
-  decl->insertAfter(insertionPoint);
+  if (insertionPoint->getNextNode())
+    dibuilder().insertDeclare(var->value(), dilv, expr, vloc,
+                              insertionPoint->getNextNode());
+  else
+    dibuilder().insertDeclare(var->value(), dilv, expr, vloc,
+                              insertionPoint->getParent());
 }
 
 void DIBuildHelper::endFunction(Bfunction *function)
@@ -310,7 +313,7 @@
 
 std::string DIBuildHelper::applyDebugPrefix(llvm::StringRef path) {
   for (const auto &remap : debugPrefixMap_)
-    if (path.startswith(remap.first))
+    if (path.starts_with(remap.first))
       return (llvm::Twine(remap.second) +
               path.substr(remap.first.size())).str();
   return path.str();

diff --git a/bridge/go-llvm-irbuilders.cpp b/bridge/go-llvm-irbuilders.cpp
index de007b1..d883cec 100644
--- a/bridge/go-llvm-irbuilders.cpp
+++ b/bridge/go-llvm-irbuilders.cpp

@@ -25,14 +25,14 @@
 
 BlockLIRBuilder::~BlockLIRBuilder()
 {
-  assert(dummyBlock_->getInstList().empty());
+  assert(dummyBlock_->empty());
   dummyBlock_->removeFromParent();
 }
 
 std::vector<llvm::Instruction*> BlockLIRBuilder::instructions()
 {
   std::vector<llvm::Instruction*> rv;
-  for (auto &i : dummyBlock_->getInstList())
+  for (auto &i : *dummyBlock_)
     rv.push_back(&i);
   for (auto &i : rv) {
     i->removeFromParent();

diff --git a/bridge/go-llvm-irbuilders.h b/bridge/go-llvm-irbuilders.h
index 537eb1d..d54f1b6 100644
--- a/bridge/go-llvm-irbuilders.h
+++ b/bridge/go-llvm-irbuilders.h

@@ -31,8 +31,7 @@
   void setDest(Bexpression *expr) { assert(!expr_); expr_ = expr; }
 
   void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name,
-                    llvm::BasicBlock *BB,
-                    llvm::BasicBlock::iterator InsertPt) const {
+                    llvm::BasicBlock::iterator InsertPt) const override {
     assert(expr_);
     expr_->appendInstruction(I);
     I->setName(Name);

diff --git a/bridge/go-llvm-materialize.cpp b/bridge/go-llvm-materialize.cpp
index 8e89288..3d2bc1a 100644
--- a/bridge/go-llvm-materialize.cpp
+++ b/bridge/go-llvm-materialize.cpp

@@ -121,8 +121,7 @@
   assert(valtyp->isPointerTy());
   if (valtyp->getPointerAddressSpace() != addressSpace_) {
     llvm::Type *typ =
-        llvm::PointerType::get(valtyp->getPointerElementType(),
-                               addressSpace_);
+        llvm::PointerType::get(valtyp->getContext(), addressSpace_);
     val = new llvm::AddrSpaceCastInst(val, typ, "ascast");
   }
 
@@ -176,9 +175,8 @@
     }
     if (lvalue || useCopyForLoadStore(type->type())) {
       llvm::Type *et = expr->btype()->type();
-      if (valType->isPointerTy() &&
-          valType->getPointerElementType() == et)
-        toType = llvm::PointerType::get(toType, addressSpace_);
+      if (valType->isPointerTy())
+        toType = llvm::PointerType::get(toType->getContext(), addressSpace_);
     }
   }
 
@@ -230,8 +228,7 @@
     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);
+      llvm::Type *pt = llvm::PointerType::get(val->getContext(), 0);
       std::string tname(namegen("ascast"));
       val = builder.CreateAddrSpaceCast(val, pt, tname);
       expr = nbuilder_.mkConversion(type, val, expr, location);
@@ -248,8 +245,7 @@
     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);
+      pt = llvm::PointerType::get(toType->getContext(), 0);
     }
     std::string tname(namegen("itpcast"));
     llvm::Value *itpcast = builder.CreateIntToPtr(val, pt, tname);
@@ -342,14 +338,13 @@
   return rval;
 }
 
-llvm::Value *Llvm_backend::makePointerOffsetGEP(llvm::PointerType *llpt,
-                                                llvm::Value *idxval,
-                                                llvm::Value *sptr)
-{
+llvm::Value *Llvm_backend::makePointerOffsetGEP(Btype *pt, llvm::Value *idxval,
+                                                llvm::Value *sptr) {
   LIRBuilder builder(context_, llvm::ConstantFolder());
   llvm::SmallVector<llvm::Value *, 1> elems(1);
   elems[0] = idxval;
-  llvm::Value *val = builder.CreateGEP(llpt->getElementType(), sptr, elems, namegen("ptroff"));
+  llvm::Type *eltTy = pt->castToBPointerType()->toType()->type();
+  llvm::Value *val = builder.CreateGEP(eltTy, sptr, elems, namegen("ptroff"));
   return val;
 }
 
@@ -365,12 +360,10 @@
   return val;
 }
 
-llvm::Value *Llvm_backend::makeFieldGEP(unsigned fieldIndex,
-                                        llvm::Value *sptr)
-{
+llvm::Value *Llvm_backend::makeFieldGEP(unsigned fieldIndex, llvm::Type *sty,
+                                        llvm::Value *sptr) {
   assert(sptr->getType()->isPointerTy());
-  llvm::PointerType *srcTyp = llvm::cast<llvm::PointerType>(sptr->getType());
-  llvm::StructType *llst = llvm::cast<llvm::StructType>(srcTyp->getElementType());
+  llvm::StructType *llst = llvm::cast<llvm::StructType>(sty);
   LIRBuilder builder(context_, llvm::ConstantFolder());
   assert(fieldIndex < llst->getNumElements());
   std::string tag(namegen("field"));
@@ -401,7 +394,7 @@
   if (bstruct->isConstant())
     fval = llvm::cast<llvm::Constant>(sval)->getAggregateElement(index);
   else
-    fval = makeFieldGEP(index, sval);
+    fval = makeFieldGEP(index, llt, sval);
   Btype *bft = elementTypeByIndex(bstruct->btype(), index);
 
   // Wrap result in a Bexpression
@@ -632,29 +625,9 @@
   if (leftType == rightType)
     return rval;
 
-  // Case 1: nil op X
-  if (llvm::isa<llvm::ConstantPointerNull>(leftVal) &&
-      rightType->isPointerTy()) {
-    BexprLIRBuilder builder(context_, left);
-    std::string tag(namegen("cast"));
-    llvm::Value *bitcast = builder.CreateBitCast(leftVal, rightType, tag);
-    rval.first = bitcast;
-    return rval;
-  }
-
-  // Case 2: X op nil
-  if (llvm::isa<llvm::ConstantPointerNull>(rightVal) &&
-      leftType->isPointerTy()) {
-    BexprLIRBuilder builder(context_, right);
-    std::string tag(namegen("cast"));
-    llvm::Value *bitcast = builder.CreateBitCast(rightVal, leftType, tag);
-    rval.second = bitcast;
-    return rval;
-  }
-
   // Case 3: shift with different sized operands (ex: int64(v) << uint8(3)).
   // Promote or demote shift amount operand to match width of left operand.
-  if ((op == OPERATOR_LSHIFT || op == OPERATOR_RSHIFT) &&
+  if ((op == OPERATOR_LSHIFT || op == OPERATOR_RSHIFT || op == OPERATOR_EQEQ) &&
       leftType != rightType) {
     BexprLIRBuilder builder(context_, right);
     llvm::IntegerType *leftITyp = llvm::cast<llvm::IntegerType>(leftType);
@@ -668,24 +641,6 @@
     return rval;
   }
 
-  // Case 4: pointer type comparison
-  // We check that if both are pointer types and pointing to the same type,
-  // insert a cast (it doesn't matter we cast which one). This mostly needed
-  // for circular pointer types (ex: type T *T; var p, q T; p == &q), where
-  // the two sides have semantically identical types but with different
-  // representations (in this case, T vs. *T).
-  if (leftType->isPointerTy() && rightType->isPointerTy()) {
-    BPointerType *lbpt = left->btype()->castToBPointerType();
-    BPointerType *rbpt = right->btype()->castToBPointerType();
-    if (lbpt->toType()->type() == rbpt->toType()->type()) {
-      BexprLIRBuilder builder(context_, right);
-      std::string tag(namegen("cast"));
-      llvm::Value *bitcast = builder.CreateBitCast(rightVal, leftType, tag);
-      rval.second = bitcast;
-      return rval;
-    }
-  }
-
   return rval;
 }
 
@@ -1024,10 +979,8 @@
   base = resolveVarContext(base);
 
   // Construct an appropriate GEP
-  llvm::PointerType *llpt =
-      llvm::cast<llvm::PointerType>(base->btype()->type());
   llvm::Value *gep =
-      makePointerOffsetGEP(llpt, index->value(), base->value());
+      makePointerOffsetGEP(base->btype(), index->value(), base->value());
 
   // Wrap in a Bexpression
   Bexpression *rval = nbuilder_.mkPointerOffset(base->btype(), gep, base,
@@ -1192,7 +1145,7 @@
       if (paramInfo.attr() == AttrByVal && vt->getPointerAddressSpace() != 0) {
         // We pass a stack address, which is always in address space 0.
         std::string castname(namegen("ascast"));
-        llvm::Type *pt = llvm::PointerType::get(vt->getPointerElementType(), 0);
+        llvm::Type *pt = llvm::PointerType::get(vt->getContext(), 0);
         val = builder.CreateAddrSpaceCast(val, pt, castname);
       }
 
@@ -1240,29 +1193,13 @@
           Bvariable *cv = genVarForConstant(cval, resarg->btype());
           val = cv->value();
         }
-        std::string castname(namegen("cast"));
-        // We are going to do a load, so the address space does not matter.
-        // It seems we may get here with either address space, so we just
-        // do an address-space-preserving cast.
-        llvm::Type *ptv =
-            llvm::PointerType::get(paramInfo.abiType(),
-                                   val->getType()->getPointerAddressSpace());
-        llvm::Value *bitcast = builder.CreateBitCast(val, ptv, castname);
         std::string ltag(namegen("ld"));
-        llvm::Value *ld = builder.CreateLoad(paramInfo.abiType(), bitcast, ltag);
+        llvm::Value *ld = builder.CreateLoad(paramInfo.abiType(), val, ltag);
         state.llargs.push_back(ld);
         continue;
       }
       // Passing a single 8-byte-or-less argument.
 
-      // Apply any necessary pointer type conversions.
-      if (val->getType()->isPointerTy() && ctx == VE_rvalue) {
-        llvm::FunctionType *llft =
-            llvm::cast<llvm::FunctionType>(state.calleeFcnType->type());
-        llvm::Type *paramTyp = llft->getParamType(paramInfo.sigOffset());
-        val = convertForAssignment(resarg, paramTyp);
-      }
-
       // Apply any necessary sign-extensions or zero-extensions.
       if (paramInfo.abiType()->isIntegerTy()) {
         if (paramInfo.attr() == AttrZext)
@@ -1283,7 +1220,6 @@
 
     // Create a struct type of the appropriate shape
     llvm::Type *llst = paramInfo.computeABIStructType(typeManager());
-    llvm::Type *ptst = makeLLVMPointerType(llst);
 
     // If the value we're passing is a composite constant, we have to
     // spill it to memory here in order for the casts below to work.
@@ -1299,16 +1235,11 @@
       val = cv->value();
     }
 
-    // Cast the value to the struct type
-    std::string tag(namegen("cast"));
-    llvm::Value *bitcast =
-        builder.CreatePointerBitCastOrAddrSpaceCast(val, ptst, tag);
-
     // Load up each field
     for ( unsigned i = 0; i < paramInfo.abiTypes().size(); ++i) {
       std::string ftag(namegen("field"+std::to_string(i)));
       llvm::Value *fieldgep =
-          builder.CreateConstInBoundsGEP2_32(llst, bitcast, 0, i, ftag);
+          builder.CreateConstInBoundsGEP2_32(llst, val, 0, i, ftag);
       std::string ltag(namegen("ld"));
       llvm::Value *ld = builder.CreateLoad(paramInfo.abiTypes()[i], fieldgep, ltag);
       state.llargs.push_back(ld);
@@ -1389,13 +1320,8 @@
       llvm::Type *rt = (returnInfo.abiTypes().size() == 1 ?
                         returnInfo.abiType()  :
                         returnInfo.computeABIStructType(typeManager()));
-      llvm::Type *ptrt = llvm::PointerType::get(rt, 0);
-      std::string castname(namegen("cast"));
-      llvm::Value *bitcast =
-          state.builder.CreateBitCast(state.sretTemp,
-                                      ptrt, castname);
       std::string stname(namegen("st"));
-      state.builder.CreateStore(callInst, bitcast);
+      state.builder.CreateStore(callInst, state.sretTemp);
       callExpr->appendInstructions(state.builder.instructions());
     }
   }
@@ -1605,152 +1531,6 @@
   return rval;
 }
 
-llvm::Value *
-Llvm_backend::convertForAssignment(Bexpression *src,
-                                   llvm::Type *dstToType)
-{
-  if (src->value()->getType() == dstToType)
-    return src->value();
-
-  llvm::Function *dummyFcn = errorFunction_->function();
-  BlockLIRBuilder builder(dummyFcn, this);
-  llvm::Value *val = convertForAssignment(src->btype(), src->value(),
-                                          dstToType, &builder);
-  src->appendInstructions(builder.instructions());
-  return val;
-}
-
-llvm::Value *
-Llvm_backend::convertForAssignment(Btype *srcBType,
-                                   llvm::Value *srcVal,
-                                   llvm::Type *dstToType,
-                                   BlockLIRBuilder *builder)
-{
-  llvm::Type *srcType = srcVal->getType();
-
-  if (dstToType == srcType)
-    return srcVal;
-
-  // Case 1: handle discrepancies between representations of function
-  // descriptors. All front end function descriptor types are structs
-  // with a single field, however this field can sometimes be a pointer
-  // to function, and sometimes it can be of uintptr type.
-  bool srcPtrToFD = isPtrToFuncDescriptorType(srcType);
-  bool dstPtrToFD = isPtrToFuncDescriptorType(dstToType);
-  if (srcPtrToFD && dstPtrToFD) {
-    std::string tag(namegen("cast"));
-    llvm::Value *bitcast = builder->CreateBitCast(srcVal, dstToType, tag);
-    return bitcast;
-  }
-
-  // Case 2: handle circular function types.
-  bool dstCircFunc = isCircularFunctionType(dstToType);
-  bool srcCircFunc = isCircularFunctionType(srcType);
-  bool srcFuncPtr = isPtrToFuncType(srcType);
-  if (((srcPtrToFD || srcFuncPtr || srcCircFunc) && dstCircFunc) ||
-       (srcCircFunc && dstPtrToFD)) {
-    std::string tag(namegen("cast"));
-    llvm::Value *bitcast = builder->CreateBitCast(srcVal, dstToType, tag);
-    return bitcast;
-  }
-
-  // Case 3: handle raw function pointer assignment (frontend will
-  // sometimes take a function pointer and assign it to "void *" without
-  // an explicit conversion).
-  bool dstPtrToVoid = isPtrToVoidType(dstToType);
-  if (dstPtrToVoid && srcFuncPtr) {
-    std::string tag(namegen("cast"));
-    llvm::Value *bitcast = builder->CreateBitCast(srcVal, dstToType, tag);
-    return bitcast;
-  }
-
-  // Case 4: in some cases when calling a function (for example, __gogo)
-  // the front end will pass a raw function vale in place of a function
-  // descriptor. Allow this case.
-  if (dstPtrToFD && srcFuncPtr) {
-    std::string tag(namegen("cast"));
-    llvm::Value *bitcast =
-        builder->CreatePointerBitCastOrAddrSpaceCast(srcVal, dstToType, tag);
-    return bitcast;
-  }
-
-  // Case 5: handle polymorphic nil pointer expressions-- these are
-  // generated without a type initially, so we need to convert them
-  // to the appropriate type if they appear in an assignment context.
-  if (srcVal == nil_pointer_expression()->value()) {
-    std::string tag(namegen("cast"));
-    llvm::Value *bitcast = builder->CreateBitCast(srcVal, dstToType, tag);
-    return bitcast;
-  }
-
-  // Case 6: the code that creates interface values stores pointers of
-  // various flavors into i8*. Ideally it would be better to insert
-  // forced type conversions in the FE, but for now we allow this case.
-  bool srcPtrToIface = isPtrToIfaceStructType(srcType);
-  if (dstPtrToVoid && srcPtrToIface) {
-    std::string tag(namegen("cast"));
-    llvm::Value *bitcast = builder->CreateBitCast(srcVal, dstToType, tag);
-    return bitcast;
-  }
-
-  // Case 7: when creating slice values it's common for the frontend
-  // to mix pointers and arrays, e.g. assign "[3 x i64]*" to "i64**".
-  // Allow this sort of conversion.
-  llvm::Type *elt =
-      (dstToType->isPointerTy() ?
-       llvm::cast<llvm::PointerType>(dstToType)->getElementType() : nullptr);
-  if (elt && isPtrToArrayOf(srcType, elt)) {
-    std::string tag(namegen("cast"));
-    llvm::Value *bitcast = builder->CreateBitCast(srcVal, dstToType, tag);
-    return bitcast;
-  }
-
-  // Case 8: also when creating slice values it's common for the
-  // frontend to assign pointer-to-X to unsafe.Pointer (and vice versa)
-  // without an explicit cast. Allow this for now.
-  if ((dstToType == llvmPtrType() && llvm::isa<llvm::PointerType>(srcType)) ||
-      (srcType == llvmPtrType() && llvm::isa<llvm::PointerType>(dstToType))) {
-    std::string tag(namegen("cast"));
-    llvm::Value *bitcast = builder->CreatePointerBitCastOrAddrSpaceCast(srcVal, dstToType, tag);
-    return bitcast;
-  }
-
-  // Case 9: related to case 1 above, interface value expressions can
-  // contain C function pointers stored as "void *" instead of
-  // concrete pointer-to-function values. For example, consider a
-  // value V1 of the form
-  //
-  //       { { T1*, void* }, O* }
-  //
-  // where T1 is a type descriptor and O is an object; this value can
-  // sometimes be assigned to a location of type
-  //
-  //       { { T1*, F* }, O* }
-  //
-  // where F is a concrete C pointer-to-function (as opposed to "void*").
-  // Allow conversions of this sort for now.
-  std::set<llvm::Type *> visited;
-  if (fcnPointerCompatible(dstToType, srcType, visited)) {
-    std::string tag(namegen("cast"));
-    llvm::Value *bitcast =
-        builder->CreatePointerBitCastOrAddrSpaceCast(srcVal, dstToType, tag);
-    return bitcast;
-  }
-
-  // Case 10: circular pointer type (ex: type T *T; var p T; p = &p)
-  BPointerType *srcbpt = srcBType->castToBPointerType();
-  if (srcbpt) {
-    Btype *ctypconv = circularTypeAddrConversion(srcbpt->toType());
-    if (ctypconv != nullptr && ctypconv->type() == dstToType) {
-      std::string tag(namegen("cast"));
-      llvm::Value *bitcast = builder->CreateBitCast(srcVal, dstToType, tag);
-      return bitcast;
-    }
-  }
-
-  return srcVal;
-}
-
 // Walk the specified expression and invoke setVarExprPending on
 // each var expression, with correct lvalue/rvalue tag depending on
 // context.

diff --git a/bridge/go-llvm-typemanager.cpp b/bridge/go-llvm-typemanager.cpp
index 4301233..d853e43 100644
--- a/bridge/go-llvm-typemanager.cpp
+++ b/bridge/go-llvm-typemanager.cpp

@@ -1008,8 +1008,8 @@
   // Circular function/pointer types have isPlaceholder false, but they do
   // need to resolve, so special-case them.
   if (!placeholder->isPlaceholder() &&
-      circularPointerTypes_.find(placeholder->type()) == circularPointerTypes_.end() &&
-      circularFunctionTypes_.find(placeholder->type()) == circularFunctionTypes_.end())
+      circularPointerTypes_.find(placeholder) == circularPointerTypes_.end() &&
+      circularFunctionTypes_.find(placeholder) == circularFunctionTypes_.end())
     return true;
 
   assert(anonTypes_.find(placeholder) == anonTypes_.end());
@@ -1038,8 +1038,8 @@
       }
 
       // Circular pointer type handling
-      circularConversionLoadMap_[cpt->type()] = elt;
-      circularConversionAddrMap_[elt->type()] = cpt;
+      circularConversionLoadMap_[cpt] = elt;
+      circularConversionAddrMap_[elt] = cpt;
 
       return setPlaceholderPointerType(placeholder, cpt);
     }
@@ -1056,9 +1056,9 @@
     std::cerr << "redir: "; to_type->dump();
   }
 
-  auto it = circularFunctionTypes_.find(placeholder->type());
+  auto it = circularFunctionTypes_.find(placeholder);
   if (it != circularFunctionTypes_.end())
-    circularFunctionTypes_.insert(to_type->type());
+    circularFunctionTypes_.insert(to_type);
 
   // Update the target type for the pointer
   BPointerType *bpt = placeholder->castToBPointerType();
@@ -1251,11 +1251,11 @@
     // Push marker and placeholder onto a stack so that we can
     // update them when the appropriate function type is created.
     circularFunctionPlaceholderTypes_.insert(placeholder);
-    circularFunctionTypes_.insert(rval->type());
+    circularFunctionTypes_.insert(rval);
   } else {
     // Set up to start tracking the types that will make up the
     // loop involved in the cycle.
-    circularPointerTypes_.insert(circ_typ);
+    circularPointerTypes_.insert(rval);
   }
 
   if (traceLevel() > 1) {
@@ -1278,35 +1278,25 @@
   auto it = circularFunctionPlaceholderTypes_.find(btype);
   if (it != circularFunctionPlaceholderTypes_.end())
     return true;
-  return isCircularFunctionType(btype->type());
-}
-
-bool TypeManager::isCircularFunctionType(llvm::Type *typ) {
-  assert(typ);
-  auto it = circularFunctionTypes_.find(typ);
-  return it != circularFunctionTypes_.end();
+  auto it2 = circularFunctionTypes_.find(btype);
+  return it2 != circularFunctionTypes_.end();
 }
 
 // Return whether we might be looking at a circular pointer type.
 
-bool TypeManager::isCircularPointerType(Btype *btype) {
-  assert(btype);
-  return isCircularPointerType(btype->type());
-}
-
-bool TypeManager::isCircularPointerType(llvm::Type *typ) {
+bool TypeManager::isCircularPointerType(Btype *typ) {
   assert(typ);
   auto it = circularPointerTypes_.find(typ);
   return it != circularPointerTypes_.end();
 }
 
 Btype *TypeManager::circularTypeLoadConversion(Btype *typ) {
-  auto it = circularConversionLoadMap_.find(typ->type());
+  auto it = circularConversionLoadMap_.find(typ);
   return it != circularConversionLoadMap_.end()  ? it->second : nullptr;
 }
 
 Btype *TypeManager::circularTypeAddrConversion(Btype *typ) {
-  auto it = circularConversionAddrMap_.find(typ->type());
+  auto it = circularConversionAddrMap_.find(typ);
   if (it != circularConversionAddrMap_.end())
     return it->second;
   return nullptr;
@@ -1506,7 +1496,7 @@
   if (btype == errorType_)
     return 1;
   llvm::Type *toget = getPlaceholderProxyIfNeeded(btype);
-  unsigned uval = datalayout_->getABITypeAlignment(toget);
+  unsigned uval = datalayout_->getABITypeAlign(toget).value();
   return static_cast<int64_t>(uval);
 }
 
@@ -1538,7 +1528,7 @@
   llvm::StructType *dummyst = llvm::StructType::get(context_, elems);
   const llvm::StructLayout *sl = datalayout_->getStructLayout(dummyst);
   uint64_t uoff = sl->getElementOffset(1);
-  unsigned talign = datalayout_->getABITypeAlignment(toget);
+  unsigned talign = datalayout_->getABITypeAlign(toget).value();
   int64_t rval = (uoff < talign ? uoff : talign);
   return rval;
 }
@@ -1564,134 +1554,6 @@
   return static_cast<int64_t>(uoff);
 }
 
-bool TypeManager::isPtrToIfaceStructType(llvm::Type *typ)
-{
-  if (! typ->isPointerTy())
-    return false;
-  llvm::PointerType *pt = llvm::cast<llvm::PointerType>(typ);
-  llvm::Type *elt = pt->getElementType();
-  if (! elt->isStructTy())
-    return false;
-  llvm::StructType *st = llvm::cast<llvm::StructType>(elt);
-  if (st->getNumElements() != 2)
-    return false;
-  llvm::SmallPtrSet<llvm::Type *, 32> vis;
-  // expect { ptr, ptr } or { ptr, uintptr }
-  return (st->getElementType(0)->isPointerTy() &&
-          (st->getElementType(1)->isPointerTy() ||
-           st->getElementType(1) == llvmIntegerType()));
-}
-
-bool TypeManager::isFuncDescriptorType(llvm::Type *typ)
-{
-  if (! typ->isStructTy())
-    return false;
-  llvm::StructType *st = llvm::cast<llvm::StructType>(typ);
-  if (st->getNumElements() != 1)
-    return false;
-  llvm::Type *f0t = st->getElementType(0);
-  llvm::PointerType *f0tpt = nullptr;
-  if (f0t->isPointerTy())
-    f0tpt = llvm::cast<llvm::PointerType>(f0t);
-  if (f0t != llvmIntegerType_ &&
-      !f0t->isFunctionTy() &&
-      !(f0tpt && f0tpt->getElementType()->isFunctionTy()))
-    return false;
-  return true;
-}
-
-bool TypeManager::isPtrToFuncDescriptorType(llvm::Type *typ)
-{
-  if (! typ->isPointerTy())
-    return false;
-  llvm::PointerType *pt = llvm::cast<llvm::PointerType>(typ);
-  return isFuncDescriptorType(pt->getElementType());
-}
-
-bool TypeManager::isPtrToFuncType(llvm::Type *typ)
-{
-  if (! typ->isPointerTy())
-    return false;
-  llvm::PointerType *pt = llvm::cast<llvm::PointerType>(typ);
-  return pt->getElementType()->isFunctionTy();
-}
-
-bool TypeManager::isPtrToVoidType(llvm::Type *typ)
-{
-  if (! typ->isPointerTy())
-    return false;
-  llvm::PointerType *pt = llvm::cast<llvm::PointerType>(typ);
-  return pt->getElementType() == llvmInt8Type_;
-}
-
-bool TypeManager::isPtrToArrayOf(llvm::Type *typ, llvm::Type *arElmTyp)
-{
-  if (! typ->isPointerTy())
-    return false;
-  llvm::PointerType *pt = llvm::cast<llvm::PointerType>(typ);
-  llvm::Type *elt = pt->getElementType();
-  if (! elt->isArrayTy())
-    return false;
-  llvm::ArrayType *llat = llvm::cast<llvm::ArrayType>(elt);
-  llvm::Type *aelt = llat->getElementType();
-  if (aelt == arElmTyp)
-    return true;
-  if (isCircularFunctionType(aelt) && isCircularFunctionType(arElmTyp))
-    return true; // TODO: check they are same circular function type?
-  return false;
-}
-
-bool TypeManager::fcnPointerCompatible(llvm::Type *left,
-                                       llvm::Type *right,
-                                       std::set<llvm::Type *> &visited)
-{
-  // Allow for pointer-to-fp and func-desc matching
-  bool leftFPD = isPtrToFuncType(left) || isPtrToVoidType(left);
-  bool rightFPD = isPtrToFuncType(right) || isPtrToVoidType(right);
-  if (leftFPD && rightFPD)
-    return true;
-
-  bool visleft = (visited.find(left) != visited.end());
-  bool visright = (visited.find(right) != visited.end());
-  if (visleft != visright)
-    return false;
-  if (visleft)
-    return true;
-  visited.insert(left);
-  visited.insert(right);
-
-  // Compare type ID, children, etc.
-  if (left->getTypeID() != right->getTypeID())
-    return false;
-
-  // For pointer types, visit pointed-to elements
-  if (left->isPointerTy()) {
-    llvm::PointerType *ptl = llvm::cast<llvm::PointerType>(left);
-    llvm::PointerType *ptr = llvm::cast<llvm::PointerType>(right);
-    llvm::Type *eltl = ptl->getElementType();
-    llvm::Type *eltr = ptr->getElementType();
-    return fcnPointerCompatible(eltl, eltr, visited);
-  }
-
-  // For aggregate types, compare children.
-  if (left->isAggregateType()) {
-    unsigned leftnct = left->getNumContainedTypes();
-    unsigned rightnct = right->getNumContainedTypes();
-    if (leftnct != rightnct)
-      return false;
-    for (unsigned cti = 0; cti < leftnct; cti++) {
-      llvm::Type *leftchild = left->getContainedType(cti);
-      llvm::Type *rightchild = right->getContainedType(cti);
-      if (!fcnPointerCompatible(leftchild, rightchild, visited))
-        return false;
-    }
-    return true;
-  } else {
-    // For non-aggregate types, we expect underlying llvm types to match
-    return (left == right);
-  }
-}
-
 std::string TypeManager::typToString(Btype *typ)
 {
   std::map<Btype *, std::string> smap;
@@ -1750,7 +1612,7 @@
       assert(!bpt->isPlaceholder());
 
       // handle circular pointer types
-      auto cpit = circularPointerTypes_.find(typ->type());
+      auto cpit = circularPointerTypes_.find(typ);
       if (cpit != circularPointerTypes_.end()) {
         std::string s;
         llvm::raw_string_ostream os(s);
@@ -1848,7 +1710,7 @@
   // Now create struct type itself.  Q: should this be
   // getTypeAllocSize here instead of getTypeSizeInBits?
   uint64_t sizeInBits = datalayout_->getTypeSizeInBits(bst->type());
-  uint32_t alignInBits = datalayout_->getABITypeAlignment(bst->type());
+  uint32_t alignInBits = datalayout_->getABITypeAlign(bst->type()).value();
   llvm::DIType *derivedFrom = nullptr;
   llvm::DICompositeType *dist =
       dibuilder.createStructType(scope, typToString(bst),
@@ -1976,7 +1838,7 @@
       uint64_t arElems = bat->nelSize();
       uint64_t arSize = datalayout_->getTypeSizeInBits(bat->type());
       uint64_t arAlign =
-          datalayout_->getABITypeAlignment(bat->elemType()->type());
+          datalayout_->getABITypeAlign(bat->elemType()->type()).value();
       llvm::SmallVector<llvm::Metadata *, 1> subscripts;
       subscripts.push_back(dibuilder.getOrCreateSubrange(0, arElems));
       llvm::DINodeArray subsAr = dibuilder.getOrCreateArray(subscripts);

diff --git a/bridge/go-llvm-typemanager.h b/bridge/go-llvm-typemanager.h
index d77a3ab..4db9ccc 100644
--- a/bridge/go-llvm-typemanager.h
+++ b/bridge/go-llvm-typemanager.h

@@ -74,9 +74,7 @@
   Btype *namedType(const std::string &, Btype *, Location);
   Btype *circularPointerType(Btype *, bool);
   bool isCircularPointerType(Btype *);
-  bool isCircularPointerType(llvm::Type *);
   bool isCircularFunctionType(Btype *);
-  bool isCircularFunctionType(llvm::Type *);
   int64_t typeSize(Btype *);
   int64_t typeAlignment(Btype *);
   int64_t typeFieldAlignment(Btype *);
@@ -205,24 +203,6 @@
   // found.
   bool addPlaceholderRefs(Btype *type);
 
-  // Helpers
-  bool isFuncDescriptorType(llvm::Type *typ);
-  bool isPtrToFuncDescriptorType(llvm::Type *typ);
-  bool isPtrToIfaceStructType(llvm::Type *typ);
-  bool isPtrToFuncType(llvm::Type *typ);
-  bool isPtrToVoidType(llvm::Type *typ);
-  bool isPtrToArrayOf(llvm::Type *ptyp, llvm::Type *arrayElmTyp);
-
-  // This helper looks at two LLVM types and does a structural
-  // comparison to determine if 'left' is equivalent to 'right' modulo
-  // discrepancies between raw function pointers and "void *" (or
-  // equivalent). This is to allow for cases where the front end will
-  // store a function pointer in a table or struct somewhere as "void
-  // *" instead of the precise function type.
-  bool fcnPointerCompatible(llvm::Type *left,
-                            llvm::Type *right,
-                            std::set<llvm::Type *> &visited);
-
   // If specified type is a pointer flagged as being a circular
   // type, return conversion needed on load from that type, or NULL
   // if the type is not circular.
@@ -337,15 +317,15 @@
 
   // Set of circular pointer types. These are pointers to opaque types that
   // are returned by the ::circular_pointer_type() method.
-  std::unordered_set<llvm::Type *> circularPointerTypes_;
+  std::unordered_set<Btype *> circularPointerTypes_;
 
   // Map from placeholder type to circular pointer type. Key is placeholder
   // pointer type, value is circular pointer type marker.
   std::unordered_map<Btype *, Btype *> circularPointerTypeMap_;
 
   // Maps for inserting conversions involving circular pointers.
-  std::unordered_map<llvm::Type *, Btype *> circularConversionLoadMap_;
-  std::unordered_map<llvm::Type *, Btype *> circularConversionAddrMap_;
+  std::unordered_map<Btype *, Btype *> circularConversionLoadMap_;
+  std::unordered_map<Btype *, Btype *> circularConversionAddrMap_;
 
   // Set of top-level circular function types.
   std::unordered_set<Btype *> circularFunctionPlaceholderTypes_;
@@ -353,7 +333,7 @@
   // This set holds the marker types returned for the self-referential
   // elements within a circular function type, also any resolved LLVM
   // function types created from placeholders.
-  std::unordered_set<llvm::Type *> circularFunctionTypes_;
+  std::unordered_set<Btype *> circularFunctionTypes_;
 
   // Name generation helper
   NameGen *nametags_;

diff --git a/bridge/go-llvm.cpp b/bridge/go-llvm.cpp
index 8ee5a24..be0f0bc 100644
--- a/bridge/go-llvm.cpp
+++ b/bridge/go-llvm.cpp

@@ -412,10 +412,7 @@
 Bfunction *Llvm_backend::createIntrinsicFcn(const std::string &name,
                                             llvm::Function *fcn)
 {
-  llvm::PointerType *llpft =
-      llvm::cast<llvm::PointerType>(fcn->getType());
-  llvm::FunctionType *llft =
-      llvm::cast<llvm::FunctionType>(llpft->getElementType());
+  llvm::FunctionType *llft = fcn->getFunctionType();
   BFunctionType *fcnType = makeAuxFcnType(llft);
   Location pdcl = linemap()->get_predeclared_location();
   Bfunction *bfunc = new Bfunction(fcn, fcnType, name, name, pdcl,
@@ -567,18 +564,10 @@
   llvm::Type *vt = val->getType();
   assert(vt->isPointerTy());
   llvm::Type *llToType = toType->type();
-  if (expr->varExprPending()) {
-    llvm::Type *et = expr->btype()->type();
-    if (vt->getPointerElementType() == et)
-      llToType = llvm::PointerType::get(llToType, vt->getPointerAddressSpace());
-  }
   if (vt == llToType)
     return expr;
 
-  std::string tag(namegen("cast"));
-  LIRBuilder builder(context_, llvm::ConstantFolder());
-  llvm::Value *bitcast = builder.CreatePointerBitCastOrAddrSpaceCast(val, llToType, tag);
-  return nbuilder_.mkConversion(toType, bitcast, expr, loc);
+  return nbuilder_.mkConversion(toType, val, expr, loc);
 }
 
 Bexpression *Llvm_backend::genLoad(Bexpression *expr,
@@ -593,6 +582,7 @@
   // pointer types.
   Bexpression *space = expr;
   Btype *loadResultType;
+  bool needs_extra_deref = false;
   if (btype) {
     loadResultType = btype;
     Btype *tctyp = circularTypeLoadConversion(expr->btype());
@@ -600,6 +590,21 @@
       space = genCircularConversion(pointer_type(tctyp), expr, loc);
       loadResultType = tctyp;
     }
+    int flavor = expr->flavor();
+    // In most cases loadResultType is the same as value llvm type,
+    // or they're both pointers. Still in some cases we need additional
+    // level of indirection. This happens when:
+    // 1. expr is used to access variable, structure field or is a compound
+    //    expression. Those expression's llvm value is alloca or GEP, which
+    //    is actually a pointer to a value, not value itself.
+    // 2. expr is dereference (N_Deref), which has not yet been fully handled
+    //    by the bridge. In such case the load instruction has not yet been
+    //    generated.
+    if (!loadResultType->type()->isPointerTy())
+      needs_extra_deref =
+          ((flavor == N_Deref && expr->varExprPending()) || flavor == N_Var ||
+           flavor == N_StructField || flavor == N_Compound);
+
   } else {
     // Here we are resolving a pending var expression. The LLVM
     // value should already be pointer to the expression type.
@@ -608,18 +613,10 @@
   }
 
   llvm::Value *spaceVal = space->value();
-  if (spaceVal == nil_pointer_expression()->value()) {
-    llvm::Function *dummyFcn = errorFunction_->function();
-    BlockLIRBuilder builder(dummyFcn, this);
-    llvm::Type *spaceTyp = llvm::PointerType::get(loadResultType->type(), addressSpace_);
-    std::string tag(namegen("cast"));
-    spaceVal = builder.CreateBitCast(spaceVal, spaceTyp, tag);
-    space->appendInstructions(builder.instructions());
-  }
-
-  llvm::PointerType *llpt =
-      llvm::cast<llvm::PointerType>(spaceVal->getType());
-  llvm::Type *llrt = llpt->getElementType();
+  llvm::Type *llrt = loadResultType->type();
+  if (needs_extra_deref)
+    llrt = llvm::PointerType::get(
+        llrt, expr->btype()->type()->getPointerAddressSpace());
 
   // If this type meets our criteria (composite/aggregate whose
   // size is above a certain threshhold) then assume that the
@@ -631,13 +628,11 @@
     std::string ldname(tag);
     ldname += ".ld";
     ldname = namegen(ldname);
-    llvm::Type *vt = spaceVal->getType()->getPointerElementType();
     llvm::Instruction *insBefore = nullptr;
-    llvm::Align ldAlign = datalayout_->getABITypeAlign(vt);
+    llvm::Align ldAlign = datalayout_->getABITypeAlign(llrt);
     bool isVolatile = false;
-    llvm::Instruction *loadInst = new llvm::LoadInst(vt, spaceVal, ldname,
-                                                     isVolatile, ldAlign,
-                                                     insBefore);
+    llvm::Instruction *loadInst = new llvm::LoadInst(
+        llrt, spaceVal, ldname, isVolatile, ldAlign, insBefore);
     rval = nbuilder_.mkDeref(loadResultType, loadInst, space, loc);
     rval->appendInstruction(loadInst);
   } else {
@@ -879,17 +874,6 @@
   // Decide whether we want a simple store instruction or a memcpy.
   if (! useCopyForLoadStore(srcType)) {
 
-    if (srcVal->getType()->isPointerTy()) {
-      llvm::PointerType *dstpt =
-          llvm::cast<llvm::PointerType>(dstType);
-      srcVal = convertForAssignment(srcType, srcVal,
-                                    dstpt->getElementType(), builder);
-    }
-
-    // At this point the types should agree
-    llvm::PointerType *dpt = llvm::cast<llvm::PointerType>(dstType);
-    assert(srcVal->getType() == dpt->getElementType());
-
     // Create and return store
     return builder->CreateStore(srcVal, dstLoc);
   }
@@ -1101,21 +1085,6 @@
 
   // Normal case
   llvm::Value *varval = var->value();
-
-  // Special case for zero-sized globals. These require a type conversion,
-  // since the underlying definition has been coerced to something with
-  // non-zero size (as a means of avoiding linker misbehavior).
-  Btype *underlyingType = var->underlyingType();
-  if (underlyingType != nullptr) {
-    LIRBuilder irbuilder(context_, llvm::ConstantFolder());
-    std::string tag(namegen("zeroSizeCast"));
-    llvm::Type *toType = llvm::PointerType::get(var->btype()->type(),
-                                                addressSpace_);
-    llvm::Value *bitcast =
-        irbuilder.CreateBitCast(var->value(), toType, tag);
-    varval = bitcast;
-  }
-
   Bexpression *varexp = nbuilder_.mkVar(var, varval, location);
   varexp->setTag(var->name().c_str());
   return varexp;
@@ -1172,13 +1141,13 @@
   BIntegerType *bit = btype->castToBIntegerType();
   if (bit->isUnsigned()) {
     uint64_t val = checked_convert_mpz_to_int<uint64_t>(mpz_val);
-    llvm::APInt apiv(bit->bits(), val);
+    llvm::APInt apiv(bit->bits(), val, false, true);
     llvm::Constant *lval = llvm::ConstantInt::get(btype->type(), apiv);
     Bexpression *bconst = nbuilder_.mkConst(btype, lval);
     return makeGlobalExpression(bconst, lval, btype, Location());
   } else {
     int64_t val = checked_convert_mpz_to_int<int64_t>(mpz_val);
-    llvm::APInt apiv(bit->bits(), val, true);
+    llvm::APInt apiv(bit->bits(), val, true, true);
     llvm::Constant *lval = llvm::ConstantInt::get(btype->type(), apiv);
     Bexpression *bconst = nbuilder_.mkConst(btype, lval);
     return makeGlobalExpression(bconst, lval, btype, Location());
@@ -1310,11 +1279,9 @@
                     MV_SkipDebug, llvm::GlobalValue::PrivateLinkage,
                     scon, 1);
   llvm::Constant *varval = llvm::cast<llvm::Constant>(svar->value());
-  llvm::Constant *bitcast =
-      llvm::ConstantExpr::getBitCast(varval, stringType()->type());
-  Bexpression *bconst = nbuilder_.mkConst(stringType(), bitcast);
+  Bexpression *bconst = nbuilder_.mkConst(stringType(), varval);
   Bexpression *rval =
-      makeGlobalExpression(bconst, bitcast, stringType(), Location());
+      makeGlobalExpression(bconst, varval, stringType(), Location());
   stringConstantMap_[scon] = rval;
   return rval;
 }
@@ -2159,7 +2126,7 @@
   llvm::Value *old = nullptr;
   if (glob && glob->getLinkage() == linkage) {
     // A global variable with same name already exists.
-    if (glob->getType()->getElementType() == btype->type()) {
+    if (glob->getValueType() == btype->type()) {
       if (isExtInit == MV_NotExternallyInitialized) {
         // A definition overrides a declaration for external var.
         glob->setExternallyInitialized(false);
@@ -2190,16 +2157,12 @@
         // Here we are creating an external declaration
         // of a different type. We make a bitcast to the
         // new type.
-        llvm::Constant *decl = module_->getOrInsertGlobal(gname, btype->type());
-        bool addressTaken = true; // for now
-        Bvariable *bv =
-            new Bvariable(btype, location, gname, GlobalVar, addressTaken, decl);
-        assert(valueVarMap_.find(bv->value()) == valueVarMap_.end());
-        valueVarMap_[bv->value()] = bv;
-        if (genDebug == MV_GenDebug && dibuildhelper() && !errorCount_) {
-          bool exported = (linkage == llvm::GlobalValue::ExternalLinkage);
-          dibuildhelper()->processGlobal(bv, exported);
-        }
+
+        // Starting from LLVM-17 we're no longer using bitcasts
+        // for pointer types
+        auto it = valueVarMap_.find(glob);
+        assert(it != valueVarMap_.end());
+        Bvariable *bv = it->second;
         return bv;
       }
     }
@@ -2239,8 +2202,7 @@
   // Fix up old declaration if there is one
   if (old) {
     assert(llvm::isa<llvm::PointerType>(old->getType()));
-    llvm::Type *declTyp =
-        llvm::cast<llvm::PointerType>(old->getType())->getElementType();
+    llvm::Type *declTyp = llvm::cast<llvm::GlobalValue>(old)->getValueType();
     llvm::Constant *newDecl = module_->getOrInsertGlobal(gname, declTyp);
     old->replaceAllUsesWith(newDecl);
     // NB: previously we had a call to old->deleteValue() here, but this
@@ -2534,7 +2496,7 @@
   // A global with the same name already declared?
   llvm::GlobalVariable *glob = module_->getGlobalVariable(gname);
   if (glob) {
-    assert(glob->getType()->getElementType() == btype->type());
+    assert(glob->getValueType() == btype->type());
     auto it = valueVarMap_.find(glob);
     assert(it != valueVarMap_.end());
     Bvariable *bv = it->second;
@@ -2784,17 +2746,17 @@
          fns == "runtime.mapaccess2_fast64" ||
          fns == "runtime.mapaccess2_faststr" ||
          fns == "runtime.mapaccess2_fat"))
-      fcn->addFnAttr(llvm::Attribute::ReadOnly);
+      fcn->setOnlyReadsMemory();
 
     // memcmp-like.
     if (fns == "runtime.memequal" ||
         fns == "runtime.cmpstring") {
-      fcn->addFnAttr(llvm::Attribute::ReadOnly);
-      fcn->addFnAttr(llvm::Attribute::ArgMemOnly);
+      fcn->setOnlyReadsMemory();
+      fcn->setOnlyAccessesArgMemory();
     }
 
     if (fns == "runtime.memclrNoHeapPointers")
-      fcn->addFnAttr(llvm::Attribute::ArgMemOnly);
+      fcn->setOnlyAccessesArgMemory();
 
     // These functions are called in unlikely branches. But they
     // themselves are not actually cold in the runtime. So only
@@ -3152,10 +3114,7 @@
   // possibly-excepting call with landing pad.
   llvm::SmallVector<llvm::Value *, 8> args(call->arg_begin(), call->arg_end());
   llvm::Value *callop = call->getCalledOperand();
-  llvm::PointerType *pft =
-      llvm::cast<llvm::PointerType>(callop->getType());
-  llvm::FunctionType *fty =
-      llvm::cast<llvm::FunctionType>(pft->getElementType());
+  llvm::FunctionType *fty = call->getFunctionType();
   llvm::InvokeInst *invcall =
       llvm::InvokeInst::Create(fty, callop, contbb, padbb, args,
                                call->getName());
@@ -3284,7 +3243,7 @@
       changed = true;
     if (dibuildhelper_)
       dibuildhelper_->processExprInst(containingStmt, expr, inst);
-    curblock->getInstList().push_back(inst);
+    inst->insertBefore(*curblock, curblock->end());
     curblock = pair.second;
     newinsts.push_back(inst);
 
@@ -3294,7 +3253,7 @@
       // current block.
       LIRBuilder builder(context_, llvm::ConstantFolder());
       llvm::Instruction *unreachable = builder.CreateUnreachable();
-      curblock->getInstList().push_back(unreachable);
+      unreachable->insertBefore(*curblock, curblock->end());
       curblock = nullptr;
       changed = true;
 
@@ -3370,7 +3329,7 @@
     else {
       LIRBuilder builder(context_, llvm::ConstantFolder());
       llvm::Instruction *unreachable = builder.CreateUnreachable();
-      tsucc->getInstList().push_back(unreachable);
+      unreachable->insertBefore(*tsucc, tsucc->end());
     }
   }
 
@@ -3383,7 +3342,7 @@
       else {
         LIRBuilder builder(context_, llvm::ConstantFolder());
         llvm::Instruction *unreachable = builder.CreateUnreachable();
-        fsucc->getInstList().push_back(unreachable);
+        unreachable->insertBefore(*fsucc, fsucc->end());
       }
     }
   }
@@ -3578,12 +3537,12 @@
       if (&inst == term)
         break; // terminator is handled below
       llvm::Instruction *c = cloneInstruction(&inst, argMap);
-      curblock->getInstList().push_back(c);
+      c->insertBefore(*curblock, curblock->end());
     }
     if (llvm::isa<llvm::InvokeInst>(term)) {
       // This is the call to DEFERRETURN. Copy this then we're done.
       llvm::Instruction *c = cloneInstruction(term, argMap);
-      curblock->getInstList().push_back(c);
+      c->insertBefore(*curblock, curblock->end());
       break;
     }
     // By construction it should be linear code.
@@ -3736,7 +3695,8 @@
   // Populate resume block
   builder.SetInsertPoint(finResBB);
   std::string ename(be_->namegen("excv"));
-  llvm::LoadInst *exload = builder.CreateLoad(extmp->getType()->getPointerElementType(), extmp, ename);
+  llvm::Type *vty = llvm::cast<llvm::AllocaInst>(extmp)->getAllocatedType();
+  llvm::LoadInst *exload = builder.CreateLoad(vty, extmp, ename);
   builder.CreateResume(exload);
 
   return finRetBB;
@@ -4021,7 +3981,7 @@
       llvm::Value *zv = llvm::Constant::getNullValue(rtyp);
       ri = builder.CreateRet(zv);
     }
-    epilog->getInstList().push_back(ri);
+    ri->insertBefore(*epilog, epilog->end());
   }
 }
 

diff --git a/bridge/go-llvm.h b/bridge/go-llvm.h
index cd4d855..78602e3 100644
--- a/bridge/go-llvm.h
+++ b/bridge/go-llvm.h

@@ -65,7 +65,7 @@
 struct GenCallState;
 
 #include "llvm/IR/GlobalValue.h"
-#include "llvm/ADT/Triple.h"
+#include "llvm/TargetParser/Triple.h"
 
 //
 // LLVM-specific implementation of the Backend class; the code in
@@ -487,7 +487,7 @@
                                       Location location);
 
   // Field GEP helper
-  llvm::Value *makeFieldGEP(unsigned fieldIndex,
+  llvm::Value *makeFieldGEP(unsigned fieldIndex, llvm::Type *sty,
                             llvm::Value *sptr);
 
   // Array indexing GEP helper
@@ -496,8 +496,7 @@
                                  llvm::Value *sptr);
 
   // Pointer indexing GEP helper
-  llvm::Value *makePointerOffsetGEP(llvm::PointerType *pt,
-                                    llvm::Value *idx,
+  llvm::Value *makePointerOffsetGEP(Btype *pt, llvm::Value *idx,
                                     llvm::Value *sptr);
 
   // Assignment helper
@@ -614,39 +613,6 @@
   // error statement, returning TRUE if so.
   bool stmtVectorHasError(const std::vector<Bstatement *> &stmts);
 
-  // Converts value "src" for assignment to container of type
-  // "dstType" in assignment-like contexts. This helper exists to help
-  // with cases where the frontend is creating an assignment of form
-  // "X = Y" where X and Y's types are considered matching by the
-  // front end, but are non-matching in an LLVM context. For example,
-  //
-  //   type Ifi func(int) int
-  //   ...
-  //   var fp Ifi = myfunctionfoobar
-  //
-  // Here the right hand side will come out as pointer-to-descriptor,
-  // whereas variable "fp" will have type "pointer to functon", which are
-  // not the same. Another example is assignments involving nil, e.g.
-  //
-  //   var ip *float32
-  //   ...
-  //   ip = nil
-  //
-  // The type of the right hand side of the assignment will be a
-  // generic "*i64" as opposed to "*float32", since the backend
-  // "nil_pointer_expression" does not allow for creation of nil
-  // pointers of specific types.
-  //
-  // Return value will be a new convert Bexpression if a convert is
-  // needed, NULL otherwise.
-  llvm::Value *convertForAssignment(Bexpression *src,
-                                    llvm::Type *dstToType);
-  // lower-level version of the routine above
-  llvm::Value *convertForAssignment(Btype *srcType,
-                                    llvm::Value *srcVal,
-                                    llvm::Type *dstToType,
-                                    BlockLIRBuilder *builder);
-
 
   // Apply type conversion for a binary operation. This helper exists
   // to resolve situations where expressions are created by the front

diff --git a/bridge/go-sha1.cpp b/bridge/go-sha1.cpp
index 54925d5..e978c8e 100644
--- a/bridge/go-sha1.cpp
+++ b/bridge/go-sha1.cpp

@@ -47,7 +47,8 @@
 std::string
 Llvm_Sha1_Helper::finish()
 {
-  std::string result(ctx_->final().str(), 0, checksum_len);
+  auto arr = ctx_->final();
+  std::string result(std::begin(arr), std::begin(arr) + checksum_len);
   return result;
 }
 

diff --git a/driver-main/llvm-goc.cpp b/driver-main/llvm-goc.cpp
index 472dc2f..f635e00 100644
--- a/driver-main/llvm-goc.cpp
+++ b/driver-main/llvm-goc.cpp

@@ -26,7 +26,6 @@
 #include "Tool.h"
 
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/Triple.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Bitcode/BitcodeWriterPass.h"
 #include "llvm/IR/DiagnosticInfo.h"
@@ -35,7 +34,6 @@
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Verifier.h"
-#include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"
@@ -43,8 +41,8 @@
 #include "llvm/Passes/PassBuilder.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
-#include "llvm/Support/Format.h"
 #include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Format.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
@@ -56,8 +54,9 @@
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
+#include "llvm/TargetParser/SubtargetFeature.h"
+#include "llvm/TargetParser/Triple.h"
 #include "llvm/Transforms/IPO.h"
-#include "llvm/Transforms/IPO/PassManagerBuilder.h"
 
 #include <algorithm>
 #include <cstring>
@@ -95,7 +94,7 @@
   const char *progname = argv[0];
 
   unsigned missingArgIndex, missingArgCount;
-  ArrayRef<const char *> argvv = makeArrayRef(argv, argc);
+  ArrayRef<const char *> argvv(argv, argc);
   args_ = opts_->ParseArgs(argvv.slice(1), missingArgIndex, missingArgCount);
 
   // Honor --help first
@@ -172,9 +171,8 @@
   // that standard input be empty (so as to support the Go tool, but
   // not act as a general-purposes C compiler).
   opt::Arg *xarg = args_.getLastArg(gollvm::options::OPT_x);
-  if (xarg != nullptr &&
-      ! llvm::StringRef(xarg->getValue()).equals("c") &&
-      ! llvm::StringRef(xarg->getValue()).equals("go")) {
+  if (xarg != nullptr && llvm::StringRef(xarg->getValue()) != "c" &&
+      llvm::StringRef(xarg->getValue()) != "go") {
     errs() << progname << ": invalid argument '"
            << xarg->getValue() << "' to '"
            << xarg->getAsString(args_) << "' option\n";

diff --git a/driver/ArchCpuSetup.cpp b/driver/ArchCpuSetup.cpp
index a7eb765..bf91983 100644
--- a/driver/ArchCpuSetup.cpp
+++ b/driver/ArchCpuSetup.cpp

@@ -13,8 +13,8 @@
 #include "ArchCpuSetup.h"
 
 #include "llvm/Option/Arg.h"
-#include "llvm/Support/Host.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/TargetParser/Host.h"
 
 namespace gollvm { namespace arch {
 #include "ArchCpusAttrs.h"

diff --git a/driver/Command.cpp b/driver/Command.cpp
index 2f10e8c..956108a 100644
--- a/driver/Command.cpp
+++ b/driver/Command.cpp

@@ -36,13 +36,11 @@
   argv.reserve(n);
   for (size_t i = 0; i < n; ++i)
     argv.push_back(arguments_[i]);
-  return llvm::sys::ExecuteAndWait(executable_,
-                                   argv,
-                                   /*env=*/llvm::None,
-                                   /*Redirects*/{},
+  return llvm::sys::ExecuteAndWait(executable_, argv,
+                                   /*env=*/{},
+                                   /*Redirects*/ {},
                                    /*secondsToWait=*/0,
-                                   /*memoryLimit=*/0,
-                                   errMsg);
+                                   /*memoryLimit=*/0, errMsg);
 }
 
 void Command::print(llvm::raw_ostream &os, bool quoteArgs)

diff --git a/driver/Compilation.cpp b/driver/Compilation.cpp
index 4123e40..6abf2f0 100644
--- a/driver/Compilation.cpp
+++ b/driver/Compilation.cpp

@@ -127,8 +127,8 @@
   return newFileArtifact(ofn.c_str(), false);
 }
 
-llvm::Optional<Artifact*> Compilation::createTemporaryFileArtifact(Action *act)
-{
+std::optional<Artifact *>
+Compilation::createTemporaryFileArtifact(Action *act) {
   llvm::SmallString<128> tempFileName;
   std::error_code tfcEC =
       llvm::sys::fs::createTemporaryFile(act->getName(),
@@ -137,7 +137,7 @@
   if (tfcEC) {
     llvm::errs() << driver_.progname() << ": error: "
                  << tfcEC.message() << "\n";
-    return llvm::None;
+    return {};
   }
   return newFileArtifact(tempFileName.c_str(), true);
 }

diff --git a/driver/Compilation.h b/driver/Compilation.h
index ec96bc8..4861b60 100644
--- a/driver/Compilation.h
+++ b/driver/Compilation.h

@@ -45,9 +45,9 @@
   // Generate a new temp file and return an artifact for it. Here
   // llvm::Optional is used in case the temp file creation fails for
   // some reason.
-  llvm::Optional<Artifact*> createTemporaryFileArtifact(Action *act);
+  std::optional<Artifact *> createTemporaryFileArtifact(Action *act);
 
-    // Create new artifact based on file name. If 'isTempfile' is set,
+  // Create new artifact based on file name. If 'isTempfile' is set,
   // the file should be scheduled for deletion after compilation finishes.
   Artifact *newFileArtifact(const char *path, bool isTempFile);
 

diff --git a/driver/CompileGo.cpp b/driver/CompileGo.cpp
index 26af4e7..3601a36 100644
--- a/driver/CompileGo.cpp
+++ b/driver/CompileGo.cpp

@@ -41,25 +41,24 @@
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
-#include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LLVMRemarkStreamer.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Verifier.h"
-#include "llvm/MC/SubtargetFeature.h"
+#include "llvm/IRPrinter/IRPrintingPasses.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Passes/PassBuilder.h"
+#include "llvm/Passes/StandardInstrumentations.h"
 #include "llvm/Remarks/RemarkStreamer.h"
 #include "llvm/Remarks/YAMLRemarkSerializer.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
-#include "llvm/Support/Host.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
@@ -70,11 +69,14 @@
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
+#include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
+#include "llvm/TargetParser/Host.h"
+#include "llvm/TargetParser/SubtargetFeature.h"
 #include "llvm/Transforms/IPO.h"
-#include "llvm/Transforms/IPO/PassManagerBuilder.h"
 #include "llvm/Transforms/Utils.h"
+#include "llvm/Transforms/Utils/AddDiscriminators.h"
 
 #include <sstream>
 
@@ -111,8 +113,10 @@
   const char *progname_;
   std::string executablePath_;
   opt::InputArgList &args_;
-  CodeGenOpt::Level cgolvl_;
-  unsigned olvl_;
+  CodeGenOptLevel cgolvl_;
+  OptimizationLevel olvl_;
+  PipelineTuningOptions pto_;
+  std::optional<PGOOptions> pgo_;
   bool hasError_;
   std::unique_ptr<Llvm_backend> bridge_;
   std::unique_ptr<TargetMachine> target_;
@@ -129,8 +133,6 @@
   std::string sampleProfileFile_;
   bool enable_gc_;
 
-  void createPasses(legacy::PassManager &MPM,
-                    legacy::FunctionPassManager &FPM);
   void setupGoSearchPath();
   void setCConv();
 
@@ -148,22 +150,13 @@
   bool enableVectorization(bool slp);
 };
 
-CompileGoImpl::CompileGoImpl(CompileGo &cg,
-                             ToolChain &tc,
+CompileGoImpl::CompileGoImpl(CompileGo &cg, ToolChain &tc,
                              const std::string &executablePath)
-    : cg_(cg),
-      triple_(tc.driver().triple()),
-      toolchain_(tc),
-      driver_(tc.driver()),
-      cconv_(CallingConvId::MaxID),
-      progname_(tc.driver().progname()),
-      executablePath_(executablePath),
-      args_(tc.driver().args()),
-      cgolvl_(CodeGenOpt::Default),
-      olvl_(2),
-      hasError_(false),
-      enable_gc_(false)
-{
+    : cg_(cg), triple_(tc.driver().triple()), toolchain_(tc),
+      driver_(tc.driver()), cconv_(CallingConvId::MaxID),
+      progname_(tc.driver().progname()), executablePath_(executablePath),
+      args_(tc.driver().args()), cgolvl_(CodeGenOptLevel::Default),
+      olvl_(OptimizationLevel::O2), hasError_(false), enable_gc_(false) {
   InitializeAllTargets();
   InitializeAllTargetMCs();
   InitializeAllAsmPrinters();
@@ -311,21 +304,28 @@
     }
     switch (lev[0]) {
       case '0':
-        olvl_ = 0;
-        cgolvl_ = CodeGenOpt::None;
+        olvl_ = OptimizationLevel::O0;
+        cgolvl_ = CodeGenOptLevel::None;
         break;
       case '1':
-        olvl_ = 1;
-        cgolvl_ = CodeGenOpt::Less;
+        olvl_ = OptimizationLevel::O1;
+        cgolvl_ = CodeGenOptLevel::Less;
         break;
-      case 's': // TODO: -Os same as -O for now.
+      case 'z':
+        olvl_ = OptimizationLevel::Oz;
+        cgolvl_ = CodeGenOptLevel::Less;
+        break;
+      case 's':
+        olvl_ = OptimizationLevel::Os;
+        cgolvl_ = CodeGenOptLevel::Less;
+        break;
       case '2':
-        olvl_ = 2;
-        cgolvl_ = CodeGenOpt::Default;
+        olvl_ = OptimizationLevel::O2;
+        cgolvl_ = CodeGenOptLevel::Default;
         break;
       case '3':
-        olvl_ = 3;
-        cgolvl_ = CodeGenOpt::Aggressive;
+        olvl_ = OptimizationLevel::O3;
+        cgolvl_ = CodeGenOptLevel::Aggressive;
         break;
       default:
         errs() << progname_ << ": invalid optimization level.\n";
@@ -333,11 +333,18 @@
     }
   }
 
-  go_no_warn = args_.hasArg(gollvm::options::OPT_w);
-  go_loc_show_column =
-      driver_.reconcileOptionPair(gollvm::options::OPT_fshow_column,
-                                  gollvm::options::OPT_fno_show_column,
-                                  true);
+  pto_.LoopVectorization = enableVectorization(false);
+  pto_.SLPVectorization = enableVectorization(true);
+  pto_.LoopUnrolling = driver_.reconcileOptionPair(gollvm::options::OPT_funroll_loops,
+                                                   gollvm::options::OPT_fno_unroll_loops, true);
+  pto_.LoopInterleaving = driver_.reconcileOptionPair(gollvm::options::OPT_finterleave_loops,
+                                                      gollvm::options::OPT_fno_interleave_loops, true);
+  // Merge identical functions at the LLVM IR level.
+  pto_.MergeFunctions = driver_.reconcileOptionPair(gollvm::options::OPT_fmerge_functions,
+                                                    gollvm::options::OPT_fno_merge_functions, false);
+  // Provide .cgoprofile section for lld to order functions.
+  pto_.CallGraphProfile = driver_.reconcileOptionPair(gollvm::options::OPT_fcg_profile,
+                                                      gollvm::options::OPT_fno_cg_profile, false);
 
   // AutoFDO.
   opt::Arg *sprofarg =
@@ -365,6 +372,29 @@
     }
   }
 
+  pto_.LoopVectorization = enableVectorization(false);
+  pto_.SLPVectorization = enableVectorization(true);
+  pto_.LoopUnrolling =
+      driver_.reconcileOptionPair(gollvm::options::OPT_funroll_loops,
+                                  gollvm::options::OPT_fno_unroll_loops, true);
+  pto_.LoopInterleaving = driver_.reconcileOptionPair(
+      gollvm::options::OPT_finterleave_loops,
+      gollvm::options::OPT_fno_interleave_loops, true);
+  // Merge identical functions at the LLVM IR level.
+  pto_.MergeFunctions = driver_.reconcileOptionPair(
+      gollvm::options::OPT_fmerge_functions,
+      gollvm::options::OPT_fno_merge_functions, false);
+  // Provide .cgoprofile section for lld to order functions.
+  pto_.CallGraphProfile =
+      driver_.reconcileOptionPair(gollvm::options::OPT_fcg_profile,
+                                  gollvm::options::OPT_fno_cg_profile, false);
+
+  go_no_warn = args_.hasArg(gollvm::options::OPT_w);
+  go_loc_show_column =
+      driver_.reconcileOptionPair(gollvm::options::OPT_fshow_column,
+                                  gollvm::options::OPT_fno_show_column,
+                                  true);
+
   // Capture optimization record.
   opt::Arg *optrecordarg =
       args_.getLastArg(gollvm::options::OPT_fsave_optimization_record,
@@ -420,7 +450,7 @@
   llvm::DebugCompressionType dct = llvm::DebugCompressionType::None;
   if (!driver_.determineDebugCompressionType(&dct))
     return false;
-  Options.CompressDebugSections = dct;
+  Options.MCOptions.CompressDebugSections = dct;
 
   // FIXME: this hard-wires on the equivalent of -ffunction-sections
   // and -fdata-sections, since there doesn't seem to be a high-level
@@ -473,7 +503,7 @@
     return false;
 
   // Create target machine
-  Optional<llvm::CodeModel::Model> CM = None;
+  std::optional<llvm::CodeModel::Model> CM = {};
   target_.reset(
       TheTarget->createTargetMachine(triple_.getTriple(),
                                      targetCpuAttr_, targetFeaturesAttr_,
@@ -497,7 +527,7 @@
       std::make_unique<BEDiagnosticHandler>(&this->hasError_,
                                             this->remarkCtl_));
 
-  llvm::Optional<unsigned> enable_gc =
+  std::optional<unsigned> enable_gc =
       driver_.getLastArgAsInteger(gollvm::options::OPT_enable_gc_EQ, 0u);
   enable_gc_ = enable_gc && *enable_gc;
 
@@ -523,7 +553,7 @@
   bridge_.reset(new Llvm_backend(context_, module_.get(), linemap_.get(), addrspace, triple_, cconv_));
 
   // Honor inline, tracelevel cmd line options
-  llvm::Optional<unsigned> tl =
+  std::optional<unsigned> tl =
       driver_.getLastArgAsInteger(gollvm::options::OPT_tracelevel_EQ, 0u);
   if (!tl)
     return false;
@@ -601,7 +631,7 @@
                                   true);
   args.compiling_runtime =
       args_.hasArg(gollvm::options::OPT_fgo_compiling_runtime);
-  llvm::Optional<int> del =
+  std::optional<int> del =
       driver_.getLastArgAsInteger(gollvm::options::OPT_fgo_debug_escape_EQ, 0);
   if (!del)
     return false;
@@ -759,7 +789,7 @@
     bridge_->dumpModule();
   if (!args_.hasArg(gollvm::options::OPT_noverify) && !go_be_saw_errors())
     bridge_->verifyModule();
-  llvm::Optional<unsigned> tl =
+  std::optional<unsigned> tl =
       driver_.getLastArgAsInteger(gollvm::options::OPT_tracelevel_EQ, 0u);
   if (*tl)
     std::cerr << "linemap stats:" << linemap_->statistics() << "\n";
@@ -780,7 +810,7 @@
 
 bool CompileGoImpl::enableVectorization(bool slp)
 {
-  bool enable = (olvl_ > 1);
+  bool enable = (olvl_.getSpeedupLevel() > 1);
   if (slp)
     return driver_.reconcileOptionPair(gollvm::options::OPT_fslp_vectorize,
                                        gollvm::options::OPT_fno_slp_vectorize,
@@ -791,108 +821,116 @@
                                        enable);
 }
 
-static void addAddDiscriminatorsPass(const llvm::PassManagerBuilder &Builder,
-                                     llvm::legacy::PassManagerBase &PM) {
-  PM.add(createAddDiscriminatorsPass());
-}
-
-void CompileGoImpl::createPasses(legacy::PassManager &MPM,
-                                 legacy::FunctionPassManager &FPM)
+bool CompileGoImpl::invokeBackEnd(const Action &jobAction)
 {
-  if (args_.hasArg(gollvm::options::OPT_disable_llvm_passes))
-    return;
+  LoopAnalysisManager lam;
+  FunctionAnalysisManager fam;
+  CGSCCAnalysisManager gcam;
+  ModuleAnalysisManager mam;
 
-  // FIXME: support LTO, ThinLTO, PGO
+  bool debugPassStructure = false;
+  bool debugPassManager = args_.hasArg(gollvm::options::OPT_fdebug_pass_manager);
+  bool verifyEach = args_.hasArg(gollvm::options::OPT_fverify_each);
+  PassInstrumentationCallbacks pic;
+  PrintPassOptions printPassOpts;
+  printPassOpts.Indent = debugPassStructure;
+  printPassOpts.SkipAnalyses = debugPassStructure;
+  StandardInstrumentations si(context_, debugPassManager || debugPassStructure,
+                              verifyEach, printPassOpts);
 
-  PassManagerBuilder pmb;
+  // TODO: Maybe better to keep some kind of pass table.
+  pic.addClassToPassName("GoStatepoints", "go-statepoints");
+  pic.addClassToPassName("GoSafeGetgPass", "go-safegetg");
+  pic.addClassToPassName("RemoveAddrSpacePass", "remove-addrspacecast");
 
-  // Configure the inliner
-  if (args_.hasArg(gollvm::options::OPT_fno_inline) || olvl_ == 0) {
-    // Nothing here at the moment. There is go:noinline, but no equivalent
-    // of go:alwaysinline.
-  } else {
-    bool disableInlineHotCallSite = false; // for autofdo, not yet supported
-    pmb.Inliner =
-        createFunctionInliningPass(olvl_, 2, disableInlineHotCallSite);
+  si.registerCallbacks(pic);
+
+  PassBuilder pb(target_.get(), pto_, pgo_, &pic);
+
+  // Register the target library analysis directly and give it a customized
+  // preset TLI.
+  tlii_.reset(new TargetLibraryInfoImpl(triple_));
+  fam.registerPass([this] { return TargetLibraryAnalysis(*tlii_); });
+
+  // Register all the basic analyses with the managers.
+  pb.registerModuleAnalyses(mam);
+  pb.registerCGSCCAnalyses(gcam);
+  pb.registerFunctionAnalyses(fam);
+  pb.registerLoopAnalyses(lam);
+  pb.crossRegisterProxies(lam, fam, gcam, mam);
+
+  bool disablePasses =  args_.hasArg(gollvm::options::OPT_disable_llvm_passes);
+  ThinOrFullLTOPhase lto_phase = ThinOrFullLTOPhase::None;
+
+  ModulePassManager modulePasses;
+  if (!disablePasses) {
+    if (olvl_ == OptimizationLevel::O0) {
+
+      modulePasses = pb.buildO0DefaultPipeline(olvl_, lto_phase);
+    } else if (lto_phase == ThinOrFullLTOPhase::ThinLTOPreLink) {
+      modulePasses = pb.buildThinLTOPreLinkDefaultPipeline(olvl_);
+    } else if (lto_phase == ThinOrFullLTOPhase::FullLTOPreLink) {
+      modulePasses = pb.buildLTOPreLinkDefaultPipeline(olvl_);
+    } else {
+      modulePasses = pb.buildPerModuleDefaultPipeline(olvl_);
+    }
   }
 
-  pmb.OptLevel = olvl_;
-  pmb.SizeLevel = 0; // TODO: decide on right value here
-  pmb.PrepareForThinLTO = false;
-  pmb.PrepareForLTO = false;
-  pmb.SLPVectorize = enableVectorization(true);
-  pmb.LoopVectorize = enableVectorization(false);
+  bool needDwarfDiscr = !sampleProfileFile_.empty();
 
-  bool needDwarfDiscr = false;
-  if (! sampleProfileFile_.empty()) {
-    pmb.PGOSampleUse = sampleProfileFile_;
-    needDwarfDiscr = true;
-  }
   opt::Arg *dbgprofarg =
       args_.getLastArg(gollvm::options::OPT_fdebug_info_for_profiling,
                        gollvm::options::OPT_fno_debug_info_for_profiling);
   if (dbgprofarg) {
-    if (dbgprofarg->getOption().matches(gollvm::options::OPT_fdebug_info_for_profiling))
+    if (dbgprofarg->getOption().matches(
+            gollvm::options::OPT_fdebug_info_for_profiling))
       needDwarfDiscr = true;
     else
       needDwarfDiscr = false;
   }
-  if (needDwarfDiscr)
-    pmb.addExtension(llvm::PassManagerBuilder::EP_EarlyAsPossible,
-                           addAddDiscriminatorsPass);
-
-
-  FPM.add(new TargetLibraryInfoWrapperPass(*tlii_));
-  if (! args_.hasArg(gollvm::options::OPT_noverify))
-    FPM.add(createVerifierPass());
-
-  pmb.populateFunctionPassManager(FPM);
-  pmb.populateModulePassManager(MPM);
-}
-
-bool CompileGoImpl::invokeBackEnd(const Action &jobAction)
-{
-  tlii_.reset(new TargetLibraryInfoImpl(triple_));
-
-  // Set up module and function passes
-  legacy::PassManager modulePasses;
-  modulePasses.add(
-      createTargetTransformInfoWrapperPass(target_->getTargetIRAnalysis()));
-  legacy::FunctionPassManager functionPasses(module_.get());
-  functionPasses.add(
-      createTargetTransformInfoWrapperPass(target_->getTargetIRAnalysis()));
-  createPasses(modulePasses, functionPasses);
+  if (needDwarfDiscr) {
+    pb.registerPipelineStartEPCallback([](llvm::ModulePassManager &MPM,
+                                          llvm::OptimizationLevel) {
+      MPM.addPass(createModuleToFunctionPassAdaptor(AddDiscriminatorsPass()));
+    });
+  }
 
   // Disable inlining getg in some cases on x86_64.
   if (triple_.getArch() == llvm::Triple::x86_64) {
-      modulePasses.add(createGoSafeGetgPass());
+    modulePasses.addPass(GoSafeGetgPass());
   }
 
   // Add statepoint insertion pass to the end of optimization pipeline,
   // right before lowering to machine IR.
   if (enable_gc_) {
-    modulePasses.add(createGoStatepointsLegacyPass());
-    modulePasses.add(createRemoveAddrSpacePass(target_->createDataLayout()));
+    modulePasses.addPass(GoStatepoints());
+    modulePasses.addPass(RemoveAddrSpacePass(target_->createDataLayout()));
   }
 
+  // We still use the legacy PM to run the codegen pipeline since the new PM
+  // does not work with the codegen pipeline.
   legacy::PassManager codeGenPasses;
   bool noverify = args_.hasArg(gollvm::options::OPT_noverify);
-  CodeGenFileType ft = (jobAction.type() == Action::A_CompileAndAssemble ?
-                        CGFT_ObjectFile : CGFT_AssemblyFile);
 
   // Add passes to emit bitcode or LLVM IR as appropriate. Here we mimic
   // clang behavior, which is to emit bitcode when "-emit-llvm" is specified
   // but an LLVM IR dump of "-S -emit-llvm" is used.
   raw_pwrite_stream *OS = &asmout_->os();
   if (args_.hasArg(gollvm::options::OPT_emit_llvm)) {
+    if (!noverify) {
+      modulePasses.addPass(VerifierPass());
+    }
     bool bitcode = !args_.hasArg(gollvm::options::OPT_S);
     bool preserveUseLists =
         driver_.reconcileOptionPair(gollvm::options::OPT_emit_llvm_uselists,
                                     gollvm::options::OPT_no_emit_llvm_uselists,
                                     false);
-    modulePasses.add(bitcode ?
-                     createBitcodeWriterPass(*OS, preserveUseLists) :
-                     createPrintModulePass(*OS, "", preserveUseLists));
+    if (bitcode) {
+      modulePasses.addPass(BitcodeWriterPass(*OS, preserveUseLists,
+                                             /* ThinLTO summary */ false));
+    } else {
+      modulePasses.addPass(PrintModulePass(*OS, "", preserveUseLists));
+    }
     goto run;
   }
 
@@ -909,7 +947,11 @@
   // LLVMTargetMachine::addPassesToEmitFile (and its callee).
   // TODO: error check.
   {
-    LLVMTargetMachine *lltm = (LLVMTargetMachine*)(target_.get()); // FIXME: TargetMachine doesn't support llvm::cast?
+    CodeGenFileType ft = (jobAction.type() == Action::A_CompileAndAssemble
+                              ? CodeGenFileType::ObjectFile
+                              : CodeGenFileType::AssemblyFile);
+    llvm::TargetMachine *lltm =
+        target_.get(); // FIXME: TargetMachine doesn't support llvm::cast?
     TargetPassConfig *passConfig = lltm->createPassConfig(codeGenPasses);
     // Set PassConfig options provided by TargetMachine.
     passConfig->setDisableVerify(noverify);
@@ -932,15 +974,8 @@
   }
 
 run:
-  // Here we go... first function passes
-  functionPasses.doInitialization();
-  for (Function &F : *module_.get())
-    if (!F.isDeclaration())
-      functionPasses.run(F);
-  functionPasses.doFinalization();
-
   // ... then module passes
-  modulePasses.run(*module_.get());
+  modulePasses.run(*module_.get(), mam);
 
   // ... and finally code generation
   if (!args_.hasArg(gollvm::options::OPT_emit_llvm))

diff --git a/driver/Distro.cpp b/driver/Distro.cpp
index 2eace0d..0b02411 100644
--- a/driver/Distro.cpp
+++ b/driver/Distro.cpp

@@ -12,7 +12,7 @@
 
 #include "Distro.h"
 
-#include "llvm/Support/Host.h"
+#include "llvm/TargetParser/Host.h"
 
 namespace distro {
 

diff --git a/driver/Distro.h b/driver/Distro.h
index 4bd0a36..086e0e7 100644
--- a/driver/Distro.h
+++ b/driver/Distro.h

@@ -14,7 +14,7 @@
 #define GOLLVM_DRIVER_DISTRO_H
 
 #include "GccUtils.h"
-#include "llvm/ADT/Triple.h"
+#include "llvm/TargetParser/Triple.h"
 
 namespace distro {
 

diff --git a/driver/Driver.cpp b/driver/Driver.cpp
index 777cc2b..4355475 100644
--- a/driver/Driver.cpp
+++ b/driver/Driver.cpp

@@ -11,9 +11,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/FileSystem.h"
-#include "llvm/Support/Host.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
+#include "llvm/TargetParser/Host.h"
 
 #include <sstream>
 
@@ -185,9 +185,9 @@
         value == "--nocompress-debug-sections") {
       continue;
     }
-    if (value.startswith("-compress-debug-sections") ||
-        value.startswith("--compress-debug-sections") ||
-        value.startswith("-march")) {
+    if (value.starts_with("-compress-debug-sections") ||
+        value.starts_with("--compress-debug-sections") ||
+        value.starts_with("-march")) {
       continue;
     }
     // Unrecognized -Wa,... option
@@ -203,11 +203,11 @@
                                                llvm::DebugCompressionType *dct,
                                                const char *which)
 {
-  if (ga == "zlib") {
-    *dct = llvm::DebugCompressionType::Z;
+  if (ga == "zlib" || ga == "zlib-gnu") {
+    *dct = llvm::DebugCompressionType::Zlib;
     return dct;
-  } else if (ga == "zlib-gnu") {
-    *dct = llvm::DebugCompressionType::GNU;
+  } else if (ga == "zstd") {
+    *dct = llvm::DebugCompressionType::Zstd;
     return dct;
   } else if (ga == "none") {
     *dct = llvm::DebugCompressionType::None;
@@ -231,7 +231,7 @@
                                             gollvm::options::OPT_Wa_COMMA,
                                             gollvm::options::OPT_Xassembler)) {
     if (arg->getOption().matches(gollvm::options::OPT_gz)) {
-      *dct = llvm::DebugCompressionType::GNU;
+      *dct = llvm::DebugCompressionType::Zlib;
     } else if (arg->getOption().matches(gollvm::options::OPT_gz_EQ)) {
       auto value = llvm::StringRef(arg->getValue());
      if (gzArgToDCT(value, dct, "-gz=") == nullptr)
@@ -242,15 +242,15 @@
       if (value == "-nocompress-debug-sections" ||
           value == "--nocompress-debug-sections") {
         *dct = llvm::DebugCompressionType::None;
-      } else if (value.startswith("-compress-debug-sections") ||
-                 value.startswith("--compress-debug-sections")) {
+      } else if (value.starts_with("-compress-debug-sections") ||
+                 value.starts_with("--compress-debug-sections")) {
         const char *wh =
             (arg->getOption().matches(gollvm::options::OPT_Xassembler) ?
              "-Xassembler" : "-Wa,");
         value.consume_front("--compress-debug-sections");
         value.consume_front("-compress-debug-sections");
         auto arg = value;
-        if (value.startswith("="))
+        if (value.starts_with("="))
           arg.consume_front("=");
         else
           arg = "zlib";
@@ -365,20 +365,16 @@
   return false;
 }
 
-Optional<Reloc::Model>
-Driver::reconcileRelocModel()
-{
+std::optional<Reloc::Model> Driver::reconcileRelocModel() {
   auto picLevel = getPicLevel();
   if (picLevel != PICLevel::NotPIC) {
     Reloc::Model R = Reloc::PIC_;
     return R;
   }
-  return None;
+  return {};
 }
 
-Optional<FPOpFusion::FPOpFusionMode>
-Driver::getFPOpFusionMode()
-{
+std::optional<FPOpFusion::FPOpFusionMode> Driver::getFPOpFusionMode() {
   opt::Arg *arg = args_.getLastArg(gollvm::options::OPT_ffp_contract_EQ);
   FPOpFusion::FPOpFusionMode res = FPOpFusion::Standard;
   if (arg != nullptr) {
@@ -393,7 +389,7 @@
       errs() << progname_ << ": invalid argument '"
              << arg->getValue() << "' to '"
              << arg->getAsString(args_) << "' option\n";
-      return None;
+      return {};
     }
   }
   return res;
@@ -504,8 +500,8 @@
       opt::Arg *xarg = args_.getLastArg(gollvm::options::OPT_x);
       assert(xarg);
       const char *suf =
-          (llvm::StringRef(xarg->getValue()).equals("c") ? "c" :
-           (llvm::StringRef(xarg->getValue()).equals("go") ? "go" : "?"));
+          (xarg->containsValue("c") ? "c"
+                                    : (xarg->containsValue("go") ? "go" : "?"));
       act = new ReadStdinAction(suf);
       schedAction = true;
     } else {

diff --git a/driver/Driver.h b/driver/Driver.h
index 3b2813d..6c87d5d 100644
--- a/driver/Driver.h
+++ b/driver/Driver.h

@@ -13,16 +13,15 @@
 #ifndef GOLLVM_DRIVER_DRIVER_H
 #define GOLLVM_DRIVER_DRIVER_H
 
-#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Triple.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetOptions.h"
+#include "llvm/TargetParser/Triple.h"
 
 #include "Action.h"
 #include "Artifact.h"
@@ -112,14 +111,14 @@
   bool supportedAsmOptions();
   bool determineDebugCompressionType(llvm::DebugCompressionType *dct);
   bool usingSplitStack() const { return usingSplitStack_; }
-  template<typename IT>
-  llvm::Optional<IT> getLastArgAsInteger(gollvm::options::ID id,
-                                         IT defaultValue);
-  llvm::Optional<llvm::Reloc::Model> reconcileRelocModel();
+  template <typename IT>
+  std::optional<IT> getLastArgAsInteger(gollvm::options::ID id,
+                                        IT defaultValue);
+  std::optional<llvm::Reloc::Model> reconcileRelocModel();
   bool reconcileOptionPair(gollvm::options::ID yesOption,
                            gollvm::options::ID noOption,
                            bool defaultVal);
-  llvm::Optional<llvm::FPOpFusion::FPOpFusionMode> getFPOpFusionMode();
+  std::optional<llvm::FPOpFusion::FPOpFusionMode> getFPOpFusionMode();
   typedef llvm::SmallVector<llvm::opt::Arg *, 8> inarglist;
   void appendInputActions(const inarglist &infiles,
                           ActionList &result,
@@ -155,11 +154,9 @@
                                          const char *which);
 };
 
-template<typename IT>
-llvm::Optional<IT>
-Driver::getLastArgAsInteger(gollvm::options::ID id,
-                            IT defaultValue)
-{
+template <typename IT>
+std::optional<IT> Driver::getLastArgAsInteger(gollvm::options::ID id,
+                                              IT defaultValue) {
   IT result = defaultValue;
   llvm::opt::Arg *arg = args_.getLastArg(id);
   if (arg != nullptr) {
@@ -167,7 +164,7 @@
       llvm::errs() << progname_ << ": invalid argument '"
                    << arg->getValue() << "' to '"
                    << arg->getAsString(args_) << "' option\n";
-      return llvm::None;
+      return {};
     }
   }
   return result;

diff --git a/driver/GollvmOptions.cpp b/driver/GollvmOptions.cpp
index 4455b1a..d8697e9 100644
--- a/driver/GollvmOptions.cpp
+++ b/driver/GollvmOptions.cpp

@@ -20,23 +20,35 @@
 #include "GollvmOptions.inc"
 #undef PREFIX
 
+#define OPTTABLE_STR_TABLE_CODE
+#include "GollvmOptions.inc"
+#undef OPTTABLE_STR_TABLE_CODE
+
+#define OPTTABLE_VALUES_CODE
+#include "GollvmOptions.inc"
+#undef OPTTABLE_VALUES_CODE
+
+#define OPTTABLE_PREFIXES_TABLE_CODE
+#include "GollvmOptions.inc"
+#undef OPTTABLE_PREFIXES_TABLE_CODE
+
+#define OPTTABLE_PREFIXES_UNION_CODE
+#include "GollvmOptions.inc"
+#undef OPTTABLE_PREFIXES_UNION_CODE
+
 static const OptTable::Info InfoTable[] = {
-#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
-               HELPTEXT, METAVAR, VALUES)                                      \
-  {PREFIX, NAME,  HELPTEXT,    METAVAR,     OPT_##ID,  Option::KIND##Class,    \
-   PARAM,  FLAGS, OPT_##GROUP, OPT_##ALIAS, ALIASARGS, VALUES},
+#define OPTION(...) LLVM_CONSTRUCT_OPT_INFO(__VA_ARGS__),
 #include "GollvmOptions.inc"
 #undef OPTION
 };
 
 namespace {
-
-class DriverOptTable : public OptTable {
+class DriverOptTable : public PrecomputedOptTable {
 public:
   DriverOptTable()
-      : OptTable(InfoTable) {}
+      : PrecomputedOptTable(OptionStrTable, OptionPrefixesTable, InfoTable,
+                            OptionPrefixesUnion) {}
 };
-
 }
 
 std::unique_ptr<OptTable> createGollvmDriverOptTable() {

diff --git a/driver/GollvmOptions.h b/driver/GollvmOptions.h
index 5ab4477..2a98647 100644
--- a/driver/GollvmOptions.h
+++ b/driver/GollvmOptions.h

@@ -9,6 +9,7 @@
 #ifndef LLVM_GOLLVM_DRIVER_GOLLVMOPTIONS_H
 #define LLVM_GOLLVM_DRIVER_GOLLVMOPTIONS_H
 
+#include "llvm/Option/OptTable.h"
 #include <memory>
 
 namespace llvm {
@@ -31,9 +32,7 @@
 
 enum ID {
     OPT_INVALID = 0, // This is not an option ID.
-#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
-               HELPTEXT, METAVAR, VALUES)                                      \
-  OPT_##ID,
+#define OPTION(...) LLVM_MAKE_OPT_ID(__VA_ARGS__),
 #include "GollvmOptions.inc"
     LastOption
 #undef OPTION

diff --git a/driver/GollvmOptions.td b/driver/GollvmOptions.td
index 404a1ad..18e0e99 100644
--- a/driver/GollvmOptions.td
+++ b/driver/GollvmOptions.td

@@ -275,6 +275,26 @@
 def fno_slp_vectorize : Flag<["-"], "fno-slp-vectorize">, Group<f_Group>,
   HelpText<"Disable the superword-level parallelism vectorization passes">;
 
+def fmerge_functions : Flag<["-"], "fmerge-functions">, Group<f_Group>,
+    HelpText<"Enable merging identical functions">;
+def fno_merge_functions : Flag<["-"], "fno-merge-functions">, Group<f_Group>,
+    HelpText<"Disable merging identical functions">;
+
+def funroll_loops : Flag<["-"], "funroll-loops">, Group<f_Group>,
+    HelpText<"Enable loop unrolling">;
+def fno_unroll_loops : Flag<["-"], "fno-unroll-loops">, Group<f_Group>,
+    HelpText<"Disable loop unrolling">;
+
+def finterleave_loops : Flag<["-"], "finterleave-loops">, Group<f_Group>,
+    HelpText<"Enable loop interleaving">;
+def fno_interleave_loops : Flag<["-"], "fno-interleave-loops">, Group<f_Group>,
+    HelpText<"Disable loop interleaving">;
+
+def fcg_profile : Flag<["-"], "fcg-profile">, Group<f_Group>,
+    HelpText<"Enable linker re-ordering functions by CG profile (supported by LLD)">;
+def fno_cg_profile : Flag<["-"], "fno-cg-profile">, Group<f_Group>,
+    HelpText<"Disable linker re-ordering functions by CG profile">;
+
 def ffp_contract_EQ : Joined<["-"], "ffp-contract=">, Group<f_Group>,
   HelpText<"Form fused FP ops (e.g. FMAs): fast (everywhere)"
   " | on (according to FP_CONTRACT pragma, default) | off (never fuse)">,
@@ -443,9 +463,6 @@
 def finline_functions : Flag<["-"], "finline-functions">,
     Flags<[Ignored]>, HelpText<"This option is ignored">;
 
-def funroll_loops : Flag<["-"], "funroll-loops">,
-    Flags<[Ignored]>, HelpText<"This option is ignored">;
-
 def pedantic_errors : Flag<["-"], "pedantic-errors">,
     Flags<[Ignored]>, HelpText<"This option is ignored">;
 
@@ -519,3 +536,9 @@
 
 def enable_gc_EQ : Joined<["-"], "enable-gc=">,
   HelpText<"Enable stack map generation">;
+
+def fdebug_pass_manager : Flag<["-"], "fdebug-pass-manager">,
+  HelpText<"Print passes run and other information for debugging the pass manager">;
+
+def fverify_each : Flag<["-"], "fverify-each">,
+  HelpText<"Run verification after each pass in new pass manager">;

diff --git a/driver/IntegAssembler.cpp b/driver/IntegAssembler.cpp
index a40be9f..0cdea73 100644
--- a/driver/IntegAssembler.cpp
+++ b/driver/IntegAssembler.cpp

@@ -27,7 +27,6 @@
 #include "Driver.h"
 #include "ToolChain.h"
 
-#include "llvm/ADT/Triple.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/MC/MCAsmBackend.h"
@@ -52,7 +51,6 @@
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FileSystem.h"
-#include "llvm/Support/Host.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
@@ -63,6 +61,8 @@
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
+#include "llvm/TargetParser/Host.h"
+#include "llvm/TargetParser/Triple.h"
 
 #include <sstream>
 
@@ -194,7 +194,7 @@
 
   // Ensure MCAsmInfo initialization occurs before any use, otherwise sections
   // may be created with a combination of default and explicit settings.
-  MAI->setCompressDebugSections(CompressDebugSections);
+  MCOptions.CompressDebugSections = CompressDebugSections;
 
   // Build up the feature string from the target feature list.
   std::string FS;
@@ -242,8 +242,7 @@
     Out = BOS.get();
   }
 
-  std::unique_ptr<MCCodeEmitter> CE(
-      TheTarget->createMCCodeEmitter(*MCII, *MRI, Ctx));
+  std::unique_ptr<MCCodeEmitter> CE(TheTarget->createMCCodeEmitter(*MCII, Ctx));
   std::unique_ptr<MCAsmBackend> MAB(
       TheTarget->createMCAsmBackend(*STI, *MRI, MCOptions));
   std::unique_ptr<MCObjectWriter> OW = MAB->createObjectWriter(*Out);

diff --git a/driver/LinuxToolChain.cpp b/driver/LinuxToolChain.cpp
index a12b794..f8ebea7 100644
--- a/driver/LinuxToolChain.cpp
+++ b/driver/LinuxToolChain.cpp

@@ -101,7 +101,7 @@
 Tool *Linux::buildCompiler()
 {
   llvm::opt::Arg *xarg = driver().args().getLastArg(gollvm::options::OPT_x);
-  if (xarg != nullptr && llvm::StringRef(xarg->getValue()).equals("c")) {
+  if (xarg != nullptr && xarg->containsValue("c")) {
     // This is a dummy C compile.
     return new DummyCompileC(*this, driver().executablePath());
   }

diff --git a/driver/Tool.h b/driver/Tool.h
index abde3ca..17d3b19 100644
--- a/driver/Tool.h
+++ b/driver/Tool.h

@@ -13,9 +13,9 @@
 #ifndef GOLLVM_DRIVER_TOOL_H
 #define GOLLVM_DRIVER_TOOL_H
 
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/Triple.h"
 #include "Artifact.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/TargetParser/Triple.h"
 
 namespace gollvm {
 namespace driver {

diff --git a/driver/ToolChain.h b/driver/ToolChain.h
index c20e14b..89a28df 100644
--- a/driver/ToolChain.h
+++ b/driver/ToolChain.h

@@ -13,9 +13,9 @@
 #ifndef GOLLVM_DRIVER_TOOLCHAIN_H
 #define GOLLVM_DRIVER_TOOLCHAIN_H
 
-#include <string>
-#include "llvm/ADT/Triple.h"
 #include "llvm/Option/ArgList.h"
+#include "llvm/TargetParser/Triple.h"
+#include <string>
 
 #include "Action.h"
 #include "Tool.h"

diff --git a/libgo/godumpspec/godumpspec.cpp b/libgo/godumpspec/godumpspec.cpp
index 37a854d..15a66d2 100644
--- a/libgo/godumpspec/godumpspec.cpp
+++ b/libgo/godumpspec/godumpspec.cpp

@@ -26,6 +26,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/DIContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/ObjectFile.h"

diff --git a/passes/GC.cpp b/passes/GC.cpp
index 3932bab..e5dd0bc 100644
--- a/passes/GC.cpp
+++ b/passes/GC.cpp

@@ -44,7 +44,7 @@
     // TODO: write barrier?
   }
 
-  Optional<bool> isGCManagedPointer(const Type *Ty) const override {
+  std::optional<bool> isGCManagedPointer(const Type *Ty) const override {
     return isa<PointerType>(Ty);
   }
 };
@@ -171,7 +171,7 @@
       for (uint8_t Byte : V)
         OS.emitIntValue(Byte, 1);
     }
-    OS.emitValueToAlignment(8);
+    OS.emitValueToAlignment(llvm::Align(8));
   }
 }
 
@@ -183,7 +183,7 @@
   // Create the section.
   MCSection *StackMapSection =
       OutContext.getObjectFileInfo()->getStackMapSection();
-  OS.SwitchSection(StackMapSection);
+  OS.switchSection(StackMapSection);
 
   emitCallsiteEntries(SM, OS);
 

diff --git a/passes/GoAnnotation.cpp b/passes/GoAnnotation.cpp
index 95f5fe3..d180248 100644
--- a/passes/GoAnnotation.cpp
+++ b/passes/GoAnnotation.cpp

@@ -19,6 +19,7 @@
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/TargetInstrInfo.h"
+#include "llvm/IR/Module.h"
 #include "llvm/PassRegistry.h"
 #include "llvm/Target/TargetMachine.h"
 

diff --git a/passes/GoNilChecks.cpp b/passes/GoNilChecks.cpp
index 7561d65..e091699 100644
--- a/passes/GoNilChecks.cpp
+++ b/passes/GoNilChecks.cpp

@@ -25,8 +25,6 @@
 #include "GollvmPasses.h"
 
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/None.h"
-#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
@@ -102,11 +100,11 @@
 
     /// If non-None, then an instruction in \p Insts that also must be
     /// hoisted.
-    Optional<ArrayRef<MachineInstr *>::iterator> PotentialDependence;
+    std::optional<ArrayRef<MachineInstr *>::iterator> PotentialDependence;
 
     /*implicit*/ DependenceResult(
         bool CanReorder,
-        Optional<ArrayRef<MachineInstr *>::iterator> PotentialDependence)
+        std::optional<ArrayRef<MachineInstr *>::iterator> PotentialDependence)
         : CanReorder(CanReorder), PotentialDependence(PotentialDependence) {
       assert((!PotentialDependence || CanReorder) &&
              "!CanReorder && PotentialDependence.hasValue() not allowed!");
@@ -252,18 +250,18 @@
   assert(llvm::all_of(Block, canHandle) && "Check this first!");
   assert(!is_contained(Block, MI) && "Block must be exclusive of MI!");
 
-  Optional<ArrayRef<MachineInstr *>::iterator> Dep;
+  std::optional<ArrayRef<MachineInstr *>::iterator> Dep;
 
   for (auto I = Block.begin(), E = Block.end(); I != E; ++I) {
     if (canReorder(*I, MI))
       continue;
 
-    if (Dep == None) {
+    if (!Dep.has_value()) {
       // Found one possible dependency, keep track of it.
       Dep = I;
     } else {
       // We found two dependencies, so bail out.
-      return {false, None};
+      return {false, {}};
     }
   }
 
@@ -654,7 +652,7 @@
     // Insert an *unconditional* branch to not-null successor.
     if (!CheckBB->isLayoutSuccessor(NC.getNotNullSucc()))
       TII->insertBranch(*CheckBB, NC.getNotNullSucc(), nullptr,
-                        /*Cond=*/None, DL);
+                        /*Cond=*/{}, DL);
 
     NumImplicitNullChecks++;
 
@@ -724,7 +722,7 @@
         MI.eraseFromParent();
         break;
       }
-    TII->insertBranch(*FaultBB, PadBB, nullptr, None, DL);
+    TII->insertBranch(*FaultBB, PadBB, nullptr, {}, DL);
   }
 
   // Add EH labels before and after the faulting op.

diff --git a/passes/GoSafeGetg.cpp b/passes/GoSafeGetg.cpp
index 52b54c2..66dbedd 100644
--- a/passes/GoSafeGetg.cpp
+++ b/passes/GoSafeGetg.cpp

@@ -12,6 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "GoSafeGetg.h"
 #include "GollvmPasses.h"
 
 #include "llvm/IR/BasicBlock.h"
@@ -76,8 +77,7 @@
 // found, replace it with a call of runtime.getg (i.e. undoing the
 // inlining).
 //
-bool
-GoSafeGetg::runOnModule(Module &M) {
+static bool updateModule(Module &M) {
   GlobalVariable *GV = M.getGlobalVariable("runtime.g");
   if (!GV)
     return false; // no access of g, nothing to do
@@ -132,3 +132,12 @@
 
   return Changed;
 }
+
+bool GoSafeGetg::runOnModule(Module &M) { return updateModule(M); }
+
+PreservedAnalyses GoSafeGetgPass::run(Module &M, ModuleAnalysisManager &AM) {
+  bool Changed = updateModule(M);
+  if (!Changed)
+    return PreservedAnalyses::all();
+  return PreservedAnalyses::none();
+}

diff --git a/passes/GoSafeGetg.h b/passes/GoSafeGetg.h
new file mode 100644
index 0000000..89e9d23
--- /dev/null
+++ b/passes/GoSafeGetg.h

@@ -0,0 +1,26 @@
+//===--- GoSafeGetg.h -----------------------------------------------------===//
+//
+// Copyright 2024 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.
+//
+//===----------------------------------------------------------------------===//
+//
+// Make sure the TLS address is not cached across a thread switch.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_GOLLVM_PASSES_GOSAFEGETG_H
+#define LLVM_GOLLVM_PASSES_GOSAFEGETG_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+struct GoSafeGetgPass : public PassInfoMixin<GoSafeGetgPass> {
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+} // namespace llvm
+
+#endif // LLVM_GOLLVM_PASSES_GOSAFEGETG_H

diff --git a/passes/GoStatepoints.cpp b/passes/GoStatepoints.cpp
index 6453db4..02062f6 100644
--- a/passes/GoStatepoints.cpp
+++ b/passes/GoStatepoints.cpp

@@ -22,8 +22,6 @@
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/MapVector.h"
-#include "llvm/ADT/None.h"
-#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallSet.h"
@@ -34,6 +32,7 @@
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/IR/Argument.h"
+#include "llvm/IR/AttributeMask.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constant.h"
@@ -58,8 +57,8 @@
 #include "llvm/IR/User.h"
 #include "llvm/IR/Value.h"
 #include "llvm/IR/ValueHandle.h"
-#include "llvm/Pass.h"
 #include "llvm/InitializePasses.h"
+#include "llvm/Pass.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
@@ -120,6 +119,32 @@
 
 static bool shouldRewriteStatepointsIn(Function &F);
 
+static Type *getPointerElementType(Value *V) {
+  assert(V->getType()->isPointerTy());
+  if (Argument *A = dyn_cast<Argument>(V)) {
+    if (A->hasByValAttr())
+      return A->getParamByValType();
+    // FIXME: Do we need to handle other types of arguments?
+    // fallback to ptr
+    return V->getType();
+
+  } else if (AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
+    return AI->getAllocatedType();
+  } else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(V)) {
+    return GEP->getResultElementType();
+  } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
+    auto *Inst = CE->getAsInstruction();
+    Type *ITy = getPointerElementType(CE->getAsInstruction());
+    Inst->deleteValue();
+    return ITy;
+  } else if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
+    return GV->getValueType();
+  } else {
+    // fallback to ptr
+    return V->getType();
+  }
+}
+
 PreservedAnalyses GoStatepoints::run(Module &M,
                                      ModuleAnalysisManager &AM) {
   // Create a sentinel global variable for stack maps.
@@ -993,8 +1018,9 @@
       // TODO: In many cases, the new instruction is just EE itself.  We should
       // exploit this, but can't do it here since it would break the invariant
       // about the BDV not being known to be a base.
-      auto *BaseInst = ExtractElementInst::Create(
-          State.getBaseValue(), EE->getIndexOperand(), "base_ee", EE);
+      auto *BaseInst = ExtractElementInst::Create(State.getBaseValue(),
+                                                  EE->getIndexOperand(),
+                                                  "base_ee", EE->getIterator());
       BaseInst->setMetadata("is_base_value", MDNode::get(I->getContext(), {}));
       States[I] = BDVState(BDVState::Base, BaseInst);
     }
@@ -1015,29 +1041,30 @@
         int NumPreds = pred_size(BB);
         assert(NumPreds > 0 && "how did we reach here");
         std::string Name = suffixed_name_or(I, ".base", "base_phi");
-        return PHINode::Create(I->getType(), NumPreds, Name, I);
+        return PHINode::Create(I->getType(), NumPreds, Name, I->getIterator());
       } else if (SelectInst *SI = dyn_cast<SelectInst>(I)) {
         // The undef will be replaced later
         UndefValue *Undef = UndefValue::get(SI->getType());
         std::string Name = suffixed_name_or(I, ".base", "base_select");
-        return SelectInst::Create(SI->getCondition(), Undef, Undef, Name, SI);
+        return SelectInst::Create(SI->getCondition(), Undef, Undef, Name,
+                                  SI->getIterator());
       } else if (auto *EE = dyn_cast<ExtractElementInst>(I)) {
         UndefValue *Undef = UndefValue::get(EE->getVectorOperand()->getType());
         std::string Name = suffixed_name_or(I, ".base", "base_ee");
         return ExtractElementInst::Create(Undef, EE->getIndexOperand(), Name,
-                                          EE);
+                                          EE->getIterator());
       } else if (auto *IE = dyn_cast<InsertElementInst>(I)) {
         UndefValue *VecUndef = UndefValue::get(IE->getOperand(0)->getType());
         UndefValue *ScalarUndef = UndefValue::get(IE->getOperand(1)->getType());
         std::string Name = suffixed_name_or(I, ".base", "base_ie");
-        return InsertElementInst::Create(VecUndef, ScalarUndef,
-                                         IE->getOperand(2), Name, IE);
+        return InsertElementInst::Create(
+            VecUndef, ScalarUndef, IE->getOperand(2), Name, IE->getIterator());
       } else {
         auto *SV = cast<ShuffleVectorInst>(I);
         UndefValue *VecUndef = UndefValue::get(SV->getOperand(0)->getType());
         std::string Name = suffixed_name_or(I, ".base", "base_sv");
         return new ShuffleVectorInst(VecUndef, VecUndef, SV->getOperand(2),
-                                     Name, SV);
+                                     Name, SV->getIterator());
       }
     };
     Instruction *BaseInst = MakeBaseInstPlaceholder(I);
@@ -1067,7 +1094,8 @@
     assert(Base && "Can't be null");
     // The cast is needed since base traversal may strip away bitcasts
     if (Base->getType() != Input->getType() && InsertPt)
-      Base = CastInst::CreatePointerBitCastOrAddrSpaceCast(Base, Input->getType(), "cast", InsertPt);
+      Base = CastInst::CreatePointerBitCastOrAddrSpaceCast(
+          Base, Input->getType(), "cast", InsertPt->getIterator());
     return Base;
   };
 
@@ -1262,8 +1290,6 @@
 // both function declarations and call sites.
 static constexpr Attribute::AttrKind FnAttrsToStrip[] =
   {Attribute::ReadNone, Attribute::ReadOnly, Attribute::WriteOnly,
-   Attribute::ArgMemOnly, Attribute::InaccessibleMemOnly,
-   Attribute::InaccessibleMemOrArgMemOnly,
    Attribute::NoSync, Attribute::NoFree};
 
 // List of all parameter and return attributes which must be stripped when
@@ -1356,7 +1382,7 @@
       // Note: we've inserted instructions, so the call to llvm.deoptimize may
       // not necessarily be followed by the matching return.
       auto *RI = cast<ReturnInst>(OldI->getParent()->getTerminator());
-      new UnreachableInst(RI->getContext(), RI);
+      new UnreachableInst(RI->getContext(), RI->getIterator());
       RI->eraseFromParent();
     }
 
@@ -1430,7 +1456,7 @@
     if (isa<AllocaInst>(V) ||
         (isa<Argument>(V) && cast<Argument>(V)->hasByValAttr())) {
       // Byval argument is at a fixed frame offset. Treat it the same as alloca.
-      Type *T = cast<PointerType>(V->getType())->getElementType();
+      Type *T = getPointerElementType(V);
       if (hasPointer(T)) {
         PtrFields.push_back(V);
         getPtrBitmapForType(T, DL, PtrFields);
@@ -1627,8 +1653,9 @@
   SetVector<Value *> AllAllocas;
   if (ClobberNonLive)
     for (Instruction &I : F.getEntryBlock())
-      if (isa<AllocaInst>(I) && hasPointer(I.getType()->getPointerElementType()))
-        AllAllocas.insert(&I);
+      if (AllocaInst *AI = dyn_cast<AllocaInst>(&I))
+        if (hasPointer(AI->getAllocatedType()))
+          AllAllocas.insert(&I);
 
   computeLiveInValues(DT, F, OriginalLivenessData, AddrTakenAllocas,
                       ToZero, BadLoads, DVCache);
@@ -1702,7 +1729,7 @@
           } else if (ToZero.count(V) != 0) {
             // Non-addrtaken alloca. Just insert zeroing, keep the lifetime marker.
             IRBuilder<> Builder(I.getNextNode());
-            Value *Zero = Constant::getNullValue(V->getType()->getPointerElementType());
+            Value *Zero = Constant::getNullValue(getPointerElementType(V));
             Builder.CreateStore(Zero, V);
             // Don't remove V from ToZero for now, as there may be multiple
             // lifetime start markers, where we need to insert zeroing.
@@ -1737,14 +1764,14 @@
   for (Instruction &I : F.getEntryBlock())
     if (ToZero.count(&I) != 0) {
       IRBuilder<> Builder(I.getNextNode());
-      Type *ElemTyp = I.getType()->getPointerElementType();
       if (AddrTakenAllocas.count(&I) != 0) {
+        Type *ElemTyp = cast<AllocaInst>(I).getAllocatedType();
         // For addrtaken alloca, we removed the lifetime marker above.
         // Insert a new one at the entry block.
         unsigned Size = DL.getTypeStoreSize(ElemTyp);
         Builder.CreateLifetimeStart(&I, ConstantInt::get(Int64Ty, Size));
       }
-      Value *Zero = Constant::getNullValue(ElemTyp);
+      Value *Zero = Constant::getNullValue(getPointerElementType(&I));
       Builder.CreateStore(Zero, &I);
       ToZero.remove(&I);
     }
@@ -1942,8 +1969,8 @@
     // That Value* no longer exists and we need to use the new gc_result.
     // Thankfully, the live set is embedded in the statepoint (and updated), so
     // we just grab that.
-    Live.insert(Live.end(), Info.StatepointToken->gc_args_begin(),
-                Info.StatepointToken->gc_args_end());
+    Live.insert(Live.end(), Info.StatepointToken->gc_live_begin(),
+                Info.StatepointToken->gc_live_end());
 #ifndef NDEBUG
     // Do some basic sanity checks on our liveness results before performing
     // relocation.  Relocation can and will turn mistakes in liveness results
@@ -1951,7 +1978,7 @@
     // TODO: It would be nice to test consistency as well
     assert(DT.isReachableFromEntry(Info.StatepointToken->getParent()) &&
            "statepoint must be reachable or liveness is meaningless");
-    for (Value *V : Info.StatepointToken->gc_args()) {
+    for (Value *V : Info.StatepointToken->gc_live()) {
       if (!isa<Instruction>(V))
         // Non-instruction values trivial dominate all possible uses
         continue;
@@ -2024,7 +2051,7 @@
   if (isa<PointerType>(F.getReturnType()))
     RemoveNonValidAttrAtIndex(Ctx, F, AttributeList::ReturnIndex);
 
-    for (auto Attr : FnAttrsToStrip)
+  for (auto Attr : FnAttrsToStrip)
     F.removeFnAttr(Attr);
 }
 
@@ -2161,11 +2188,12 @@
       // Create a dummy landing pad block.
       LLVMContext &C = F.getContext();
       BasicBlock *PadBB = BasicBlock::Create(C, "dummy", &F);
-      Type *ExnTy = StructType::get(Type::getInt8PtrTy(C), Type::getInt32Ty(C));
+      Type *ExnTy =
+          StructType::get(PointerType::getUnqual(C), Type::getInt32Ty(C));
 
       LandingPadInst *LPad =
           LandingPadInst::Create(ExnTy, 1, "dummy.ex", PadBB);
-      LPad->addClause(Constant::getNullValue(Type::getInt8PtrTy(C)));
+      LPad->addClause(Constant::getNullValue(PointerType::getUnqual(C)));
       new UnreachableInst(PadBB->getContext(), PadBB);
 
       BasicBlock *Old = CI->getParent();
@@ -2179,7 +2207,7 @@
       for (DomTreeNode *I : Children)
         DT.changeImmediateDominator(I, NewNode);
 
-      DTU.insertEdge(Old, PadBB);
+      DTU.applyUpdates({{DominatorTree::Insert, Old, PadBB}});
     }
   }
 
@@ -2269,10 +2297,11 @@
 
 static Value*
 isTrackedAlloca(Value *V, DefiningValueMapTy &DVCache) {
-  Value *Base = isAlloca(V, DVCache);
-  if (Base &&
-      hasPointer(Base->getType()->getPointerElementType()))
-    return Base;
+  if (Value *Base = isAlloca(V, DVCache)) {
+    Type *AllocedTy = cast<AllocaInst>(Base)->getAllocatedType();
+    if (Base && hasPointer(AllocedTy))
+      return Base;
+  }
   return nullptr;
 }
 
@@ -2450,7 +2479,7 @@
   // Use the metadata inserted by the FE.
   for (Instruction &I : F.getEntryBlock())
     if (isa<AllocaInst>(I) && I.getMetadata("go_addrtaken") &&
-        hasPointer(I.getType()->getPointerElementType()))
+        hasPointer(cast<AllocaInst>(I).getAllocatedType()))
       AddrTakenAllocas.insert(&I);
 
   // The FE's addrtaken mark may be imprecise. Look for certain
@@ -2581,7 +2610,7 @@
                SetVector<Value *> &ToZero,
                DefiningValueMapTy &DVCache) {
   unsigned PtrSize = DL.getPointerSize();
-  unsigned Size = DL.getTypeStoreSize(V->getType()->getPointerElementType());
+  unsigned Size = DL.getTypeStoreSize(cast<AllocaInst>(V)->getAllocatedType());
   if (Size <= PtrSize)
     return;
 
@@ -2597,7 +2626,8 @@
       if (hasStructRetAttr(CI)) {
         Value *Ptr = CI->getOperand(0);
         if (isTrackedAlloca(Ptr, DVCache) == V)
-          StoreSize += DL.getTypeStoreSize(Ptr->getType()->getPointerElementType());
+          StoreSize +=
+              DL.getTypeStoreSize(cast<AllocaInst>(Ptr)->getAllocatedType());
       }
       if (Function *Fn = CI->getCalledFunction())
         switch (Fn->getIntrinsicID()) {
@@ -2621,7 +2651,9 @@
       if (hasStructRetAttr(II)) {
         Value *Ptr = II->getOperand(0);
         if (isTrackedAlloca(Ptr, DVCache) == V)
-          if (DL.getTypeStoreSize(Ptr->getType()->getPointerElementType()) + PtrSize - 1 >= Size)
+          if (DL.getTypeStoreSize(cast<AllocaInst>(Ptr)->getAllocatedType()) +
+                  PtrSize - 1 >=
+              Size)
             // We are storing the whole type
             return;
 
@@ -2919,8 +2951,8 @@
       Value *V = Ptr->stripPointerCasts();
       const DataLayout &DL = Inst->getModule()->getDataLayout();
       if (!Data.LiveIn[BB].count(V) &&
-          (DL.getTypeStoreSize(Ptr->getType()->getPointerElementType()) >=
-           DL.getTypeStoreSize(V->getType()->getPointerElementType())))
+          (DL.getTypeStoreSize(getPointerElementType(Ptr)) >=
+           DL.getTypeStoreSize(getPointerElementType(V))))
         LiveOut.remove(V);
     }
 
@@ -2935,7 +2967,7 @@
       Value *Bad = ConstantInt::get(Int8Ty, 0xff);
       for (Value *Alloca : ToClobber) {
         unsigned Siz =
-            DL.getTypeStoreSize(Alloca->getType()->getPointerElementType());
+            DL.getTypeStoreSize(cast<AllocaInst>(Alloca)->getAllocatedType());
         Builder.CreateMemSet(Alloca, Bad, Siz, MaybeAlign(0));
         //dbgs() << "clobber " << *Alloca << " at " << *Inst << "\n";
       }
@@ -2962,7 +2994,7 @@
   for (Instruction &I : instructions(F)) {
     if (auto *CI = dyn_cast<CallInst>(&I))
       if (Function *Callee = CI->getCalledFunction()) {
-        if (Callee->getName().equals("runtime.gcWriteBarrier")) {
+        if (Callee->getName() == "runtime.gcWriteBarrier") {
           // gcWriteBarrier(dst, val)
           // there is an extra "nest" argument.
           Value *Dst = CI->getArgOperand(1), *Val = CI->getArgOperand(2);
@@ -2974,7 +3006,7 @@
                                       PointerType::get(Val->getType(), AS));
           Builder.CreateStore(Val, Dst);
           ToDel.insert(CI);
-        } else if (Callee->getName().equals("runtime.typedmemmove")) {
+        } else if (Callee->getName() == "runtime.typedmemmove") {
           // typedmemmove(typ, dst, src)
           // there is an extra "nest" argument.
           Value *Dst = CI->getArgOperand(2), *Src = CI->getArgOperand(3);
@@ -2986,7 +3018,7 @@
           // for now. The size is the first field. The optimizer should be
           // able to constant-fold it.
           Value *TD = CI->getArgOperand(1);
-          Type *etyp = TD->getType()->getPointerElementType();
+          Type *etyp = cast<GlobalValue>(TD)->getValueType();
           Value *GEP = Builder.CreateConstInBoundsGEP2_32(
               etyp, TD, 0, 0);
           Value *Siz = Builder.CreateLoad(etyp, GEP);

diff --git a/passes/GollvmPasses.h b/passes/GollvmPasses.h
index 398df82..d1900a4 100644
--- a/passes/GollvmPasses.h
+++ b/passes/GollvmPasses.h

@@ -11,6 +11,10 @@
 
 #include "llvm/ADT/SmallVector.h"
 
+#include "GoSafeGetg.h"
+#include "GoStatepoints.h"
+#include "RemoveAddrSpace.h"
+
 namespace llvm {
 
 class DataLayout;
@@ -25,14 +29,14 @@
 void initializeGoSafeGetgPass(PassRegistry&);
 void initializeGoStatepointsLegacyPassPass(PassRegistry&);
 void initializeGoWrappersPass(PassRegistry&);
-void initializeRemoveAddrSpacePassPass(PassRegistry&);
+void initializeRemoveAddrSpaceWrapperPass(PassRegistry&);
 
 FunctionPass *createGoAnnotationPass();
 FunctionPass *createGoNilChecksPass();
 ModulePass *createGoSafeGetgPass();
 ModulePass *createGoStatepointsLegacyPass();
 FunctionPass *createGoWrappersPass();
-ModulePass *createRemoveAddrSpacePass(const DataLayout&);
+ModulePass *createRemoveAddrSpaceWrapper(const DataLayout&);
 
 void linkGoGC();
 void linkGoGCPrinter();

diff --git a/passes/RemoveAddrSpace.cpp b/passes/RemoveAddrSpace.cpp
index e31e9ac..085db3d 100644
--- a/passes/RemoveAddrSpace.cpp
+++ b/passes/RemoveAddrSpace.cpp

@@ -1,4 +1,4 @@
-//===--- GoStackMap.cpp ---------------------------------------------------===//
+//===--- RemoveAddrSpace.cpp ----------------------------------------------===//
 //
 // Copyright 2018 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -12,6 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "RemoveAddrSpace.h"
 #include "GollvmPasses.h"
 
 #include "llvm/ADT/DenseSet.h"
@@ -27,21 +28,8 @@
 
 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
+class RemoveAddrSpace {
+  Type *IntTy {nullptr}; // 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
 
@@ -49,20 +37,44 @@
   // of ptr-to-int and int-to-ptr casts, as codegen cannot handle
   // addrspacecast in static initializer.
   void removeAddrSpaceCast(Constant *C);
+
+public:
+  RemoveAddrSpace(const DataLayout &DL) : DL(DL) {}
+  bool runOnModule(Module &M);
+};
+
+
+class RemoveAddrSpaceWrapper : public ModulePass {
+  DataLayout DL;
+
+ public:
+  static char ID;
+
+  RemoveAddrSpaceWrapper() : ModulePass(ID), DL("") {}
+
+  RemoveAddrSpaceWrapper(const DataLayout &DL) : ModulePass(ID), DL(DL) {
+    initializeRemoveAddrSpaceWrapperPass(
+        *PassRegistry::getPassRegistry());
+  }
+
+  bool runOnModule(Module &M) override {
+    RemoveAddrSpace R(DL);
+    return R.runOnModule(M);
+  }
 };
 
 } // namespace
 
-char RemoveAddrSpacePass::ID = 0;
-INITIALIZE_PASS(RemoveAddrSpacePass, "remove-addrspacecast",
+char RemoveAddrSpaceWrapper::ID = 0;
+INITIALIZE_PASS(RemoveAddrSpaceWrapper, "remove-addrspacecast",
                 "Remove addrspacecast instructions", false,
                 false)
-ModulePass *llvm::createRemoveAddrSpacePass(const DataLayout &DL) {
-  return new RemoveAddrSpacePass(DL);
+ModulePass *llvm::createRemoveAddrSpaceWrapper(const DataLayout &DL) {
+  return new RemoveAddrSpaceWrapper(DL);
 }
 
 void
-RemoveAddrSpacePass::removeAddrSpaceCast(Constant *C) {
+RemoveAddrSpace::removeAddrSpaceCast(Constant *C) {
   if (Visited.count(C))
     return;
   Visited.insert(C);
@@ -86,7 +98,7 @@
 }
 
 bool
-RemoveAddrSpacePass::runOnModule(Module &M) {
+RemoveAddrSpace::runOnModule(Module &M) {
   // At this point we no longer need non-integral pointers.
   // Set data layout back to default.
   M.setDataLayout(DL);
@@ -97,3 +109,10 @@
       removeAddrSpaceCast(GV.getInitializer());
   return true;
 }
+
+PreservedAnalyses llvm::RemoveAddrSpacePass::run(Module &M,
+                                                 ModuleAnalysisManager &AM) {
+  RemoveAddrSpace R(DL);
+  R.runOnModule(M);
+  return PreservedAnalyses::all();
+}

diff --git a/passes/RemoveAddrSpace.h b/passes/RemoveAddrSpace.h
new file mode 100644
index 0000000..e994139
--- /dev/null
+++ b/passes/RemoveAddrSpace.h

@@ -0,0 +1,36 @@
+//===--- RemoveAddrSpace.h ------------------------------------------------===//
+//
+// 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).
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_GOLLVM_PASSES_REMOVEADDRSPACE_H
+#define LLVM_GOLLVM_PASSES_REMOVEADDRSPACE_H
+
+#include "llvm/IR/DataLayout.h"
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class RemoveAddrSpacePass : public PassInfoMixin<RemoveAddrSpacePass> {
+  DataLayout DL; // data layout without non-integral pointer
+
+public:
+  /// Construct a pass with update data layout optional optmizations.
+  RemoveAddrSpacePass(const DataLayout &DL) : DL(DL) {}
+
+  /// Run the pass over the module.
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+} // namespace llvm
+
+#endif // LLVM_GOLLVM_PASSES_REMOVEADDRSPACE_H

diff --git a/passes/Util.cpp b/passes/Util.cpp
index 08b3ddb..00bc3bd 100644
--- a/passes/Util.cpp
+++ b/passes/Util.cpp

@@ -61,7 +61,7 @@
     for (unsigned i = 0, n = T->getArrayNumElements(); i < n; ++i) {
       Value *ivals[2] = { ConstantInt::get(Int32Ty, 0),
                           ConstantInt::get(Int32Ty, i) };
-      ArrayRef<Value*> Idx = makeArrayRef(ivals, 2);
+      ArrayRef<Value *> Idx(ivals, 2);
       uint64_t Offset = DL.getIndexedOffsetInType(T, Idx);
       getPtrBitmapForTypeHelper(ET, DL, BaseOffset+Offset, BV);
     }
@@ -73,7 +73,7 @@
     for (unsigned i = 0, n = VT->getNumElements(); i < n; ++i) {
       Value *ivals[2] = { ConstantInt::get(Int32Ty, 0),
                           ConstantInt::get(Int32Ty, i) };
-      ArrayRef<Value*> Idx = makeArrayRef(ivals, 2);
+      ArrayRef<Value *> Idx(ivals, 2);
       uint64_t Offset = DL.getIndexedOffsetInType(T, Idx);
       getPtrBitmapForTypeHelper(ET, DL, BaseOffset+Offset, BV);
     }
@@ -86,7 +86,7 @@
         continue;
       Value *ivals[2] = { ConstantInt::get(Int32Ty, 0),
                           ConstantInt::get(Int32Ty, i) };
-      ArrayRef<Value*> Idx = makeArrayRef(ivals, 2);
+      ArrayRef<Value *> Idx(ivals, 2);
       uint64_t Offset = DL.getIndexedOffsetInType(T, Idx);
       getPtrBitmapForTypeHelper(ET, DL, BaseOffset+Offset, BV);
     }

diff --git a/unittests/BackendCore/BackendArrayStruct.cpp b/unittests/BackendCore/BackendArrayStruct.cpp
index a488338..4fd7244 100644
--- a/unittests/BackendCore/BackendArrayStruct.cpp
+++ b/unittests/BackendCore/BackendArrayStruct.cpp

@@ -79,19 +79,18 @@
   h.mkAssign(bfex2, bc2);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %cast.0 = bitcast { i8*, i32 }* %loc1 to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.0, i8* align 8 bitcast ({ i8*, i32 }* @const.0 to i8*), i64 16, i1 false)
-    store { i8*, i32 }* %loc1, { i8*, i32 }** %loc2, align 8
-    store i32 0, i32* %x, align 4
-    %field.0 = getelementptr inbounds { i8*, i32 }, { i8*, i32 }* %loc1, i32 0, i32 1
-    %loc1.field.ld.0 = load i32, i32* %field.0, align 4
-    store i32 %loc1.field.ld.0, i32* %x, align 4
-    store i8 0, i8* %b2, align 1
-    %field.1 = getelementptr inbounds { i8*, i32 }, { i8*, i32 }* %loc1, i32 0, i32 0
-    store i8* %b2, i8** %field.1, align 8
-    %loc2.ld.0 = load { i8*, i32 }*, { i8*, i32 }** %loc2, align 8
-    %field.2 = getelementptr inbounds { i8*, i32 }, { i8*, i32 }* %loc2.ld.0, i32 0, i32 1
-    store i32 2, i32* %field.2, align 4
+    call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 8 %loc1, ptr align 8 @const.0, i64 16, i1 false)
+    store ptr %loc1, ptr %loc2, align 8
+    store i32 0, ptr %x, align 4
+    %field.0 = getelementptr inbounds { ptr, i32 }, ptr %loc1, i32 0, i32 1
+    %loc1.field.ld.0 = load i32, ptr %field.0, align 4
+    store i32 %loc1.field.ld.0, ptr %x, align 4
+    store i8 0, ptr %b2, align 1
+    %field.1 = getelementptr inbounds { ptr, i32 }, ptr %loc1, i32 0, i32 0
+    store ptr %b2, ptr %field.1, align 8
+    %loc2.ld.0 = load ptr, ptr %loc2, align 8
+    %field.2 = getelementptr inbounds { ptr, i32 }, ptr %loc2.ld.0, i32 0, i32 1
+    store i32 2, ptr %field.2, align 4
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -145,24 +144,24 @@
   h.mkAssign(vex2, fex2);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define void @foo(i8* nest %nest.0) #0 {
+  define void @foo(ptr nest %nest.0) #0 {
   entry:
-    %tmp.0 = alloca { i8*, i32 }, align 8
+    %tmp.0 = alloca { ptr, i32 }, align 8
     %x = alloca i32, align 4
     %y = alloca i32, align 4
     %z = alloca i32, align 4
-    store i32 0, i32* %x, align 4
-    store i32 0, i32* %y, align 4
-    %y.ld.0 = load i32, i32* %y, align 4
-    %field.0 = getelementptr inbounds { i8*, i32 }, { i8*, i32 }* %tmp.0, i32 0, i32 0
-    store i8* null, i8** %field.0, align 8
-    %field.1 = getelementptr inbounds { i8*, i32 }, { i8*, i32 }* %tmp.0, i32 0, i32 1
-    store i32 %y.ld.0, i32* %field.1, align 4
-    %field.2 = getelementptr inbounds { i8*, i32 }, { i8*, i32 }* %tmp.0, i32 0, i32 1
-    %.field.ld.0 = load i32, i32* %field.2, align 4
-    store i32 %.field.ld.0, i32* %x, align 4
-    store i32 0, i32* %z, align 4
-    store i32 42, i32* %z, align 4
+    store i32 0, ptr %x, align 4
+    store i32 0, ptr %y, align 4
+    %y.ld.0 = load i32, ptr %y, align 4
+    %field.0 = getelementptr inbounds { ptr, i32 }, ptr %tmp.0, i32 0, i32 0
+    store ptr null, ptr %field.0, align 8
+    %field.1 = getelementptr inbounds { ptr, i32 }, ptr %tmp.0, i32 0, i32 1
+    store i32 %y.ld.0, ptr %field.1, align 4
+    %field.2 = getelementptr inbounds { ptr, i32 }, ptr %tmp.0, i32 0, i32 1
+    %.field.ld.0 = load i32, ptr %field.2, align 4
+    store i32 %.field.ld.0, ptr %x, align 4
+    store i32 0, ptr %z, align 4
+    store i32 42, ptr %z, align 4
     ret void
   }
   )RAW_RESULT");
@@ -231,34 +230,34 @@
   h.mkAssign(vex3, eex3);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define void @foo(i8* nest %nest.0) #0 {
+  define void @foo(ptr nest %nest.0) #0 {
   entry:
     %tmp.0 = alloca [4 x i64], align 8
     %x = alloca i64, align 8
     %y = alloca i64, align 8
     %z = alloca i64, align 8
     %w = alloca i64, align 8
-    store i64 0, i64* %x, align 8
-    store i64 0, i64* %y, align 8
-    %y.ld.0 = load i64, i64* %y, align 8
-    %index.0 = getelementptr [4 x i64], [4 x i64]* %tmp.0, i32 0, i32 0
-    store i64 %y.ld.0, i64* %index.0, align 8
-    %index.1 = getelementptr [4 x i64], [4 x i64]* %tmp.0, i32 0, i32 1
-    store i64 3, i64* %index.1, align 8
-    %index.2 = getelementptr [4 x i64], [4 x i64]* %tmp.0, i32 0, i32 2
-    store i64 2, i64* %index.2, align 8
-    %index.3 = getelementptr [4 x i64], [4 x i64]* %tmp.0, i32 0, i32 3
-    store i64 1, i64* %index.3, align 8
-    %index.4 = getelementptr [4 x i64], [4 x i64]* %tmp.0, i32 0, i32 1
-    %.index.ld.0 = load i64, i64* %index.4, align 8
-    store i64 %.index.ld.0, i64* %x, align 8
-    store i64 0, i64* %z, align 8
-    store i64 3, i64* %z, align 8
-    store i64 0, i64* %w, align 8
-    %x.ld.0 = load i64, i64* %x, align 8
-    %index.5 = getelementptr [4 x i64], [4 x i64]* @const.0, i32 0, i64 %x.ld.0
-    %.index.ld.1 = load i64, i64* %index.5, align 8
-    store i64 %.index.ld.1, i64* %w, align 8
+    store i64 0, ptr %x, align 8
+    store i64 0, ptr %y, align 8
+    %y.ld.0 = load i64, ptr %y, align 8
+    %index.0 = getelementptr [4 x i64], ptr %tmp.0, i32 0, i32 0
+    store i64 %y.ld.0, ptr %index.0, align 8
+    %index.1 = getelementptr [4 x i64], ptr %tmp.0, i32 0, i32 1
+    store i64 3, ptr %index.1, align 8
+    %index.2 = getelementptr [4 x i64], ptr %tmp.0, i32 0, i32 2
+    store i64 2, ptr %index.2, align 8
+    %index.3 = getelementptr [4 x i64], ptr %tmp.0, i32 0, i32 3
+    store i64 1, ptr %index.3, align 8
+    %index.4 = getelementptr [4 x i64], ptr %tmp.0, i32 0, i32 1
+    %.index.ld.0 = load i64, ptr %index.4, align 8
+    store i64 %.index.ld.0, ptr %x, align 8
+    store i64 0, ptr %z, align 8
+    store i64 3, ptr %z, align 8
+    store i64 0, ptr %w, align 8
+    %x.ld.0 = load i64, ptr %x, align 8
+    %index.5 = getelementptr [4 x i64], ptr @const.0, i32 0, i64 %x.ld.0
+    %.index.ld.1 = load i64, ptr %index.5, align 8
+    store i64 %.index.ld.1, ptr %w, align 8
     ret void
   }
   )RAW_RESULT");
@@ -306,20 +305,18 @@
   h.mkLocal("ac", at4, arcon3);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %cast.0 = bitcast [4 x i64]* %aa to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.0, i8* align 8 bitcast ([4 x i64]* @const.0 to i8*), i64 32, i1 false)
-    %cast.1 = bitcast [4 x i64]* %ab to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.1, i8* align 8 bitcast ([4 x i64]* @const.1 to i8*), i64 32, i1 false)
-    store i64 0, i64* %z, align 8
-    %z.ld.0 = load i64, i64* %z, align 8
-    %index.0 = getelementptr [4 x i64], [4 x i64]* %ac, i32 0, i32 0
-    store i64 0, i64* %index.0, align 8
-    %index.1 = getelementptr [4 x i64], [4 x i64]* %ac, i32 0, i32 1
-    store i64 %z.ld.0, i64* %index.1, align 8
-    %index.2 = getelementptr [4 x i64], [4 x i64]* %ac, i32 0, i32 2
-    store i64 0, i64* %index.2, align 8
-    %index.3 = getelementptr [4 x i64], [4 x i64]* %ac, i32 0, i32 3
-    store i64 0, i64* %index.3, align 8
+    call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 8 %aa, ptr align 8 @const.0, i64 32, i1 false)
+    call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 8 %ab, ptr align 8 @const.1, i64 32, i1 false)
+    store i64 0, ptr %z, align 8
+    %z.ld.0 = load i64, ptr %z, align 8
+    %index.0 = getelementptr [4 x i64], ptr %ac, i32 0, i32 0
+    store i64 0, ptr %index.0, align 8
+    %index.1 = getelementptr [4 x i64], ptr %ac, i32 0, i32 1
+    store i64 %z.ld.0, ptr %index.1, align 8
+    %index.2 = getelementptr [4 x i64], ptr %ac, i32 0, i32 2
+    store i64 0, ptr %index.2, align 8
+    %index.3 = getelementptr [4 x i64], ptr %ac, i32 0, i32 3
+    store i64 0, ptr %index.3, align 8
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -367,14 +364,13 @@
   h.mkLocal("loc2", s2t, scon2);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %cast.0 = bitcast { i32*, i32 }* %loc1 to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.0, i8* align 8 bitcast ({ i32*, i32 }* @const.0 to i8*), i64 16, i1 false)
-    %field.0 = getelementptr inbounds { i32*, i32 }, { i32*, i32 }* %loc1, i32 0, i32 1
-    %loc1.field.ld.0 = load i32, i32* %field.0, align 4
-    %field.1 = getelementptr inbounds { i32*, i32 }, { i32*, i32 }* %loc2, i32 0, i32 0
-    store i32* %param1.addr, i32** %field.1, align 8
-    %field.2 = getelementptr inbounds { i32*, i32 }, { i32*, i32 }* %loc2, i32 0, i32 1
-    store i32 %loc1.field.ld.0, i32* %field.2, align 4
+    call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 8 %loc1, ptr align 8 @const.0, i64 16, i1 false)
+    %field.0 = getelementptr inbounds { ptr, i32 }, ptr %loc1, i32 0, i32 1
+    %loc1.field.ld.0 = load i32, ptr %field.0, align 4
+    %field.1 = getelementptr inbounds { ptr, i32 }, ptr %loc2, i32 0, i32 0
+    store ptr %param1.addr, ptr %field.1, align 8
+    %field.2 = getelementptr inbounds { ptr, i32 }, ptr %loc2, i32 0, i32 1
+    store i32 %loc1.field.ld.0, ptr %field.2, align 4
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -423,18 +419,15 @@
   h.mkAssign(vex, scon2);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %cast.0 = bitcast { { i32*, i32 }, float }* %loc1 to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.0, i8* align 8 bitcast ({ { i32*, i32 }, float }* @const.0 to i8*), i64 24, i1 false)
-    %field.0 = getelementptr inbounds { i32*, i32 }, { i32*, i32 }* %tmp.0, i32 0, i32 0
-    store i32* %param1.addr, i32** %field.0, align 8
-    %field.1 = getelementptr inbounds { i32*, i32 }, { i32*, i32 }* %tmp.0, i32 0, i32 1
-    store i32 3, i32* %field.1, align 4
-    %field.2 = getelementptr inbounds { { i32*, i32 }, float }, { { i32*, i32 }, float }* %loc1, i32 0, i32 0
-    %cast.1 = bitcast { i32*, i32 }* %field.2 to i8*
-    %cast.2 = bitcast { i32*, i32 }* %tmp.0 to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.1, i8* align 8 %cast.2, i64 16, i1 false)
-    %field.3 = getelementptr inbounds { { i32*, i32 }, float }, { { i32*, i32 }, float }* %loc1, i32 0, i32 1
-    store float 3.000000e+00, float* %field.3, align 4
+    call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 8 %loc1, ptr align 8 @const.0, i64 24, i1 false)
+    %field.0 = getelementptr inbounds { ptr, i32 }, ptr %tmp.0, i32 0, i32 0
+    store ptr %param1.addr, ptr %field.0, align 8
+    %field.1 = getelementptr inbounds { ptr, i32 }, ptr %tmp.0, i32 0, i32 1
+    store i32 3, ptr %field.1, align 4
+    %field.2 = getelementptr inbounds { { ptr, i32 }, float }, ptr %loc1, i32 0, i32 0
+    call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 8 %field.2, ptr align 8 %tmp.0, i64 16, i1 false)
+    %field.3 = getelementptr inbounds { { ptr, i32 }, float }, ptr %loc1, i32 0, i32 1
+    store float 3.000000e+00, ptr %field.3, align 4
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -472,12 +465,12 @@
   h.mkAssign(dex, scon);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %p0.ld.0 = load { i32*, i32 }*, { i32*, i32 }** %p0.addr, align 8
-    %p1.ld.0 = load i32*, i32** %p1.addr, align 8
-    %field.0 = getelementptr inbounds { i32*, i32 }, { i32*, i32 }* %p0.ld.0, i32 0, i32 0
-    store i32* %p1.ld.0, i32** %field.0, align 8
-    %field.1 = getelementptr inbounds { i32*, i32 }, { i32*, i32 }* %p0.ld.0, i32 0, i32 1
-    store i32 101, i32* %field.1, align 4
+    %p0.ld.0 = load ptr, ptr %p0.addr, align 8
+    %p1.ld.0 = load ptr, ptr %p1.addr, align 8
+    %field.0 = getelementptr inbounds { ptr, i32 }, ptr %p0.ld.0, i32 0, i32 0
+    store ptr %p1.ld.0, ptr %field.0, align 8
+    %field.1 = getelementptr inbounds { ptr, i32 }, ptr %p0.ld.0, i32 0, i32 1
+    store i32 101, ptr %field.1, align 4
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -521,11 +514,11 @@
   h.mkLocal("t2", s1t, scon2);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %x.ld.0 = load i32, i32* @x, align 4
-    store i32 %x.ld.0, i32* getelementptr inbounds ({ i32 }, { i32 }* @t, i32 0, i32 0), align 4
-    %t.field.ld.0 = load i32, i32* getelementptr inbounds ({ i32 }, { i32 }* @t, i32 0, i32 0), align 4
-    %field.2 = getelementptr inbounds { i32 }, { i32 }* %t2, i32 0, i32 0
-    store i32 %t.field.ld.0, i32* %field.2, align 4
+    %x.ld.0 = load i32, ptr @x, align 4
+    store i32 %x.ld.0, ptr @t, align 4
+    %t.field.ld.0 = load i32, ptr @t, align 4
+    %field.2 = getelementptr inbounds { i32 }, ptr %t2, i32 0, i32 0
+    store i32 %t.field.ld.0, ptr %field.2, align 4
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -575,16 +568,15 @@
   h.mkAssign(aa4, aa3);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %cast.0 = bitcast [4 x i64]* %aa to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.0, i8* align 8 bitcast ([4 x i64]* @const.0 to i8*), i64 32, i1 false)
-    %index.0 = getelementptr [4 x i64], [4 x i64]* %aa, i32 0, i32 1
-    %aa.index.ld.0 = load i64, i64* %index.0, align 8
-    %index.1 = getelementptr [4 x i64], [4 x i64]* %aa, i32 0, i64 %aa.index.ld.0
-    %index.2 = getelementptr [4 x i64], [4 x i64]* %aa, i32 0, i64 3
-    %aa.index.ld.1 = load i64, i64* %index.2, align 8
-    %index.3 = getelementptr [4 x i64], [4 x i64]* %aa, i32 0, i64 %aa.index.ld.1
-    %aa.index.ld.2 = load i64, i64* %index.3, align 8
-    store i64 %aa.index.ld.2, i64* %index.1, align 8
+    call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 8 %aa, ptr align 8 @const.0, i64 32, i1 false)
+    %index.0 = getelementptr [4 x i64], ptr %aa, i32 0, i32 1
+    %aa.index.ld.0 = load i64, ptr %index.0, align 8
+    %index.1 = getelementptr [4 x i64], ptr %aa, i32 0, i64 %aa.index.ld.0
+    %index.2 = getelementptr [4 x i64], ptr %aa, i32 0, i64 3
+    %aa.index.ld.1 = load i64, ptr %index.2, align 8
+    %index.3 = getelementptr [4 x i64], ptr %aa, i32 0, i64 %aa.index.ld.1
+    %aa.index.ld.2 = load i64, ptr %index.3, align 8
+    store i64 %aa.index.ld.2, ptr %index.1, align 8
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -644,15 +636,12 @@
     h.mkAssign(fx, bi64five);
 
     DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %cast.0 = bitcast [10 x { i8, [4 x { i64, i64 }*], i8 }*]* %t1 to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.0, i8* align 8 bitcast ([10 x { i8, [4 x { i64, i64 }*], i8 }*]* @const.0 to i8*), i64 80, i1 false)
-    %index.0 = getelementptr [10 x { i8, [4 x { i64, i64 }*], i8 }*], [10 x { i8, [4 x { i64, i64 }*], i8 }*]* %t1, i32 0, i32 7
-    %t1.index.ld.0 = load { i8, [4 x { i64, i64 }*], i8 }*, { i8, [4 x { i64, i64 }*], i8 }** %index.0, align 8
-    %field.0 = getelementptr inbounds { i8, [4 x { i64, i64 }*], i8 }, { i8, [4 x { i64, i64 }*], i8 }* %t1.index.ld.0, i32 0, i32 1
-    %index.1 = getelementptr [4 x { i64, i64 }*], [4 x { i64, i64 }*]* %field.0, i32 0, i32 3
-    %.field.index.ld.0 = load { i64, i64 }*, { i64, i64 }** %index.1, align 8
-    %field.1 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %.field.index.ld.0, i32 0, i32 0
-    store i64 5, i64* %field.1, align 8
+      call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 8 %t1, ptr align 8 @const.0, i64 80, i1 false)
+      %index.0 = getelementptr [10 x ptr], ptr %t1, i32 0, i32 7
+      %field.0 = getelementptr inbounds { i8, [4 x ptr], i8 }, ptr %index.0, i32 0, i32 1
+      %index.1 = getelementptr [4 x ptr], ptr %field.0, i32 0, i32 3
+      %field.1 = getelementptr inbounds { i64, i64 }, ptr %index.1, i32 0, i32 0
+      store i64 5, ptr %field.1, align 8
     )RAW_RESULT");
 
     bool isOK = h.expectBlock(exp);
@@ -675,14 +664,12 @@
     h.mkLocal("q", bi64t, fx);
 
     DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %index.2 = getelementptr [10 x { i8, [4 x { i64, i64 }*], i8 }*], [10 x { i8, [4 x { i64, i64 }*], i8 }*]* %t1, i32 0, i32 0
-    %t1.index.ld.1 = load { i8, [4 x { i64, i64 }*], i8 }*, { i8, [4 x { i64, i64 }*], i8 }** %index.2, align 8
-    %field.2 = getelementptr inbounds { i8, [4 x { i64, i64 }*], i8 }, { i8, [4 x { i64, i64 }*], i8 }* %t1.index.ld.1, i32 0, i32 1
-    %index.3 = getelementptr [4 x { i64, i64 }*], [4 x { i64, i64 }*]* %field.2, i32 0, i32 0
-    %.field.index.ld.1 = load { i64, i64 }*, { i64, i64 }** %index.3, align 8
-    %field.3 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %.field.index.ld.1, i32 0, i32 1
-    %.field.ld.0 = load i64, i64* %field.3, align 8
-    store i64 %.field.ld.0, i64* %q, align 8
+      %index.2 = getelementptr [10 x ptr], ptr %t1, i32 0, i32 0
+      %field.2 = getelementptr inbounds { i8, [4 x ptr], i8 }, ptr %index.2, i32 0, i32 1
+      %index.3 = getelementptr [4 x ptr], ptr %field.2, i32 0, i32 0
+      %field.3 = getelementptr inbounds { i64, i64 }, ptr %index.3, i32 0, i32 1
+      %.field.ld.0 = load i64, ptr %field.3, align 8
+      store i64 %.field.ld.0, ptr %q, align 8
     )RAW_RESULT");
 
     bool isOK = h.expectBlock(exp);
@@ -725,20 +712,12 @@
   h.mkAssign(ve3, ve4);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %cast.0 = bitcast { i8* }* %x1 to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.0, i8* align 8 bitcast ({ i8* }* @const.0 to i8*), i64 8, i1 false)
-    %cast.1 = bitcast { i8* }* %y1 to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.1, i8* align 8 bitcast ({ i8* }* @const.0 to i8*), i64 8, i1 false)
-    %cast.2 = bitcast { i64, i64, i64, i64, i64, i64 }* %x2 to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.2, i8* align 8 bitcast ({ i64, i64, i64, i64, i64, i64 }* @const.1 to i8*), i64 48, i1 false)
-    %cast.3 = bitcast { i64, i64, i64, i64, i64, i64 }* %y2 to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.3, i8* align 8 bitcast ({ i64, i64, i64, i64, i64, i64 }* @const.1 to i8*), i64 48, i1 false)
-    %cast.4 = bitcast { i8* }* %x1 to i8*
-    %cast.5 = bitcast { i8* }* %y1 to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.4, i8* align 8 %cast.5, i64 8, i1 false)
-    %cast.6 = bitcast { i64, i64, i64, i64, i64, i64 }* %x2 to i8*
-    %cast.7 = bitcast { i64, i64, i64, i64, i64, i64 }* %y2 to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.6, i8* align 8 %cast.7, i64 48, i1 false)
+    call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 8 %x1, ptr align 8 @const.0, i64 8, i1 false)
+    call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 8 %y1, ptr align 8 @const.0, i64 8, i1 false)
+    call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 8 %x2, ptr align 8 @const.1, i64 48, i1 false)
+    call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 8 %y2, ptr align 8 @const.1, i64 48, i1 false)
+    call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 8 %x1, ptr align 8 %y1, i64 8, i1 false)
+    call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 8 %x2, ptr align 8 %y2, i64 48, i1 false)
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -780,11 +759,10 @@
   h.mkLocal("a2", bpi32t, aex2);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %cast.0 = bitcast { i32 }* %t1 to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %cast.0, i8* align 4 bitcast ({ i32 }* @const.0 to i8*), i64 4, i1 false)
-    %field.0 = getelementptr inbounds { i32 }, { i32 }* %t1, i32 0, i32 0
-    store i32* %field.0, i32** %a1, align 8
-    store i32* getelementptr inbounds ({ i32 }, { i32 }* @t2, i32 0, i32 0), i32** %a2, align 8
+    call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 4 %t1, ptr align 4 @const.0, i64 4, i1 false)
+    %field.0 = getelementptr inbounds { i32 }, ptr %t1, i32 0, i32 0
+    store ptr %field.0, ptr %a1, align 8
+    store ptr @t2, ptr %a2, align 8
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);

diff --git a/unittests/BackendCore/BackendCABIOracleTests.cpp b/unittests/BackendCore/BackendCABIOracleTests.cpp
index 3f3c902..e675043 100644
--- a/unittests/BackendCore/BackendCABIOracleTests.cpp
+++ b/unittests/BackendCore/BackendCABIOracleTests.cpp

@@ -55,7 +55,7 @@
     CABIOracle cab(befty1, be->typeManager());
     DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
       Return: Direct { { double, double } } sigOffset: -1
-      Param 1: Direct AttrNest { i8* } sigOffset: 0
+      Param 1: Direct AttrNest { ptr } sigOffset: 0
       Param 2: Direct AttrSext { i8 } sigOffset: 1
       Param 3: Direct { float } sigOffset: 2
       Param 4: Ignore { void } sigOffset: -1
@@ -65,7 +65,7 @@
     bool equal = difftokens(exp.content, cab.toString(), reason);
     EXPECT_EQ("pass", equal ? "pass" : reason);
     EXPECT_EQ(repr(cab.getFunctionTypeForABI()),
-              "{ double, double } (i8*, i8, float, i64)");
+              "{ double, double } (ptr, i8, float, i64)");
   }
 }
 
@@ -118,99 +118,98 @@
   std::vector<FcnItem> items = {
 
       // 1
-      FcnItem( { }, { },
+      FcnItem({}, {},
               "Return: Ignore { void } sigOffset: -1 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 0",
-              "void (i8*)"),
+              "Param 1: Direct AttrNest { ptr } sigOffset: 0",
+              "void (ptr)"),
 
       // 2
-      FcnItem( { bi8t }, { },
+      FcnItem({bi8t}, {},
               "Return: Direct AttrSext { i8 } sigOffset: -1 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 0",
-              "i8 (i8*)"),
+              "Param 1: Direct AttrNest { ptr } sigOffset: 0",
+              "i8 (ptr)"),
 
       // 3
-      FcnItem( { }, { bi8t },
+      FcnItem({}, {bi8t},
               "Return: Ignore { void } sigOffset: -1 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+              "Param 1: Direct AttrNest { ptr } sigOffset: 0 "
               "Param 2: Direct AttrSext { i8 } sigOffset: 1",
-              "void (i8*, i8)"),
+              "void (ptr, i8)"),
 
       // 4
-      FcnItem( { }, { st5, bpf64t },
+      FcnItem({}, {st5, bpf64t},
               "Return: Ignore { void } sigOffset: -1 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+              "Param 1: Direct AttrNest { ptr } sigOffset: 0 "
               "Param 2: Direct { float } sigOffset: 1 "
-              "Param 3: Direct { double* } sigOffset: 2",
-              "void (i8*, float, double*)"),
+              "Param 3: Direct { ptr } sigOffset: 2",
+              "void (ptr, float, ptr)"),
 
       // 5
-      FcnItem({ bi8t, bf64t }, { bi8t, bu8t, st0 },
+      FcnItem({bi8t, bf64t}, {bi8t, bu8t, st0},
               "Return: Direct { { i8, double } } sigOffset: -1 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+              "Param 1: Direct AttrNest { ptr } sigOffset: 0 "
               "Param 2: Direct AttrSext { i8 } sigOffset: 1 "
               "Param 3: Direct AttrZext { i8 } sigOffset: 2 "
               "Param 4: Ignore { void } sigOffset: -1",
-              "{ i8, double } (i8*, i8, i8)"),
+              "{ i8, double } (ptr, i8, i8)"),
 
       // 6
-      FcnItem({ st2 }, { st2, st0, st4, st1 },
+      FcnItem({st2}, {st2, st0, st4, st1},
               "Return: Direct { { double, double } } sigOffset: -1 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+              "Param 1: Direct AttrNest { ptr } sigOffset: 0 "
               "Param 2: Direct { double, double } sigOffset: 1 "
               "Param 3: Ignore { void } sigOffset: -1 "
               "Param 4: Direct { <2 x float> } sigOffset: 3 "
               "Param 5: Direct { i64 } sigOffset: 4 ",
-              "{ double, double } (i8*, double, double, <2 x float>, i64)"),
+              "{ double, double } (ptr, double, double, <2 x float>, i64)"),
 
       // 7
-      FcnItem({ st3 }, { st3, st0, bu8t },
-              "Return: Indirect AttrStructReturn { { { double, double }, i8 }* } sigOffset: 0 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 1 "
-              "Param 2: Indirect AttrByVal { { { double, double }, i8 }* } sigOffset: 2 "
+      FcnItem({st3}, {st3, st0, bu8t},
+              "Return: Indirect AttrStructReturn { ptr } sigOffset: 0 "
+              "Param 1: Direct AttrNest { ptr } sigOffset: 1 "
+              "Param 2: Indirect AttrByVal { ptr } sigOffset: 2 "
               "Param 3: Ignore { void } sigOffset: -1 "
               "Param 4: Direct AttrZext { i8 } sigOffset: 3 ",
-              "void ({ { double, double }, i8 }*, i8*, "
-              "{ { double, double }, i8 }*, i8)"),
+              "void (ptr, ptr, ptr, i8)"),
 
       // 8
-      FcnItem( { st6 }, { st6, st6 },
+      FcnItem({st6}, {st6, st6},
               "Return: Direct { { i64, i64 } } sigOffset: -1 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+              "Param 1: Direct AttrNest { ptr } sigOffset: 0 "
               "Param 2: Direct { i64, i64 } sigOffset: 1 "
               "Param 3: Direct { i64, i64 } sigOffset: 3",
-              "{ i64, i64 } (i8*, i64, i64, i64, i64)"),
+              "{ i64, i64 } (ptr, i64, i64, i64, i64)"),
 
       // 9
-      FcnItem( { st8 }, { st8 },
+      FcnItem({st8}, {st8},
               "Return: Direct { { i64, i32 } } sigOffset: -1 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+              "Param 1: Direct AttrNest { ptr } sigOffset: 0 "
               "Param 2: Direct { i64, i32 } sigOffset: 1",
-              "{ i64, i32 } (i8*, i64, i32)"),
+              "{ i64, i32 } (ptr, i64, i32)"),
 
       // 10
-      FcnItem( { at0 }, { at1 },
+      FcnItem({at0}, {at1},
               "Return: Ignore { void } sigOffset: -1 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+              "Param 1: Direct AttrNest { ptr } sigOffset: 0 "
               "Param 2: Direct { i32 } sigOffset: 1",
-              "void (i8*, i32)"),
+              "void (ptr, i32)"),
 
       // 11
-      FcnItem( { at2 }, { at3 },
+      FcnItem({at2}, {at3},
               "Return: Direct { { i64, i32 } } sigOffset: -1 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+              "Param 1: Direct AttrNest { ptr } sigOffset: 0 "
               "Param 2: Direct { i64, i64 } sigOffset: 1",
-              "{ i64, i32 } (i8*, i64, i64)"),
+              "{ i64, i32 } (ptr, i64, i64)"),
 
       // 12
       // Make sure pointerness is preserved.
-      FcnItem( { stip }, { stii, stpp, stpi },
-              "Return: Direct { { i64, i8* } } sigOffset: -1 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+      FcnItem({stip}, {stii, stpp, stpi},
+              "Return: Direct { { i64, ptr } } sigOffset: -1 "
+              "Param 1: Direct AttrNest { ptr } sigOffset: 0 "
               "Param 2: Direct { i64, i64 } sigOffset: 1 "
-              "Param 3: Direct { i8*, i8* } sigOffset: 3 "
-              "Param 4: Direct { i8*, i64 } sigOffset: 5",
-              "{ i64, i8* } (i8*, i64, i64, i8*, i8*, i8*, i64)"),
+              "Param 3: Direct { ptr, ptr } sigOffset: 3 "
+              "Param 4: Direct { ptr, i64 } sigOffset: 5",
+              "{ i64, ptr } (ptr, i64, i64, ptr, ptr, ptr, i64)"),
   };
 
   unsigned count = 1;
@@ -303,99 +302,97 @@
       // 1
       FcnItem({}, {},
               "Return: Ignore { void } sigOffset: -1 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 0",
-              "void (i8*)"),
+              "Param 1: Direct AttrNest { ptr } sigOffset: 0",
+              "void (ptr)"),
 
       // 2
       FcnItem({bi8t}, {},
               "Return: Direct AttrSext { i8 } sigOffset: -1 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 0",
-              "i8 (i8*)"),
+              "Param 1: Direct AttrNest { ptr } sigOffset: 0",
+              "i8 (ptr)"),
 
       // 3
       FcnItem({}, {bi8t},
               "Return: Ignore { void } sigOffset: -1 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+              "Param 1: Direct AttrNest { ptr } sigOffset: 0 "
               "Param 2: Direct AttrSext { i8 } sigOffset: 1",
-              "void (i8*, i8)"),
+              "void (ptr, i8)"),
 
       // 4
       FcnItem({}, {st5, bpf64t},
               "Return: Ignore { void } sigOffset: -1 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+              "Param 1: Direct AttrNest { ptr } sigOffset: 0 "
               "Param 2: Direct { float } sigOffset: 1 "
-              "Param 3: Direct { double* } sigOffset: 2",
-              "void (i8*, float, double*)"),
+              "Param 3: Direct { ptr } sigOffset: 2",
+              "void (ptr, float, ptr)"),
 
       // 5
       FcnItem({bi8t, bf64t}, {bi8t, bu8t, st0},
               "Return: Direct { { i64, i64 } } sigOffset: -1 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+              "Param 1: Direct AttrNest { ptr } sigOffset: 0 "
               "Param 2: Direct AttrSext { i8 } sigOffset: 1 "
               "Param 3: Direct AttrZext { i8 } sigOffset: 2 "
               "Param 4: Ignore { void } sigOffset: -1",
-              "{ i64, i64 } (i8*, i8, i8)"),
+              "{ i64, i64 } (ptr, i8, i8)"),
 
       // 6
       FcnItem({st2}, {st2, st0, st4, st1},
               "Return: Direct { { double, double } } sigOffset: -1 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+              "Param 1: Direct AttrNest { ptr } sigOffset: 0 "
               "Param 2: Direct { [2 x double] } sigOffset: 1 "
               "Param 3: Ignore { void } sigOffset: -1 "
               "Param 4: Direct { [2 x float] } sigOffset: 2 "
               "Param 5: Direct { i64 } sigOffset:  3",
-              "{ double, double } (i8*, [2 x double], [2 x float], i64)"),
+              "{ double, double } (ptr, [2 x double], [2 x float], i64)"),
 
       // 7
       FcnItem({st3}, {st3, st0, bu8t},
-              "Return: Indirect AttrStructReturn { { { double, double }, i8 "
-              "}* } sigOffset: 0 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 1 "
-              "Param 2: Indirect AttrDoCopy { { { double, double }, i8 }* } "
+              "Return: Indirect AttrStructReturn { ptr } sigOffset: 0 "
+              "Param 1: Direct AttrNest { ptr } sigOffset: 1 "
+              "Param 2: Indirect AttrDoCopy { ptr } "
               "sigOffset: 2 "
               "Param 3: Ignore { void } sigOffset: -1 "
               "Param 4: Direct AttrZext { i8 } sigOffset: 3 ",
-              "void ({ { double, double }, i8 }*, i8*, "
-              "{ { double, double }, i8 }*, i8)"),
+              "void (ptr, ptr, ptr, i8)"),
 
       // 8
       FcnItem({st6}, {st6, st6},
               "Return: Direct { { i64, i64 } } sigOffset: -1 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+              "Param 1: Direct AttrNest { ptr } sigOffset: 0 "
               "Param 2: Direct { i64, i64 } sigOffset: 1 "
               "Param 3: Direct { i64, i64 } sigOffset: 3",
-              "{ i64, i64 } (i8*, i64, i64, i64, i64)"),
+              "{ i64, i64 } (ptr, i64, i64, i64, i64)"),
 
       // 9
       FcnItem({st8}, {st8},
               "Return: Direct { { i64, i32 } } sigOffset: -1 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+              "Param 1: Direct AttrNest { ptr } sigOffset: 0 "
               "Param 2: Direct { i64, i32 } sigOffset: 1",
-              "{ i64, i32 } (i8*, i64, i32)"),
+              "{ i64, i32 } (ptr, i64, i32)"),
 
       // 10
       FcnItem({at0}, {at1},
               "Return: Ignore { void } sigOffset: -1 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+              "Param 1: Direct AttrNest { ptr } sigOffset: 0 "
               "Param 2: Direct { i32 } sigOffset: 1",
-              "void (i8*, i32)"),
+              "void (ptr, i32)"),
 
       // 11
       FcnItem({at2}, {at3},
               "Return: Direct { { i64, i32 } } sigOffset: -1 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+              "Param 1: Direct AttrNest { ptr } sigOffset: 0 "
               "Param 2: Direct { i64, i64 } sigOffset: 1",
-              "{ i64, i32 } (i8*, i64, i64)"),
+              "{ i64, i32 } (ptr, i64, i64)"),
 
       // 12
       // Make sure pointerness is preserved.
       FcnItem({stip}, {stii, stpp, stpi},
-              "Return: Direct { { i64, i8* } } sigOffset: -1 "
-              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+              "Return: Direct { { i64, ptr } } sigOffset: -1 "
+              "Param 1: Direct AttrNest { ptr } sigOffset: 0 "
               "Param 2: Direct { i64, i64 } sigOffset: 1 "
-              "Param 3: Direct { i8*, i8* } sigOffset: 3 "
-              "Param 4: Direct { i8*, i64 } sigOffset: 5",
-              "{ i64, i8* } (i8*, i64, i64, i8*, i8*, i8*, i64)"),
+              "Param 3: Direct { ptr, ptr } sigOffset: 3 "
+              "Param 4: Direct { ptr, i64 } sigOffset: 5",
+              "{ i64, ptr } (ptr, i64, i64, ptr, ptr, ptr, i64)"),
   };
 
   unsigned count = 1;
@@ -532,24 +529,20 @@
   Bstatement *rst2 = h.mkReturn(rvals2, FcnTestHarness::NoAppend);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %p3.ld.0 = load i8, i8* %p3.addr, align 1
+    %p3.ld.0 = load i8, ptr %p3.addr, align 1
     %sub.0 = sub i8 %p3.ld.0, 1
-    %p4.ld.0 = load i8, i8* %p4.addr, align 1
-    %cast.1 = bitcast { float, float, i16, i16, i16 }* %p0.addr to { <2 x float>, i48 }*
-    %field0.0 = getelementptr inbounds { <2 x float>, i48 }, { <2 x float>, i48 }* %cast.1, i32 0, i32 0
-    %ld.1 = load <2 x float>, <2 x float>* %field0.0, align 8
-    %field1.0 = getelementptr inbounds { <2 x float>, i48 }, { <2 x float>, i48 }* %cast.1, i32 0, i32 1
-    %ld.2 = load i48, i48* %field1.0, align 8
-    %cast.2 = bitcast { double, float, float }* %p1.addr to { double, <2 x float> }*
-    %field0.1 = getelementptr inbounds { double, <2 x float> }, { double, <2 x float> }* %cast.2, i32 0, i32 0
-    %ld.3 = load double, double* %field0.1, align 8
-    %field1.1 = getelementptr inbounds { double, <2 x float> }, { double, <2 x float> }* %cast.2, i32 0, i32 1
-    %ld.4 = load <2 x float>, <2 x float>* %field1.1, align 8
-    %call.0 = call addrspace(0) { double, <2 x float> } @foo(i8* nest undef, <2 x float> %ld.1, i48 %ld.2, double %ld.3, <2 x float> %ld.4, i8 zeroext %sub.0, i8 signext %p4.ld.0, { { float, float, i16, i16, i16 }, { double, float, float } }* byval({ { float, float, i16, i16, i16 }, { double, float, float } }) %p5)
-    %cast.3 = bitcast { double, float, float }* %sret.actual.0 to { double, <2 x float> }*
-    store { double, <2 x float> } %call.0, { double, <2 x float> }* %cast.3, align 8
-    %cast.4 = bitcast { double, float, float }* %sret.actual.0 to { double, <2 x float> }*
-    %ld.5 = load { double, <2 x float> }, { double, <2 x float> }* %cast.4, align 8
+    %p4.ld.0 = load i8, ptr %p4.addr, align 1
+    %field0.0 = getelementptr inbounds { <2 x float>, i48 }, ptr %p0.addr, i32 0, i32 0
+    %ld.1 = load <2 x float>, ptr %field0.0, align 8
+    %field1.0 = getelementptr inbounds { <2 x float>, i48 }, ptr %p0.addr, i32 0, i32 1
+    %ld.2 = load i48, ptr %field1.0, align 8
+    %field0.1 = getelementptr inbounds { double, <2 x float> }, ptr %p1.addr, i32 0, i32 0
+    %ld.3 = load double, ptr %field0.1, align 8
+    %field1.1 = getelementptr inbounds { double, <2 x float> }, ptr %p1.addr, i32 0, i32 1
+    %ld.4 = load <2 x float>, ptr %field1.1, align 8
+    %call.0 = call addrspace(0) { double, <2 x float> } @foo(ptr nest undef, <2 x float> %ld.1, i48 %ld.2, double %ld.3, <2 x float> %ld.4, i8 zeroext %sub.0, i8 signext %p4.ld.0, ptr byval({ { float, float, i16, i16, i16 }, { double, float, float } }) %p5)
+    store { double, <2 x float> } %call.0, ptr %sret.actual.0, align 8
+    %ld.5 = load { double, <2 x float> }, ptr %sret.actual.0, align 8
     ret { double, <2 x float> } %ld.5
   )RAW_RESULT");
 
@@ -651,27 +644,21 @@
   Bstatement *rst2 = h.mkReturn(rvals2, FcnTestHarness::NoAppend);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %p3.ld.0 = load i8, i8* %p3.addr, align 1
+    %p3.ld.0 = load i8, ptr %p3.addr, align 1
     %sub.0 = sub i8 %p3.ld.0, 1
-    %p4.ld.0 = load i8, i8* %p4.addr, align 1
-    %cast.1 = bitcast { float, float, i16, i16, i16 }* %p0.addr to { i64, i48 }*
-    %field0.0 = getelementptr inbounds { i64, i48 }, { i64, i48 }* %cast.1, i32 0, i32 0
-    %ld.1 = load i64, i64* %field0.0, align 8
-    %field1.0 = getelementptr inbounds { i64, i48 }, { i64, i48 }* %cast.1, i32 0, i32 1
-    %ld.2 = load i48, i48* %field1.0, align 8
-    %cast.2 = bitcast { double, float, float }* %p1.addr to { i64, i64 }*
-    %field0.1 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %cast.2, i32 0, i32 0
-    %ld.3 = load i64, i64* %field0.1, align 8
-    %field1.1 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %cast.2, i32 0, i32 1
-    %ld.4 = load i64, i64* %field1.1, align 8
-    %cast.3 = bitcast { { float, float, i16, i16, i16 }, { double, float, float } }* %doCopy.addr.0 to i8*
-    %cast.4 = bitcast { { float, float, i16, i16, i16 }, { double, float, float } }* %p5 to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.3, i8* align 8 %cast.4, i64 32, i1 false)
-    %call.0 = call addrspace(0) { i64, i64 } @foo(i8* nest undef, i64 %ld.1, i48 %ld.2, i64 %ld.3, i64 %ld.4, i8 zeroext %sub.0, i8 signext %p4.ld.0, { { float, float, i16, i16, i16 }, { double, float, float } }* %doCopy.addr.0)
-    %cast.5 = bitcast { double, float, float }* %sret.actual.0 to { i64, i64 }*
-    store { i64, i64 } %call.0, { i64, i64 }* %cast.5, align 8
-    %cast.6 = bitcast { double, float, float }* %sret.actual.0 to { i64, i64 }*
-    %ld.5 = load { i64, i64 }, { i64, i64 }* %cast.6, align 8
+    %p4.ld.0 = load i8, ptr %p4.addr, align 1
+    %field0.0 = getelementptr inbounds { i64, i48 }, ptr %p0.addr, i32 0, i32 0
+    %ld.1 = load i64, ptr %field0.0, align 8
+    %field1.0 = getelementptr inbounds { i64, i48 }, ptr %p0.addr, i32 0, i32 1
+    %ld.2 = load i48, ptr %field1.0, align 8
+    %field0.1 = getelementptr inbounds { i64, i64 }, ptr %p1.addr, i32 0, i32 0
+    %ld.3 = load i64, ptr %field0.1, align 8
+    %field1.1 = getelementptr inbounds { i64, i64 }, ptr %p1.addr, i32 0, i32 1
+    %ld.4 = load i64, ptr %field1.1, align 8
+    call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 8 %doCopy.addr.0, ptr align 8 %p5, i64 32, i1 false)
+    %call.0 = call addrspace(0) { i64, i64 } @foo(ptr nest undef, i64 %ld.1, i48 %ld.2, i64 %ld.3, i64 %ld.4, i8 zeroext %sub.0, i8 signext %p4.ld.0, ptr %doCopy.addr.0)
+    store { i64, i64 } %call.0, ptr %sret.actual.0, align 8
+    %ld.5 = load { i64, i64 }, ptr %sret.actual.0, align 8
     ret { i64, i64 } %ld.5
   )RAW_RESULT");
 
@@ -716,12 +703,9 @@
   h.mkReturn(rvals);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %cast.0 = bitcast [2 x float]* %p0.addr to <2 x float>*
-    %ld.0 = load <2 x float>, <2 x float>* %cast.0, align 8
-    call addrspace(0) void @foo([3 x double]* sret([3 x double]) "go_sret" %sret.actual.0, i8* nest undef, <2 x float> %ld.0)
-    %cast.1 = bitcast [3 x double]* %sret.formal.0 to i8*
-    %cast.2 = bitcast [3 x double]* %sret.actual.0 to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.1, i8* align 8 %cast.2, i64 24, i1 false)
+    %ld.0 = load <2 x float>, ptr %p0.addr, align 8
+    call addrspace(0) void @foo(ptr sret([3 x double]) "go_sret" %sret.actual.0, ptr nest undef, <2 x float> %ld.0)
+    call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 8 %sret.formal.0, ptr align 8 %sret.actual.0, i64 24, i1 false)
     ret void
   )RAW_RESULT");
 
@@ -760,12 +744,10 @@
   h.mkReturn(rvals);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %ld.0 = load [2 x float], [2 x float]* %p0.addr, align 4
-    %call.0 = call addrspace(0) { double, double, double } @foo(i8* nest undef, [2 x float] %ld.0)
-    %cast.1 = bitcast [3 x double]* %sret.actual.0 to { double, double, double }*
-    store { double, double, double } %call.0, { double, double, double }* %cast.1, align 8
-    %cast.2 = bitcast [3 x double]* %sret.actual.0 to { double, double, double }*
-    %ld.1 = load { double, double, double }, { double, double, double }* %cast.2, align 8
+    %ld.0 = load [2 x float], ptr %p0.addr, align 4
+    %call.0 = call addrspace(0) { double, double, double } @foo(ptr nest undef, [2 x float] %ld.0)
+    store { double, double, double } %call.0, ptr %sret.actual.0, align 8
+    %ld.1 = load { double, double, double }, ptr %sret.actual.0, align 8
     ret { double, double, double } %ld.1
   )RAW_RESULT");
 
@@ -813,7 +795,7 @@
   h.mkReturn(rvals);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    call addrspace(0) void @foo(i8* nest undef, i32 4)
+    call addrspace(0) void @foo(ptr nest undef, i32 4)
     ret void
   )RAW_RESULT");
 
@@ -895,26 +877,20 @@
   h.mkReturn(rvals);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %cast.0 = bitcast { float, float }* %p0.addr to <2 x float>*
-    %ld.0 = load <2 x float>, <2 x float>* %cast.0, align 8
-    %field0.0 = getelementptr inbounds { double, double }, { double, double }* %p1.addr, i32 0, i32 0
-    %ld.1 = load double, double* %field0.0, align 8
-    %field1.0 = getelementptr inbounds { double, double }, { double, double }* %p1.addr, i32 0, i32 1
-    %ld.2 = load double, double* %field1.0, align 8
-    %call.0 = call addrspace(0) <2 x float> @foo(i8* nest undef, <2 x float> %ld.0, double %ld.1, double %ld.2)
-    %cast.2 = bitcast { float, float }* %sret.actual.0 to <2 x float>*
-    store <2 x float> %call.0, <2 x float>* %cast.2, align 8
-    %cast.3 = bitcast { float, float }* %z to i8*
-    %cast.4 = bitcast { float, float }* %sret.actual.0 to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %cast.3, i8* align 4 %cast.4, i64 8, i1 false)
-    %ld.3 = load <2 x float>, <2 x float>* bitcast ({ float, float }* @const.0 to <2 x float>*), align 8
-    %ld.4 = load double, double* getelementptr inbounds ({ double, double }, { double, double }* @const.1, i32 0, i32 0), align 8
-    %ld.5 = load double, double* getelementptr inbounds ({ double, double }, { double, double }* @const.1, i32 0, i32 1), align 8
-    %call.1 = call addrspace(0) <2 x float> @foo(i8* nest undef, <2 x float> %ld.3, double %ld.4, double %ld.5)
-    %cast.7 = bitcast { float, float }* %sret.actual.1 to <2 x float>*
-    store <2 x float> %call.1, <2 x float>* %cast.7, align 8
-    %cast.8 = bitcast { float, float }* %sret.actual.1 to <2 x float>*
-    %ld.6 = load <2 x float>, <2 x float>* %cast.8, align 8
+    %ld.0 = load <2 x float>, ptr %p0.addr, align 8
+    %field0.0 = getelementptr inbounds { double, double }, ptr %p1.addr, i32 0, i32 0
+    %ld.1 = load double, ptr %field0.0, align 8
+    %field1.0 = getelementptr inbounds { double, double }, ptr %p1.addr, i32 0, i32 1
+    %ld.2 = load double, ptr %field1.0, align 8
+    %call.0 = call addrspace(0) <2 x float> @foo(ptr nest undef, <2 x float> %ld.0, double %ld.1, double %ld.2)
+    store <2 x float> %call.0, ptr %sret.actual.0, align 8
+    call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 4 %z, ptr align 4 %sret.actual.0, i64 8, i1 false)
+    %ld.3 = load <2 x float>, ptr @const.0, align 8
+    %ld.4 = load double, ptr @const.1, align 8
+    %ld.5 = load double, ptr getelementptr inbounds ({ double, double }, ptr @const.1, i32 0, i32 1), align 8
+    %call.1 = call addrspace(0) <2 x float> @foo(ptr nest undef, <2 x float> %ld.3, double %ld.4, double %ld.5)
+    store <2 x float> %call.1, ptr %sret.actual.1, align 8
+    %ld.6 = load <2 x float>, ptr %sret.actual.1, align 8
     ret <2 x float> %ld.6
   )RAW_RESULT");
 
@@ -968,20 +944,16 @@
   h.mkReturn(rvals);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %cast.0 = bitcast { float, float }* %p0.addr to [2 x float]*
-    %ld.0 = load [2 x float], [2 x float]* %cast.0, align 4
-    %cast.1 = bitcast { double, double }* %p1.addr to [2 x double]*
-    %ld.1 = load [2 x double], [2 x double]* %cast.1, align 8
-    %call.0 = call addrspace(0) { float, float } @foo(i8* nest undef, [2 x float] %ld.0, [2 x double] %ld.1)
-    store { float, float } %call.0, { float, float }* %sret.actual.0, align 4
-    %cast.3 = bitcast { float, float }* %z to i8*
-    %cast.4 = bitcast { float, float }* %sret.actual.0 to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %cast.3, i8* align 4 %cast.4, i64 8, i1 false)
-    %ld.2 = load [2 x float], [2 x float]* bitcast ({ float, float }* @const.0 to [2 x float]*), align 4
-    %ld.3 = load [2 x double], [2 x double]* bitcast ({ double, double }* @const.1 to [2 x double]*), align 8
-    %call.1 = call addrspace(0) { float, float } @foo(i8* nest undef, [2 x float] %ld.2, [2 x double] %ld.3)
-    store { float, float } %call.1, { float, float }* %sret.actual.1, align 4
-    %ld.4 = load { float, float }, { float, float }* %sret.actual.1, align 4
+    %ld.0 = load [2 x float], ptr %p0.addr, align 4
+    %ld.1 = load [2 x double], ptr %p1.addr, align 8
+    %call.0 = call addrspace(0) { float, float } @foo(ptr nest undef, [2 x float] %ld.0, [2 x double] %ld.1)
+    store { float, float } %call.0, ptr %sret.actual.0, align 4
+    call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 4 %z, ptr align 4 %sret.actual.0, i64 8, i1 false)
+    %ld.2 = load [2 x float], ptr @const.0, align 4
+    %ld.3 = load [2 x double], ptr @const.1, align 8
+    %call.1 = call addrspace(0) { float, float } @foo(ptr nest undef, [2 x float] %ld.2, [2 x double] %ld.3)
+    store { float, float } %call.1, ptr %sret.actual.1, align 4
+    %ld.4 = load { float, float }, ptr %sret.actual.1, align 4
     ret { float, float } %ld.4
   )RAW_RESULT");
 

diff --git a/unittests/BackendCore/BackendCallTests.cpp b/unittests/BackendCore/BackendCallTests.cpp
index b8d7eaf..bd9da2a 100644
--- a/unittests/BackendCore/BackendCallTests.cpp
+++ b/unittests/BackendCore/BackendCallTests.cpp

@@ -47,9 +47,9 @@
   h.mkReturn(be->var_expression(x, loc));
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %call.0 = call addrspace(0) i64 @foo(i8* nest undef, i32 3, i32 6, i64* null)
-    store i64 %call.0, i64* %x, align 8
-    %x.ld.0 = load i64, i64* %x, align 8
+    %call.0 = call addrspace(0) i64 @foo(ptr nest undef, i32 3, i32 6, ptr null)
+    store i64 %call.0, ptr %x, align 8
+    %x.ld.0 = load i64, ptr %x, align 8
     ret i64 %x.ld.0
   )RAW_RESULT");
 
@@ -80,7 +80,7 @@
   h.mkExprStmt(call);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    call addrspace(0) void @bar(i8* nest undef)
+    call addrspace(0) void @bar(ptr nest undef)
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -119,8 +119,7 @@
 
   {
     DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-      %cast.0 = bitcast { i8*, i32*, i64*, i64 }* %sret.formal.0 to i8*
-      call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.0, i8* align 8 bitcast ({ i8*, i32*, i64*, i64 }* @const.0 to i8*), i64 32, i1 false)
+      call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 8 %sret.formal.0, ptr align 8 @const.0, i64 32, i1 false)
       ret void
     )RAW_RESULT");
 
@@ -143,19 +142,17 @@
 
   {
     DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %p0.ld.0 = load i8*, i8** %p0.addr, align 8
-    %field.0 = getelementptr inbounds { i8*, i32*, i64*, i64 }, { i8*, i32*, i64*, i64 }* %tmp.0, i32 0, i32 0
-    store i8* %p0.ld.0, i8** %field.0, align 8
-    %field.1 = getelementptr inbounds { i8*, i32*, i64*, i64 }, { i8*, i32*, i64*, i64 }* %tmp.0, i32 0, i32 1
-    store i32* null, i32** %field.1, align 8
-    %field.2 = getelementptr inbounds { i8*, i32*, i64*, i64 }, { i8*, i32*, i64*, i64 }* %tmp.0, i32 0, i32 2
-    store i64* null, i64** %field.2, align 8
-    %field.3 = getelementptr inbounds { i8*, i32*, i64*, i64 }, { i8*, i32*, i64*, i64 }* %tmp.0, i32 0, i32 3
-    store i64 101, i64* %field.3, align 8
-    %cast.2 = bitcast { i8*, i32*, i64*, i64 }* %sret.formal.0 to i8*
-    %cast.3 = bitcast { i8*, i32*, i64*, i64 }* %tmp.0 to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.2, i8* align 8 %cast.3, i64 32, i1 false)
-    ret void
+      %p0.ld.0 = load ptr, ptr %p0.addr, align 8
+      %field.0 = getelementptr inbounds { ptr, ptr, ptr, i64 }, ptr %tmp.0, i32 0, i32 0
+      store ptr %p0.ld.0, ptr %field.0, align 8
+      %field.1 = getelementptr inbounds { ptr, ptr, ptr, i64 }, ptr %tmp.0, i32 0, i32 1
+      store ptr null, ptr %field.1, align 8
+      %field.2 = getelementptr inbounds { ptr, ptr, ptr, i64 }, ptr %tmp.0, i32 0, i32 2
+      store ptr null, ptr %field.2, align 8
+      %field.3 = getelementptr inbounds { ptr, ptr, ptr, i64 }, ptr %tmp.0, i32 0, i32 3
+      store i64 101, ptr %field.3, align 8
+      call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 8 %sret.formal.0, ptr align 8 %tmp.0, i64 32, i1 false)
+      ret void
     )RAW_RESULT");
 
     bool isOK = h.expectStmt(s2, exp);
@@ -206,12 +203,12 @@
          FcnTestHarness::YesAppend);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define void @foo(i8* nest %nest.0) #0 {
+    define void @foo(ptr nest %nest.0) #0 {
     entry:
       br i1 true, label %then.0, label %else.0
 
     then.0:                                           ; preds = %entry
-      call void @noret(i8* nest undef)
+      call void @noret(ptr nest undef)
       unreachable
 
     fallthrough.0:                                    ; preds = %else.0
@@ -283,18 +280,18 @@
   h.mkReturn(be->var_expression(z, loc));
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %asmcall.0 = call addrspace(0) i64* asm sideeffect "adrp x0, :tlsdesc:runtime.g\0Aldr  $0, [x0, :tlsdesc_lo12:runtime.g]\0Aadd  x0, x0, :tlsdesc_lo12:runtime.g\0A.tlsdesccall runtime.g\0Ablr  $0\0Amrs  $0, TPIDR_EL0\0Aldr  $0, [$0, x0]\0A", "=r,~{x0}"()
-    store i64* %asmcall.0, i64** %x, align 8
-    call addrspace(0) void @bar(i8* nest undef)
-    %asmcall.1 = call addrspace(0) i64* asm sideeffect "adrp x0, :tlsdesc:runtime.g\0Aldr  $0, [x0, :tlsdesc_lo12:runtime.g]\0Aadd  x0, x0, :tlsdesc_lo12:runtime.g\0A.tlsdesccall runtime.g\0Ablr  $0\0Amrs  $0, TPIDR_EL0\0Aldr  $0, [$0, x0]\0A", "=r,~{x0}"()
-    store i64* %asmcall.1, i64** %y, align 8
-    %x.ld.0 = load i64*, i64** %x, align 8
-    %.ld.0 = load i64, i64* %x.ld.0, align 8
-    %y.ld.0 = load i64*, i64** %y, align 8
-    %.ld.1 = load i64, i64* %y.ld.0, align 8
+    %asmcall.0 = call addrspace(0) ptr asm sideeffect "adrp x0, :tlsdesc:runtime.g\0Aldr  $0, [x0, :tlsdesc_lo12:runtime.g]\0Aadd  x0, x0, :tlsdesc_lo12:runtime.g\0A.tlsdesccall runtime.g\0Ablr  $0\0Amrs  $0, TPIDR_EL0\0Aldr  $0, [$0, x0]\0A", "=r,~{x0}"()
+    store ptr %asmcall.0, ptr %x, align 8
+    call addrspace(0) void @bar(ptr nest undef)
+    %asmcall.1 = call addrspace(0) ptr asm sideeffect "adrp x0, :tlsdesc:runtime.g\0Aldr  $0, [x0, :tlsdesc_lo12:runtime.g]\0Aadd  x0, x0, :tlsdesc_lo12:runtime.g\0A.tlsdesccall runtime.g\0Ablr  $0\0Amrs  $0, TPIDR_EL0\0Aldr  $0, [$0, x0]\0A", "=r,~{x0}"()
+    store ptr %asmcall.1, ptr %y, align 8
+    %x.ld.0 = load ptr, ptr %x, align 8
+    %.ld.0 = load i64, ptr %x.ld.0, align 8
+    %y.ld.0 = load ptr, ptr %y, align 8
+    %.ld.1 = load i64, ptr %y.ld.0, align 8
     %add.0 = add i64 %.ld.0, %.ld.1
-    store i64 %add.0, i64* %z, align 8
-    %z.ld.0 = load i64, i64* %z, align 8
+    store i64 %add.0, ptr %z, align 8
+    %z.ld.0 = load i64, ptr %z, align 8
     ret i64 %z.ld.0
   )RAW_RESULT");
 

diff --git a/unittests/BackendCore/BackendCoreTests.cpp b/unittests/BackendCore/BackendCoreTests.cpp
index 30923a0..9ca75f5 100644
--- a/unittests/BackendCore/BackendCoreTests.cpp
+++ b/unittests/BackendCore/BackendCoreTests.cpp

@@ -86,7 +86,7 @@
   ASSERT_TRUE(best != nullptr);
   ASSERT_TRUE(llst != nullptr);
   EXPECT_EQ(llst, best->type());
-  EXPECT_EQ(repr(best->type()), "{ i8, float*, i64 }");
+  EXPECT_EQ(repr(best->type()), "{ i8, ptr, i64 }");
 
   // If a field has error type, entire struct has error type
   std::vector<Backend::Btyped_identifier> fields = {
@@ -186,14 +186,14 @@
   Btype *phpt2 = be->placeholder_pointer_type("ph", loc, false);
   Btype *phpt3 = be->placeholder_pointer_type("ph", loc, false);
   ASSERT_TRUE(phpt2 != phpt3);
-  EXPECT_TRUE(phpt2->type() != phpt3->type());
+  // ptr == ptr
+  EXPECT_TRUE(phpt2->type() == phpt3->type());
 
   // Replace placeholder pointer type
   Btype *pst = be->pointer_type(mkBackendThreeFieldStruct(be.get()));
   be->set_placeholder_pointer_type(phpt1, pst);
   ASSERT_TRUE(phpt1->type()->isPointerTy());
   PointerType *llpt = cast<PointerType>(phpt1->type());
-  EXPECT_TRUE(llpt->getElementType()->isStructTy());
 
   // Placeholder struct type
   Btype *phst1 = be->placeholder_struct_type("ph", loc);
@@ -398,8 +398,6 @@
   // However the underlying LLVM types should be considered
   // assignment-compatible.
   std::set<llvm::Type *> visited;
-  bool equiv = tm->fcnPointerCompatible(pht->type(), pht2->type(), visited);
-  EXPECT_TRUE(equiv);
 
   bool broken = h.finish(PreserveDebugInfo);
   EXPECT_FALSE(broken && "Module failed to verify.");
@@ -468,9 +466,9 @@
   EXPECT_FALSE(broken && "Module failed to verify.");
 
   bool ok = h.expectModuleDumpContains(
-      "@gv = global { { i8, i8*, i32 }, %ph.0 } { { i8, i8*, i32 } { i8 0, "
-      "i8* "
-      "null, i32 101 }, %ph.0 { i8 0, i8* null, i32 101 } }");
+      "@gv = global { { i8, ptr, i32 }, %ph.0 } { { i8, ptr, i32 } { i8 0, "
+      "ptr "
+      "null, i32 101 }, %ph.0 { i8 0, ptr null, i32 101 } }");
   EXPECT_TRUE(ok);
 }
 

diff --git a/unittests/BackendCore/BackendDebugEmit.cpp b/unittests/BackendCore/BackendDebugEmit.cpp
index 7859104..f880cb2 100644
--- a/unittests/BackendCore/BackendDebugEmit.cpp
+++ b/unittests/BackendCore/BackendDebugEmit.cpp

@@ -42,13 +42,13 @@
   h.mkLocal("x", bu32t);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define void @foo(i8* nest %nest.0) #0 {
-  entry:
-    %x = alloca i32, align 4
-    store i32 0, i32* %x, align 4
-    call void @llvm.dbg.declare(metadata i32* %x, metadata !4, metadata !DIExpression()), !dbg !12
-    ret void
-  }
+    define void @foo(ptr nest %nest.0) #0 {
+    entry:
+      %x = alloca i32, align 4
+      store i32 0, ptr %x, align 4
+        #dbg_declare(ptr %x, !4, !DIExpression(), !12)
+      ret void
+    }
   )RAW_RESULT");
 
   bool broken = h.finish(PreserveDebugInfo);
@@ -76,11 +76,11 @@
   EXPECT_FALSE(broken && "Module failed to verify.");
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define void @foo(i8* nest %nest.0, { i64, i64, i64 }* byval({ i64, i64, i64 }) %p0) #0 {
-  entry:
-    call void @llvm.dbg.declare(metadata { i64, i64, i64 }* %p0, metadata !4, metadata !DIExpression()), !dbg !18
-    ret void
-  }
+    define void @foo(ptr nest %nest.0, ptr byval({ i64, i64, i64 }) %p0) #0 {
+    entry:
+        #dbg_declare(ptr %p0, !4, !DIExpression(), !18)
+      ret void
+    }
   )RAW_RESULT");
 
   bool isOK = h.expectValue(func->function(), exp);
@@ -103,10 +103,9 @@
   EXPECT_FALSE(broken && "Module failed to verify.");
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define void @foo(i8* nest %nest.0, { i64, i64, i64 }* %p0) #0 {
+    define void @foo(ptr nest %nest.0, ptr %p0) #0 {
     entry:
-      call void @llvm.dbg.declare(metadata { i64, i64, i64 }* %p0, metadata !4,
-                                  metadata !DIExpression()), !dbg !18
+        #dbg_declare(ptr %p0, !4, !DIExpression(), !18)
       ret void
     }
   )RAW_RESULT");
@@ -188,7 +187,7 @@
   std::vector<std::string> tokens = tokenize(fdump);
   unsigned declcount = 0;
   for (auto t : tokens)
-    if (t == "@llvm.dbg.declare(metadata")
+    if (t == "#dbg_declare(ptr")
       declcount += 1;
 
   // seven formals and six locals => 13 var decls
@@ -210,11 +209,11 @@
   h.mkLocal("x", bu32t);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define void @foo(i8* nest %nest.0) #0 !dbg !4 {
-  entry:
-    %x = alloca i32, align 4
-    ret void, !dbg !10
-  }
+    define void @foo(ptr nest %nest.0) #0 !dbg !4 {
+    entry:
+      %x = alloca i32, align 4
+      ret void, !dbg !10
+    }
   )RAW_RESULT");
 
   bool broken = h.finish(PreserveDebugInfo);

diff --git a/unittests/BackendCore/BackendExprTests.cpp b/unittests/BackendCore/BackendExprTests.cpp
index a476f06..5ead97e 100644
--- a/unittests/BackendCore/BackendExprTests.cpp
+++ b/unittests/BackendCore/BackendExprTests.cpp

@@ -196,7 +196,7 @@
   Btype *pbt = be->pointer_type(bt);
   Bexpression *bpzero = be->zero_expression(pbt);
   ASSERT_TRUE(bpzero != nullptr);
-  EXPECT_EQ(repr(bpzero->value()), "i8* null");
+  EXPECT_EQ(repr(bpzero->value()), "ptr null");
   Btype *bi32t = be->integer_type(false, 32);
   Btype *s2t = mkBackendStruct(be, pbt, "f1", bi32t, "f2", nullptr);
   Bexpression *bszero = be->zero_expression(s2t);
@@ -244,10 +244,9 @@
   h.mkAssign(fex, mkInt32Const(be, 22));
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    store i64 0, i64* %x, align 8
-    %cast.0 = bitcast i64* %x to { i32, i32 }*
-    %field.0 = getelementptr inbounds { i32, i32 }, { i32, i32 }* %cast.0, i32 0, i32 1
-    store i32 22, i32* %field.0, align 4
+    store i64 0, ptr %x, align 8
+    %field.0 = getelementptr inbounds { i32, i32 }, ptr %x, i32 0, i32 1
+    store i32 22, ptr %field.0, align 4
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -295,14 +294,13 @@
   }
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %param3.ld.0 = load i64*, i64** %param3.addr, align 8
-    %cast.0 = bitcast i64* %param3.ld.0 to i32*
-    store i32 5, i32* %cast.0, align 4
-    store double 0.000000e+00, double* %p, align 8
-    %p.ld.0 = load double, double* %p, align 8
+    %param3.ld.0 = load ptr, ptr %param3.addr, align 8
+    store i32 5, ptr %param3.ld.0, align 4
+    store double 0.000000e+00, ptr %p, align 8
+    %p.ld.0 = load double, ptr %p, align 8
     %ftoui.0 = fptoui double %p.ld.0 to i64
-    %itpcast.0 = inttoptr i64 %ftoui.0 to i32*
-    store i32 5, i32* %itpcast.0, align 4
+    %itpcast.0 = inttoptr i64 %ftoui.0 to ptr
+    store i32 5, ptr %itpcast.0, align 4
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -354,92 +352,92 @@
   }
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %p1.ld.0 = load double, double* %p1.addr, align 8
+    %p1.ld.0 = load double, ptr %p1.addr, align 8
     %fptrunc.0 = fptrunc double %p1.ld.0 to float
-    store float %fptrunc.0, float* %p0.addr, align 4
-    %p0.ld.0 = load float, float* %p0.addr, align 4
+    store float %fptrunc.0, ptr %p0.addr, align 4
+    %p0.ld.0 = load float, ptr %p0.addr, align 4
     %fpext.0 = fpext float %p0.ld.0 to double
-    store double %fpext.0, double* %p1.addr, align 8
-    %p2.ld.0 = load i32, i32* %p2.addr, align 4
+    store double %fpext.0, ptr %p1.addr, align 8
+    %p2.ld.0 = load i32, ptr %p2.addr, align 4
     %sitof.0 = sitofp i32 %p2.ld.0 to float
-    store float %sitof.0, float* %p0.addr, align 4
-    %p0.ld.1 = load float, float* %p0.addr, align 4
+    store float %sitof.0, ptr %p0.addr, align 4
+    %p0.ld.1 = load float, ptr %p0.addr, align 4
     %ftosi.0 = fptosi float %p0.ld.1 to i32
-    store i32 %ftosi.0, i32* %p2.addr, align 4
-    %p2.ld.1 = load i32, i32* %p2.addr, align 4
+    store i32 %ftosi.0, ptr %p2.addr, align 4
+    %p2.ld.1 = load i32, ptr %p2.addr, align 4
     %sitof.1 = sitofp i32 %p2.ld.1 to double
-    store double %sitof.1, double* %p1.addr, align 8
-    %p1.ld.1 = load double, double* %p1.addr, align 8
+    store double %sitof.1, ptr %p1.addr, align 8
+    %p1.ld.1 = load double, ptr %p1.addr, align 8
     %ftosi.1 = fptosi double %p1.ld.1 to i32
-    store i32 %ftosi.1, i32* %p2.addr, align 4
-    %p3.ld.0 = load i64, i64* %p3.addr, align 8
+    store i32 %ftosi.1, ptr %p2.addr, align 4
+    %p3.ld.0 = load i64, ptr %p3.addr, align 8
     %sitof.2 = sitofp i64 %p3.ld.0 to float
-    store float %sitof.2, float* %p0.addr, align 4
-    %p0.ld.2 = load float, float* %p0.addr, align 4
+    store float %sitof.2, ptr %p0.addr, align 4
+    %p0.ld.2 = load float, ptr %p0.addr, align 4
     %ftosi.2 = fptosi float %p0.ld.2 to i64
-    store i64 %ftosi.2, i64* %p3.addr, align 8
-    %p3.ld.1 = load i64, i64* %p3.addr, align 8
+    store i64 %ftosi.2, ptr %p3.addr, align 8
+    %p3.ld.1 = load i64, ptr %p3.addr, align 8
     %sitof.3 = sitofp i64 %p3.ld.1 to double
-    store double %sitof.3, double* %p1.addr, align 8
-    %p1.ld.2 = load double, double* %p1.addr, align 8
+    store double %sitof.3, ptr %p1.addr, align 8
+    %p1.ld.2 = load double, ptr %p1.addr, align 8
     %ftosi.3 = fptosi double %p1.ld.2 to i64
-    store i64 %ftosi.3, i64* %p3.addr, align 8
-    %p3.ld.2 = load i64, i64* %p3.addr, align 8
+    store i64 %ftosi.3, ptr %p3.addr, align 8
+    %p3.ld.2 = load i64, ptr %p3.addr, align 8
     %trunc.0 = trunc i64 %p3.ld.2 to i32
-    store i32 %trunc.0, i32* %p2.addr, align 4
-    %p2.ld.2 = load i32, i32* %p2.addr, align 4
+    store i32 %trunc.0, ptr %p2.addr, align 4
+    %p2.ld.2 = load i32, ptr %p2.addr, align 4
     %sext.0 = sext i32 %p2.ld.2 to i64
-    store i64 %sext.0, i64* %p3.addr, align 8
-    %p4.ld.0 = load i32, i32* %p4.addr, align 4
+    store i64 %sext.0, ptr %p3.addr, align 8
+    %p4.ld.0 = load i32, ptr %p4.addr, align 4
     %uitof.0 = uitofp i32 %p4.ld.0 to float
-    store float %uitof.0, float* %p0.addr, align 4
-    %p0.ld.3 = load float, float* %p0.addr, align 4
+    store float %uitof.0, ptr %p0.addr, align 4
+    %p0.ld.3 = load float, ptr %p0.addr, align 4
     %ftoui.0 = fptoui float %p0.ld.3 to i32
-    store i32 %ftoui.0, i32* %p4.addr, align 4
-    %p4.ld.1 = load i32, i32* %p4.addr, align 4
+    store i32 %ftoui.0, ptr %p4.addr, align 4
+    %p4.ld.1 = load i32, ptr %p4.addr, align 4
     %uitof.1 = uitofp i32 %p4.ld.1 to double
-    store double %uitof.1, double* %p1.addr, align 8
-    %p1.ld.3 = load double, double* %p1.addr, align 8
+    store double %uitof.1, ptr %p1.addr, align 8
+    %p1.ld.3 = load double, ptr %p1.addr, align 8
     %ftoui.1 = fptoui double %p1.ld.3 to i32
-    store i32 %ftoui.1, i32* %p4.addr, align 4
-    %p4.ld.2 = load i32, i32* %p4.addr, align 4
-    store i32 %p4.ld.2, i32* %p2.addr, align 4
-    %p2.ld.3 = load i32, i32* %p2.addr, align 4
-    store i32 %p2.ld.3, i32* %p4.addr, align 4
-    %p4.ld.3 = load i32, i32* %p4.addr, align 4
+    store i32 %ftoui.1, ptr %p4.addr, align 4
+    %p4.ld.2 = load i32, ptr %p4.addr, align 4
+    store i32 %p4.ld.2, ptr %p2.addr, align 4
+    %p2.ld.3 = load i32, ptr %p2.addr, align 4
+    store i32 %p2.ld.3, ptr %p4.addr, align 4
+    %p4.ld.3 = load i32, ptr %p4.addr, align 4
     %zext.0 = zext i32 %p4.ld.3 to i64
-    store i64 %zext.0, i64* %p3.addr, align 8
-    %p3.ld.3 = load i64, i64* %p3.addr, align 8
+    store i64 %zext.0, ptr %p3.addr, align 8
+    %p3.ld.3 = load i64, ptr %p3.addr, align 8
     %trunc.1 = trunc i64 %p3.ld.3 to i32
-    store i32 %trunc.1, i32* %p4.addr, align 4
-    %p5.ld.0 = load i64, i64* %p5.addr, align 8
+    store i32 %trunc.1, ptr %p4.addr, align 4
+    %p5.ld.0 = load i64, ptr %p5.addr, align 8
     %uitof.2 = uitofp i64 %p5.ld.0 to float
-    store float %uitof.2, float* %p0.addr, align 4
-    %p0.ld.4 = load float, float* %p0.addr, align 4
+    store float %uitof.2, ptr %p0.addr, align 4
+    %p0.ld.4 = load float, ptr %p0.addr, align 4
     %ftoui.2 = fptoui float %p0.ld.4 to i64
-    store i64 %ftoui.2, i64* %p5.addr, align 8
-    %p5.ld.1 = load i64, i64* %p5.addr, align 8
+    store i64 %ftoui.2, ptr %p5.addr, align 8
+    %p5.ld.1 = load i64, ptr %p5.addr, align 8
     %uitof.3 = uitofp i64 %p5.ld.1 to double
-    store double %uitof.3, double* %p1.addr, align 8
-    %p1.ld.4 = load double, double* %p1.addr, align 8
+    store double %uitof.3, ptr %p1.addr, align 8
+    %p1.ld.4 = load double, ptr %p1.addr, align 8
     %ftoui.3 = fptoui double %p1.ld.4 to i64
-    store i64 %ftoui.3, i64* %p5.addr, align 8
-    %p5.ld.2 = load i64, i64* %p5.addr, align 8
+    store i64 %ftoui.3, ptr %p5.addr, align 8
+    %p5.ld.2 = load i64, ptr %p5.addr, align 8
     %trunc.2 = trunc i64 %p5.ld.2 to i32
-    store i32 %trunc.2, i32* %p2.addr, align 4
-    %p2.ld.4 = load i32, i32* %p2.addr, align 4
+    store i32 %trunc.2, ptr %p2.addr, align 4
+    %p2.ld.4 = load i32, ptr %p2.addr, align 4
     %sext.1 = sext i32 %p2.ld.4 to i64
-    store i64 %sext.1, i64* %p5.addr, align 8
-    %p5.ld.3 = load i64, i64* %p5.addr, align 8
-    store i64 %p5.ld.3, i64* %p3.addr, align 8
-    %p3.ld.4 = load i64, i64* %p3.addr, align 8
-    store i64 %p3.ld.4, i64* %p5.addr, align 8
-    %p5.ld.4 = load i64, i64* %p5.addr, align 8
+    store i64 %sext.1, ptr %p5.addr, align 8
+    %p5.ld.3 = load i64, ptr %p5.addr, align 8
+    store i64 %p5.ld.3, ptr %p3.addr, align 8
+    %p3.ld.4 = load i64, ptr %p3.addr, align 8
+    store i64 %p3.ld.4, ptr %p5.addr, align 8
+    %p5.ld.4 = load i64, ptr %p5.addr, align 8
     %trunc.3 = trunc i64 %p5.ld.4 to i32
-    store i32 %trunc.3, i32* %p4.addr, align 4
-    %p4.ld.4 = load i32, i32* %p4.addr, align 4
+    store i32 %trunc.3, ptr %p4.addr, align 4
+    %p4.ld.4 = load i32, ptr %p4.addr, align 4
     %zext.1 = zext i32 %p4.ld.4 to i64
-    store i64 %zext.1, i64* %p5.addr, align 8
+    store i64 %zext.1, ptr %p5.addr, align 8
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -493,7 +491,7 @@
   h.mkAssign(xvex4, convex4);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define void @foo(i8* nest %nest.0) #0 {
+  define void @foo(ptr nest %nest.0) #0 {
   entry:
     %tmp.3 = alloca { double, double }, align 8
     %tmp.2 = alloca { float, float }, align 4
@@ -503,52 +501,36 @@
     %b = alloca { float, float }, align 4
     %x = alloca { double, double }, align 8
     %y = alloca { double, double }, align 8
-    %cast.0 = bitcast { float, float }* %a to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %cast.0, i8* align 4 bitcast ({ float, float }* @const.0 to i8*), i64 8, i1 false)
-    %cast.1 = bitcast { float, float }* %b to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %cast.1, i8* align 4 bitcast ({ float, float }* @const.0 to i8*), i64 8, i1 false)
-    %cast.2 = bitcast { double, double }* %x to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.2, i8* align 8 bitcast ({ double, double }* @const.1 to i8*), i64 16, i1 false)
-    %cast.3 = bitcast { double, double }* %y to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.3, i8* align 8 bitcast ({ double, double }* @const.1 to i8*), i64 16, i1 false)
-    %cast.4 = bitcast { double, double }* %tmp.0 to i8*
-    %cast.5 = bitcast { double, double }* %x to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.4, i8* align 8 %cast.5, i64 16, i1 false)
-    %field.0 = getelementptr inbounds { double, double }, { double, double }* %tmp.0, i32 0, i32 0
-    %.real.ld.0 = load double, double* %field.0, align 8
+    call void @llvm.memcpy.p0.p0.i64(ptr align 4 %a, ptr align 4 @const.0, i64 8, i1 false)
+    call void @llvm.memcpy.p0.p0.i64(ptr align 4 %b, ptr align 4 @const.0, i64 8, i1 false)
+    call void @llvm.memcpy.p0.p0.i64(ptr align 8 %x, ptr align 8 @const.1, i64 16, i1 false)
+    call void @llvm.memcpy.p0.p0.i64(ptr align 8 %y, ptr align 8 @const.1, i64 16, i1 false)
+    call void @llvm.memcpy.p0.p0.i64(ptr align 8 %tmp.0, ptr align 8 %x, i64 16, i1 false)
+    %field.0 = getelementptr inbounds { double, double }, ptr %tmp.0, i32 0, i32 0
+    %.real.ld.0 = load double, ptr %field.0, align 8
     %fptrunc.0 = fptrunc double %.real.ld.0 to float
-    %field.1 = getelementptr inbounds { double, double }, { double, double }* %tmp.0, i32 0, i32 1
-    %.imag.ld.0 = load double, double* %field.1, align 8
+    %field.1 = getelementptr inbounds { double, double }, ptr %tmp.0, i32 0, i32 1
+    %.imag.ld.0 = load double, ptr %field.1, align 8
     %fptrunc.1 = fptrunc double %.imag.ld.0 to float
-    %field.2 = getelementptr inbounds { float, float }, { float, float }* %tmp.1, i32 0, i32 0
-    store float %fptrunc.0, float* %field.2, align 4
-    %field.3 = getelementptr inbounds { float, float }, { float, float }* %tmp.1, i32 0, i32 1
-    store float %fptrunc.1, float* %field.3, align 4
-    %cast.6 = bitcast { float, float }* %a to i8*
-    %cast.7 = bitcast { float, float }* %tmp.1 to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %cast.6, i8* align 4 %cast.7, i64 8, i1 false)
-    %cast.8 = bitcast { float, float }* %tmp.2 to i8*
-    %cast.9 = bitcast { float, float }* %b to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %cast.8, i8* align 4 %cast.9, i64 8, i1 false)
-    %field.4 = getelementptr inbounds { float, float }, { float, float }* %tmp.2, i32 0, i32 0
-    %.real.ld.1 = load float, float* %field.4, align 4
+    %field.2 = getelementptr inbounds { float, float }, ptr %tmp.1, i32 0, i32 0
+    store float %fptrunc.0, ptr %field.2, align 4
+    %field.3 = getelementptr inbounds { float, float }, ptr %tmp.1, i32 0, i32 1
+    store float %fptrunc.1, ptr %field.3, align 4
+    call void @llvm.memcpy.p0.p0.i64(ptr align 4 %a, ptr align 4 %tmp.1, i64 8, i1 false)
+    call void @llvm.memcpy.p0.p0.i64(ptr align 4 %tmp.2, ptr align 4 %b, i64 8, i1 false)
+    %field.4 = getelementptr inbounds { float, float }, ptr %tmp.2, i32 0, i32 0
+    %.real.ld.1 = load float, ptr %field.4, align 4
     %fpext.0 = fpext float %.real.ld.1 to double
-    %field.5 = getelementptr inbounds { float, float }, { float, float }* %tmp.2, i32 0, i32 1
-    %.imag.ld.1 = load float, float* %field.5, align 4
+    %field.5 = getelementptr inbounds { float, float }, ptr %tmp.2, i32 0, i32 1
+    %.imag.ld.1 = load float, ptr %field.5, align 4
     %fpext.1 = fpext float %.imag.ld.1 to double
-    %field.6 = getelementptr inbounds { double, double }, { double, double }* %tmp.3, i32 0, i32 0
-    store double %fpext.0, double* %field.6, align 8
-    %field.7 = getelementptr inbounds { double, double }, { double, double }* %tmp.3, i32 0, i32 1
-    store double %fpext.1, double* %field.7, align 8
-    %cast.10 = bitcast { double, double }* %y to i8*
-    %cast.11 = bitcast { double, double }* %tmp.3 to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.10, i8* align 8 %cast.11, i64 16, i1 false)
-    %cast.12 = bitcast { float, float }* %a to i8*
-    %cast.13 = bitcast { float, float }* %b to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %cast.12, i8* align 4 %cast.13, i64 8, i1 false)
-    %cast.14 = bitcast { double, double }* %x to i8*
-    %cast.15 = bitcast { double, double }* %y to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.14, i8* align 8 %cast.15, i64 16, i1 false)
+    %field.6 = getelementptr inbounds { double, double }, ptr %tmp.3, i32 0, i32 0
+    store double %fpext.0, ptr %field.6, align 8
+    %field.7 = getelementptr inbounds { double, double }, ptr %tmp.3, i32 0, i32 1
+    store double %fpext.1, ptr %field.7, align 8
+    call void @llvm.memcpy.p0.p0.i64(ptr align 8 %y, ptr align 8 %tmp.3, i64 16, i1 false)
+    call void @llvm.memcpy.p0.p0.i64(ptr align 4 %a, ptr align 4 %b, i64 8, i1 false)
+    call void @llvm.memcpy.p0.p0.i64(ptr align 8 %x, ptr align 8 %y, i64 16, i1 false)
     ret void
   }
   )RAW_RESULT");
@@ -630,61 +612,61 @@
   }
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    store i64 0, i64* %x, align 8
-    store i64 0, i64* %y, align 8
-    store double 0.000000e+00, double* %z, align 8
-    %x.ld.0 = load i64, i64* %x, align 8
+    store i64 0, ptr %x, align 8
+    store i64 0, ptr %y, align 8
+    store double 0.000000e+00, ptr %z, align 8
+    %x.ld.0 = load i64, ptr %x, align 8
     %icmp.0 = icmp eq i64 9, %x.ld.0
     %zext.0 = zext i1 %icmp.0 to i8
-    %x.ld.1 = load i64, i64* %x, align 8
+    %x.ld.1 = load i64, ptr %x, align 8
     %icmp.1 = icmp ne i64 9, %x.ld.1
     %zext.1 = zext i1 %icmp.1 to i8
-    %x.ld.2 = load i64, i64* %x, align 8
+    %x.ld.2 = load i64, ptr %x, align 8
     %icmp.2 = icmp slt i64 9, %x.ld.2
     %zext.2 = zext i1 %icmp.2 to i8
-    %x.ld.3 = load i64, i64* %x, align 8
+    %x.ld.3 = load i64, ptr %x, align 8
     %icmp.3 = icmp sle i64 9, %x.ld.3
     %zext.3 = zext i1 %icmp.3 to i8
-    %x.ld.4 = load i64, i64* %x, align 8
+    %x.ld.4 = load i64, ptr %x, align 8
     %icmp.4 = icmp sgt i64 9, %x.ld.4
     %zext.4 = zext i1 %icmp.4 to i8
-    %x.ld.5 = load i64, i64* %x, align 8
+    %x.ld.5 = load i64, ptr %x, align 8
     %icmp.5 = icmp sge i64 9, %x.ld.5
     %zext.5 = zext i1 %icmp.5 to i8
-    %y.ld.0 = load i64, i64* %y, align 8
+    %y.ld.0 = load i64, ptr %y, align 8
     %icmp.6 = icmp eq i64 9, %y.ld.0
     %zext.6 = zext i1 %icmp.6 to i8
-    %y.ld.1 = load i64, i64* %y, align 8
+    %y.ld.1 = load i64, ptr %y, align 8
     %icmp.7 = icmp ne i64 9, %y.ld.1
     %zext.7 = zext i1 %icmp.7 to i8
-    %y.ld.2 = load i64, i64* %y, align 8
+    %y.ld.2 = load i64, ptr %y, align 8
     %icmp.8 = icmp ult i64 9, %y.ld.2
     %zext.8 = zext i1 %icmp.8 to i8
-    %y.ld.3 = load i64, i64* %y, align 8
+    %y.ld.3 = load i64, ptr %y, align 8
     %icmp.9 = icmp ule i64 9, %y.ld.3
     %zext.9 = zext i1 %icmp.9 to i8
-    %y.ld.4 = load i64, i64* %y, align 8
+    %y.ld.4 = load i64, ptr %y, align 8
     %icmp.10 = icmp ugt i64 9, %y.ld.4
     %zext.10 = zext i1 %icmp.10 to i8
-    %y.ld.5 = load i64, i64* %y, align 8
+    %y.ld.5 = load i64, ptr %y, align 8
     %icmp.11 = icmp uge i64 9, %y.ld.5
     %zext.11 = zext i1 %icmp.11 to i8
-    %z.ld.0 = load double, double* %z, align 8
+    %z.ld.0 = load double, ptr %z, align 8
     %fcmp.0 = fcmp oeq double 9.000000e+00, %z.ld.0
     %zext.12 = zext i1 %fcmp.0 to i8
-    %z.ld.1 = load double, double* %z, align 8
+    %z.ld.1 = load double, ptr %z, align 8
     %fcmp.1 = fcmp une double 9.000000e+00, %z.ld.1
     %zext.13 = zext i1 %fcmp.1 to i8
-    %z.ld.2 = load double, double* %z, align 8
+    %z.ld.2 = load double, ptr %z, align 8
     %fcmp.2 = fcmp olt double 9.000000e+00, %z.ld.2
     %zext.14 = zext i1 %fcmp.2 to i8
-    %z.ld.3 = load double, double* %z, align 8
+    %z.ld.3 = load double, ptr %z, align 8
     %fcmp.3 = fcmp ole double 9.000000e+00, %z.ld.3
     %zext.15 = zext i1 %fcmp.3 to i8
-    %z.ld.4 = load double, double* %z, align 8
+    %z.ld.4 = load double, ptr %z, align 8
     %fcmp.4 = fcmp ogt double 9.000000e+00, %z.ld.4
     %zext.16 = zext i1 %fcmp.4 to i8
-    %z.ld.5 = load double, double* %z, align 8
+    %z.ld.5 = load double, ptr %z, align 8
     %fcmp.5 = fcmp oge double 9.000000e+00, %z.ld.5
     %zext.17 = zext i1 %fcmp.5 to i8
   )RAW_RESULT");
@@ -727,15 +709,15 @@
   }
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    store i64 0, i64* %x, align 8
-    store double 0.000000e+00, double* %y, align 8
-    %x.ld.0 = load i64, i64* %x, align 8
+    store i64 0, ptr %x, align 8
+    store double 0.000000e+00, ptr %y, align 8
+    %x.ld.0 = load i64, ptr %x, align 8
     %add.0 = add i64 9, %x.ld.0
-    %x.ld.1 = load i64, i64* %x, align 8
+    %x.ld.1 = load i64, ptr %x, align 8
     %sub.0 = sub i64 9, %x.ld.1
-    %y.ld.0 = load double, double* %y, align 8
+    %y.ld.0 = load double, ptr %y, align 8
     %fadd.0 = fadd double 9.000000e+00, %y.ld.0
-    %y.ld.1 = load double, double* %y, align 8
+    %y.ld.1 = load double, ptr %y, align 8
     %fsub.0 = fsub double 9.000000e+00, %y.ld.1
   )RAW_RESULT");
 
@@ -769,16 +751,16 @@
   h.mkAssign(vex, ypzpw);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    store i64 0, i64* %x, align 8
-    store i64 9, i64* %y, align 8
-    store i64 10, i64* %z, align 8
-    store i64 11, i64* %w, align 8
-    %y.ld.0 = load i64, i64* %y, align 8
-    %z.ld.0 = load i64, i64* %z, align 8
+    store i64 0, ptr %x, align 8
+    store i64 9, ptr %y, align 8
+    store i64 10, ptr %z, align 8
+    store i64 11, ptr %w, align 8
+    %y.ld.0 = load i64, ptr %y, align 8
+    %z.ld.0 = load i64, ptr %z, align 8
     %add.0 = add i64 %y.ld.0, %z.ld.0
-    %w.ld.0 = load i64, i64* %w, align 8
+    %w.ld.0 = load i64, ptr %w, align 8
     %add.1 = add i64 %add.0, %w.ld.0
-    store i64 %add.1, i64* %x, align 8
+    store i64 %add.1, ptr %x, align 8
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -825,65 +807,65 @@
   }
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    store i64 0, i64* %x, align 8
-    store i64 0, i64* %y, align 8
-    store i8 0, i8* %z, align 1
-    store i64 0, i64* %x2, align 8
-    store i64 0, i64* %y2, align 8
-    store i8 0, i8* %z2, align 1
-    %x.ld.0 = load i64, i64* %x, align 8
-    %x2.ld.0 = load i64, i64* %x2, align 8
+    store i64 0, ptr %x, align 8
+    store i64 0, ptr %y, align 8
+    store i8 0, ptr %z, align 1
+    store i64 0, ptr %x2, align 8
+    store i64 0, ptr %y2, align 8
+    store i8 0, ptr %z2, align 1
+    %x.ld.0 = load i64, ptr %x, align 8
+    %x2.ld.0 = load i64, ptr %x2, align 8
     %iand.0 = and i64 %x.ld.0, %x2.ld.0
-    %x.ld.1 = load i64, i64* %x, align 8
-    %x2.ld.1 = load i64, i64* %x2, align 8
+    %x.ld.1 = load i64, ptr %x, align 8
+    %x2.ld.1 = load i64, ptr %x2, align 8
     %ior.0 = or i64 %x.ld.1, %x2.ld.1
-    %x.ld.2 = load i64, i64* %x, align 8
-    %x2.ld.2 = load i64, i64* %x2, align 8
+    %x.ld.2 = load i64, ptr %x, align 8
+    %x2.ld.2 = load i64, ptr %x2, align 8
     %iand.1 = and i64 %x.ld.2, %x2.ld.2
-    %x.ld.3 = load i64, i64* %x, align 8
-    %x2.ld.3 = load i64, i64* %x2, align 8
+    %x.ld.3 = load i64, ptr %x, align 8
+    %x2.ld.3 = load i64, ptr %x2, align 8
     %ior.1 = or i64 %x.ld.3, %x2.ld.3
-    %x.ld.4 = load i64, i64* %x, align 8
-    %x2.ld.4 = load i64, i64* %x2, align 8
+    %x.ld.4 = load i64, ptr %x, align 8
+    %x2.ld.4 = load i64, ptr %x2, align 8
     %xor.0 = xor i64 %x.ld.4, %x2.ld.4
-    %x.ld.5 = load i64, i64* %x, align 8
-    %x2.ld.5 = load i64, i64* %x2, align 8
+    %x.ld.5 = load i64, ptr %x, align 8
+    %x2.ld.5 = load i64, ptr %x2, align 8
     %iand.2 = and i64 %x.ld.5, %x2.ld.5
-    %y.ld.0 = load i64, i64* %y, align 8
-    %y2.ld.0 = load i64, i64* %y2, align 8
+    %y.ld.0 = load i64, ptr %y, align 8
+    %y2.ld.0 = load i64, ptr %y2, align 8
     %iand.3 = and i64 %y.ld.0, %y2.ld.0
-    %y.ld.1 = load i64, i64* %y, align 8
-    %y2.ld.1 = load i64, i64* %y2, align 8
+    %y.ld.1 = load i64, ptr %y, align 8
+    %y2.ld.1 = load i64, ptr %y2, align 8
     %ior.2 = or i64 %y.ld.1, %y2.ld.1
-    %y.ld.2 = load i64, i64* %y, align 8
-    %y2.ld.2 = load i64, i64* %y2, align 8
+    %y.ld.2 = load i64, ptr %y, align 8
+    %y2.ld.2 = load i64, ptr %y2, align 8
     %iand.4 = and i64 %y.ld.2, %y2.ld.2
-    %y.ld.3 = load i64, i64* %y, align 8
-    %y2.ld.3 = load i64, i64* %y2, align 8
+    %y.ld.3 = load i64, ptr %y, align 8
+    %y2.ld.3 = load i64, ptr %y2, align 8
     %ior.3 = or i64 %y.ld.3, %y2.ld.3
-    %y.ld.4 = load i64, i64* %y, align 8
-    %y2.ld.4 = load i64, i64* %y2, align 8
+    %y.ld.4 = load i64, ptr %y, align 8
+    %y2.ld.4 = load i64, ptr %y2, align 8
     %xor.1 = xor i64 %y.ld.4, %y2.ld.4
-    %y.ld.5 = load i64, i64* %y, align 8
-    %y2.ld.5 = load i64, i64* %y2, align 8
+    %y.ld.5 = load i64, ptr %y, align 8
+    %y2.ld.5 = load i64, ptr %y2, align 8
     %iand.5 = and i64 %y.ld.5, %y2.ld.5
-    %z.ld.0 = load i8, i8* %z, align 1
-    %z2.ld.0 = load i8, i8* %z2, align 1
+    %z.ld.0 = load i8, ptr %z, align 1
+    %z2.ld.0 = load i8, ptr %z2, align 1
     %iand.6 = and i8 %z.ld.0, %z2.ld.0
-    %z.ld.1 = load i8, i8* %z, align 1
-    %z2.ld.1 = load i8, i8* %z2, align 1
+    %z.ld.1 = load i8, ptr %z, align 1
+    %z2.ld.1 = load i8, ptr %z2, align 1
     %ior.4 = or i8 %z.ld.1, %z2.ld.1
-    %z.ld.2 = load i8, i8* %z, align 1
-    %z2.ld.2 = load i8, i8* %z2, align 1
+    %z.ld.2 = load i8, ptr %z, align 1
+    %z2.ld.2 = load i8, ptr %z2, align 1
     %iand.7 = and i8 %z.ld.2, %z2.ld.2
-    %z.ld.3 = load i8, i8* %z, align 1
-    %z2.ld.3 = load i8, i8* %z2, align 1
+    %z.ld.3 = load i8, ptr %z, align 1
+    %z2.ld.3 = load i8, ptr %z2, align 1
     %ior.5 = or i8 %z.ld.3, %z2.ld.3
-    %z.ld.4 = load i8, i8* %z, align 1
-    %z2.ld.4 = load i8, i8* %z2, align 1
+    %z.ld.4 = load i8, ptr %z, align 1
+    %z2.ld.4 = load i8, ptr %z2, align 1
     %xor.2 = xor i8 %z.ld.4, %z2.ld.4
-    %z.ld.5 = load i8, i8* %z, align 1
-    %z2.ld.5 = load i8, i8* %z2, align 1
+    %z.ld.5 = load i8, ptr %z, align 1
+    %z2.ld.5 = load i8, ptr %z2, align 1
     %iand.8 = and i8 %z.ld.5, %z2.ld.5
   )RAW_RESULT");
 
@@ -931,24 +913,24 @@
   }
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    store i16 0, i16* %x, align 2
-    store i16 0, i16* %y, align 2
-    store double 0.000000e+00, double* %z, align 8
-    %x.ld.0 = load i16, i16* %x, align 2
+    store i16 0, ptr %x, align 2
+    store i16 0, ptr %y, align 2
+    store double 0.000000e+00, ptr %z, align 8
+    %x.ld.0 = load i16, ptr %x, align 2
     %mul.0 = mul i16 -17, %x.ld.0
-    %x.ld.1 = load i16, i16* %x, align 2
+    %x.ld.1 = load i16, ptr %x, align 2
     %div.0 = sdiv i16 -17, %x.ld.1
-    %x.ld.2 = load i16, i16* %x, align 2
+    %x.ld.2 = load i16, ptr %x, align 2
     %mod.0 = srem i16 -17, %x.ld.2
-    %y.ld.0 = load i16, i16* %y, align 2
+    %y.ld.0 = load i16, ptr %y, align 2
     %mul.1 = mul i16 13, %y.ld.0
-    %y.ld.1 = load i16, i16* %y, align 2
+    %y.ld.1 = load i16, ptr %y, align 2
     %div.1 = udiv i16 13, %y.ld.1
-    %y.ld.2 = load i16, i16* %y, align 2
+    %y.ld.2 = load i16, ptr %y, align 2
     %mod.1 = urem i16 13, %y.ld.2
-    %z.ld.0 = load double, double* %z, align 8
+    %z.ld.0 = load double, ptr %z, align 8
     %fmul.0 = fmul double 9.000000e+00, %z.ld.0
-    %z.ld.1 = load double, double* %z, align 8
+    %z.ld.1 = load double, ptr %z, align 8
     %fdiv.0 = fdiv double 9.000000e+00, %z.ld.1
   )RAW_RESULT");
 
@@ -1011,28 +993,28 @@
   }
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    store i64 0, i64* %x, align 8
-    store i64 0, i64* %y, align 8
-    store i64 0, i64* %s, align 8
-    store i32 0, i32* %z, align 4
-    %x.ld.0 = load i64, i64* %x, align 8
-    %s.ld.0 = load i64, i64* %s, align 8
+    store i64 0, ptr %x, align 8
+    store i64 0, ptr %y, align 8
+    store i64 0, ptr %s, align 8
+    store i32 0, ptr %z, align 4
+    %x.ld.0 = load i64, ptr %x, align 8
+    %s.ld.0 = load i64, ptr %s, align 8
     %shl.0 = shl i64 %x.ld.0, %s.ld.0
-    %x.ld.1 = load i64, i64* %x, align 8
-    %s.ld.1 = load i64, i64* %s, align 8
+    %x.ld.1 = load i64, ptr %x, align 8
+    %s.ld.1 = load i64, ptr %s, align 8
     %shr.0 = ashr i64 %x.ld.1, %s.ld.1
-    %y.ld.0 = load i64, i64* %y, align 8
-    %s.ld.2 = load i64, i64* %s, align 8
+    %y.ld.0 = load i64, ptr %y, align 8
+    %s.ld.2 = load i64, ptr %s, align 8
     %shl.1 = shl i64 %y.ld.0, %s.ld.2
-    %y.ld.1 = load i64, i64* %y, align 8
-    %s.ld.3 = load i64, i64* %s, align 8
+    %y.ld.1 = load i64, ptr %y, align 8
+    %s.ld.3 = load i64, ptr %s, align 8
     %shr.1 = lshr i64 %y.ld.1, %s.ld.3
-    %x.ld.2 = load i64, i64* %x, align 8
-    %z.ld.0 = load i32, i32* %z, align 4
+    %x.ld.2 = load i64, ptr %x, align 8
+    %z.ld.0 = load i32, ptr %z, align 4
     %zext.0 = zext i32 %z.ld.0 to i64
     %shl.2 = shl i64 %x.ld.2, %zext.0
-    %z.ld.1 = load i32, i32* %z, align 4
-    %y.ld.2 = load i64, i64* %y, align 8
+    %z.ld.1 = load i32, ptr %z, align 4
+    %y.ld.2 = load i64, ptr %y, align 8
     %trunc.0 = trunc i64 %y.ld.2 to i32
     %shr.2 = lshr i32 %z.ld.1, %trunc.0
   )RAW_RESULT");
@@ -1074,7 +1056,7 @@
   }
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define void @foo(i8* nest %nest.0) #0 {
+  define void @foo(ptr nest %nest.0) #0 {
   entry:
     %tmp.12 = alloca { double, double }, align 8
     %tmp.11 = alloca { double, double }, align 8
@@ -1093,134 +1075,105 @@
     %y = alloca { double, double }, align 8
     %z = alloca { double, double }, align 8
     %b = alloca i8, align 1
-    %cast.0 = bitcast { double, double }* %x to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.0, i8* align 8 bitcast ({ double, double }* @const.0 to i8*), i64 16, i1 false)
-    %cast.1 = bitcast { double, double }* %y to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.1, i8* align 8 bitcast ({ double, double }* @const.0 to i8*), i64 16, i1 false)
-    %cast.2 = bitcast { double, double }* %z to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.2, i8* align 8 bitcast ({ double, double }* @const.0 to i8*), i64 16, i1 false)
-    store i8 0, i8* %b, align 1
-    %cast.3 = bitcast { double, double }* %tmp.0 to i8*
-    %cast.4 = bitcast { double, double }* %x to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.3, i8* align 8 %cast.4, i64 16, i1 false)
-    %cast.5 = bitcast { double, double }* %tmp.1 to i8*
-    %cast.6 = bitcast { double, double }* %y to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.5, i8* align 8 %cast.6, i64 16, i1 false)
-    %field.0 = getelementptr inbounds { double, double }, { double, double }* %tmp.0, i32 0, i32 0
-    %.real.ld.0 = load double, double* %field.0, align 8
-    %field.1 = getelementptr inbounds { double, double }, { double, double }* %tmp.1, i32 0, i32 0
-    %.real.ld.1 = load double, double* %field.1, align 8
+    call void @llvm.memcpy.p0.p0.i64(ptr align 8 %x, ptr align 8 @const.0, i64 16, i1 false)
+    call void @llvm.memcpy.p0.p0.i64(ptr align 8 %y, ptr align 8 @const.0, i64 16, i1 false)
+    call void @llvm.memcpy.p0.p0.i64(ptr align 8 %z, ptr align 8 @const.0, i64 16, i1 false)
+    store i8 0, ptr %b, align 1
+    call void @llvm.memcpy.p0.p0.i64(ptr align 8 %tmp.0, ptr align 8 %x, i64 16, i1 false)
+    call void @llvm.memcpy.p0.p0.i64(ptr align 8 %tmp.1, ptr align 8 %y, i64 16, i1 false)
+    %field.0 = getelementptr inbounds { double, double }, ptr %tmp.0, i32 0, i32 0
+    %.real.ld.0 = load double, ptr %field.0, align 8
+    %field.1 = getelementptr inbounds { double, double }, ptr %tmp.1, i32 0, i32 0
+    %.real.ld.1 = load double, ptr %field.1, align 8
     %fadd.0 = fadd double %.real.ld.0, %.real.ld.1
-    %field.2 = getelementptr inbounds { double, double }, { double, double }* %tmp.0, i32 0, i32 1
-    %.imag.ld.0 = load double, double* %field.2, align 8
-    %field.3 = getelementptr inbounds { double, double }, { double, double }* %tmp.1, i32 0, i32 1
-    %.imag.ld.1 = load double, double* %field.3, align 8
+    %field.2 = getelementptr inbounds { double, double }, ptr %tmp.0, i32 0, i32 1
+    %.imag.ld.0 = load double, ptr %field.2, align 8
+    %field.3 = getelementptr inbounds { double, double }, ptr %tmp.1, i32 0, i32 1
+    %.imag.ld.1 = load double, ptr %field.3, align 8
     %fadd.1 = fadd double %.imag.ld.0, %.imag.ld.1
-    %field.4 = getelementptr inbounds { double, double }, { double, double }* %tmp.2, i32 0, i32 0
-    store double %fadd.0, double* %field.4, align 8
-    %field.5 = getelementptr inbounds { double, double }, { double, double }* %tmp.2, i32 0, i32 1
-    store double %fadd.1, double* %field.5, align 8
-    %cast.7 = bitcast { double, double }* %z to i8*
-    %cast.8 = bitcast { double, double }* %tmp.2 to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.7, i8* align 8 %cast.8, i64 16, i1 false)
-    %cast.9 = bitcast { double, double }* %tmp.3 to i8*
-    %cast.10 = bitcast { double, double }* %x to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.9, i8* align 8 %cast.10, i64 16, i1 false)
-    %cast.11 = bitcast { double, double }* %tmp.4 to i8*
-    %cast.12 = bitcast { double, double }* %y to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.11, i8* align 8 %cast.12, i64 16, i1 false)
-    %field.6 = getelementptr inbounds { double, double }, { double, double }* %tmp.3, i32 0, i32 0
-    %.real.ld.2 = load double, double* %field.6, align 8
-    %field.7 = getelementptr inbounds { double, double }, { double, double }* %tmp.4, i32 0, i32 0
-    %.real.ld.3 = load double, double* %field.7, align 8
+    %field.4 = getelementptr inbounds { double, double }, ptr %tmp.2, i32 0, i32 0
+    store double %fadd.0, ptr %field.4, align 8
+    %field.5 = getelementptr inbounds { double, double }, ptr %tmp.2, i32 0, i32 1
+    store double %fadd.1, ptr %field.5, align 8
+    call void @llvm.memcpy.p0.p0.i64(ptr align 8 %z, ptr align 8 %tmp.2, i64 16, i1 false)
+    call void @llvm.memcpy.p0.p0.i64(ptr align 8 %tmp.3, ptr align 8 %x, i64 16, i1 false)
+    call void @llvm.memcpy.p0.p0.i64(ptr align 8 %tmp.4, ptr align 8 %y, i64 16, i1 false)
+    %field.6 = getelementptr inbounds { double, double }, ptr %tmp.3, i32 0, i32 0
+    %.real.ld.2 = load double, ptr %field.6, align 8
+    %field.7 = getelementptr inbounds { double, double }, ptr %tmp.4, i32 0, i32 0
+    %.real.ld.3 = load double, ptr %field.7, align 8
     %fsub.0 = fsub double %.real.ld.2, %.real.ld.3
-    %field.8 = getelementptr inbounds { double, double }, { double, double }* %tmp.3, i32 0, i32 1
-    %.imag.ld.2 = load double, double* %field.8, align 8
-    %field.9 = getelementptr inbounds { double, double }, { double, double }* %tmp.4, i32 0, i32 1
-    %.imag.ld.3 = load double, double* %field.9, align 8
+    %field.8 = getelementptr inbounds { double, double }, ptr %tmp.3, i32 0, i32 1
+    %.imag.ld.2 = load double, ptr %field.8, align 8
+    %field.9 = getelementptr inbounds { double, double }, ptr %tmp.4, i32 0, i32 1
+    %.imag.ld.3 = load double, ptr %field.9, align 8
     %fsub.1 = fsub double %.imag.ld.2, %.imag.ld.3
-    %field.10 = getelementptr inbounds { double, double }, { double, double }* %tmp.5, i32 0, i32 0
-    store double %fsub.0, double* %field.10, align 8
-    %field.11 = getelementptr inbounds { double, double }, { double, double }* %tmp.5, i32 0, i32 1
-    store double %fsub.1, double* %field.11, align 8
-    %cast.13 = bitcast { double, double }* %z to i8*
-    %cast.14 = bitcast { double, double }* %tmp.5 to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.13, i8* align 8 %cast.14, i64 16, i1 false)
-    %cast.15 = bitcast { double, double }* %tmp.6 to i8*
-    %cast.16 = bitcast { double, double }* %x to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.15, i8* align 8 %cast.16, i64 16, i1 false)
-    %cast.17 = bitcast { double, double }* %tmp.7 to i8*
-    %cast.18 = bitcast { double, double }* %y to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.17, i8* align 8 %cast.18, i64 16, i1 false)
-    %field.12 = getelementptr inbounds { double, double }, { double, double }* %tmp.6, i32 0, i32 0
-    %.real.ld.4 = load double, double* %field.12, align 8
-    %field.13 = getelementptr inbounds { double, double }, { double, double }* %tmp.7, i32 0, i32 0
-    %.real.ld.5 = load double, double* %field.13, align 8
+    %field.10 = getelementptr inbounds { double, double }, ptr %tmp.5, i32 0, i32 0
+    store double %fsub.0, ptr %field.10, align 8
+    %field.11 = getelementptr inbounds { double, double }, ptr %tmp.5, i32 0, i32 1
+    store double %fsub.1, ptr %field.11, align 8
+    call void @llvm.memcpy.p0.p0.i64(ptr align 8 %z, ptr align 8 %tmp.5, i64 16, i1 false)
+    call void @llvm.memcpy.p0.p0.i64(ptr align 8 %tmp.6, ptr align 8 %x, i64 16, i1 false)
+    call void @llvm.memcpy.p0.p0.i64(ptr align 8 %tmp.7, ptr align 8 %y, i64 16, i1 false)
+    %field.12 = getelementptr inbounds { double, double }, ptr %tmp.6, i32 0, i32 0
+    %.real.ld.4 = load double, ptr %field.12, align 8
+    %field.13 = getelementptr inbounds { double, double }, ptr %tmp.7, i32 0, i32 0
+    %.real.ld.5 = load double, ptr %field.13, align 8
     %fmul.0 = fmul double %.real.ld.4, %.real.ld.5
-    %field.14 = getelementptr inbounds { double, double }, { double, double }* %tmp.6, i32 0, i32 1
-    %.imag.ld.4 = load double, double* %field.14, align 8
-    %field.15 = getelementptr inbounds { double, double }, { double, double }* %tmp.7, i32 0, i32 1
-    %.imag.ld.5 = load double, double* %field.15, align 8
+    %field.14 = getelementptr inbounds { double, double }, ptr %tmp.6, i32 0, i32 1
+    %.imag.ld.4 = load double, ptr %field.14, align 8
+    %field.15 = getelementptr inbounds { double, double }, ptr %tmp.7, i32 0, i32 1
+    %.imag.ld.5 = load double, ptr %field.15, align 8
     %fmul.1 = fmul double %.imag.ld.4, %.imag.ld.5
     %fsub.2 = fsub double %fmul.0, %fmul.1
-    %field.16 = getelementptr inbounds { double, double }, { double, double }* %tmp.6, i32 0, i32 0
-    %.field.ld.0 = load double, double* %field.16, align 8
-    %field.17 = getelementptr inbounds { double, double }, { double, double }* %tmp.7, i32 0, i32 1
-    %.field.ld.1 = load double, double* %field.17, align 8
+    %field.16 = getelementptr inbounds { double, double }, ptr %tmp.6, i32 0, i32 0
+    %.field.ld.0 = load double, ptr %field.16, align 8
+    %field.17 = getelementptr inbounds { double, double }, ptr %tmp.7, i32 0, i32 1
+    %.field.ld.1 = load double, ptr %field.17, align 8
     %fmul.2 = fmul double %.field.ld.0, %.field.ld.1
-    %field.18 = getelementptr inbounds { double, double }, { double, double }* %tmp.6, i32 0, i32 1
-    %.field.ld.2 = load double, double* %field.18, align 8
-    %field.19 = getelementptr inbounds { double, double }, { double, double }* %tmp.7, i32 0, i32 0
-    %.field.ld.3 = load double, double* %field.19, align 8
+    %field.18 = getelementptr inbounds { double, double }, ptr %tmp.6, i32 0, i32 1
+    %.field.ld.2 = load double, ptr %field.18, align 8
+    %field.19 = getelementptr inbounds { double, double }, ptr %tmp.7, i32 0, i32 0
+    %.field.ld.3 = load double, ptr %field.19, align 8
     %fmul.3 = fmul double %.field.ld.2, %.field.ld.3
     %fadd.2 = fadd double %fmul.2, %fmul.3
-    %field.20 = getelementptr inbounds { double, double }, { double, double }* %tmp.8, i32 0, i32 0
-    store double %fsub.2, double* %field.20, align 8
-    %field.21 = getelementptr inbounds { double, double }, { double, double }* %tmp.8, i32 0, i32 1
-    store double %fadd.2, double* %field.21, align 8
-    %cast.19 = bitcast { double, double }* %z to i8*
-    %cast.20 = bitcast { double, double }* %tmp.8 to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.19, i8* align 8 %cast.20, i64 16, i1 false)
-    %cast.21 = bitcast { double, double }* %tmp.9 to i8*
-    %cast.22 = bitcast { double, double }* %x to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.21, i8* align 8 %cast.22, i64 16, i1 false)
-    %cast.23 = bitcast { double, double }* %tmp.10 to i8*
-    %cast.24 = bitcast { double, double }* %y to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.23, i8* align 8 %cast.24, i64 16, i1 false)
-    %field.22 = getelementptr inbounds { double, double }, { double, double }* %tmp.9, i32 0, i32 0
-    %.real.ld.6 = load double, double* %field.22, align 8
-    %field.23 = getelementptr inbounds { double, double }, { double, double }* %tmp.10, i32 0, i32 0
-    %.real.ld.7 = load double, double* %field.23, align 8
+    %field.20 = getelementptr inbounds { double, double }, ptr %tmp.8, i32 0, i32 0
+    store double %fsub.2, ptr %field.20, align 8
+    %field.21 = getelementptr inbounds { double, double }, ptr %tmp.8, i32 0, i32 1
+    store double %fadd.2, ptr %field.21, align 8
+    call void @llvm.memcpy.p0.p0.i64(ptr align 8 %z, ptr align 8 %tmp.8, i64 16, i1 false)
+    call void @llvm.memcpy.p0.p0.i64(ptr align 8 %tmp.9, ptr align 8 %x, i64 16, i1 false)
+    call void @llvm.memcpy.p0.p0.i64(ptr align 8 %tmp.10, ptr align 8 %y, i64 16, i1 false)
+    %field.22 = getelementptr inbounds { double, double }, ptr %tmp.9, i32 0, i32 0
+    %.real.ld.6 = load double, ptr %field.22, align 8
+    %field.23 = getelementptr inbounds { double, double }, ptr %tmp.10, i32 0, i32 0
+    %.real.ld.7 = load double, ptr %field.23, align 8
     %fcmp.0 = fcmp oeq double %.real.ld.6, %.real.ld.7
     %zext.0 = zext i1 %fcmp.0 to i8
-    %field.24 = getelementptr inbounds { double, double }, { double, double }* %tmp.9, i32 0, i32 1
-    %.imag.ld.6 = load double, double* %field.24, align 8
-    %field.25 = getelementptr inbounds { double, double }, { double, double }* %tmp.10, i32 0, i32 1
-    %.imag.ld.7 = load double, double* %field.25, align 8
+    %field.24 = getelementptr inbounds { double, double }, ptr %tmp.9, i32 0, i32 1
+    %.imag.ld.6 = load double, ptr %field.24, align 8
+    %field.25 = getelementptr inbounds { double, double }, ptr %tmp.10, i32 0, i32 1
+    %.imag.ld.7 = load double, ptr %field.25, align 8
     %fcmp.1 = fcmp oeq double %.imag.ld.6, %.imag.ld.7
     %zext.1 = zext i1 %fcmp.1 to i8
     %iand.0 = and i8 %zext.0, %zext.1
-    store i8 %iand.0, i8* %b, align 1
-    %cast.25 = bitcast { double, double }* %tmp.11 to i8*
-    %cast.26 = bitcast { double, double }* %x to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.25, i8* align 8 %cast.26, i64 16, i1 false)
-    %cast.27 = bitcast { double, double }* %tmp.12 to i8*
-    %cast.28 = bitcast { double, double }* %y to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.27, i8* align 8 %cast.28, i64 16, i1 false)
-    %field.26 = getelementptr inbounds { double, double }, { double, double }* %tmp.11, i32 0, i32 0
-    %.real.ld.8 = load double, double* %field.26, align 8
-    %field.27 = getelementptr inbounds { double, double }, { double, double }* %tmp.12, i32 0, i32 0
-    %.real.ld.9 = load double, double* %field.27, align 8
+    store i8 %iand.0, ptr %b, align 1
+    call void @llvm.memcpy.p0.p0.i64(ptr align 8 %tmp.11, ptr align 8 %x, i64 16, i1 false)
+    call void @llvm.memcpy.p0.p0.i64(ptr align 8 %tmp.12, ptr align 8 %y, i64 16, i1 false)
+    %field.26 = getelementptr inbounds { double, double }, ptr %tmp.11, i32 0, i32 0
+    %.real.ld.8 = load double, ptr %field.26, align 8
+    %field.27 = getelementptr inbounds { double, double }, ptr %tmp.12, i32 0, i32 0
+    %.real.ld.9 = load double, ptr %field.27, align 8
     %fcmp.2 = fcmp une double %.real.ld.8, %.real.ld.9
     %zext.2 = zext i1 %fcmp.2 to i8
-    %field.28 = getelementptr inbounds { double, double }, { double, double }* %tmp.11, i32 0, i32 1
-    %.imag.ld.8 = load double, double* %field.28, align 8
-    %field.29 = getelementptr inbounds { double, double }, { double, double }* %tmp.12, i32 0, i32 1
-    %.imag.ld.9 = load double, double* %field.29, align 8
+    %field.28 = getelementptr inbounds { double, double }, ptr %tmp.11, i32 0, i32 1
+    %.imag.ld.8 = load double, ptr %field.28, align 8
+    %field.29 = getelementptr inbounds { double, double }, ptr %tmp.12, i32 0, i32 1
+    %.imag.ld.9 = load double, ptr %field.29, align 8
     %fcmp.3 = fcmp une double %.imag.ld.8, %.imag.ld.9
     %zext.3 = zext i1 %fcmp.3 to i8
     %ior.0 = or i8 %zext.2, %zext.3
-    store i8 %ior.0, i8* %b, align 1
+    store i8 %ior.0, ptr %b, align 1
     ret void
   }
   )RAW_RESULT");
@@ -1266,22 +1219,21 @@
   h.mkAssign(xvex3, compex);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    store double 0.000000e+00, double* %a, align 8
-    store double 0.000000e+00, double* %b, align 8
-    %cast.0 = bitcast { double, double }* %x to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.0, i8* align 8 bitcast ({ double, double }* @const.0 to i8*), i64 16, i1 false)
-    %field.0 = getelementptr inbounds { double, double }, { double, double }* %x, i32 0, i32 0
-    %x.real.ld.0 = load double, double* %field.0, align 8
-    store double %x.real.ld.0, double* %a, align 8
-    %field.1 = getelementptr inbounds { double, double }, { double, double }* %x, i32 0, i32 1
-    %x.imag.ld.0 = load double, double* %field.1, align 8
-    store double %x.imag.ld.0, double* %b, align 8
-    %b.ld.0 = load double, double* %b, align 8
-    %a.ld.0 = load double, double* %a, align 8
-    %field.2 = getelementptr inbounds { double, double }, { double, double }* %x, i32 0, i32 0
-    store double %b.ld.0, double* %field.2, align 8
-    %field.3 = getelementptr inbounds { double, double }, { double, double }* %x, i32 0, i32 1
-    store double %a.ld.0, double* %field.3, align 8
+    store double 0.000000e+00, ptr %a, align 8
+    store double 0.000000e+00, ptr %b, align 8
+    call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 8 %x, ptr align 8 @const.0, i64 16, i1 false)
+    %field.0 = getelementptr inbounds { double, double }, ptr %x, i32 0, i32 0
+    %x.real.ld.0 = load double, ptr %field.0, align 8
+    store double %x.real.ld.0, ptr %a, align 8
+    %field.1 = getelementptr inbounds { double, double }, ptr %x, i32 0, i32 1
+    %x.imag.ld.0 = load double, ptr %field.1, align 8
+    store double %x.imag.ld.0, ptr %b, align 8
+    %b.ld.0 = load double, ptr %b, align 8
+    %a.ld.0 = load double, ptr %a, align 8
+    %field.2 = getelementptr inbounds { double, double }, ptr %x, i32 0, i32 0
+    store double %b.ld.0, ptr %field.2, align 8
+    %field.3 = getelementptr inbounds { double, double }, ptr %x, i32 0, i32 1
+    store double %a.ld.0, ptr %field.3, align 8
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -1299,7 +1251,7 @@
   {
     Bexpression *snil = be->string_constant_expression("");
     DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-        i8* null
+        ptr null
       )RAW_RESULT");
     bool isOK = h.expectValue(snil->value(), exp);
     EXPECT_TRUE(isOK && "Value does not have expected contents");
@@ -1308,7 +1260,7 @@
   {
     Bexpression *sblah = be->string_constant_expression("blah");
     DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-      i8* getelementptr inbounds ([5 x i8], [5 x i8]* @const.0, i32 0, i32 0)
+      @const.0 = private constant [5 x i8] c"blah\00", align 1
     )RAW_RESULT");
     bool isOK = h.expectValue(sblah->value(), exp);
     EXPECT_TRUE(isOK && "Value does not have expected contents");
@@ -1342,28 +1294,28 @@
   h.mkExprStmt(condex);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define void @foo(i8* nest %nest.0) #0 {
+  define void @foo(ptr nest %nest.0) #0 {
   entry:
     %a = alloca i64, align 8
     %b = alloca i64, align 8
-    store i64 0, i64* %a, align 8
-    store i64 0, i64* %b, align 8
-    %a.ld.0 = load i64, i64* %a, align 8
-    %b.ld.0 = load i64, i64* %b, align 8
+    store i64 0, ptr %a, align 8
+    store i64 0, ptr %b, align 8
+    %a.ld.0 = load i64, ptr %a, align 8
+    %b.ld.0 = load i64, ptr %b, align 8
     %icmp.0 = icmp slt i64 %a.ld.0, %b.ld.0
     %zext.0 = zext i1 %icmp.0 to i8
     %trunc.0 = trunc i8 %zext.0 to i1
     br i1 %trunc.0, label %then.0, label %else.0
-  
+
   then.0:                                           ; preds = %entry
-    call void @foo(i8* nest undef)
+    call void @foo(ptr nest undef)
     br label %fallthrough.0
-  
+
   fallthrough.0:                                    ; preds = %else.0, %then.0
     ret void
-  
+
   else.0:                                           ; preds = %entry
-    call void @foo(i8* nest undef)
+    call void @foo(ptr nest undef)
     br label %fallthrough.0
   }
   )RAW_RESULT");
@@ -1399,24 +1351,24 @@
   h.mkExprStmt(condex);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define void @foo(i8* nest %nest.0) #0 {
+  define void @foo(ptr nest %nest.0) #0 {
   entry:
     %a = alloca i64, align 8
     %tmpv.0 = alloca i64, align 8
-    store i64 0, i64* %a, align 8
+    store i64 0, ptr %a, align 8
     br i1 true, label %then.0, label %else.0
-  
+
   then.0:                                           ; preds = %entry
-    call void @foo(i8* nest undef)
+    call void @foo(ptr nest undef)
     br label %fallthrough.0
-  
+
   fallthrough.0:                                    ; preds = %else.0, %then.0
-    %tmpv.0.ld.0 = load i64, i64* %tmpv.0, align 8
+    %tmpv.0.ld.0 = load i64, ptr %tmpv.0, align 8
     ret void
-  
+
   else.0:                                           ; preds = %entry
-    %a.ld.0 = load i64, i64* %a, align 8
-    store i64 %a.ld.0, i64* %tmpv.0, align 8
+    %a.ld.0 = load i64, ptr %a, align 8
+    store i64 %a.ld.0, ptr %tmpv.0, align 8
     br label %fallthrough.0
   }
   )RAW_RESULT");
@@ -1455,35 +1407,30 @@
   h.mkLocal("a", s2t, cond);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define void @foo({ [16 x i32], i32 }* sret({ [16 x i32], i32 }) %sret.formal.0, i8* nest %nest.0, { [16 x i32], i32 }* byval({ [16 x i32], i32 }) %p0, i32 %p1) #0 {
-  entry:
-    %p1.addr = alloca i32, align 4
-    %a = alloca { [16 x i32], i32 }, align 4
-    %tmpv.0 = alloca { [16 x i32], i32 }, align 4
-    store i32 %p1, i32* %p1.addr, align 4
-    %p1.ld.0 = load i32, i32* %p1.addr, align 4
-    %icmp.0 = icmp slt i32 %p1.ld.0, 7
-    %zext.0 = zext i1 %icmp.0 to i8
-    %trunc.0 = trunc i8 %zext.0 to i1
-    br i1 %trunc.0, label %then.0, label %else.0
-  
-  then.0:                                           ; preds = %entry
-    %cast.0 = bitcast { [16 x i32], i32 }* %tmpv.0 to i8*
-    %cast.1 = bitcast { [16 x i32], i32 }* %p0 to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %cast.0, i8* align 4 %cast.1, i64 68, i1 false)
-    br label %fallthrough.0
-  
-  fallthrough.0:                                    ; preds = %else.0, %then.0
-    %cast.3 = bitcast { [16 x i32], i32 }* %a to i8*
-    %cast.4 = bitcast { [16 x i32], i32 }* %tmpv.0 to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %cast.3, i8* align 4 %cast.4, i64 68, i1 false)
-    ret void
-  
-  else.0:                                           ; preds = %entry
-    %cast.2 = bitcast { [16 x i32], i32 }* %tmpv.0 to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %cast.2, i8* align 4 bitcast ({ [16 x i32], i32 }* @const.0 to i8*), i64 68, i1 false)
-    br label %fallthrough.0
-  }
+    define void @foo(ptr sret({ [16 x i32], i32 }) %sret.formal.0, ptr nest %nest.0, ptr byval({ [16 x i32], i32 }) %p0, i32 %p1) #0 {
+    entry:
+      %p1.addr = alloca i32, align 4
+      %a = alloca { [16 x i32], i32 }, align 4
+      %tmpv.0 = alloca { [16 x i32], i32 }, align 4
+      store i32 %p1, ptr %p1.addr, align 4
+      %p1.ld.0 = load i32, ptr %p1.addr, align 4
+      %icmp.0 = icmp slt i32 %p1.ld.0, 7
+      %zext.0 = zext i1 %icmp.0 to i8
+      %trunc.0 = trunc i8 %zext.0 to i1
+      br i1 %trunc.0, label %then.0, label %else.0
+
+    then.0:                                           ; preds = %entry
+      call void @llvm.memcpy.p0.p0.i64(ptr align 4 %tmpv.0, ptr align 4 %p0, i64 68, i1 false)
+      br label %fallthrough.0
+
+    fallthrough.0:                                    ; preds = %else.0, %then.0
+      call void @llvm.memcpy.p0.p0.i64(ptr align 4 %a, ptr align 4 %tmpv.0, i64 68, i1 false)
+      ret void
+
+    else.0:                                           ; preds = %entry
+      call void @llvm.memcpy.p0.p0.i64(ptr align 4 %tmpv.0, ptr align 4 @const.0, i64 68, i1 false)
+      br label %fallthrough.0
+    }
   )RAW_RESULT");
 
   bool broken = h.finish(StripDebugInfo);
@@ -1530,35 +1477,30 @@
   h.mkLocal("a", s2t, cond);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define void @foo({ [16 x i32], i32 }* sret({ [16 x i32], i32 }) %sret.formal.0, i8* nest %nest.0, { [16 x i32], i32 }* %p0, i32 %p1) #0 {
-  entry:
-    %p1.addr = alloca i32, align 4
-    %a = alloca { [16 x i32], i32 }, align 4
-    %tmpv.0 = alloca { [16 x i32], i32 }, align 4
-    store i32 %p1, i32* %p1.addr, align 4
-    %p1.ld.0 = load i32, i32* %p1.addr, align 4
-    %icmp.0 = icmp slt i32 %p1.ld.0, 7
-    %zext.0 = zext i1 %icmp.0 to i8
-    %trunc.0 = trunc i8 %zext.0 to i1
-    br i1 %trunc.0, label %then.0, label %else.0
-  
-  then.0:                                           ; preds = %entry
-    %cast.0 = bitcast { [16 x i32], i32 }* %tmpv.0 to i8*
-    %cast.1 = bitcast { [16 x i32], i32 }* %p0 to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %cast.0, i8* align 4 %cast.1, i64 68, i1 false)
-    br label %fallthrough.0
-  
-  fallthrough.0:                                    ; preds = %else.0, %then.0
-    %cast.3 = bitcast { [16 x i32], i32 }* %a to i8*
-    %cast.4 = bitcast { [16 x i32], i32 }* %tmpv.0 to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %cast.3, i8* align 4 %cast.4, i64 68, i1 false)
-    ret void
-  
-  else.0:                                           ; preds = %entry
-    %cast.2 = bitcast { [16 x i32], i32 }* %tmpv.0 to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %cast.2, i8* align 4 bitcast ({ [16 x i32], i32 }* @const.0 to i8*), i64 68, i1 false)
-    br label %fallthrough.0
-  }
+    define void @foo(ptr sret({ [16 x i32], i32 }) %sret.formal.0, ptr nest %nest.0, ptr %p0, i32 %p1) #0 {
+    entry:
+      %p1.addr = alloca i32, align 4
+      %a = alloca { [16 x i32], i32 }, align 4
+      %tmpv.0 = alloca { [16 x i32], i32 }, align 4
+      store i32 %p1, ptr %p1.addr, align 4
+      %p1.ld.0 = load i32, ptr %p1.addr, align 4
+      %icmp.0 = icmp slt i32 %p1.ld.0, 7
+      %zext.0 = zext i1 %icmp.0 to i8
+      %trunc.0 = trunc i8 %zext.0 to i1
+      br i1 %trunc.0, label %then.0, label %else.0
+
+    then.0:                                           ; preds = %entry
+      call void @llvm.memcpy.p0.p0.i64(ptr align 4 %tmpv.0, ptr align 4 %p0, i64 68, i1 false)
+      br label %fallthrough.0
+
+    fallthrough.0:                                    ; preds = %else.0, %then.0
+      call void @llvm.memcpy.p0.p0.i64(ptr align 4 %a, ptr align 4 %tmpv.0, i64 68, i1 false)
+      ret void
+
+    else.0:                                           ; preds = %entry
+      call void @llvm.memcpy.p0.p0.i64(ptr align 4 %tmpv.0, ptr align 4 @const.0, i64 68, i1 false)
+      br label %fallthrough.0
+    }
   )RAW_RESULT");
 
   bool broken = h.finish(StripDebugInfo);
@@ -1589,18 +1531,18 @@
   h.addStmt(es);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define i64 @foo(i8* nest %nest.0, i32 %param1, i32 %param2, i64* %param3) #0 {
+  define i64 @foo(ptr nest %nest.0, i32 %param1, i32 %param2, ptr %param3) #0 {
   entry:
     %param1.addr = alloca i32, align 4
     %param2.addr = alloca i32, align 4
-    %param3.addr = alloca i64*, align 8
+    %param3.addr = alloca ptr, align 8
     %x = alloca i64, align 8
-    store i32 %param1, i32* %param1.addr, align 4
-    store i32 %param2, i32* %param2.addr, align 4
-    store i64* %param3, i64** %param3.addr, align 8
-    store i64 0, i64* %x, align 8
-    store i64 5, i64* %x, align 8
-    %x.ld.0 = load i64, i64* %x, align 8
+    store i32 %param1, ptr %param1.addr, align 4
+    store i32 %param2, ptr %param2.addr, align 4
+    store ptr %param3, ptr %param3.addr, align 8
+    store i64 0, ptr %x, align 8
+    store i64 5, ptr %x, align 8
+    %x.ld.0 = load i64, ptr %x, align 8
     ret i64 0
   }
   )RAW_RESULT");
@@ -1639,30 +1581,27 @@
   h.addStmt(st2);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define i64 @foo(i8* nest %nest.0, i32 %param1, i32 %param2, i64* %param3) #0 {
+  define i64 @foo(ptr nest %nest.0, i32 %param1, i32 %param2, ptr %param3) #0 {
   entry:
     %tmp.0 = alloca { i64, i64 }, align 8
     %param1.addr = alloca i32, align 4
     %param2.addr = alloca i32, align 4
-    %param3.addr = alloca i64*, align 8
+    %param3.addr = alloca ptr, align 8
     %x = alloca i64, align 8
     %y = alloca { i64, i64 }, align 8
-    store i32 %param1, i32* %param1.addr, align 4
-    store i32 %param2, i32* %param2.addr, align 4
-    store i64* %param3, i64** %param3.addr, align 8
-    store i64 0, i64* %x, align 8
-    %cast.0 = bitcast { i64, i64 }* %y to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.0, i8* align 8 bitcast ({ i64, i64 }* @const.0 to i8*), i64 16, i1 false)
-    store i64 5, i64* %x, align 8
-    %x.ld.0 = load i64, i64* %x, align 8
-    %x.ld.1 = load i64, i64* %x, align 8
-    %field.0 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %tmp.0, i32 0, i32 0
-    store i64 %x.ld.0, i64* %field.0, align 8
-    %field.1 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %tmp.0, i32 0, i32 1
-    store i64 %x.ld.1, i64* %field.1, align 8
-    %cast.1 = bitcast { i64, i64 }* %y to i8*
-    %cast.2 = bitcast { i64, i64 }* %tmp.0 to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.1, i8* align 8 %cast.2, i64 16, i1 false)
+    store i32 %param1, ptr %param1.addr, align 4
+    store i32 %param2, ptr %param2.addr, align 4
+    store ptr %param3, ptr %param3.addr, align 8
+    store i64 0, ptr %x, align 8
+    call void @llvm.memcpy.p0.p0.i64(ptr align 8 %y, ptr align 8 @const.0, i64 16, i1 false)
+    store i64 5, ptr %x, align 8
+    %x.ld.0 = load i64, ptr %x, align 8
+    %x.ld.1 = load i64, ptr %x, align 8
+    %field.0 = getelementptr inbounds { i64, i64 }, ptr %tmp.0, i32 0, i32 0
+    store i64 %x.ld.0, ptr %field.0, align 8
+    %field.1 = getelementptr inbounds { i64, i64 }, ptr %tmp.0, i32 0, i32 1
+    store i64 %x.ld.1, ptr %field.1, align 8
+    call void @llvm.memcpy.p0.p0.i64(ptr align 8 %y, ptr align 8 %tmp.0, i64 16, i1 false)
     ret i64 0
   }
   )RAW_RESULT");
@@ -1701,32 +1640,32 @@
   h.mkAssign(dex, mkInt32Const(be, 7));
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define void @foo(i8* nest %nest.0, i32* %p0, i32* %p1) #0 {
+  define void @foo(ptr nest %nest.0, ptr %p0, ptr %p1) #0 {
   entry:
-    %p0.addr = alloca i32*, align 8
-    %p1.addr = alloca i32*, align 8
-    %tmpv.0 = alloca i32*, align 8
-    store i32* %p0, i32** %p0.addr, align 8
-    store i32* %p1, i32** %p1.addr, align 8
-    %p0.ld.0 = load i32*, i32** %p0.addr, align 8
-    %icmp.0 = icmp eq i32* %p0.ld.0, null
+    %p0.addr = alloca ptr, align 8
+    %p1.addr = alloca ptr, align 8
+    %tmpv.0 = alloca ptr, align 8
+    store ptr %p0, ptr %p0.addr, align 8
+    store ptr %p1, ptr %p1.addr, align 8
+    %p0.ld.0 = load ptr, ptr %p0.addr, align 8
+    %icmp.0 = icmp eq ptr %p0.ld.0, null
     %zext.0 = zext i1 %icmp.0 to i8
     %trunc.0 = trunc i8 %zext.0 to i1
     br i1 %trunc.0, label %then.0, label %else.0
-  
+
   then.0:                                           ; preds = %entry
-    %p1.ld.0 = load i32*, i32** %p1.addr, align 8
-    store i32* %p1.ld.0, i32** %tmpv.0, align 8
+    %p1.ld.0 = load ptr, ptr %p1.addr, align 8
+    store ptr %p1.ld.0, ptr %tmpv.0, align 8
     br label %fallthrough.0
-  
+
   fallthrough.0:                                    ; preds = %else.0, %then.0
-    %tmpv.0.ld.0 = load i32*, i32** %tmpv.0, align 8
-    store i32 7, i32* %tmpv.0.ld.0, align 4
+    %tmpv.0.ld.0 = load ptr, ptr %tmpv.0, align 8
+    store i32 7, ptr %tmpv.0.ld.0, align 4
     ret void
-  
+
   else.0:                                           ; preds = %entry
-    %p0.ld.1 = load i32*, i32** %p0.addr, align 8
-    store i32* %p0.ld.1, i32** %tmpv.0, align 8
+    %p0.ld.1 = load ptr, ptr %p0.addr, align 8
+    store ptr %p0.ld.1, ptr %tmpv.0, align 8
     br label %fallthrough.0
   }
   )RAW_RESULT");
@@ -1774,24 +1713,24 @@
   h.mkLocal("r", bf64t, be->unary_expression(OPERATOR_MINUS, veq, loc));
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    store i8 0, i8* %x, align 1
-    %x.ld.0 = load i8, i8* %x, align 1
+    store i8 0, ptr %x, align 1
+    %x.ld.0 = load i8, ptr %x, align 1
     %icmp.0 = icmp ne i8 %x.ld.0, 0
     %xor.0 = xor i1 %icmp.0, true
     %zext.0 = zext i1 %xor.0 to i8
-    store i8 %zext.0, i8* %y, align 1
-    store i32 0, i32* %a, align 4
-    %a.ld.0 = load i32, i32* %a, align 4
+    store i8 %zext.0, ptr %y, align 1
+    store i32 0, ptr %a, align 4
+    %a.ld.0 = load i32, ptr %a, align 4
     %sub.0 = sub i32 0, %a.ld.0
-    store i32 %sub.0, i32* %b, align 4
-    store i64 0, i64* %z, align 8
-    %z.ld.0 = load i64, i64* %z, align 8
+    store i32 %sub.0, ptr %b, align 4
+    store i64 0, ptr %z, align 8
+    %z.ld.0 = load i64, ptr %z, align 8
     %xor.1 = xor i64 %z.ld.0, -1
-    store i64 %xor.1, i64* %w, align 8
-    store double 0.000000e+00, double* %q, align 8
-    %q.ld.0 = load double, double* %q, align 8
+    store i64 %xor.1, ptr %w, align 8
+    store double 0.000000e+00, ptr %q, align 8
+    %q.ld.0 = load double, ptr %q, align 8
     %fsub.0 = fsub double -0.000000e+00, %q.ld.0
-    store double %fsub.0, double* %r, align 8
+    store double %fsub.0, ptr %r, align 8
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -1821,7 +1760,7 @@
   h.mkExprStmt(call1);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    call addrspace(0) void @foo(i8* nest undef, i8* null, i32* null, i64* null)
+    call addrspace(0) void @foo(ptr nest undef, ptr null, ptr null, ptr null)
   )RAW_RESULT");
 
   // Note that this

diff --git a/unittests/BackendCore/BackendFcnTests.cpp b/unittests/BackendCore/BackendFcnTests.cpp
index 2af5163..82a0d6f 100644
--- a/unittests/BackendCore/BackendFcnTests.cpp
+++ b/unittests/BackendCore/BackendFcnTests.cpp

@@ -298,8 +298,8 @@
   h.mkExprStmt(call);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    store i64 0, i64* %x, align 8
-    %x.ld.0 = load i64, i64* %x, align 8
+    store i64 0, ptr %x, align 8
+    %x.ld.0 = load i64, ptr %x, align 8
     %call.0 = call addrspace(0) i64 @llvm.cttz.i64(i64 %x.ld.0, i1 true)
   )RAW_RESULT");
 
@@ -364,17 +364,11 @@
   }
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    store i64 0, i64* %x, align 8
-    store i64 10101, i64* %y, align 8
-    %cast.0 = bitcast i64* %x to i8*
-    %cast.1 = bitcast i64* %y to i8*
-    %call.0 = call addrspace(0) i32 @memcmp(i8* %cast.0, i8* %cast.1, i64 8)
-    %cast.2 = bitcast i64* %x to i8*
-    %cast.3 = bitcast i64* %y to i8*
-    call addrspace(0) void @llvm.memmove.p0i8.p0i8.i64(i8* %cast.2, i8* %cast.3, i64 8, i1 false)
-    %cast.4 = bitcast i64* %y to i8*
-    %cast.5 = bitcast i64* %x to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* %cast.4, i8* %cast.5, i64 8, i1 false)
+    store i64 0, ptr %x, align 8
+    store i64 10101, ptr %y, align 8
+    %call.0 = call addrspace(0) i32 @memcmp(ptr %x, ptr %y, i64 8)
+    call addrspace(0) void @llvm.memmove.p0.p0.i64(ptr %x, ptr %y, i64 8, i1 false)
+    call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr %y, ptr %x, i64 8, i1 false)
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -425,10 +419,10 @@
   h.mkLocal("y", bi32t, call32);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %call.0 = call addrspace(0) i64 @syscall(i8* nest undef, i64 64)
-    store i64 %call.0, i64* %x, align 8
-    %call.1 = call addrspace(0) i32 bitcast (i64 (i8*, i64)* @syscall to i32 (i8*, i32)*)(i8* nest undef, i32 32)
-    store i32 %call.1, i32* %y, align 4
+    %call.0 = call addrspace(0) i64 @syscall(ptr nest undef, i64 64)
+    store i64 %call.0, ptr %x, align 8
+    %call.1 = call addrspace(0) i32 @syscall(ptr nest undef, i32 32)
+    store i32 %call.1, ptr %y, align 4
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -498,14 +492,14 @@
   h.mkLocal("y", bps1t, call4);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %call.0 = call addrspace(0) i32 @bar(i8* nest undef)
-    store i32 %call.0, i32* %a, align 4
-    %call.1 = call addrspace(0) i32 @bar(i8* nest undef)
-    store i32 %call.1, i32* %b, align 4
-    %call.2 = call addrspace(0) {}* bitcast ({ i32 }* (i8*)* @baz to {}* (i8*)*)(i8* nest undef)
-    store {}* %call.2, {}** %x, align 8
-    %call.3 = call addrspace(0) { i32 }* @baz(i8* nest undef)
-    store { i32 }* %call.3, { i32 }** %y, align 8
+    %call.0 = call addrspace(0) i32 @bar(ptr nest undef)
+    store i32 %call.0, ptr %a, align 4
+    %call.1 = call addrspace(0) i32 @bar(ptr nest undef)
+    store i32 %call.1, ptr %b, align 4
+    %call.2 = call addrspace(0) ptr @baz(ptr nest undef)
+    store ptr %call.2, ptr %x, align 8
+    %call.3 = call addrspace(0) ptr @baz(ptr nest undef)
+    store ptr %call.3, ptr %y, align 8
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);

diff --git a/unittests/BackendCore/BackendNodeTests.cpp b/unittests/BackendCore/BackendNodeTests.cpp
index 13a3a5a..9a9396c 100644
--- a/unittests/BackendCore/BackendNodeTests.cpp
+++ b/unittests/BackendCore/BackendNodeTests.cpp

@@ -92,36 +92,36 @@
   EXPECT_EQ(res1, matsub);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    node - pre 18
-    pre child + 18 15
-    node + pre 15
-    pre child const 15 1
+    node - pre 17
+    pre child + 17 14
+    node + pre 14
+    pre child const 14 1
     node const pre 1
     node const post 1
-    post child const 15 1
-    pre child deref 15 14
-    node deref pre 14
-    pre child var 14 8
+    post child const 14 1
+    pre child deref 14 13
+    node deref pre 13
+    pre child var 13 8
     node var pre 8
     node var post 8
-    post child var 14 8
-    node deref post 14
-    post child deref 15 14
-    node + post 15
-    post child + 18 15
-    pre child deref 18 17
-    node deref pre 17
+    post child var 13 8
+    node deref post 13
+    post child deref 14 13
+    node + post 14
+    post child + 17 14
     pre child deref 17 16
     node deref pre 16
-    pre child var 16 10
+    pre child deref 16 15
+    node deref pre 15
+    pre child var 15 10
     node var pre 10
     node var post 10
-    post child var 16 10
+    post child var 15 10
+    node deref post 15
+    post child deref 16 15
     node deref post 16
     post child deref 17 16
-    node deref post 17
-    post child deref 18 17
-    node - post 18
+    node - post 17
   )RAW_RESULT");
 
   std::string reason;
@@ -163,12 +163,12 @@
   EXPECT_NE(add, matclone);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %x.ld.0 = load i32, i32* %x, align 4
-    %z.ld.0 = load i16, i16* %z, align 2
+    %x.ld.0 = load i32, ptr %x, align 4
+    %z.ld.0 = load i16, ptr %z, align 2
     %sext.0 = sext i16 %z.ld.0 to i32
     %add.0 = add i32 %x.ld.0, %sext.0
-    %y.ld.0 = load i32*, i32** %y, align 8
-    %.ld.0 = load i32, i32* %y.ld.0, align 4
+    %y.ld.0 = load ptr, ptr %y, align 8
+    %.ld.0 = load i32, ptr %y.ld.0, align 4
     %add.1 = add i32 %add.0, %.ld.0
   )RAW_RESULT");
 
@@ -205,14 +205,14 @@
   Bexpression *matadd = be->materialize(add);
 
   DECLARE_EXPECTED_OUTPUT(exp2, R"RAW_RESULT(
-    %field.0 = getelementptr inbounds { { i32*, i32 }, { i32*, i32 } }, { { i32*, i32 }, { i32*, i32 } }* %x, i32 0, i32 0
-    %field.1 = getelementptr inbounds { i32*, i32 }, { i32*, i32 }* %field.0, i32 0, i32 0
-    %x.field.field.ld.0 = load i32*, i32** %field.1, align 8
-    %.ld.0 = load i32, i32* %x.field.field.ld.0, align 4
-    %field.2 = getelementptr inbounds { { i32*, i32 }, { i32*, i32 } }, { { i32*, i32 }, { i32*, i32 } }* %x, i32 0, i32 0
-    %field.3 = getelementptr inbounds { i32*, i32 }, { i32*, i32 }* %field.2, i32 0, i32 0
-    %.field.field.ld.0 = load i32*, i32** %field.3, align 8
-    %.ld.1 = load i32, i32* %.field.field.ld.0, align 4
+    %field.0 = getelementptr inbounds { { ptr, i32 }, { ptr, i32 } }, ptr %x, i32 0, i32 0
+    %field.1 = getelementptr inbounds { ptr, i32 }, ptr %field.0, i32 0, i32 0
+    %x.field.field.ld.0 = load ptr, ptr %field.1, align 8
+    %.ld.0 = load i32, ptr %x.field.field.ld.0, align 4
+    %field.2 = getelementptr inbounds { { ptr, i32 }, { ptr, i32 } }, ptr %x, i32 0, i32 0
+    %field.3 = getelementptr inbounds { ptr, i32 }, ptr %field.2, i32 0, i32 0
+    %.field.field.ld.0 = load ptr, ptr %field.3, align 8
+    %.ld.1 = load i32, ptr %.field.field.ld.0, align 4
     %add.0 = add i32 %.ld.0, %.ld.1
   )RAW_RESULT");
 

diff --git a/unittests/BackendCore/BackendPointerExprTests.cpp b/unittests/BackendCore/BackendPointerExprTests.cpp
index f5882ca..0de8d66 100644
--- a/unittests/BackendCore/BackendPointerExprTests.cpp
+++ b/unittests/BackendCore/BackendPointerExprTests.cpp

@@ -72,14 +72,14 @@
   }
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    store i64 10, i64* %y, align 8
-    store i64* null, i64** %x, align 8
-    store i64* %y, i64** %x, align 8
-    %x.ld.0 = load i64*, i64** %x, align 8
-    %.ld.0 = load i64, i64* %x.ld.0, align 8
-    store i64 %.ld.0, i64* %y, align 8
-    %x.ld.1 = load i64*, i64** %x, align 8
-    store i64 3, i64* %x.ld.1, align 8
+    store i64 10, ptr %y, align 8
+    store ptr null, ptr %x, align 8
+    store ptr %y, ptr %x, align 8
+    %x.ld.0 = load ptr, ptr %x, align 8
+    %.ld.0 = load i64, ptr %x.ld.0, align 8
+    store i64 %.ld.0, ptr %y, align 8
+    %x.ld.1 = load ptr, ptr %x, align 8
+    store i64 3, ptr %x.ld.1, align 8
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -130,16 +130,13 @@
   h.mkAssign(vex3, rvex3);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %cast.0 = bitcast { i64 }* %fdloc1 to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %cast.0, i8* align 8 bitcast ({ i64 }* @const.0 to i8*), i64 8, i1 false)
-    store { i64 }* %fdloc1, { i64 }** %fploc1, align 8
-    store { i64 (i8*, i32, i32, i64*)* }* null, { i64 (i8*, i32, i32, i64*)* }** %fploc2, align 8
-    %fploc1.ld.0 = load { i64 }*, { i64 }** %fploc1, align 8
-    %cast.1 = bitcast { i64 }* %fploc1.ld.0 to { i64 (i8*, i32, i32, i64*)* }*
-    store { i64 (i8*, i32, i32, i64*)* }* %cast.1, { i64 (i8*, i32, i32, i64*)* }** %fploc2, align 8
-    %fploc2.ld.0 = load { i64 (i8*, i32, i32, i64*)* }*, { i64 (i8*, i32, i32, i64*)* }** %fploc2, align 8
-    %cast.2 = bitcast { i64 (i8*, i32, i32, i64*)* }* %fploc2.ld.0 to { i64 }*
-    store { i64 }* %cast.2, { i64 }** %fploc1, align 8
+    call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 8 %fdloc1, ptr align 8 @const.0, i64 8, i1 false)
+    store ptr %fdloc1, ptr %fploc1, align 8
+    store ptr null, ptr %fploc2, align 8
+    %fploc1.ld.0 = load ptr, ptr %fploc1, align 8
+    store ptr %fploc1.ld.0, ptr %fploc2, align 8
+    %fploc2.ld.0 = load ptr, ptr %fploc2, align 8
+    store ptr %fploc2.ld.0, ptr %fploc1, align 8
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -157,7 +154,7 @@
   // Manufacture a nil pointer expression
   Bexpression *npe = be->nil_pointer_expression();
   DECLARE_EXPECTED_OUTPUT(exp1, R"RAW_RESULT(
-    i64* null
+    ptr null
   )RAW_RESULT");
   bool isOK = h.expectValue(npe->value(), exp1);
   EXPECT_TRUE(isOK && "Value does not have expected contents");
@@ -188,16 +185,16 @@
   }
 
   DECLARE_EXPECTED_OUTPUT(exp2, R"RAW_RESULT(
-    store i8 0, i8* %b1, align 1
-    store i8* null, i8** %pb1, align 8
-    %pb1.ld.0 = load i8*, i8** %pb1, align 8
-    %icmp.0 = icmp eq i8* %pb1.ld.0, null
+    store i8 0, ptr %b1, align 1
+    store ptr null, ptr %pb1, align 8
+    %pb1.ld.0 = load ptr, ptr %pb1, align 8
+    %icmp.0 = icmp eq ptr %pb1.ld.0, null
     %zext.0 = zext i1 %icmp.0 to i8
-    store i8 %zext.0, i8* %b1, align 1
-    %pb1.ld.1 = load i8*, i8** %pb1, align 8
-    %icmp.1 = icmp eq i8* null, %pb1.ld.1
+    store i8 %zext.0, ptr %b1, align 1
+    %pb1.ld.1 = load ptr, ptr %pb1, align 8
+    %icmp.1 = icmp eq ptr null, %pb1.ld.1
     %zext.1 = zext i1 %icmp.1 to i8
-    store i8 %zext.1, i8* %b1, align 1
+    store i8 %zext.1, ptr %b1, align 1
   )RAW_RESULT");
 
   bool isOK2 = h.expectBlock(exp2);
@@ -225,10 +222,9 @@
   h.mkLocal("y", bst, deref2);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %deref.ld.0 = load i32, i32* null, align 4
-    store i32 %deref.ld.0, i32* %x, align 4
-    %cast.2 = bitcast { i32, i32 }* %y to i8*
-    call addrspace(0) void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %cast.2, i8* align 4 null, i64 8, i1 false)
+    %deref.ld.0 = load i32, ptr null, align 4
+    store i32 %deref.ld.0, ptr %x, align 4
+    call addrspace(0) void @llvm.memcpy.p0.p0.i64(ptr align 4 %y, ptr align 4 null, i64 8, i1 false)
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -321,38 +317,31 @@
   }
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    store %CPT.0* null, %CPT.0** %cpv1, align 8
-    store %CPT.0* null, %CPT.0** %cpv2, align 8
-    %cast.0 = bitcast %CPT.0** %cpv2 to %CPT.0*
-    store %CPT.0* %cast.0, %CPT.0** %cpv1, align 8
-    %cast.1 = bitcast %CPT.0** %cpv1 to %CPT.0*
-    store %CPT.0* %cast.1, %CPT.0** %cpv2, align 8
-    store i8 0, i8* %b1, align 1
-    store i8 0, i8* %b2, align 1
-    store i8 0, i8* %b3, align 1
-    %cpv1.ld.0 = load %CPT.0*, %CPT.0** %cpv1, align 8
-    %cast.2 = bitcast %CPT.0** %cpv2 to %CPT.0***
-    %cpv2.ld.0 = load %CPT.0**, %CPT.0*** %cast.2, align 8
-    %.ld.0 = load %CPT.0*, %CPT.0** %cpv2.ld.0, align 8
-    %icmp.0 = icmp eq %CPT.0* %cpv1.ld.0, %.ld.0
+    store ptr null, ptr %cpv1, align 8
+    store ptr null, ptr %cpv2, align 8
+    store ptr %cpv2, ptr %cpv1, align 8
+    store ptr %cpv1, ptr %cpv2, align 8
+    store i8 0, ptr %b1, align 1
+    store i8 0, ptr %b2, align 1
+    store i8 0, ptr %b3, align 1
+    %cpv1.ld.0 = load ptr, ptr %cpv1, align 8
+    %cpv2.ld.0 = load ptr, ptr %cpv2, align 8
+    %.ld.0 = load ptr, ptr %cpv2.ld.0, align 8
+    %icmp.0 = icmp eq ptr %cpv1.ld.0, %.ld.0
     %zext.0 = zext i1 %icmp.0 to i8
-    store i8 %zext.0, i8* %b1, align 1
-    %cpv2.ld.1 = load %CPT.0*, %CPT.0** %cpv2, align 8
-    %cast.3 = bitcast %CPT.0* %cpv2.ld.1 to %CPT.0**
-    %icmp.1 = icmp eq %CPT.0** %cpv1, %cast.3
+    store i8 %zext.0, ptr %b1, align 1
+    %cpv2.ld.1 = load ptr, ptr %cpv2, align 8
+    %icmp.1 = icmp eq ptr %cpv1, %cpv2.ld.1
     %zext.1 = zext i1 %icmp.1 to i8
-    store i8 %zext.1, i8* %b2, align 1
-    %cpv1.ld.1 = load %CPT.0*, %CPT.0** %cpv1, align 8
-    %cast.4 = bitcast %CPT.0** %cpv2 to %CPT.0***
-    %cpv2.ld.2 = load %CPT.0**, %CPT.0*** %cast.4, align 8
-    %cast.5 = bitcast %CPT.0** %cpv2.ld.2 to %CPT.0***
-    %deref.ld.0 = load %CPT.0**, %CPT.0*** %cast.5, align 8
-    %cast.6 = bitcast %CPT.0** %deref.ld.0 to %CPT.0***
-    %deref.ld.1 = load %CPT.0**, %CPT.0*** %cast.6, align 8
-    %.ld.1 = load %CPT.0*, %CPT.0** %deref.ld.1, align 8
-    %icmp.2 = icmp eq %CPT.0* %cpv1.ld.1, %.ld.1
+    store i8 %zext.1, ptr %b2, align 1
+    %cpv1.ld.1 = load ptr, ptr %cpv1, align 8
+    %cpv2.ld.2 = load ptr, ptr %cpv2, align 8
+    %deref.ld.0 = load ptr, ptr %cpv2.ld.2, align 8
+    %deref.ld.1 = load ptr, ptr %deref.ld.0, align 8
+    %.ld.1 = load ptr, ptr %deref.ld.1, align 8
+    %icmp.2 = icmp eq ptr %cpv1.ld.1, %.ld.1
     %zext.2 = zext i1 %icmp.2 to i8
-    store i8 %zext.2, i8* %b3, align 1
+    store i8 %zext.2, ptr %b3, align 1
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -422,18 +411,17 @@
   }
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    store %CPT.0* null, %CPT.0** %x, align 8
-    store %CPT.0** null, %CPT.0*** %y, align 8
-    %cast.0 = bitcast %CPT.0*** %y to %CPT.0*
-    store %CPT.0* %cast.0, %CPT.0** %x, align 8
-    store %CPT.0** %x, %CPT.0*** %y, align 8
-    store i8 0, i8* %b1, align 1
-    %x.ld.0 = load %CPT.0*, %CPT.0** %x, align 8
-    %y.ld.0 = load %CPT.0**, %CPT.0*** %y, align 8
-    %.ld.0 = load %CPT.0*, %CPT.0** %y.ld.0, align 8
-    %icmp.0 = icmp eq %CPT.0* %x.ld.0, %.ld.0
+    store ptr null, ptr %x, align 8
+    store ptr null, ptr %y, align 8
+    store ptr %y, ptr %x, align 8
+    store ptr %x, ptr %y, align 8
+    store i8 0, ptr %b1, align 1
+    %x.ld.0 = load ptr, ptr %x, align 8
+    %y.ld.0 = load ptr, ptr %y, align 8
+    %.ld.0 = load ptr, ptr %y.ld.0, align 8
+    %icmp.0 = icmp eq ptr %x.ld.0, %.ld.0
     %zext.0 = zext i1 %icmp.0 to i8
-    store i8 %zext.0, i8* %b1, align 1
+    store i8 %zext.0, ptr %b1, align 1
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -477,14 +465,14 @@
   }
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %param3.ld.0 = load i64*, i64** %param3.addr, align 8
-    %ptroff.0 = getelementptr i64, i64* %param3.ld.0, i32 5
-    store i64 9, i64* %ptroff.0, align 8
-    %param3.ld.1 = load i64*, i64** %param3.addr, align 8
-    %ptroff.1 = getelementptr i64, i64* %param3.ld.1, i32 7
-    %.ptroff.ld.0 = load i64, i64* %ptroff.1, align 8
+    %param3.ld.0 = load ptr, ptr %param3.addr, align 8
+    %ptroff.0 = getelementptr i64, ptr %param3.ld.0, i32 5
+    store i64 9, ptr %ptroff.0, align 8
+    %param3.ld.1 = load ptr, ptr %param3.addr, align 8
+    %ptroff.1 = getelementptr i64, ptr %param3.ld.1, i32 7
+    %.ptroff.ld.0 = load i64, ptr %ptroff.1, align 8
     %trunc.0 = trunc i64 %.ptroff.ld.0 to i32
-    store i32 %trunc.0, i32* %param1.addr, align 4
+    store i32 %trunc.0, ptr %param1.addr, align 4
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -516,8 +504,8 @@
   h.mkAssign(vexl, ad3);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    store i64 0, i64* %x, align 8
-    store i64* %x, i64** %param3.addr, align 8
+    store i64 0, ptr %x, align 8
+    store ptr %x, ptr %param3.addr, align 8
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -569,8 +557,8 @@
   }
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    store i32 0, i32* inttoptr (i64 65793 to i32*), align 4
-    store i64 2, i64* getelementptr inbounds ({ i64, i64 }, { i64, i64 }* inttoptr (i64 34661 to { i64, i64 }*), i32 0, i32 1), align 8
+    store i32 0, ptr inttoptr (i64 65793 to ptr), align 4
+    store i64 2, ptr getelementptr inbounds ({ i64, i64 }, ptr inttoptr (i64 34661 to ptr), i32 0, i32 1), align 8
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);
@@ -622,9 +610,8 @@
   h.mkLocal("y", pbefty2);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    store i64 (i8*, i64, i64, %CFT.0*, %CFT.1*)* null, i64 (i8*, i64, i64, %CFT.0*, %CFT.1*)** %x, align 8
-    store i64 (i8*, i64, i64, %CFT.1*, %CFT.0*)* null, i64 (i8*, i64, i64, %CFT.1*, %CFT.0*)** %y, align 8
-
+    store ptr null, ptr %x, align 8
+    store ptr null, ptr %y, align 8
   )RAW_RESULT");
 
   bool isOK = h.expectBlock(exp);

diff --git a/unittests/BackendCore/BackendStmtTests.cpp b/unittests/BackendCore/BackendStmtTests.cpp
index 7e47928..c2661a9 100644
--- a/unittests/BackendCore/BackendStmtTests.cpp
+++ b/unittests/BackendCore/BackendStmtTests.cpp

@@ -40,7 +40,7 @@
   Bstatement *is = be->init_statement(func, loc1, mkInt64Const(be, 10));
   ASSERT_TRUE(is != nullptr);
   h.addStmt(is);
-  EXPECT_EQ(repr(is), "store i64 10, i64* %loc1, align 8");
+  EXPECT_EQ(repr(is), "store i64 10, ptr %loc1, align 8");
 
   // error handling
   Bvariable *loc2 = be->local_variable(func, "loc2", bi64t, nullptr, true, loc);
@@ -80,11 +80,11 @@
   h.addStmt(as2);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    store i64 0, i64* %loc1, align 8
-    store i64 123, i64* %loc1, align 8
-    store i64 0, i64* %loc2, align 8
-    %loc1.ld.0 = load i64, i64* %loc1, align 8
-    store i64 %loc1.ld.0, i64* %loc2, align 8
+    store i64 0, ptr %loc1, align 8
+    store i64 123, ptr %loc1, align 8
+    store i64 0, ptr %loc2, align 8
+    %loc1.ld.0 = load i64, ptr %loc1, align 8
+    store i64 %loc1.ld.0, ptr %loc2, align 8
   )RAW_RESULT");
   bool isOK = h.expectBlock(exp);
   EXPECT_TRUE(isOK && "Block does not have expected contents");
@@ -116,7 +116,7 @@
   Bstatement *ret = h.mkReturn(ve1);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    %loc1.ld.0 = load i64, i64* %loc1, align 8
+    %loc1.ld.0 = load i64, ptr %loc1, align 8
     ret i64 %loc1.ld.0
   )RAW_RESULT");
   std::string reason;
@@ -157,19 +157,19 @@
   h.mkReturn(addexpr);
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define i64 @foo(i8* nest %nest.0, i32 %param1, i32 %param2, i64* %param3) #0 {
-  entry:
-    %param1.addr = alloca i32, align 4
-    %param2.addr = alloca i32, align 4
-    %param3.addr = alloca i64*, align 8
-    %x = alloca i64, align 8
-    store i32 %param1, i32* %param1.addr, align 4
-    store i32 %param2, i32* %param2.addr, align 4
-    store i64* %param3, i64** %param3.addr, align 8
-    store i64 10, i64* %x, align 8
-    %x.ld.0 = load i64, i64* %x, align 8
-    ret i64 %x.ld.0
-  }
+    define i64 @foo(ptr nest %nest.0, i32 %param1, i32 %param2, ptr %param3) #0 {
+    entry:
+      %param1.addr = alloca i32, align 4
+      %param2.addr = alloca i32, align 4
+      %param3.addr = alloca ptr, align 8
+      %x = alloca i64, align 8
+      store i32 %param1, ptr %param1.addr, align 4
+      store i32 %param2, ptr %param2.addr, align 4
+      store ptr %param3, ptr %param3.addr, align 8
+      store i64 10, ptr %x, align 8
+      %x.ld.0 = load i64, ptr %x, align 8
+     ret i64 %x.ld.0
+    }
   )RAW_RESULT");
 
   bool broken = h.finish(StripDebugInfo);
@@ -240,17 +240,17 @@
   EXPECT_FALSE(broken && "Module failed to verify.");
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define void @foo(i8* nest %nest.0) #0 {
-  entry:
-    %loc1 = alloca i8, align 1
-    store i8 0, i8* %loc1, align 1
-    call void @bar(i8* nest undef, i8* blockaddress(@foo, %label.0))
-    br label %label.0
-  
-  label.0:                                          ; preds = %entry
-    store i8 0, i8* %loc1, align 1
-    ret void
-  }
+    define void @foo(ptr nest %nest.0) #0 {
+    entry:
+      %loc1 = alloca i8, align 1
+      store i8 0, ptr %loc1, align 1
+      call void @bar(ptr nest undef, ptr blockaddress(@foo, %label.0))
+      br label %label.0
+
+    label.0:                                          ; preds = %entry
+      store i8 0, ptr %loc1, align 1
+      ret void
+    }
   )RAW_RESULT");
 
   bool isOK = h.expectValue(func->function(), exp);
@@ -311,41 +311,41 @@
 
   // verify
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define i64 @foo(i8* nest %nest.0, i32 %param1, i32 %param2, i64* %param3) #0 {
-  entry:
-    %param1.addr = alloca i32, align 4
-    %param2.addr = alloca i32, align 4
-    %param3.addr = alloca i64*, align 8
-    %loc1 = alloca i64, align 8
-    %loc2 = alloca i64, align 8
-    store i32 %param1, i32* %param1.addr, align 4
-    store i32 %param2, i32* %param2.addr, align 4
-    store i64* %param3, i64** %param3.addr, align 8
-    store i64 0, i64* %loc1, align 8
-    store i64 0, i64* %loc2, align 8
-    br i1 true, label %then.0, label %else.0
-  
-  then.0:                                           ; preds = %entry
-    br i1 true, label %then.1, label %else.1
-  
-  fallthrough.0:                                    ; preds = %else.0, %fallthrough.1
-    ret i64 10101
-  
-  else.0:                                           ; preds = %entry
-    store i64 456, i64* %loc2, align 8
-    br label %fallthrough.0
-  
-  then.1:                                           ; preds = %then.0
-    store i64 123, i64* %loc1, align 8
-    br label %fallthrough.1
-  
-  fallthrough.1:                                    ; preds = %else.1, %then.1
-    br label %fallthrough.0
-  
-  else.1:                                           ; preds = %then.0
-    store i64 987, i64* %loc1, align 8
-    br label %fallthrough.1
-  }
+    define i64 @foo(ptr nest %nest.0, i32 %param1, i32 %param2, ptr %param3) #0 {
+    entry:
+      %param1.addr = alloca i32, align 4
+      %param2.addr = alloca i32, align 4
+      %param3.addr = alloca ptr, align 8
+      %loc1 = alloca i64, align 8
+      %loc2 = alloca i64, align 8
+      store i32 %param1, ptr %param1.addr, align 4
+      store i32 %param2, ptr %param2.addr, align 4
+      store ptr %param3, ptr %param3.addr, align 8
+      store i64 0, ptr %loc1, align 8
+      store i64 0, ptr %loc2, align 8
+      br i1 true, label %then.0, label %else.0
+
+    then.0:                                           ; preds = %entry
+      br i1 true, label %then.1, label %else.1
+
+    fallthrough.0:                                    ; preds = %else.0, %fallthrough.1
+      ret i64 10101
+
+    else.0:                                           ; preds = %entry
+      store i64 456, ptr %loc2, align 8
+      br label %fallthrough.0
+
+    then.1:                                           ; preds = %then.0
+      store i64 123, ptr %loc1, align 8
+      br label %fallthrough.1
+
+    fallthrough.1:                                    ; preds = %else.1, %then.1
+      br label %fallthrough.0
+
+    else.1:                                           ; preds = %then.0
+      store i64 987, ptr %loc1, align 8
+      br label %fallthrough.1
+    }
   )RAW_RESULT");
 
   bool isOK = h.expectValue(func->function(), exp);
@@ -435,65 +435,65 @@
 
   // verify
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define i64 @foo(i8* nest %nest.0, i32 %param1, i32 %param2, i64* %param3) #0 {
-  entry:
-    %param1.addr = alloca i32, align 4
-    %param2.addr = alloca i32, align 4
-    %param3.addr = alloca i64*, align 8
-    %loc1 = alloca i64, align 8
-    %tmpv.0 = alloca i64, align 8
-    store i32 %param1, i32* %param1.addr, align 4
-    store i32 %param2, i32* %param2.addr, align 4
-    store i64* %param3, i64** %param3.addr, align 8
-    store i64 0, i64* %loc1, align 8
-    %loc1.ld.4 = load i64, i64* %loc1, align 8
-    switch i64 %loc1.ld.4, label %default.0 [
-      i64 1, label %case.0
-      i64 2, label %case.0
-      i64 3, label %case.1
-      i64 4, label %case.1
-      i64 5, label %case.2
-    ]
-  
-  case.0:                                           ; preds = %entry, %entry
-    %loc1.ld.0 = load i64, i64* %loc1, align 8
-    %div.0 = sdiv i64 %loc1.ld.0, 123
-    store i64 %div.0, i64* %loc1, align 8
-    br label %label.0
-  
-  case.1:                                           ; preds = %entry, %entry
-    %loc1.ld.1 = load i64, i64* %loc1, align 8
-    %icmp.0 = icmp sle i64 %loc1.ld.1, 987
-    %zext.0 = zext i1 %icmp.0 to i8
-    %trunc.0 = trunc i8 %zext.0 to i1
-    br i1 %trunc.0, label %then.0, label %else.0
-  
-  case.2:                                           ; preds = %entry, %fallthrough.0
-    br label %default.0
-  
-  default.0:                                        ; preds = %entry, %case.2
-    store i64 456, i64* %loc1, align 8
-    br label %label.0
-  
-  label.0:                                          ; preds = %default.0, %case.0
-    ret i64 10101
-  
-  then.0:                                           ; preds = %case.1
-    %loc1.ld.3 = load i64, i64* %loc1, align 8
-    store i64 %loc1.ld.3, i64* %tmpv.0, align 8
-    br label %fallthrough.0
-  
-  fallthrough.0:                                    ; preds = %else.0, %then.0
-    %tmpv.0.ld.0 = load i64, i64* %tmpv.0, align 8
-    store i64 %tmpv.0.ld.0, i64* %loc1, align 8
-    br label %case.2
-  
-  else.0:                                           ; preds = %case.1
-    %loc1.ld.2 = load i64, i64* %loc1, align 8
-    %mul.0 = mul i64 987, %loc1.ld.2
-    store i64 %mul.0, i64* %tmpv.0, align 8
-    br label %fallthrough.0
-  }
+    define i64 @foo(ptr nest %nest.0, i32 %param1, i32 %param2, ptr %param3) #0 {
+    entry:
+      %param1.addr = alloca i32, align 4
+      %param2.addr = alloca i32, align 4
+      %param3.addr = alloca ptr, align 8
+      %loc1 = alloca i64, align 8
+      %tmpv.0 = alloca i64, align 8
+      store i32 %param1, ptr %param1.addr, align 4
+      store i32 %param2, ptr %param2.addr, align 4
+      store ptr %param3, ptr %param3.addr, align 8
+      store i64 0, ptr %loc1, align 8
+      %loc1.ld.4 = load i64, ptr %loc1, align 8
+      switch i64 %loc1.ld.4, label %default.0 [
+        i64 1, label %case.0
+        i64 2, label %case.0
+        i64 3, label %case.1
+        i64 4, label %case.1
+        i64 5, label %case.2
+      ]
+
+    case.0:                                           ; preds = %entry, %entry
+      %loc1.ld.0 = load i64, ptr %loc1, align 8
+      %div.0 = sdiv i64 %loc1.ld.0, 123
+      store i64 %div.0, ptr %loc1, align 8
+      br label %label.0
+
+    case.1:                                           ; preds = %entry, %entry
+      %loc1.ld.1 = load i64, ptr %loc1, align 8
+      %icmp.0 = icmp sle i64 %loc1.ld.1, 987
+      %zext.0 = zext i1 %icmp.0 to i8
+      %trunc.0 = trunc i8 %zext.0 to i1
+      br i1 %trunc.0, label %then.0, label %else.0
+
+    case.2:                                           ; preds = %entry, %fallthrough.0
+      br label %default.0
+
+    default.0:                                        ; preds = %entry, %case.2
+      store i64 456, ptr %loc1, align 8
+      br label %label.0
+
+    label.0:                                          ; preds = %default.0, %case.0
+      ret i64 10101
+
+    then.0:                                           ; preds = %case.1
+      %loc1.ld.3 = load i64, ptr %loc1, align 8
+      store i64 %loc1.ld.3, ptr %tmpv.0, align 8
+      br label %fallthrough.0
+
+    fallthrough.0:                                    ; preds = %else.0, %then.0
+      %tmpv.0.ld.0 = load i64, ptr %tmpv.0, align 8
+      store i64 %tmpv.0.ld.0, ptr %loc1, align 8
+      br label %case.2
+
+    else.0:                                           ; preds = %case.1
+      %loc1.ld.2 = load i64, ptr %loc1, align 8
+      %mul.0 = mul i64 987, %loc1.ld.2
+      store i64 %mul.0, ptr %tmpv.0, align 8
+      br label %fallthrough.0
+    }
   )RAW_RESULT");
 
   bool isOK = h.expectValue(func->function(), exp);
@@ -584,28 +584,28 @@
   EXPECT_FALSE(broken && "Module failed to verify.");
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define void @foo(i8* nest %nest.0) #0 personality i32 (i32, i32, i64, i8*, i8*)* @__gccgo_personality_v0 {
-  entry:
-    %x = alloca i8, align 1
-    store i8 0, i8* %x, align 1
-    br label %finish.0
-  
-  pad.0:                                            ; preds = %finish.0
-    %ex.0 = landingpad { i8*, i32 }
-            catch i8* null
-    br label %catch.0
-  
-  catch.0:                                          ; preds = %pad.0
-    call void @checkdefer(i8* nest undef, i8* %x)
-    br label %finish.0
-  
-  finish.0:                                         ; preds = %catch.0, %entry
-    invoke void @deferreturn(i8* nest undef, i8* %x)
-            to label %cont.0 unwind label %pad.0
-  
-  cont.0:                                           ; preds = %finish.0
-    ret void
-  }
+    define void @foo(ptr nest %nest.0) #0 personality ptr @__gccgo_personality_v0 {
+    entry:
+      %x = alloca i8, align 1
+      store i8 0, ptr %x, align 1
+      br label %finish.0
+
+    pad.0:                                            ; preds = %finish.0
+      %ex.0 = landingpad { ptr, i32 }
+              catch ptr null
+      br label %catch.0
+
+    catch.0:                                          ; preds = %pad.0
+      call void @checkdefer(ptr nest undef, ptr %x)
+      br label %finish.0
+
+    finish.0:                                         ; preds = %catch.0, %entry
+      invoke void @deferreturn(ptr nest undef, ptr %x)
+              to label %cont.0 unwind label %pad.0
+
+    cont.0:                                           ; preds = %finish.0
+      ret void
+    }
   )RAW_RESULT");
 
   bool isOK = h.expectValue(func->function(), exp);
@@ -697,94 +697,94 @@
   EXPECT_FALSE(broken && "Module failed to verify.");
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define void @baz(i8* nest %nest.0) #0 personality i32 (i32, i32, i64, i8*, i8*)* @__gccgo_personality_v0 {
-  entry:
-    %ehtmp.0 = alloca { i8*, i32 }, align 8
-    %x = alloca i64, align 8
-    %y = alloca i8, align 1
-    %sret.actual.0 = alloca { i8, i8 }, align 1
-    %sret.actual.1 = alloca { i8, i8 }, align 1
-    %finvar.0 = alloca i8, align 1
-    store i64 0, i64* %x, align 8
-    store i8 0, i8* %y, align 1
-    %call.0 = invoke i64 @id(i8* nest undef, i64 99)
-            to label %cont.1 unwind label %pad.1
-  
-  finok.0:                                          ; preds = %cont.4
-    store i8 1, i8* %finvar.0, align 1
-    br label %finally.0
-  
-  finally.0:                                        ; preds = %catchpad.0, %finok.0
-    br label %finish.0
-  
-  pad.0:                                            ; preds = %fallthrough.0, %finish.0
-    %ex.0 = landingpad { i8*, i32 }
-            catch i8* null
-    br label %catch.0
-  
-  catch.0:                                          ; preds = %pad.0
-    call void @checkdefer(i8* nest undef, i8* %y)
-    br label %finish.0
-  
-  finish.0:                                         ; preds = %catch.0, %finally.0
-    invoke void @deferreturn(i8* nest undef, i8* %y)
-            to label %cont.0 unwind label %pad.0
-  
-  cont.0:                                           ; preds = %fallthrough.0, %finish.0
-    %fload.0 = load i8, i8* %finvar.0, align 1
-    %icmp.0 = icmp eq i8 %fload.0, 1
-    br i1 %icmp.0, label %finret.0, label %finres.0
-  
-  pad.1:                                            ; preds = %then.0, %cont.1, %entry
-    %ex.1 = landingpad { i8*, i32 }
-            catch i8* null
-    br label %catch.1
-  
-  catch.1:                                          ; preds = %pad.1
-    invoke void @plix(i8* nest undef)
-            to label %cont.4 unwind label %catchpad.0
-  
-  catchpad.0:                                       ; preds = %catch.1
-    %ex2.0 = landingpad { i8*, i32 }
-            cleanup
-    store { i8*, i32 } %ex2.0, { i8*, i32 }* %ehtmp.0, align 8
-    store i8 0, i8* %finvar.0, align 1
-    br label %finally.0
-  
-  cont.1:                                           ; preds = %entry
-    store i64 %call.0, i64* %x, align 8
-    invoke void @plark(i8* nest undef)
-            to label %cont.2 unwind label %pad.1
-  
-  cont.2:                                           ; preds = %cont.1
-    br i1 false, label %then.0, label %else.0
-  
-  then.0:                                           ; preds = %cont.2
-    %call.1 = invoke i16 @noret(i8* nest undef)
-            to label %cont.3 unwind label %pad.1
-  
-  fallthrough.0:                                    ; preds = %else.0
-    store i64 123, i64* %x, align 8
-    store i8 1, i8* %finvar.0, align 1
-    invoke void @deferreturn(i8* nest undef, i8* %y)
-            to label %cont.0 unwind label %pad.0
-  
-  else.0:                                           ; preds = %cont.2
-    br label %fallthrough.0
-  
-  cont.3:                                           ; preds = %then.0
-    unreachable
-  
-  cont.4:                                           ; preds = %catch.1
-    br label %finok.0
-  
-  finres.0:                                         ; preds = %cont.0
-    %excv.0 = load { i8*, i32 }, { i8*, i32 }* %ehtmp.0, align 8
-    resume { i8*, i32 } %excv.0
-  
-  finret.0:                                         ; preds = %cont.0
-    ret void
-  }
+    define void @baz(ptr nest %nest.0) #0 personality ptr @__gccgo_personality_v0 {
+    entry:
+      %ehtmp.0 = alloca { ptr, i32 }, align 8
+      %x = alloca i64, align 8
+      %y = alloca i8, align 1
+      %sret.actual.0 = alloca { i8, i8 }, align 1
+      %sret.actual.1 = alloca { i8, i8 }, align 1
+      %finvar.0 = alloca i8, align 1
+      store i64 0, ptr %x, align 8
+      store i8 0, ptr %y, align 1
+      %call.0 = invoke i64 @id(ptr nest undef, i64 99)
+              to label %cont.1 unwind label %pad.1
+
+    finok.0:                                          ; preds = %cont.4
+      store i8 1, ptr %finvar.0, align 1
+      br label %finally.0
+
+    finally.0:                                        ; preds = %catchpad.0, %finok.0
+      br label %finish.0
+
+    pad.0:                                            ; preds = %fallthrough.0, %finish.0
+      %ex.0 = landingpad { ptr, i32 }
+              catch ptr null
+      br label %catch.0
+
+    catch.0:                                          ; preds = %pad.0
+      call void @checkdefer(ptr nest undef, ptr %y)
+      br label %finish.0
+
+    finish.0:                                         ; preds = %catch.0, %finally.0
+      invoke void @deferreturn(ptr nest undef, ptr %y)
+              to label %cont.0 unwind label %pad.0
+
+    cont.0:                                           ; preds = %fallthrough.0, %finish.0
+      %fload.0 = load i8, ptr %finvar.0, align 1
+      %icmp.0 = icmp eq i8 %fload.0, 1
+      br i1 %icmp.0, label %finret.0, label %finres.0
+
+    pad.1:                                            ; preds = %then.0, %cont.1, %entry
+      %ex.1 = landingpad { ptr, i32 }
+              catch ptr null
+      br label %catch.1
+
+    catch.1:                                          ; preds = %pad.1
+      invoke void @plix(ptr nest undef)
+              to label %cont.4 unwind label %catchpad.0
+
+    catchpad.0:                                       ; preds = %catch.1
+      %ex2.0 = landingpad { ptr, i32 }
+              cleanup
+      store { ptr, i32 } %ex2.0, ptr %ehtmp.0, align 8
+      store i8 0, ptr %finvar.0, align 1
+      br label %finally.0
+
+    cont.1:                                           ; preds = %entry
+      store i64 %call.0, ptr %x, align 8
+      invoke void @plark(ptr nest undef)
+              to label %cont.2 unwind label %pad.1
+
+    cont.2:                                           ; preds = %cont.1
+      br i1 false, label %then.0, label %else.0
+
+    then.0:                                           ; preds = %cont.2
+      %call.1 = invoke i16 @noret(ptr nest undef)
+              to label %cont.3 unwind label %pad.1
+
+    fallthrough.0:                                    ; preds = %else.0
+      store i64 123, ptr %x, align 8
+      store i8 1, ptr %finvar.0, align 1
+      invoke void @deferreturn(ptr nest undef, ptr %y)
+              to label %cont.0 unwind label %pad.0
+
+    else.0:                                           ; preds = %cont.2
+      br label %fallthrough.0
+
+    cont.3:                                           ; preds = %then.0
+      unreachable
+
+    cont.4:                                           ; preds = %catch.1
+      br label %finok.0
+
+    finres.0:                                         ; preds = %cont.0
+      %excv.0 = load { ptr, i32 }, ptr %ehtmp.0, align 8
+      resume { ptr, i32 } %excv.0
+
+    finret.0:                                         ; preds = %cont.0
+      ret void
+    }
   )RAW_RESULT");
 
   bool isOK = h.expectValue(func->function(), exp);
@@ -886,90 +886,91 @@
   EXPECT_FALSE(broken && "Module failed to verify.");
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define i64 @baz(i8* nest %nest.0, i64 %p0) #0 personality i32 (i32, i32, i64, i8*, i8*)* @__gccgo_personality_v0 {
-  entry:
-    %ehtmp.0 = alloca { i8*, i32 }, align 8
-    %p0.addr = alloca i64, align 8
-    %ret = alloca i64, align 8
-    %x = alloca i8, align 1
-    %finvar.0 = alloca i8, align 1
-    store i64 %p0, i64* %p0.addr, align 8
-    store i64 0, i64* %ret, align 8
-    store i8 0, i8* %x, align 1
-    %call.0 = invoke i64 @splat(i8* nest undef, i64 99)
-            to label %cont.1 unwind label %pad.1
-  
-  finok.0:                                          ; preds = %cont.2
-    store i8 1, i8* %finvar.0, align 1
-    br label %finally.0
-  
-  finally.0:                                        ; preds = %catchpad.0, %finok.0
-    br label %finish.0
-  
-  pad.0:                                            ; preds = %else.0, %then.0, %finish.0
-    %ex.0 = landingpad { i8*, i32 }
-            catch i8* null
-    br label %catch.0
-  
-  catch.0:                                          ; preds = %pad.0
-    call void @checkdefer(i8* nest undef, i8* %x)
-    br label %finish.0
-  
-  finish.0:                                         ; preds = %catch.0, %finally.0
-    invoke void @deferreturn(i8* nest undef, i8* %x)
-            to label %cont.0 unwind label %pad.0
-  
-  cont.0:                                           ; preds = %else.0, %then.0, %finish.0
-    %fload.0 = load i8, i8* %finvar.0, align 1
-    %icmp.1 = icmp eq i8 %fload.0, 1
-    br i1 %icmp.1, label %finret.0, label %finres.0
-  
-  pad.1:                                            ; preds = %entry
-    %ex.1 = landingpad { i8*, i32 }
-            catch i8* null
-    br label %catch.1
-  
-  catch.1:                                          ; preds = %pad.1
-    %call.1 = invoke i64 @splat(i8* nest undef, i64 13)
-            to label %cont.2 unwind label %catchpad.0
-  
-  catchpad.0:                                       ; preds = %catch.1
-    %ex2.0 = landingpad { i8*, i32 }
-            cleanup
-    store { i8*, i32 } %ex2.0, { i8*, i32 }* %ehtmp.0, align 8
-    store i8 0, i8* %finvar.0, align 1
-    br label %finally.0
-  
-  cont.1:                                           ; preds = %entry
-    %icmp.0 = icmp eq i64 %call.0, 88
-    %zext.0 = zext i1 %icmp.0 to i8
-    %trunc.0 = trunc i8 %zext.0 to i1
-    br i1 %trunc.0, label %then.0, label %else.0
-  
-  then.0:                                           ; preds = %cont.1
-    store i64 22, i64* %ret, align 8
-    store i8 1, i8* %finvar.0, align 1
-    invoke void @deferreturn(i8* nest undef, i8* %x)
-            to label %cont.0 unwind label %pad.0
-  
-  else.0:                                           ; preds = %cont.1
-    %p0.ld.0 = load i64, i64* %p0.addr, align 8
-    store i64 %p0.ld.0, i64* %ret, align 8
-    store i8 1, i8* %finvar.0, align 1
-    invoke void @deferreturn(i8* nest undef, i8* %x)
-            to label %cont.0 unwind label %pad.0
-  
-  cont.2:                                           ; preds = %catch.1
-    br label %finok.0
-  
-  finres.0:                                         ; preds = %cont.0
-    %excv.0 = load { i8*, i32 }, { i8*, i32 }* %ehtmp.0, align 8
-    resume { i8*, i32 } %excv.0
-  
-  finret.0:                                         ; preds = %cont.0
-    %ret.ld.1 = load i64, i64* %ret, align 8
-    ret i64 %ret.ld.1
-  }
+    define i64 @baz(ptr nest %nest.0, i64 %p0) #0 personality ptr @__gccgo_personality_v0 {
+    entry:
+      %ehtmp.0 = alloca { ptr, i32 }, align 8
+      %p0.addr = alloca i64, align 8
+      %ret = alloca i64, align 8
+      %x = alloca i8, align 1
+      %finvar.0 = alloca i8, align 1
+      store i64 %p0, ptr %p0.addr, align 8
+      store i64 0, ptr %ret, align 8
+      store i8 0, ptr %x, align 1
+      %call.0 = invoke i64 @splat(ptr nest undef, i64 99)
+              to label %cont.1 unwind label %pad.1
+
+    finok.0:                                          ; preds = %cont.2
+      store i8 1, ptr %finvar.0, align 1
+      br label %finally.0
+
+    finally.0:                                        ; preds = %catchpad.0, %finok.0
+      br label %finish.0
+
+    pad.0:                                            ; preds = %else.0, %then.0, %finish.0
+      %ex.0 = landingpad { ptr, i32 }
+              catch ptr null
+      br label %catch.0
+
+    catch.0:                                          ; preds = %pad.0
+      call void @checkdefer(ptr nest undef, ptr %x)
+      br label %finish.0
+
+    finish.0:                                         ; preds = %catch.0, %finally.0
+      invoke void @deferreturn(ptr nest undef, ptr %x)
+              to label %cont.0 unwind label %pad.0
+
+    cont.0:                                           ; preds = %else.0, %then.0, %finish.0
+      %fload.0 = load i8, ptr %finvar.0, align 1
+      %icmp.1 = icmp eq i8 %fload.0, 1
+      br i1 %icmp.1, label %finret.0, label %finres.0
+
+    pad.1:                                            ; preds = %entry
+      %ex.1 = landingpad { ptr, i32 }
+              catch ptr null
+      br label %catch.1
+
+    catch.1:                                          ; preds = %pad.1
+      %call.1 = invoke i64 @splat(ptr nest undef, i64 13)
+              to label %cont.2 unwind label %catchpad.0
+
+    catchpad.0:                                       ; preds = %catch.1
+      %ex2.0 = landingpad { ptr, i32 }
+              cleanup
+      store { ptr, i32 } %ex2.0, ptr %ehtmp.0, align 8
+      store i8 0, ptr %finvar.0, align 1
+      br label %finally.0
+
+    cont.1:                                           ; preds = %entry
+      %icmp.0 = icmp eq i64 %call.0, 88
+
+      %zext.0 = zext i1 %icmp.0 to i8
+      %trunc.0 = trunc i8 %zext.0 to i1
+      br i1 %trunc.0, label %then.0, label %else.0
+
+    then.0:                                           ; preds = %cont.1
+      store i64 22, ptr %ret, align 8
+      store i8 1, ptr %finvar.0, align 1
+      invoke void @deferreturn(ptr nest undef, ptr %x)
+              to label %cont.0 unwind label %pad.0
+
+    else.0:                                           ; preds = %cont.1
+      %p0.ld.0 = load i64, ptr %p0.addr, align 8
+      store i64 %p0.ld.0, ptr %ret, align 8
+      store i8 1, ptr %finvar.0, align 1
+      invoke void @deferreturn(ptr nest undef, ptr %x)
+              to label %cont.0 unwind label %pad.0
+
+    cont.2:                                           ; preds = %catch.1
+      br label %finok.0
+
+    finres.0:                                         ; preds = %cont.0
+      %excv.0 = load { ptr, i32 }, ptr %ehtmp.0, align 8
+      resume { ptr, i32 } %excv.0
+
+    finret.0:                                         ; preds = %cont.0
+      %ret.ld.1 = load i64, ptr %ret, align 8
+      ret i64 %ret.ld.1
+    }
   )RAW_RESULT");
 
   bool isOK = h.expectValue(func->function(), exp);

diff --git a/unittests/BackendCore/BackendVarTests.cpp b/unittests/BackendCore/BackendVarTests.cpp
index 526cd9d..48da657 100644
--- a/unittests/BackendCore/BackendVarTests.cpp
+++ b/unittests/BackendCore/BackendVarTests.cpp

@@ -66,7 +66,7 @@
   ASSERT_TRUE(ve2 != nullptr);
   Bstatement *es = h.mkExprStmt(ve2);
   EXPECT_EQ(repr(ve2->value()), "%loc1 = alloca i64, align 8");
-  EXPECT_EQ(repr(es), "%loc1.ld.0 = load i64, i64* %loc1, align 8");
+  EXPECT_EQ(repr(es), "%loc1.ld.0 = load i64, ptr %loc1, align 8");
 
   // Make sure error detection is working
   Bvariable *loce = be->local_variable(func1, "", be->error_type(), nullptr,
@@ -159,7 +159,7 @@
                                            false, loc, &inits);
   ASSERT_TRUE(tvar != nullptr);
   ASSERT_TRUE(inits != nullptr);
-  EXPECT_EQ(repr(inits), "store i64 64, i64* %tmpv.0, align 8");
+  EXPECT_EQ(repr(inits), "store i64 64, ptr %tmpv.0, align 8");
 
   h.addStmt(inits);
 
@@ -302,8 +302,7 @@
 
   {
     DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-      @desc = internal constant { i64 } { i64 ptrtoint
-      (i64 (i8*, i32, i32, i64*)* @foo to i64) }
+      @desc = internal constant { i64 } { i64 ptrtoint (ptr @foo to i64) }
     )RAW_RESULT");
 
     bool isOK = h.expectValue(ims->value(), exp);
@@ -460,8 +459,7 @@
   ASSERT_TRUE(gv != nullptr);
   EXPECT_TRUE(isa<GlobalVariable>(gv->value()));
   EXPECT_EQ(repr(gv->value()), "@x = global { i32 } zeroinitializer");
-  EXPECT_EQ(repr(gvdecl->value()),
-            "i32* getelementptr inbounds ({ i32 }, { i32 }* @x, i32 0, i32 0)");
+  EXPECT_EQ(repr(gvdecl->value()), "@x = global { i32 } zeroinitializer");
 
   // Create them in the other order: definition first,
   // then external declaration.
@@ -478,8 +476,7 @@
   ASSERT_TRUE(gvdecl2 != nullptr);
   EXPECT_TRUE(isa<GlobalVariable>(gv2->value()));
   EXPECT_EQ(repr(gv2->value()), "@y = global { i32 } zeroinitializer");
-  EXPECT_EQ(repr(gvdecl2->value()),
-      "i32* getelementptr inbounds ({ i32 }, { i32 }* @y, i32 0, i32 0)");
+  EXPECT_EQ(repr(gvdecl2->value()), "@y = global { i32 } zeroinitializer");
 
   bool broken = h.finish(PreserveDebugInfo);
   EXPECT_FALSE(broken && "Module failed to verify.");
@@ -519,26 +516,21 @@
   EXPECT_FALSE(broken && "Module failed to verify.");
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define void @foo(i8* nest %nest.0) #0 {
-  entry:
-    %x = alloca i32, align 4
-    %y = alloca { i32, i32 }, align 4
-    %0 = bitcast i32* %x to i8*
-    call void @llvm.lifetime.start.p0i8(i64 4, i8* %0)
-    %1 = bitcast { i32, i32 }* %y to i8*
-    call void @llvm.lifetime.start.p0i8(i64 8, i8* %1)
-    store i32 0, i32* %x, align 4
-    %cast.0 = bitcast { i32, i32 }* %y to i8*
-    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %cast.0, i8* align 4 bitcast ({ i32, i32 }* @const.0 to i8*), i64 8, i1 false)
-    %field.0 = getelementptr inbounds { i32, i32 }, { i32, i32 }* %y, i32 0, i32 1
-    %y.field.ld.0 = load i32, i32* %field.0, align 4
-    store i32 %y.field.ld.0, i32* %x, align 4
-    %2 = bitcast i32* %x to i8*
-    call void @llvm.lifetime.end.p0i8(i64 4, i8* %2)
-    %3 = bitcast { i32, i32 }* %y to i8*
-    call void @llvm.lifetime.end.p0i8(i64 8, i8* %3)
-    ret void
-  }
+    define void @foo(ptr nest %nest.0) #0 {
+    entry:
+      %x = alloca i32, align 4
+      %y = alloca { i32, i32 }, align 4
+      call void @llvm.lifetime.start.p0(i64 4, ptr %x)
+      call void @llvm.lifetime.start.p0(i64 8, ptr %y)
+      store i32 0, ptr %x, align 4
+      call void @llvm.memcpy.p0.p0.i64(ptr align 4 %y, ptr align 4 @const.0, i64 8, i1 false)
+      %field.0 = getelementptr inbounds { i32, i32 }, ptr %y, i32 0, i32 1
+      %y.field.ld.0 = load i32, ptr %field.0, align 4
+      store i32 %y.field.ld.0, ptr %x, align 4
+      call void @llvm.lifetime.end.p0(i64 4, ptr %x)
+      call void @llvm.lifetime.end.p0(i64 8, ptr %y)
+      ret void
+    }
   )RAW_RESULT");
 
   bool isOK = h.expectValue(func->function(), exp);
@@ -659,12 +651,12 @@
   EXPECT_FALSE(broken && "Module failed to verify.");
 
   DECLARE_EXPECTED_OUTPUT(exp, R"RAW_RESULT(
-    define void @foo(i8* nest %nest.0) #0 {
-  entry:
-    %localemptys2f = alloca { {}, {} }, align 1
-    %localemptyintar = alloca [0 x i32], align 4
-    ret void
-  }
+    define void @foo(ptr nest %nest.0) #0 {
+    entry:
+      %localemptys2f = alloca { {}, {} }, align 1
+      %localemptyintar = alloca [0 x i32], align 4
+      ret void
+    }
   )RAW_RESULT");
   bool isOK = h.expectValue(func->function(), exp);
   EXPECT_TRUE(isOK && "Value does not have expected contents");
@@ -711,7 +703,7 @@
 
   // Expect to see only one lifetime start, since A) loc1 is at the top
   // level, and B) loc2 uses loc1 as declVar.
-  const char *expected = "call void @llvm.lifetime.start.p0i8(i64";
+  const char *expected = "call void @llvm.lifetime.start.p0(i64";
   EXPECT_EQ(h.countInstancesInModuleDump(expected), 1u);
 }
 

diff --git a/unittests/BackendCore/TestUtils.h b/unittests/BackendCore/TestUtils.h
index fa6774e..14dc355 100644
--- a/unittests/BackendCore/TestUtils.h
+++ b/unittests/BackendCore/TestUtils.h

@@ -10,8 +10,10 @@
 #define GOLLVM_UNITTESTS_BACKENDCORE_TESTUTILS_H
 
 #include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/Function.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/Value.h"
 #include "llvm/IR/Verifier.h"

diff --git a/unittests/Driver/DriverTests.cpp b/unittests/Driver/DriverTests.cpp
index 80ddcc2..93bd287 100644
--- a/unittests/Driver/DriverTests.cpp
+++ b/unittests/Driver/DriverTests.cpp

@@ -56,7 +56,7 @@
   std::unique_ptr<opt::OptTable> opts =
       gollvm::options::createGollvmDriverOptTable();
   unsigned missingArgIndex, missingArgCount;
-  ArrayRef<const char *> argvv = makeArrayRef(args_);
+  ArrayRef<const char *> argvv(args_);
   opt::InputArgList args =
       opts->ParseArgs(argvv, missingArgIndex, missingArgCount);
 

diff --git a/unittests/TestUtils/DiffUtils.cpp b/unittests/TestUtils/DiffUtils.cpp
index 98786d7..e4d8a7e 100644
--- a/unittests/TestUtils/DiffUtils.cpp
+++ b/unittests/TestUtils/DiffUtils.cpp

@@ -30,9 +30,9 @@
 // ending line (20). Which one will matter for the machinery that does
 // test remastering.
 static bool macroLineAtStart() {
-  if (baseline.line == 16) {
+  if (baseline.line == 17) {
     return true;
-  } else if (baseline.line == 20) {
+  } else if (baseline.line == 21) {
     return false;
   } else {
     assert(false && "macroLineAtStart broken -- source edited?");