diff --git a/README.md b/README.md
index 8a98ebf..b9881fa 100644
--- a/README.md
+++ b/README.md
@@ -264,7 +264,7 @@
 
 ## Which architectures and operating systems are supported for gollvm? <a name="supported"></a>
 
-Gollvm is currently supported only for x86_64 Linux.
+Gollvm is currently supported only for x86_64 and aarch64 Linux.
 
 ## How does the gollvm runtime differ from the main Go runtime?  <a name="runtimediffs"></a>
 
diff --git a/bridge/go-llvm-bfunction.cpp b/bridge/go-llvm-bfunction.cpp
index 5afdcaa..2dc331b 100644
--- a/bridge/go-llvm-bfunction.cpp
+++ b/bridge/go-llvm-bfunction.cpp
@@ -132,7 +132,8 @@
       case ParmIndirect: {
         paramValues_.push_back(arguments_[argIdx]);
         assert(paramInfo.numArgSlots() == 1);
-        arguments_[argIdx]->addAttr(llvm::Attribute::ByVal);
+        if (paramInfo.attr() == AttrByVal)
+          arguments_[argIdx]->addAttr(llvm::Attribute::ByVal);
         argIdx += 1;
         break;
       }
diff --git a/bridge/go-llvm-cabi-oracle.cpp b/bridge/go-llvm-cabi-oracle.cpp
index b5d870b..45c2406 100644
--- a/bridge/go-llvm-cabi-oracle.cpp
+++ b/bridge/go-llvm-cabi-oracle.cpp
@@ -22,7 +22,16 @@
 // need to be passed in an integer or SSE register (or if it is
 // some combination of entirely empty structs/arrays).
 
-enum TypDisp { FlavSSE, FlavInt, FlavEmpty };
+enum TypDisp { FlavSSE, FlavSIMDFP, FlavInt, FlavEmpty };
+
+// Arm64 ABI AAPCS64 defines HFA as follows:
+// An Homogeneous Floating-point Aggregate (HFA) is an Homogeneous Aggregate with
+// a Fundamental Data Type that is a Floating-Point type and at most four uniquely
+// addressable members.
+struct HFAInfo {
+  unsigned number;
+  llvm::Type *type;
+};
 
 // Here "meet" is in the dataflow anlysis sense (meet operator on lattice
 // values).
@@ -59,6 +68,8 @@
 // elements relative to the start of the object; "abiDirectType" holds
 // the type used to pass the elements if we're passing the entire
 // object directly (in registers) as opposed in on the stack.
+//
+// Implementation of Arm64 ABI AAPCS64 reused this struct.
 
 struct EightByteRegion {
   EightByteRegion() : abiDirectType(nullptr), attr(AttrNone) { }
@@ -111,18 +122,22 @@
   EightByteInfo(Btype *bt, TypeManager *tm);
 
   std::vector<EightByteRegion> &regions() { return ebrs_; }
+  HFAInfo &getHFA() { return hfa_; }
   void getRegisterRequirements(unsigned *numInt, unsigned *numSSE);
 
  private:
   std::vector<EightByteRegion> ebrs_;
+  HFAInfo hfa_;
   TypeManager *typeManager_;
 
   typedef std::pair<Btype *, unsigned> typAndOffset;
   void addLeafTypes(Btype *bt, unsigned off, std::vector<typAndOffset> *leaves);
   void explode(Btype *bt);
+  void setHFA();
   void explodeStruct(Btype *bst);
   void explodeArray(BArrayType *bat);
   void incorporateScalar(Btype *bt);
+  void determineABITypesForARM_AAPCS();
   void determineABITypesForX86_64_SysV();
   TypeManager *tm() const { return typeManager_; }
 };
@@ -136,6 +151,13 @@
   case llvm::CallingConv::X86_64_SysV:
     determineABITypesForX86_64_SysV();
     break;
+  case llvm::CallingConv::ARM_AAPCS:
+    setHFA();
+    if (getHFA().number == 0 && tmgr->typeSize(bt) <= 16) {
+      // For HFA and indirect cases, we don't need do this.
+      determineABITypesForARM_AAPCS();
+    }
+    break;
   default:
     llvm::errs() << "unsupported llvm::CallingConv::ID " << cconv << "\n";
     break;
@@ -199,7 +221,7 @@
   leaves->push_back(std::make_pair(bt, offset));
 }
 
-// Given a struct type, explode it into 0, 1, or two EightByteRegion
+// Given a struct type, explode it into zero, one or multiple EightByteRegion
 // descriptors. Examples of the contents of EightByteInfo structs
 // for various Go types follow. The first type (empty struct) results
 // in a single EightByteRegion struct with empty vectors. The second
@@ -245,7 +267,7 @@
   }
 }
 
-// Given an array type, explode it into 0, 1, or two EightByteInfo
+// Given an array type, explode it into zero, one or multiple EightByteInfo
 // descriptors. Examples appear below; the first array type results
 // in a single EightByteInfo with empty type/offset vectors, then the second
 // array type results in a single EightByteInfo, and the thrd array
@@ -323,6 +345,79 @@
       *numInt += 1;
 }
 
+// Check if the parameter is an Homogeneous Floating-point Aggregates (HFA),
+// and set hfa_ according to the result.
+void EightByteInfo::setHFA() {
+  if (ebrs_.empty()) {
+    hfa_ = HFAInfo{0, nullptr};
+    return;
+  }
+  unsigned num = 0;
+  llvm::Type *typ = ebrs_[0].types[0];
+  if (typ != tm()->llvmDoubleType() && typ != tm()->llvmFloatType()) {
+    hfa_ = HFAInfo{0, nullptr};
+    return;
+  }
+  for (auto &ebr : ebrs_) {
+    for (auto &t : ebr.types) {
+      if (t != typ || num > 3) {
+        hfa_ = HFAInfo{0, nullptr};
+        return;
+      }
+      ++num;
+    }
+  }
+  hfa_ = HFAInfo{num, typ};
+}
+
+// Select the appropriate abi type for each eight-byte region within
+// an EightByteInfo. HFA and arguments larger than 16 bytes have been
+// processed, so the arguments processed here can only be integer types,
+// pointer types or a mix of integer and non-integer, mapped it onto
+// the pointer type or the appropriately sized integer type.
+//
+// Problems arise in the code below when dealing with structures with
+// constructs that inject additional padding. For example, consider
+// the following struct passed by value:
+//
+//      struct {
+//        f1 int8
+//        f2 [0]uint64
+//        f3 int8
+//      }
+//
+// Without taking into account the over-alignment of field f3, we would
+// wind up with two regions, each with type int8. This in itself is not so
+// bad, but creating a struct from these two types (via ::computeABIStructType)
+// would give us { int8, int8 }, in which the second field doesn't have
+// the correct alignment. Work around this by checking for such situations
+// and promoting the type of the first EBR to 64 bits.
+//
+void EightByteInfo::determineABITypesForARM_AAPCS() {
+  assert(ebrs_.size() <= 2);
+  for (auto &ebr : ebrs_) {
+    if (ebr.abiDirectType != nullptr)
+      continue;
+    // Preserve pointerness for the use of GC.
+    // TODO: this assumes pointer is 8 byte, so we never pack pointer
+    // and other stuff together.
+    if (ebr.types[0]->isPointerTy()) {
+      ebr.abiDirectType = tm()->llvmPtrType();
+      continue;
+    }
+    unsigned nel = ebr.offsets.size();
+    unsigned bytes = ebr.offsets[nel - 1] - ebr.offsets[0] +
+                     tm()->llvmTypeSize(ebr.types[nel - 1]);
+    assert(bytes && bytes <= 8);
+    ebr.abiDirectType = tm()->llvmArbitraryIntegerType(bytes);
+  }
+
+  // See the example above for more on why this is needed.
+  if (ebrs_.size() == 2 && ebrs_[0].abiDirectType->isIntegerTy()) {
+    ebrs_[0].abiDirectType = tm()->llvmArbitraryIntegerType(8);
+  }
+}
+
 // Select the appropriate abi type for each eight-byte region within
 // an EightByteInfo. Pure floating point types are mapped onto float,
 // double, or <2 x float> (a vector type), integer types (or something
@@ -427,7 +522,8 @@
            (attr() == AttrByVal ? " AttrByVal" :
             (attr() == AttrNest ? " AttrNest" :
              (attr() == AttrZext ? " AttrZext" :
-              (attr() == AttrSext ? " AttrSext" : " <unknown>")))));
+              (attr() == AttrSext ? " AttrSext" :
+               (attr() == AttrDoCopy ? " AttrDoCopy" : " <unknown>"))))));
   os << " { ";
   unsigned idx = 0;
   for (auto &abit : abiTypes_) {
@@ -454,6 +550,10 @@
       availIntRegs_ = 6;
       availSSERegs_ = 8;
       break;
+    case llvm::CallingConv::ARM_AAPCS:
+      availIntRegs_ = 8;
+      availSIMDFPRegs_ = 8;
+      break;
     default:
       llvm::errs() << "unsupported llvm::CallingConv::ID " << cconv << "\n";
       break;
@@ -469,20 +569,33 @@
       availSSERegs_ -= 1;
     argCount_ += 1;
   }
+  // For ARM_AAPCS HFA, one argument may takes multiple registers.
+  void addDirectSIMDFPArg(unsigned sr = 1) {
+    unsigned t = availSIMDFPRegs_ - sr;
+    if (availSIMDFPRegs_ > t)
+      availSIMDFPRegs_ = t;
+    argCount_ += 1;
+  }
   void addIndirectArg() { argCount_ += 1; }
   void addIndirectReturn() {
     if (availIntRegs_)
       availIntRegs_ -= 1;
     argCount_ += 1;
   }
+  // ARM_AAPCS uses separate x8 to store return address.
+  void addIndirectReturnForARM_AAPCS() { argCount_ += 1; }
   void addChainArg() { argCount_ += 1; }
   unsigned argCount() const { return argCount_; }
   unsigned availIntRegs() const { return availIntRegs_; }
   unsigned availSSERegs() const { return availSSERegs_; }
+  unsigned availSIMDFPRegs() const { return availSIMDFPRegs_; }
+  void clearAvailIntRegs() { availIntRegs_ = 0; }
+  void clearAvailSIMDFPRegs() { availSIMDFPRegs_ = 0; }
 
 private:
   unsigned availIntRegs_;
   unsigned availSSERegs_;
+  unsigned availSIMDFPRegs_;
   unsigned argCount_;
 };
 
@@ -523,7 +636,8 @@
   assert(typeManager_ != nullptr);
   ccID_ = typeManager_->callingConv();
   // Supported architectures at present.
-  assert(ccID_ == llvm::CallingConv::X86_64_SysV);
+  assert(ccID_ == llvm::CallingConv::X86_64_SysV ||
+         ccID_ == llvm::CallingConv::ARM_AAPCS);
 
   if (cc_ != nullptr) {
     return;
@@ -532,6 +646,9 @@
   case llvm::CallingConv::X86_64_SysV:
     cc_ = std::unique_ptr<CABIOracleArgumentAnalyzer>(new CABIOracleX86_64_SysV(typeManager_));
     break;
+  case llvm::CallingConv::ARM_AAPCS:
+    cc_ = std::unique_ptr<CABIOracleArgumentAnalyzer>(new CABIOracleARM_AAPCS(typeManager_));
+    break;
   default:
     llvm::errs() << "unsupported llvm::CallingConv::ID " << ccID_ << "\n";
     break;
@@ -829,3 +946,212 @@
 }
 
 //......................................................................
+
+CABIOracleARM_AAPCS::CABIOracleARM_AAPCS(TypeManager *typeManager)
+    : CABIOracleArgumentAnalyzer(typeManager) {}
+
+// Given the number of registers that we think a param is going to consume, and
+// a state object storing the registers used so far, canPassDirectly() makes a
+// decision as to whether a given param can be passed directly in registers vs
+// in memory.
+//
+// Note the first clause, "if (regsInt + regsSIMDFP == 1) return true". This may
+// seem counter-intuitive (why no check against the state object?), but this way
+// of doing things is the convention used by other front ends (e.g. clang). What
+// is happening here is that for larger aggregate/array params (things that
+// don't fit into a single register), we'll make the pass-through-memory
+// semantics explicit in the function signature and generate the explict code to
+// copy things into memory. For params that do fit into a single register,
+// however, we just leave them all as by-value parameters and then assume that
+// the back end will do the right thing (e.g. pass the first few in registers
+// and then the remaining ones in memory).
+//
+// Doing things this way has performance advantages in that the middle-end
+// (all of the machine-independent LLVM optimization passes) won't have
+// to deal with the additional chunks of stack memory and code to copy
+// things onto and off of the stack (not to mention the aliasing concerns
+// when a local variable's address is taken and then passed in a function
+// call).
+
+bool CABIOracleARM_AAPCS::canPassDirectly(unsigned regsInt,
+                                          unsigned regsSIMDFP,
+                                          ABIState &state)
+{
+  if (regsInt + regsSIMDFP == 1) // see comment above
+    return true;
+  if (regsInt <= state.availIntRegs() && regsSIMDFP <= state.availSIMDFPRegs())
+    return true;
+  return false;
+}
+
+CABIParamInfo CABIOracleARM_AAPCS::analyzeABIParam(Btype *paramType, ABIState &state)
+{
+  llvm::Type *ptyp = paramType->type();
+
+  // The only situations in which we should be seeing AuxT types here is
+  // in cases where we're analyzing the signatures of builtin functions,
+  // meaning that there should be no structures or arrays.
+  assert(paramType->flavor() != Btype::AuxT || ptyp->isVoidTy() ||
+         !(ptyp->isStructTy() || ptyp->isArrayTy() || ptyp->isVectorTy() ||
+           ptyp->isEmptyTy() || ptyp->isIntegerTy(8) || ptyp->isIntegerTy(16)));
+
+  if (ptyp == tm_->llvmVoidType()) {
+    // Empty struct or array
+    llvm::Type *voidType = tm_->llvmVoidType();
+    return CABIParamInfo(voidType, ParmIgnore, AttrNone, -1);
+  }
+
+  // If ptyp is llvmVoidType, we may not able to get the size of it,
+  // so we can't combine the following if statement with the above one.
+  int64_t sz = tm_->typeSize(paramType);
+  if (sz == 0) {
+    // Empty struct or array
+    llvm::Type *voidType = tm_->llvmVoidType();
+    return CABIParamInfo(voidType, ParmIgnore, AttrNone, -1);
+  }
+
+  int sigOff = state.argCount();
+
+  // Go has only two floating point types: float32 and float64, so the size of
+  // an HFA does not exceed 32 bytes.
+  if (sz > 32) {
+    // Value will be passed in memory on stack.
+    // Stack is always in address space 0.
+    llvm::Type *ptrTyp = llvm::PointerType::get(ptyp, 0);
+    state.addIndirectArg();
+    return CABIParamInfo(ptrTyp, ParmIndirect, AttrDoCopy, sigOff);
+  }
+
+  EightByteInfo ebi(paramType, tm_);
+  auto &hfa = ebi.getHFA();
+  if (hfa.number != 0) {
+    // Is HFA.
+    llvm::Type * abiType = hfa.type;
+    if (hfa.number > 1) {
+      // If it contains multiple elements, make the param as an Array
+      // type. This ensures that an HFA is passed as a whole.
+      abiType = llvm::ArrayType::get(hfa.type, hfa.number);
+    }
+    if (canPassDirectly(0, hfa.number, state)) {
+      state.addDirectSIMDFPArg(hfa.number);
+    } else {
+      state.clearAvailSIMDFPRegs();
+      state.addIndirectArg();
+    }
+    // Whether or not an HFA can be passed in registers, we use
+    // ParmDirect. This is because HFA is passed by value on stack
+    // in indirect cases, and we happen to be able to reuse the
+    // processing logic of the direct cases.
+    return CABIParamInfo(abiType, ParmDirect, AttrNone, sigOff);
+  }
+  if (sz > 16) {
+    // Not an HFA,value will be passed in memory on stack.
+    // Stack is always in address space 0.
+    llvm::Type *ptrTyp = llvm::PointerType::get(ptyp, 0);
+    state.addIndirectArg();
+    return CABIParamInfo(ptrTyp, ParmIndirect, AttrDoCopy, sigOff);
+  }
+
+  // Direct case.
+  auto &regions = ebi.regions();
+  // Make direct/indirect decision
+  CABIParamAttr attr = AttrNone;
+  if (canPassDirectly(regions.size(), 0, state)) {
+    std::vector<llvm::Type *> abiTypes;
+    for (auto &ebr : regions) {
+      abiTypes.push_back(ebr.abiDirectType);
+      if (ebr.attr != AttrNone) {
+        assert(attr == AttrNone || attr == ebr.attr);
+        attr = ebr.attr;
+      }
+      state.addDirectIntArg();
+    }
+    return CABIParamInfo(abiTypes, ParmDirect, attr, sigOff);
+  } else {
+    state.clearAvailIntRegs();
+    state.addIndirectArg();
+    llvm::Type *abiType = regions[0].abiDirectType;
+    if (regions.size() > 1) {
+      // Convert the argument to an array type so that the backend considers it as a
+      // whole whether it can be passed through registers.
+      abiType = llvm::ArrayType::get(tm_->llvmArbitraryIntegerType(8), regions.size());
+    }
+    // Pass by value on stack, so use ParmDirect.
+    return CABIParamInfo(abiType, ParmDirect, AttrNone, sigOff);
+  }
+}
+
+CABIParamInfo CABIOracleARM_AAPCS::analyzeABIReturn(Btype *resultType,
+                                                    ABIState &state) {
+  llvm::Type *rtyp = resultType->type();
+
+  if (rtyp == tm_->llvmVoidType()) {
+    // This corresponds to a function with no returns or
+    // returning an empty composite.
+    llvm::Type *voidType = tm_->llvmVoidType();
+    return CABIParamInfo(voidType, ParmIgnore, AttrNone, -1);
+  }
+
+  // If rtyp is llvmVoidType, we may not able to get the size of it,
+  // so we can't combine the following if statement with the above one.
+  int64_t sz = tm_->typeSize(resultType);
+  if (sz == 0) {
+    // This corresponds to a function with no returns or
+    // returning an empty composite.
+    llvm::Type *voidType = tm_->llvmVoidType();
+    return CABIParamInfo(voidType, ParmIgnore, AttrNone, -1);
+  }
+
+  // Go has only two floating point types: float32 and float64, so the size of
+  // an HFA does not exceed 32 bytes.
+  if (sz > 32) {
+    // Return value will be passed in memory, via a hidden
+    // struct return param.
+    // It is on stack, therefore address space 0.
+    llvm::Type *ptrTyp = llvm::PointerType::get(rtyp, 0);
+    // Indirect return value is passed by register R8, so doesn't occupy any int
+    // register.
+    state.addIndirectReturnForARM_AAPCS();
+    return CABIParamInfo(ptrTyp, ParmIndirect, AttrStructReturn, 0);
+  }
+
+  EightByteInfo ebi(resultType, tm_);
+  auto &hfa = ebi.getHFA();
+  if (hfa.number != 0) {
+    // Is HFA.
+    // If only one element, don't bother to make a llvm struct type.
+    if (hfa.number == 1) {
+      return CABIParamInfo(hfa.type, ParmDirect, AttrNone, -1);
+    }
+    std::vector<llvm::Type *> fields;
+    for (unsigned i = 0; i < hfa.number; ++i) {
+      fields.push_back(hfa.type);
+    }
+    llvm::Type *abiTyp = tm_->makeLLVMStructType(fields);
+    return CABIParamInfo(abiTyp, ParmDirect, AttrNone, -1);
+  }
+
+  // The return value is not an HFA and its size exceeds 16 bytes,
+  // be passed in memory, via a hidden struct return param.
+  if (sz > 16) {
+    llvm::Type *ptrTyp = llvm::PointerType::get(rtyp, 0);
+    state.addIndirectReturnForARM_AAPCS();
+    return CABIParamInfo(ptrTyp, ParmIndirect, AttrStructReturn, 0);
+  }
+
+  // Direct case
+  auto &regions = ebi.regions();
+  if (regions.size() == 1) {
+    // Single value
+    return CABIParamInfo(regions[0].abiDirectType, ParmDirect, regions[0].attr,
+                         -1);
+  }
+
+  // Two-element struct
+  assert(regions.size() == 2);
+  llvm::Type *abiTyp = tm_->makeLLVMTwoElementStructType(
+      regions[0].abiDirectType, regions[1].abiDirectType);
+  return CABIParamInfo(abiTyp, ParmDirect, AttrNone, -1);
+}
+
+//......................................................................
diff --git a/bridge/go-llvm-cabi-oracle.h b/bridge/go-llvm-cabi-oracle.h
index f146522..c186c38 100644
--- a/bridge/go-llvm-cabi-oracle.h
+++ b/bridge/go-llvm-cabi-oracle.h
@@ -12,8 +12,8 @@
 //
 // There are many possible complications, permutations, and oddities when
 // it comes to runtime calling conventions; the code here currently supports
-// only x86_64 SysV, which gets rid of many of the corner cases that can
-// be found in the corresponding code in Clang.
+// only x86_64 SysV and ARM AAPCS64, which gets rid of many of the corner
+// cases that can be found in the corresponding code in Clang.
 //
 //===----------------------------------------------------------------------===//
 
@@ -49,16 +49,19 @@
 
 };
 
-// Attributes on parameters. These correspond directly to the LLVM attrs
-// of the same name.
+// Attributes on parameters. Most of them correspond directly to the
+// LLVM attrs of the same name.
 
 enum CABIParamAttr : uint8_t {
-  AttrNone=0,
+  AttrNone = 0,
   AttrStructReturn,
   AttrByVal,
   AttrNest,
   AttrZext,
   AttrSext,
+  // For indirect parameter, do a copy of the parameter on stack and
+  // pass the address of the copy to callee.
+  AttrDoCopy,
 };
 
 // Container class for storing info on how a specific parameter is
@@ -133,8 +136,11 @@
   // This constant specifies the maximum possible size of vectors abiTypes_
   // in the direct parameter passing case.
   // For X86_64_SysV, the size of paramInfo.abiTypes() can't be larger than 2,
-  // because parameters that are larger than 16 bytes are passed indirectly.
-  static const unsigned int ABI_TYPES_MAX_SIZE = 2;
+  // because parameters that are larger than 16 bytes are passed indirectly. For
+  // ARM_AAPCS, as a HFA can have 4 elements, so the size can be as large as 4.
+  // Currently we simply set this value to the maximum value of the supported
+  // platforms.
+  static const unsigned int ABI_TYPES_MAX_SIZE = 4;
 
  private:
   std::vector<llvm::Type *> abiTypes_;
@@ -228,4 +234,18 @@
   CABIParamDisp classifyArgType(Btype *btype);
 };
 
+// This class implements ARM AAPCS64 calling convention.
+class CABIOracleARM_AAPCS : public CABIOracleArgumentAnalyzer {
+ public:
+  // Given information on the param types and result type for a
+  // function, create an oracle object that can answer C ABI
+  // queries about the function.
+  CABIOracleARM_AAPCS(TypeManager *typeManager);
+  CABIParamInfo analyzeABIParam(Btype *pType, ABIState &state);
+  CABIParamInfo analyzeABIReturn(Btype *resultType, ABIState &state);
+
+ private:
+  bool canPassDirectly(unsigned regsInt, unsigned regsSSE, ABIState &state);
+};
+
 #endif // LLVMGOFRONTEND_GO_LLVM_CABI_ORACLE_H
diff --git a/bridge/go-llvm-materialize.cpp b/bridge/go-llvm-materialize.cpp
index 9147ab6..5ce47bf 100644
--- a/bridge/go-llvm-materialize.cpp
+++ b/bridge/go-llvm-materialize.cpp
@@ -1194,6 +1194,24 @@
         llvm::Type *pt = llvm::PointerType::get(vt->getPointerElementType(), 0);
         val = builder.CreateAddrSpaceCast(val, pt, castname);
       }
+
+      // For some architectures, such as arm64, the indirect parameter needs to
+      // be copied to the space allocated by the caller on the stack, and pass
+      // the address of the copied version to the callee.
+      if (paramInfo.attr() == AttrDoCopy) {
+        BlockLIRBuilder bbuilder(state.callerFcn->function(), this);
+        TypeManager *tm = state.oracle.tm();
+        Btype *bty = fnarg->btype();
+        uint64_t sz = tm->typeSize(bty);
+        uint64_t algn = tm->typeAlignment(bty);
+        std::string tname(namegen("doCopy.addr"));
+        llvm::Value *tmpV = state.callerFcn->createTemporary(bty, tname);
+        bbuilder.CreateMemCpy(tmpV, algn, val, algn, sz);
+        std::vector<llvm::Instruction *> instructions = bbuilder.instructions();
+        for (auto i : instructions)
+          state.instructions.appendInstruction(i);
+        val = tmpV;
+      }
       state.llargs.push_back(val);
       continue;
     }
diff --git a/cmake/modules/ConfigSetup.cmake b/cmake/modules/ConfigSetup.cmake
index f0a0e41..0c220e2 100644
--- a/cmake/modules/ConfigSetup.cmake
+++ b/cmake/modules/ConfigSetup.cmake
@@ -141,5 +141,5 @@
 endif()
 set(USE_LIBFFI 1)
 
-# _Unwind_GetIPInfo is defined on Linux/AMD46.
+# _Unwind_GetIPInfo is defined on Linux/AMD64.
 set(HAVE_GETIPINFO 1)
diff --git a/driver/CompileGo.cpp b/driver/CompileGo.cpp
index 6875878..2dd64c0 100644
--- a/driver/CompileGo.cpp
+++ b/driver/CompileGo.cpp
@@ -634,10 +634,15 @@
                                   true);
   bridge_->setNoFpElim(!omitFp);
 
+  bool supportSplitStack = true;
+#ifndef USING_SPLIT_STACK
+  supportSplitStack = false;
+#endif
+
   bool useSplitStack =
       driver_.reconcileOptionPair(gollvm::options::OPT_fsplit_stack,
                                   gollvm::options::OPT_fno_split_stack,
-                                  true);
+                                  supportSplitStack);
   bridge_->setUseSplitStack(useSplitStack);
 
   // Honor -fdebug-prefix=... option.
@@ -810,6 +815,9 @@
     case Triple::x86_64:
       cconv_ = CallingConv::X86_64_SysV;
       break;
+    case Triple::aarch64:
+      cconv_ = CallingConv::ARM_AAPCS;
+      break;
     default:
       errs() << "currently Gollvm is not supported on architecture "
              << triple_.getArchName().str()<< "\n";
diff --git a/driver/GccUtils.cpp b/driver/GccUtils.cpp
index 0815ca3..78b88f3 100644
--- a/driver/GccUtils.cpp
+++ b/driver/GccUtils.cpp
@@ -180,7 +180,9 @@
       // more triples to be identified and added
       s.tripleAliases = {
         triple_.str(),
-        "aarch64-linux-gnu", "aarch64-unknown-linux-gnu"
+        "aarch64-linux-gnu", "aarch64-unknown-linux-gnu",
+        "aarch64-pc-linux-gnu", "aarch64-redhat-linux",
+        "aarch64-suse-linux"
       };
       // multilib is not supported on major aarch64/arm64 linux distributions
       // subject to change when more scenarios to be taken into account
diff --git a/unittests/BackendCore/BackendArrayStruct.cpp b/unittests/BackendCore/BackendArrayStruct.cpp
index 1b5cc6b..f38882b 100644
--- a/unittests/BackendCore/BackendArrayStruct.cpp
+++ b/unittests/BackendCore/BackendArrayStruct.cpp
@@ -22,7 +22,7 @@
 
 INSTANTIATE_TEST_CASE_P(
     UnitTest, BackendArrayStructTests,
-    testing::Values(llvm::CallingConv::X86_64_SysV),
+    goBackendUnitTests::CConvs,
     [](const testing::TestParamInfo<BackendArrayStructTests::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
diff --git a/unittests/BackendCore/BackendCABIOracleTests.cpp b/unittests/BackendCore/BackendCABIOracleTests.cpp
index fc6ef51..f43f8a8 100644
--- a/unittests/BackendCore/BackendCABIOracleTests.cpp
+++ b/unittests/BackendCore/BackendCABIOracleTests.cpp
@@ -23,7 +23,7 @@
 
 INSTANTIATE_TEST_CASE_P(
     UnitTest, BackendCABIOracleTests,
-    testing::Values(llvm::CallingConv::X86_64_SysV),
+    goBackendUnitTests::CConvs,
     [](const testing::TestParamInfo<BackendCABIOracleTests::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
@@ -253,6 +253,191 @@
   }
 }
 
+TEST(BackendCABIOracleTests, ExtendedArm64) {
+  LLVMContext C;
+  std::unique_ptr<Llvm_backend> bep(
+      new Llvm_backend(C, nullptr, nullptr, 0, llvm::CallingConv::ARM_AAPCS));
+  Llvm_backend *be = bep.get();
+
+  Btype *bi8t = be->integer_type(false, 8);
+  Btype *bu8t = be->integer_type(true, 8);
+  Btype *bu64t = be->integer_type(true, 64);
+  Btype *bu32t = be->integer_type(true, 32);
+  Btype *bi16t = be->integer_type(false, 16);
+  Btype *bf32t = be->float_type(32);
+  Btype *bf64t = be->float_type(64);
+  Btype *bpu64t = be->pointer_type(bu64t);
+  Btype *bpf64t = be->pointer_type(bf64t);
+  Btype *st0 = mkBackendStruct(be, nullptr);
+  Btype *st1 = mkBackendStruct(be, bi8t, "a", bu8t, "b", bf32t, "c", nullptr);
+  Btype *st2 = mkBackendStruct(be, bf64t, "f1", bf64t, "f2", nullptr);
+  Btype *st3 = mkBackendStruct(be, st2, "f1", bi8t, "f2", nullptr);
+  Btype *st4 = mkBackendStruct(be, bf32t, "f1", bf32t, "f2", nullptr);
+  Btype *st5 = mkBackendStruct(be, bf32t, "f1", nullptr);
+  Btype *st6 = mkBackendStruct(be, bf32t, "f1", bi8t, "a", bu8t, "b", bu64t,
+                               "c", nullptr);
+  Btype *st7 = mkBackendStruct(be, bf32t, "f1", bu32t, "f2", nullptr);
+  Btype *st8 = mkBackendStruct(be, bi8t, "f1", bi16t, "f2", st7, "f3", nullptr);
+  Btype *stii = mkBackendStruct(be, bu64t, "a", bu64t, "b", nullptr);
+  Btype *stip = mkBackendStruct(be, bu64t, "a", bpu64t, "b", nullptr);
+  Btype *stpi = mkBackendStruct(be, bpu64t, "a", bu64t, "b", nullptr);
+  Btype *stpp = mkBackendStruct(be, bpu64t, "a", bpu64t, "b", nullptr);
+  Btype *at0 = be->array_type(bu32t, mkInt64Const(be, int64_t(0)));
+  Btype *at1 = be->array_type(bu32t, mkInt64Const(be, int64_t(1)));
+  Btype *at2 = be->array_type(bu32t, mkInt64Const(be, int64_t(3)));
+  Btype *at3 = be->array_type(bu8t, mkInt64Const(be, int64_t(16)));
+
+  struct FcnItem {
+    FcnItem(const std::vector<Btype *> &r, const std::vector<Btype *> &p,
+            const char *d, const char *t)
+        : results(r), parms(p), expDump(d), expTyp(t) {}
+    std::vector<Btype *> results;
+    std::vector<Btype *> parms;
+    const char *expDump;
+    const char *expTyp;
+  };
+
+  Btype *nt = nullptr;
+  std::vector<FcnItem> items = {
+
+      // 1
+      FcnItem({}, {},
+              "Return: Ignore { void } sigOffset: -1 "
+              "Param 1: Direct AttrNest { i8* } sigOffset: 0",
+              "void (i8*)"),
+
+      // 2
+      FcnItem({bi8t}, {},
+              "Return: Direct AttrSext { i8 } sigOffset: -1 "
+              "Param 1: Direct AttrNest { i8* } sigOffset: 0",
+              "i8 (i8*)"),
+
+      // 3
+      FcnItem({}, {bi8t},
+              "Return: Ignore { void } sigOffset: -1 "
+              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+              "Param 2: Direct AttrSext { i8 } sigOffset: 1",
+              "void (i8*, i8)"),
+
+      // 4
+      FcnItem({}, {st5, bpf64t},
+              "Return: Ignore { void } sigOffset: -1 "
+              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+              "Param 2: Direct { float } sigOffset: 1 "
+              "Param 3: Direct { double* } sigOffset: 2",
+              "void (i8*, float, double*)"),
+
+      // 5
+      FcnItem({bi8t, bf64t}, {bi8t, bu8t, st0},
+              "Return: Direct { { i64, i64 } } sigOffset: -1 "
+              "Param 1: Direct AttrNest { i8* } 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)"),
+
+      // 6
+      FcnItem({st2}, {st2, st0, st4, st1},
+              "Return: Direct { { double, double } } sigOffset: -1 "
+              "Param 1: Direct AttrNest { i8* } 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)"),
+
+      // 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 }* } "
+              "sigOffset: 2 "
+              "Param 3: Ignore { void } sigOffset: -1 "
+              "Param 4: Direct AttrZext { i8 } sigOffset: 3 ",
+              "void ({ { double, double }, i8 }*, i8*, "
+              "{ { double, double }, i8 }*, i8)"),
+
+      // 8
+      FcnItem({st6}, {st6, st6},
+              "Return: Direct { { i64, i64 } } sigOffset: -1 "
+              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+              "Param 2: Direct { i64, i64 } sigOffset: 1 "
+              "Param 3: Direct { i64, i64 } sigOffset: 3",
+              "{ i64, i64 } (i8*, i64, i64, i64, i64)"),
+
+      // 9
+      FcnItem({st8}, {st8},
+              "Return: Direct { { i64, i32 } } sigOffset: -1 "
+              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+              "Param 2: Direct { i64, i32 } sigOffset: 1",
+              "{ i64, i32 } (i8*, i64, i32)"),
+
+      // 10
+      FcnItem({at0}, {at1},
+              "Return: Ignore { void } sigOffset: -1 "
+              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+              "Param 2: Direct { i32 } sigOffset: 1",
+              "void (i8*, i32)"),
+
+      // 11
+      FcnItem({at2}, {at3},
+              "Return: Direct { { i64, i32 } } sigOffset: -1 "
+              "Param 1: Direct AttrNest { i8* } sigOffset: 0 "
+              "Param 2: Direct { i64, i64 } sigOffset: 1",
+              "{ i64, i32 } (i8*, 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 "
+              "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)"),
+  };
+
+  unsigned count = 1;
+  for (auto &item : items) {
+    std::vector<Backend::Btyped_identifier> results;
+    std::vector<Backend::Btyped_identifier> params;
+    for (auto &r : item.results)
+      results.push_back(mkid(r));
+    for (auto &p : item.parms)
+      params.push_back(mkid(p));
+    Btype *rt = nullptr;
+    if (results.size() > 1)
+      rt = be->struct_type(results);
+    Btype *t = be->function_type(mkid(nt), params, results, rt, Location());
+    BFunctionType *bft = t->castToBFunctionType();
+    CABIOracle cab(bft, be->typeManager());
+
+    {
+      std::string reason;
+      bool equal = difftokens(item.expDump, cab.toString(), reason);
+      EXPECT_EQ("pass", equal ? "pass" : reason);
+      if (!equal) {
+        std::cerr << "count: " << count << "\n";
+        std::cerr << "exp:\n" << item.expDump << "\n";
+        std::cerr << "act:\n" << cab.toString() << "\n";
+      }
+    }
+    {
+      std::string reason;
+      std::string result(repr(cab.getFunctionTypeForABI()));
+      bool equal = difftokens(item.expTyp, result, reason);
+      EXPECT_EQ("pass", equal ? "pass" : reason);
+      if (!equal) {
+        std::cerr << "count: " << count << "\n";
+        std::cerr << "exp:\n" << item.expTyp << "\n";
+        std::cerr << "act:\n" << result << "\n";
+      }
+    }
+    count++;
+  }
+}
+
 TEST(BackendCABIOracleTests, RecursiveCall1Amd64) {
   FcnTestHarness h(llvm::CallingConv::X86_64_SysV);
   Llvm_backend *be = h.be();
@@ -378,6 +563,128 @@
   EXPECT_FALSE(broken && "Module failed to verify.");
 }
 
+TEST(BackendCABIOracleTests, RecursiveCall1Arm64) {
+  FcnTestHarness h(llvm::CallingConv::ARM_AAPCS);
+  Llvm_backend *be = h.be();
+
+  // type s1 struct {
+  //   f1, f2 float32
+  //   i1, i2, i3 int16
+  // }
+  // type s2 struct {
+  //   k float64
+  //   f1, f2 float32
+  // }
+  // type s3 struct {
+  //   f1, s1
+  //   f2, s2
+  // }
+  // type s4 struct {
+  // }
+  // func foo(x s1, y s2, z s4, sm1 uint8, sm2 int8, w s3) s2 {
+  //   if (sm1 == 0) {
+  //     return y
+  //   }
+  //   return foo(x, y, z, sm1-1, sm2, w)
+  // }
+  //
+
+  // Create struct types
+  Btype *bf32t = be->float_type(32);
+  Btype *bf64t = be->float_type(64);
+  Btype *bi16t = be->integer_type(false, 16);
+  Btype *bi8t = be->integer_type(false, 8);
+  Btype *bu8t = be->integer_type(true, 8);
+  Btype *s1 = mkBackendStruct(be, bf32t, "f1", bf32t, "f2", bi16t, "i1", bi16t,
+                              "i2", bi16t, "i3", nullptr);
+  Btype *s2 =
+      mkBackendStruct(be, bf64t, "k", bf32t, "f1", bf32t, "f2", nullptr);
+  Btype *s3 = mkBackendStruct(be, s1, "f1", s2, "f2", nullptr);
+  Btype *s4 = mkBackendStruct(be, nullptr);
+
+  // Create function type
+  BFunctionType *befty1 =
+      mkFuncTyp(be, L_PARM, s1, L_PARM, s2, L_PARM, s4, L_PARM, bu8t, L_PARM,
+                bi8t, L_PARM, s3, L_RES, s2, L_END);
+  Bfunction *func = h.mkFunction("foo", befty1);
+
+  // sm1 == 0
+  Bvariable *p3 = func->getNthParamVar(3);
+  Location loc;
+  Bexpression *vex = be->var_expression(p3, loc);
+  Bexpression *c0 = be->convert_expression(bu8t, mkInt32Const(be, 0), loc);
+  Bexpression *eq = be->binary_expression(OPERATOR_EQEQ, vex, c0, loc);
+
+  // call
+  Bexpression *fn = be->function_code_expression(func, loc);
+  std::vector<Bexpression *> args;
+  Bvariable *p0 = func->getNthParamVar(0);
+  args.push_back(be->var_expression(p0, loc));
+
+  Bvariable *p1 = func->getNthParamVar(1);
+  args.push_back(be->var_expression(p1, loc));
+
+  Bvariable *p2 = func->getNthParamVar(2);
+  args.push_back(be->var_expression(p2, loc));
+
+  Bvariable *p3x = func->getNthParamVar(3);
+  Bexpression *vex3 = be->var_expression(p3x, loc);
+  Bexpression *c1 = be->convert_expression(bu8t, mkInt32Const(be, 1), loc);
+  Bexpression *minus = be->binary_expression(OPERATOR_MINUS, vex3, c1, loc);
+  args.push_back(minus);
+
+  Bvariable *p4 = func->getNthParamVar(4);
+  args.push_back(be->var_expression(p4, loc));
+
+  Bvariable *p5 = func->getNthParamVar(5);
+  args.push_back(be->var_expression(p5, loc));
+  Bexpression *call = be->call_expression(func, fn, args, nullptr, h.loc());
+
+  // return y
+  std::vector<Bexpression *> rvals1;
+  rvals1.push_back(be->var_expression(p1, loc));
+  Bstatement *rst1 = h.mkReturn(rvals1, FcnTestHarness::NoAppend);
+
+  // return call
+  std::vector<Bexpression *> rvals2;
+  rvals2.push_back(call);
+  Bstatement *rst2 = h.mkReturn(rvals2, FcnTestHarness::NoAppend);
+
+  const char *exp = R"RAW_RESULT(
+    %p3.ld.0 = load i8, i8* %p3.addr
+    %sub.0 = sub i8 %p3.ld.0, 1
+    %p4.ld.0 = load i8, i8* %p4.addr
+    %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
+    %field1.0 = getelementptr inbounds { i64, i48 }, { i64, i48 }* %cast.1, i32 0, i32 1
+    %ld.2 = load i48, i48* %field1.0
+    %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
+    %field1.1 = getelementptr inbounds { i64, i64 }, { i64, i64 }* %cast.2, i32 0, i32 1
+    %ld.4 = load i64, i64* %field1.1
+    %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
+    %cast.6 = bitcast { double, float, float }* %sret.actual.0 to { i64, i64 }*
+    %ld.5 = load { i64, i64 }, { i64, i64 }* %cast.6
+    ret { i64, i64 } %ld.5
+  )RAW_RESULT";
+
+  bool isOK = h.expectStmt(rst2, exp);
+  EXPECT_TRUE(isOK && "Statement does not have expected contents");
+
+  // if statement
+  h.mkIf(eq, rst1, rst2);
+
+  bool broken = h.finish(PreserveDebugInfo);
+  EXPECT_FALSE(broken && "Module failed to verify.");
+}
+
 TEST(BackendCABIOracleTests, PassAndReturnArraysAmd64) {
   FcnTestHarness h(llvm::CallingConv::X86_64_SysV);
   Llvm_backend *be = h.be();
@@ -425,6 +732,50 @@
   EXPECT_FALSE(broken && "Module failed to verify.");
 }
 
+TEST(BackendCABIOracleTests, PassAndReturnArraysArm64) {
+  FcnTestHarness h(llvm::CallingConv::ARM_AAPCS);
+  Llvm_backend *be = h.be();
+
+  Btype *bf32t = be->float_type(32);
+  Btype *bf64t = be->float_type(64);
+  Btype *at2f = be->array_type(bf32t, mkInt64Const(be, int64_t(2)));
+  Btype *at3d = be->array_type(bf64t, mkInt64Const(be, int64_t(3)));
+
+  // func foo(fp [2]float32) [3]float64
+  BFunctionType *befty1 = mkFuncTyp(be, L_PARM, at2f, L_RES, at3d, L_END);
+  Bfunction *func = h.mkFunction("foo", befty1);
+
+  // foo(fp)
+  Location loc;
+  Bvariable *p0 = func->getNthParamVar(0);
+  Bexpression *vex = be->var_expression(p0, loc);
+  Bexpression *fn = be->function_code_expression(func, loc);
+  std::vector<Bexpression *> args;
+  args.push_back(vex);
+  Bexpression *call = be->call_expression(func, fn, args, nullptr, h.loc());
+
+  // return foo(fp)
+  std::vector<Bexpression *> rvals;
+  rvals.push_back(call);
+  h.mkReturn(rvals);
+
+  const char *exp = R"RAW_RESULT(
+    %ld.0 = load [2 x float], [2 x float]* %p0.addr
+    %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
+    %cast.2 = bitcast [3 x double]* %sret.actual.0 to { double, double, double }*
+    %ld.1 = load { double, double, double }, { double, double, double }* %cast.2
+    ret { double, double, double } %ld.1
+  )RAW_RESULT";
+
+  bool isOK = h.expectBlock(exp);
+  EXPECT_TRUE(isOK && "Block does not have expected contents");
+
+  bool broken = h.finish(PreserveDebugInfo);
+  EXPECT_FALSE(broken && "Module failed to verify.");
+}
+
 TEST_P(BackendCABIOracleTests, EmptyStructParamsAndReturns) {
   auto cc = GetParam();
   FcnTestHarness h(cc);
@@ -574,4 +925,71 @@
   EXPECT_FALSE(broken && "Module failed to verify.");
 }
 
+TEST(BackendCABIOracleTests, PassAndReturnComplexArm64) {
+  FcnTestHarness h(llvm::CallingConv::ARM_AAPCS);
+  Llvm_backend *be = h.be();
+
+  Btype *bc64t = be->complex_type(64);
+  Btype *bc128t = be->complex_type(128);
+
+  // func foo(x complex64, y complex128) complex64
+  BFunctionType *befty1 =
+      mkFuncTyp(be, L_PARM, bc64t, L_PARM, bc128t, L_RES, bc64t, L_END);
+  Bfunction *func = h.mkFunction("foo", befty1);
+
+  // z = foo(x, y)
+  Location loc;
+  Bvariable *x = func->getNthParamVar(0);
+  Bvariable *y = func->getNthParamVar(1);
+  Bexpression *xvex = be->var_expression(x, loc);
+  Bexpression *yvex = be->var_expression(y, loc);
+  Bexpression *fn1 = be->function_code_expression(func, loc);
+  std::vector<Bexpression *> args1 = {xvex, yvex};
+  Bexpression *call1 = be->call_expression(func, fn1, args1, nullptr, h.loc());
+  h.mkLocal("z", bc64t, call1);
+
+  // Call with constant args
+  // foo(1+2i, 3+4i)
+  mpc_t mpc_val1, mpc_val2;
+  mpc_init2(mpc_val1, 256);
+  mpc_set_d_d(mpc_val1, 1.0, 2.0, GMP_RNDN);
+  mpc_init2(mpc_val2, 256);
+  mpc_set_d_d(mpc_val2, 3.0, 4.0, GMP_RNDN);
+  Bexpression *ccon1 = be->complex_constant_expression(bc64t, mpc_val1);
+  Bexpression *ccon2 = be->complex_constant_expression(bc128t, mpc_val2);
+  mpc_clear(mpc_val1);
+  mpc_clear(mpc_val2);
+  Bexpression *fn2 = be->function_code_expression(func, loc);
+  std::vector<Bexpression *> args2 = {ccon1, ccon2};
+  Bexpression *call2 = be->call_expression(func, fn2, args2, nullptr, h.loc());
+
+  // return the call expr above
+  std::vector<Bexpression *> rvals = {call2};
+  h.mkReturn(rvals);
+
+  const char *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
+    %cast.1 = bitcast { double, double }* %p1.addr to [2 x double]*
+    %ld.1 = load [2 x double], [2 x double]* %cast.1
+    %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
+    %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]*)
+    %ld.3 = load [2 x double], [2 x double]* bitcast ({ double, double }* @const.1 to [2 x double]*)
+    %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
+    %ld.4 = load { float, float }, { float, float }* %sret.actual.1
+    ret { float, float } %ld.4
+  )RAW_RESULT";
+
+  bool isOK = h.expectBlock(exp);
+  EXPECT_TRUE(isOK && "Block does not have expected contents");
+
+  bool broken = h.finish(PreserveDebugInfo);
+  EXPECT_FALSE(broken && "Module failed to verify.");
+}
+
 } // namespace
diff --git a/unittests/BackendCore/BackendCallTests.cpp b/unittests/BackendCore/BackendCallTests.cpp
index 9ed5d93..61fdb73 100644
--- a/unittests/BackendCore/BackendCallTests.cpp
+++ b/unittests/BackendCore/BackendCallTests.cpp
@@ -22,7 +22,7 @@
 
 INSTANTIATE_TEST_CASE_P(
     UnitTest, BackendCallTests,
-    testing::Values(llvm::CallingConv::X86_64_SysV),
+    goBackendUnitTests::CConvs,
     [](const testing::TestParamInfo<BackendCallTests::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
diff --git a/unittests/BackendCore/BackendCoreTests.cpp b/unittests/BackendCore/BackendCoreTests.cpp
index 7773a26..ba7d97a 100644
--- a/unittests/BackendCore/BackendCoreTests.cpp
+++ b/unittests/BackendCore/BackendCoreTests.cpp
@@ -20,7 +20,7 @@
 
 INSTANTIATE_TEST_CASE_P(
     UnitTest, BackendCoreTests,
-    testing::Values(llvm::CallingConv::X86_64_SysV),
+    goBackendUnitTests::CConvs,
     [](const testing::TestParamInfo<BackendCoreTests::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
diff --git a/unittests/BackendCore/BackendDebugEmit.cpp b/unittests/BackendCore/BackendDebugEmit.cpp
index 03dfdd7..b54cb05 100644
--- a/unittests/BackendCore/BackendDebugEmit.cpp
+++ b/unittests/BackendCore/BackendDebugEmit.cpp
@@ -25,7 +25,7 @@
 
 INSTANTIATE_TEST_CASE_P(
     UnitTest, BackendDebugEmit,
-    testing::Values(llvm::CallingConv::X86_64_SysV),
+    goBackendUnitTests::CConvs,
     [](const testing::TestParamInfo<BackendDebugEmit::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
@@ -89,6 +89,34 @@
   EXPECT_TRUE(isOK && "Function does not have expected contents");
 }
 
+TEST(BackendDebugEmit, TestSimpleDecl2Arm64) {
+  // Test that parameters of empty function are handled correctly.
+  FcnTestHarness h(llvm::CallingConv::ARM_AAPCS);
+  Llvm_backend *be = h.be();
+  Btype *bi64t = be->integer_type(false, 64);
+  Btype *bst = mkBackendStruct(be, bi64t, "f1", bi64t, "f2", bi64t, "f3",
+                               nullptr); // large struct, pass by reference
+  BFunctionType *befty = mkFuncTyp(be, L_PARM, bst, L_END);
+  Bfunction *func = h.mkFunction("foo", befty);
+
+  // function with no code
+
+  bool broken = h.finish(PreserveDebugInfo);
+  EXPECT_FALSE(broken && "Module failed to verify.");
+
+  const char *exp = R"RAW_RESULT(
+    define void @foo(i8* nest %nest.0, { i64, i64, i64 }* %p0) #0 {
+    entry:
+      call void @llvm.dbg.declare(metadata { i64, i64, i64 }* %p0, metadata !5,
+                                  metadata !DIExpression()), !dbg !18
+      ret void
+    }
+  )RAW_RESULT";
+
+  bool isOK = h.expectValue(func->function(), exp);
+  EXPECT_TRUE(isOK && "Function does not have expected contents");
+}
+
 // This test is designed to make sure that debug meta-data generation
 // handles corner clases like vars with zero size (empty struct).
 
diff --git a/unittests/BackendCore/BackendExprTests.cpp b/unittests/BackendCore/BackendExprTests.cpp
index b34ac85..3343734 100644
--- a/unittests/BackendCore/BackendExprTests.cpp
+++ b/unittests/BackendCore/BackendExprTests.cpp
@@ -22,7 +22,7 @@
 
 INSTANTIATE_TEST_CASE_P(
     UnitTest, BackendExprTests,
-    testing::Values(llvm::CallingConv::X86_64_SysV),
+    goBackendUnitTests::CConvs,
     [](const testing::TestParamInfo<BackendExprTests::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
@@ -1500,6 +1500,82 @@
   EXPECT_TRUE(isOK && "Block does not have expected contents");
 }
 
+TEST(BackendExprTests, TestConditionalExpression3Arm64) {
+  FcnTestHarness h(llvm::CallingConv::ARM_AAPCS);
+  Llvm_backend *be = h.be();
+  Btype *bi32t = be->integer_type(false, 32);
+  Btype *abt = be->array_type(bi32t, mkInt64Const(be, int64_t(16)));
+  // type s2t struct {
+  //   f1 [16]int32
+  //   f2 int32
+  // }
+  Btype *s2t = mkBackendStruct(be, abt, "f1", bi32t, "f2", nullptr);
+
+  // func foo(p0v s2t, p1v int32) (a s2t)
+  BFunctionType *befty1 =
+      mkFuncTyp(be, L_RES, s2t, L_PARM, s2t, L_PARM, bi32t, L_END);
+  Bfunction *func = h.mkFunction("foo", befty1);
+  Location loc;
+
+  // Local var with conditional expression as init
+  Bvariable *p0v = func->getNthParamVar(0);
+  Bvariable *p1v = func->getNthParamVar(1);
+  Bexpression *vep1 = be->var_expression(p1v, loc);
+  // p1v < 7
+  Bexpression *cmp = be->binary_expression(OPERATOR_LT, vep1,
+                                           mkInt32Const(be, int32_t(7)), loc);
+  Bexpression *vep0 = be->var_expression(p0v, loc);
+  Bexpression *bzero = be->zero_expression(s2t);
+
+  // if (p1v < 7) {
+  //   a = p0v
+  // } else {
+  //   a = nil
+  // }
+  Bexpression *cond =
+      be->conditional_expression(func, s2t, cmp, vep0, bzero, loc);
+  h.mkLocal("a", s2t, cond);
+
+  const char *exp = R"RAW_RESULT(
+    define void @foo({ [16 x i32], i32 }* sret %sret.formal.0, i8* nest %nest.0, { [16 x i32], i32 }* %p0, i32 %p1) #0 {
+    entry:
+      %p1.addr = alloca i32
+      %a = alloca { [16 x i32], i32 }
+      %tmpv.0 = alloca { [16 x i32], i32 }
+      store i32 %p1, i32* %p1.addr
+      %p1.ld.0 = load i32, i32* %p1.addr
+      %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.4 = bitcast { [16 x i32], i32 }* %a to i8*
+      %cast.5 = bitcast { [16 x i32], i32 }* %tmpv.0 to i8*
+      call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %cast.4, i8* align 4 %cast.5, i64 68, i1 false)
+      ret void
+
+    else.0:                                           ; preds = %entry
+      %cast.2 = bitcast { [16 x i32], i32 }* %tmpv.0 to i8*
+      %cast.3 = bitcast { [16 x i32], i32 }* @const.0 to i8*
+      call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %cast.2, i8* align 4 %cast.3, i64 68, i1 false)
+      br label %fallthrough.0
+    }
+  )RAW_RESULT";
+
+  bool broken = h.finish(StripDebugInfo);
+  EXPECT_FALSE(broken && "Module failed to verify.");
+
+  bool isOK = h.expectValue(func->function(), exp);
+  EXPECT_TRUE(isOK && "Block does not have expected contents");
+}
+
 TEST_P(BackendExprTests, TestCompoundExpression) {
   auto cc = GetParam();
   FcnTestHarness h(cc, "foo");
diff --git a/unittests/BackendCore/BackendFcnTests.cpp b/unittests/BackendCore/BackendFcnTests.cpp
index 8a7e9bb..dd5bc52 100644
--- a/unittests/BackendCore/BackendFcnTests.cpp
+++ b/unittests/BackendCore/BackendFcnTests.cpp
@@ -20,7 +20,7 @@
 
 INSTANTIATE_TEST_CASE_P(
     UnitTest, BackendFcnTests,
-    testing::Values(llvm::CallingConv::X86_64_SysV),
+    goBackendUnitTests::CConvs,
     [](const testing::TestParamInfo<BackendFcnTests::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
diff --git a/unittests/BackendCore/BackendNodeTests.cpp b/unittests/BackendCore/BackendNodeTests.cpp
index 83416ea..dbed932 100644
--- a/unittests/BackendCore/BackendNodeTests.cpp
+++ b/unittests/BackendCore/BackendNodeTests.cpp
@@ -23,7 +23,7 @@
 
 INSTANTIATE_TEST_CASE_P(
     UnitTest, BackendNodeTests,
-    testing::Values(llvm::CallingConv::X86_64_SysV),
+    goBackendUnitTests::CConvs,
     [](const testing::TestParamInfo<BackendNodeTests::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
diff --git a/unittests/BackendCore/BackendPointerExprTests.cpp b/unittests/BackendCore/BackendPointerExprTests.cpp
index e8a24fe..2cc63fd 100644
--- a/unittests/BackendCore/BackendPointerExprTests.cpp
+++ b/unittests/BackendCore/BackendPointerExprTests.cpp
@@ -22,7 +22,7 @@
 
 INSTANTIATE_TEST_CASE_P(
     UnitTest, BackendPointerExprTests,
-    testing::Values(llvm::CallingConv::X86_64_SysV),
+    goBackendUnitTests::CConvs,
     [](const testing::TestParamInfo<BackendPointerExprTests::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
diff --git a/unittests/BackendCore/BackendStmtTests.cpp b/unittests/BackendCore/BackendStmtTests.cpp
index 0b07dcb..f00301b 100644
--- a/unittests/BackendCore/BackendStmtTests.cpp
+++ b/unittests/BackendCore/BackendStmtTests.cpp
@@ -20,7 +20,7 @@
 
 INSTANTIATE_TEST_CASE_P(
     UnitTest, BackendStmtTests,
-    testing::Values(llvm::CallingConv::X86_64_SysV),
+    goBackendUnitTests::CConvs,
     [](const testing::TestParamInfo<BackendStmtTests::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
diff --git a/unittests/BackendCore/BackendTreeIntegrity.cpp b/unittests/BackendCore/BackendTreeIntegrity.cpp
index 06b9e62..0c31828 100644
--- a/unittests/BackendCore/BackendTreeIntegrity.cpp
+++ b/unittests/BackendCore/BackendTreeIntegrity.cpp
@@ -20,7 +20,7 @@
 
 INSTANTIATE_TEST_CASE_P(
     UnitTest, BackendTreeIntegrity,
-    testing::Values(llvm::CallingConv::X86_64_SysV),
+    goBackendUnitTests::CConvs,
     [](const testing::TestParamInfo<BackendTreeIntegrity::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
diff --git a/unittests/BackendCore/BackendVarTests.cpp b/unittests/BackendCore/BackendVarTests.cpp
index 149cbc5..ef2fbd4 100644
--- a/unittests/BackendCore/BackendVarTests.cpp
+++ b/unittests/BackendCore/BackendVarTests.cpp
@@ -24,7 +24,7 @@
 
 INSTANTIATE_TEST_CASE_P(
     UnitTest, BackendVarTests,
-    testing::Values(llvm::CallingConv::X86_64_SysV),
+    goBackendUnitTests::CConvs,
     [](const testing::TestParamInfo<BackendVarTests::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
diff --git a/unittests/BackendCore/TestUtils.h b/unittests/BackendCore/TestUtils.h
index a75202e..313af8e 100644
--- a/unittests/BackendCore/TestUtils.h
+++ b/unittests/BackendCore/TestUtils.h
@@ -27,11 +27,16 @@
 #include "DiffUtils.h"
 
 #include <stdarg.h>
+#include "gtest/gtest.h"
 
 #define RAW_RESULT(x) #x
 
 namespace goBackendUnitTests {
 
+// All supported calling conventions
+auto CConvs = testing::Values(llvm::CallingConv::X86_64_SysV,
+                              llvm::CallingConv::ARM_AAPCS);
+
 // Convert llvm::CallingConv::ID to its coresponding string name.
 std::string ccName(llvm::CallingConv::ID);
 
diff --git a/unittests/DriverUtils/DriverUtilsTests.cpp b/unittests/DriverUtils/DriverUtilsTests.cpp
index 643e8a8..d6e2fd2 100644
--- a/unittests/DriverUtils/DriverUtilsTests.cpp
+++ b/unittests/DriverUtils/DriverUtilsTests.cpp
@@ -279,7 +279,7 @@
   GCCInstallationDetector detector_;
 };
 
-TEST(DriverUtilsTests, GCCInstallationDetectorBasic) {
+TEST(DriverUtilsTests, GCCInstallationDetectorBasicAmd64) {
 
   // Here we have two installations, version 6 and version 7.
   const char *install = R"RAW_RESULT(
@@ -317,7 +317,32 @@
   EXPECT_TRUE(isOK2);
 }
 
-TEST(DriverUtilsTests, GCCInstallationDetectorSysRoot) {
+TEST(DriverUtilsTests, GCCInstallationDetectorBasicARM64) {
+
+  // Here we have two installations, version 6 and version 7.
+  const char *install = R"RAW_RESULT(
+      /mumble
+      /usr/lib/gcc/aarch64-linux-gnu/blah
+      /usr/lib/gcc/aarch64-linux-gnu/6/crtbegin.o
+      /usr/lib/gcc/aarch64-linux-gnu/7/crtbegin.o
+    )RAW_RESULT";
+
+  // Case 1: no sysroot, looking for 64-bit compiler.
+  // Gcc doesn't support multilib on Arm64, so don't need
+  // to test that case.
+  DetectorHarness harness1(install, "aarch64-linux-gnu", "");
+  const char *exp64 = R"RAW_RESULT(
+      version: 7
+      foundTriple: aarch64-linux-gnu
+      libPath: /usr/lib/gcc/aarch64-linux-gnu/7
+      parentLibPath: /usr/lib/gcc/aarch64-linux-gnu/7/../..
+      installPath: /usr/lib/gcc/aarch64-linux-gnu/7
+    )RAW_RESULT";
+  bool isOK1 = expectToString(harness1.detector(), exp64);
+  EXPECT_TRUE(isOK1);
+}
+
+TEST(DriverUtilsTests, GCCInstallationDetectorSysRootAmd64) {
 
   const char *install = R"RAW_RESULT(
       /mumble
@@ -339,7 +364,29 @@
   EXPECT_TRUE(isOK1);
 }
 
-TEST(DriverUtilsTests, GCCInstallationDetectorTripleAliases) {
+TEST(DriverUtilsTests, GCCInstallationDetectorSysRootARM64) {
+
+  const char *install = R"RAW_RESULT(
+      /mumble
+      /usr/lib/gcc/aarch64-linux-gnu/7/crtbegin.o
+      /mysysroot/usr/lib/gcc/aarch64-linux-gnu/6.2.3/crtbegin.o
+    )RAW_RESULT";
+
+  // We have GCC 7 installed on the host, but GCC 6 in sysroot,
+  // which in this case is what we want.
+  DetectorHarness harness1(install, "aarch64-linux-gnu", "/mysysroot");
+  const char *exp64 = R"RAW_RESULT(
+      version: 6.2.3
+      foundTriple: aarch64-linux-gnu
+      libPath: /mysysroot/usr/lib/gcc/aarch64-linux-gnu/6.2.3
+      parentLibPath: /mysysroot/usr/lib/gcc/aarch64-linux-gnu/6.2.3/../..
+      installPath: /mysysroot/usr/lib/gcc/aarch64-linux-gnu/6.2.3
+    )RAW_RESULT";
+  bool isOK1 = expectToString(harness1.detector(), exp64);
+  EXPECT_TRUE(isOK1);
+}
+
+TEST(DriverUtilsTests, GCCInstallationDetectorTripleAliasesAmd64) {
 
   // Regrettably, there is a fair amount of variation in terms
   // of target triples and how GCC is installed. This test checks
@@ -378,8 +425,46 @@
   EXPECT_TRUE(isOK2);
 }
 
-TEST(DriverUtilsTests, GCCInstallationDetectorBiarchAliases)
-{
+TEST(DriverUtilsTests, GCCInstallationDetectorTripleAliasesARM64) {
+
+  // Regrettably, there is a fair amount of variation in terms
+  // of target triples and how GCC is installed. This test checks
+  // to make sure we can accommodate such differences.
+
+  const char *install = R"RAW_RESULT(
+      /mumble
+      /usr/lib/gcc/aarch64-linux-gnu/5/crtbegin.o
+      /usr/lib/gcc/aarch64-linux-gnu/7/crtbegin.o
+    )RAW_RESULT";
+
+  // Case 1: install is aarch64-linux-gnu, but we are looking for
+  // aarch64-unknown-linux-gnu
+  DetectorHarness harness1(install, "aarch64-unknown-linux-gnu", "");
+  const char *exp1 = R"RAW_RESULT(
+      version: 7
+      foundTriple: aarch64-linux-gnu
+      libPath: /usr/lib/gcc/aarch64-linux-gnu/7
+      parentLibPath: /usr/lib/gcc/aarch64-linux-gnu/7/../..
+      installPath: /usr/lib/gcc/aarch64-linux-gnu/7
+    )RAW_RESULT";
+  bool isOK1 = expectToString(harness1.detector(), exp1);
+  EXPECT_TRUE(isOK1);
+
+  // Case 2: install is aarch64-linux-gnu, but we are looking for
+  // aarch64-redhat-linux-gnu
+  DetectorHarness harness2(install, "aarch64-redhat-linux-gnu", "");
+  const char *exp2 = R"RAW_RESULT(
+      version: 7
+      foundTriple: aarch64-linux-gnu
+      libPath: /usr/lib/gcc/aarch64-linux-gnu/7
+      parentLibPath: /usr/lib/gcc/aarch64-linux-gnu/7/../..
+      installPath: /usr/lib/gcc/aarch64-linux-gnu/7
+    )RAW_RESULT";
+  bool isOK2 = expectToString(harness2.detector(), exp2);
+  EXPECT_TRUE(isOK2);
+}
+
+TEST(DriverUtilsTests, GCCInstallationDetectorBiarchAliasesAmd64) {
   const char *install = R"RAW_RESULT(
       /mumble
       /usr/lib/gcc/x86_64-redhat-linux/6/lib32/crtbegin.o