diff --git a/bridge/go-llvm-bfunction.cpp b/bridge/go-llvm-bfunction.cpp
index 7109ccb..5afdcaa 100644
--- a/bridge/go-llvm-bfunction.cpp
+++ b/bridge/go-llvm-bfunction.cpp
@@ -187,11 +187,11 @@
       if (paramInfo.abiTypes().size() == 1) {
         arguments_[soff]->setName(name);
       } else {
-        assert(paramInfo.abiTypes().size() == 2);
-        std::string argp1(name); argp1 += ".chunk0";
-        std::string argp2(name); argp2 += ".chunk1";
-        arguments_[soff]->setName(argp1);
-        arguments_[soff+1]->setName(argp2);
+        assert(paramInfo.abiTypes().size() <= CABIParamInfo::ABI_TYPES_MAX_SIZE);
+        for (unsigned i = 0; i < paramInfo.abiTypes().size(); ++i) {
+          std::string argp = name + ".chunk" + std::to_string(i);
+          arguments_[soff+i]->setName(argp);
+        }
       }
       std::string aname(name);
       aname += ".addr";
@@ -372,36 +372,31 @@
     paramVar->setInitializer(si);
     return 1;
   }
-  assert(paramInfo.abiTypes().size() == 2);
 
-  // More complex case: param arrives in two registers.
+  assert(paramInfo.abiTypes().size() <= CABIParamInfo::ABI_TYPES_MAX_SIZE);
+  // More complex case: param arrives in multiple registers.
 
-  // Create struct type corresponding to first and second params
+  // Create struct type corresponding to multiple params.
   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 the first field
-  std::string tag0(namegen("field0"));
-  llvm::Value *field0gep =
-      builder.CreateConstInBoundsGEP2_32(llst, bitcast, 0, 0, tag0);
-  llvm::Value *argChunk0 = arguments_[paramInfo.sigOffset()];
-  builder.CreateStore(argChunk0, field0gep);
-
-  // Generate a store to the second field
-  std::string tag1(namegen("field1"));
-  llvm::Value *field1gep =
-      builder.CreateConstInBoundsGEP2_32(llst, bitcast, 0, 1, tag0);
-  llvm::Value *argChunk1 = arguments_[paramInfo.sigOffset()+1];
-  llvm::Instruction *stinst = builder.CreateStore(argChunk1, field1gep);
-
+  // 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);
+    llvm::Value *argChunk = arguments_[paramInfo.sigOffset() + i];
+    stinst = builder.CreateStore(argChunk, fieldgep);
+  }
   paramVar->setInitializer(stinst);
 
   // All done.
-  return 2;
+  return paramInfo.abiTypes().size();
 }
 
 void Bfunction::genProlog(llvm::BasicBlock *entry)
diff --git a/bridge/go-llvm-cabi-oracle.cpp b/bridge/go-llvm-cabi-oracle.cpp
index 95b9b10..b5d870b 100644
--- a/bridge/go-llvm-cabi-oracle.cpp
+++ b/bridge/go-llvm-cabi-oracle.cpp
@@ -42,17 +42,6 @@
 static TypDisp getTypDisp(llvm::Type *typ) {
   if (typ->isFloatTy() || typ->isDoubleTy())
     return FlavSSE;
-  if (typ->isArrayTy()) {
-    llvm::ArrayType *at = llvm::cast<llvm::ArrayType>(typ);
-    return getTypDisp(at->getTypeAtIndex(0u));
-  }
-  if (typ->isStructTy()) {
-    llvm::StructType *st = llvm::cast<llvm::StructType>(typ);
-    TypDisp disp = FlavEmpty;
-    for (unsigned idx = 0; idx < st->getNumElements(); idx++)
-      disp = dispMeet(getTypDisp(st->getElementType(idx)), disp);
-    return disp;
-  }
   return FlavInt;
 }
 
@@ -129,30 +118,28 @@
   TypeManager *typeManager_;
 
   typedef std::pair<Btype *, unsigned> typAndOffset;
-  void addLeafTypes(Btype *bt, unsigned off,
-                    std::vector<typAndOffset> *leaves);
+  void addLeafTypes(Btype *bt, unsigned off, std::vector<typAndOffset> *leaves);
+  void explode(Btype *bt);
   void explodeStruct(Btype *bst);
   void explodeArray(BArrayType *bat);
   void incorporateScalar(Btype *bt);
-  void determineABITypes();
+  void determineABITypesForX86_64_SysV();
   TypeManager *tm() const { return typeManager_; }
 };
 
 EightByteInfo::EightByteInfo(Btype *bt, TypeManager *tmgr)
     : typeManager_(tmgr)
 {
-  BStructType *bst = bt->castToBStructType();
-  BComplexType *bct = bt->castToBComplexType();
-  BArrayType *bat = bt->castToBArrayType();
-  if (bst || bct) {
-    explodeStruct(bt);
-  } else if (bat) {
-    explodeArray(bat);
-  } else {
-    incorporateScalar(bt);
+  explode(bt);
+  llvm::CallingConv::ID cconv = tmgr->callingConv();
+  switch (cconv) {
+  case llvm::CallingConv::X86_64_SysV:
+    determineABITypesForX86_64_SysV();
+    break;
+  default:
+    llvm::errs() << "unsupported llvm::CallingConv::ID " << cconv << "\n";
+    break;
   }
-  assert(ebrs_.size() <= 2);
-  determineABITypes();
 }
 
 // Perform a pre-order walk of a type, collecting the various leaf
@@ -233,26 +220,25 @@
 //    type bar struct {
 //      f1 double;            [0]  double             0
 //      f2 uint8;             [1]  unsigned char      64
-//      f3 int16;                  short              70
+//      f3 int16;                  short              80
 //    }
 //
 
 void EightByteInfo::explodeStruct(Btype *bst)
 {
-  assert(tm()->typeSize(bst) <= 16);
-
   std::vector<typAndOffset> leafTypes;
   addLeafTypes(bst, 0, &leafTypes);
 
   // collect offsets and field types
   EightByteRegion *cur8 = nullptr;
-
+  unsigned curOffset = 0;
   for (auto &pair : leafTypes) {
     Btype *lt = pair.first;
     unsigned offset = pair.second;
-    if (cur8 == nullptr || (offset >= 8 && ebrs_.size() == 1)) {
+    if (cur8 == nullptr || (offset - curOffset >= 8)) {
       ebrs_.push_back(EightByteRegion());
       cur8 = &ebrs_.back();
+      curOffset = offset;
     }
     cur8->types.push_back(lt->type());
     cur8->offsets.push_back(offset);
@@ -279,24 +265,23 @@
 //                                 unsigned short     32
 //                                 unsigned short     48
 //                            [1]  unsigned short     64
-//                                 unsigned short     70
+//                                 unsigned short     80
 
 void EightByteInfo::explodeArray(BArrayType *bat)
 {
-  assert(tm()->typeSize(bat) <= 16);
   EightByteRegion *cur8 = nullptr;
   unsigned curOffset = 0;
   unsigned elSize = tm()->typeSize(bat->elemType());
   for (unsigned elidx = 0; elidx < bat->nelSize(); ++elidx) {
     unsigned offset = elidx * elSize;
-    if (cur8 == nullptr || (offset >= 8 && curOffset < 8)) {
+    if (cur8 == nullptr || (offset - curOffset >= 8)) {
       ebrs_.push_back(EightByteRegion());
       cur8 = &ebrs_.back();
+      curOffset = offset;
     }
     // note that elem type here may be composite
     cur8->types.push_back(bat->elemType()->type());
     cur8->offsets.push_back(offset);
-    curOffset = offset;
   }
 }
 
@@ -313,6 +298,20 @@
   ebrs_.push_back(ebr);
 }
 
+// Convert a Btype into EightByteRegions.
+void EightByteInfo::explode(Btype *bt)
+{
+  BStructType *bst = bt->castToBStructType();
+  BComplexType *bct = bt->castToBComplexType();
+  BArrayType *bat = bt->castToBArrayType();
+  if (bst || bct || bat) {
+    // Flatten all composite types.
+    explodeStruct(bt);
+  } else {
+    incorporateScalar(bt);
+  }
+}
+
 void EightByteInfo::getRegisterRequirements(unsigned *numInt, unsigned *numSSE)
 {
   *numInt = 0;
@@ -347,8 +346,11 @@
 // the correct alignment. Work around this by checking for such situations
 // and promoting the type of the first EBR to 64 bits.
 //
-void EightByteInfo::determineABITypes()
+void EightByteInfo::determineABITypesForX86_64_SysV()
 {
+  // In the direct case, ebrs_.size() cannot be greater than 2 because parameters
+  // larger than 16 bytes are passed indirectly.
+  assert(ebrs_.size() <= 2);
   unsigned intRegions = 0;
   unsigned floatRegions = 0;
   for (auto &ebr : ebrs_) {
@@ -401,10 +403,9 @@
     assert(abiTypes_[0]->isStructTy());
     return abiTypes_[0];
   }
-  assert(abiTypes_.size() == 2);
-  llvm::Type *ft0 = abiTypes_[0];
-  llvm::Type *ft1 = abiTypes_[1];
-  llvm::Type *llst = tm->makeLLVMTwoElementStructType(ft0, ft1);
+
+  assert(abiTypes_.size() <= CABIParamInfo::ABI_TYPES_MAX_SIZE);
+  llvm::Type *llst = tm->makeLLVMStructType(abiTypes_);
   return llst;
 }
 
@@ -444,8 +445,20 @@
 // signature) along with available int/sse regs.
 
 class ABIState {
- public:
-  ABIState() : availIntRegs_(6), availSSERegs_(8), argCount_(0) { }
+public:
+  ABIState(TypeManager *typm) : argCount_(0) {
+    assert(typm != nullptr);
+    llvm::CallingConv::ID cconv = typm->callingConv();
+    switch (cconv) {
+    case llvm::CallingConv::X86_64_SysV:
+      availIntRegs_ = 6;
+      availSSERegs_ = 8;
+      break;
+    default:
+      llvm::errs() << "unsupported llvm::CallingConv::ID " << cconv << "\n";
+      break;
+    }
+  }
   void addDirectIntArg() {
     if (availIntRegs_)
       availIntRegs_ -= 1;
@@ -455,23 +468,19 @@
     if (availSSERegs_)
       availSSERegs_ -= 1;
     argCount_ += 1;
-    }
-  void addIndirectArg() {
-    argCount_ += 1;
   }
+  void addIndirectArg() { argCount_ += 1; }
   void addIndirectReturn() {
     if (availIntRegs_)
       availIntRegs_ -= 1;
     argCount_ += 1;
   }
-  void addChainArg() {
-    argCount_ += 1;
-  }
+  void addChainArg() { argCount_ += 1; }
   unsigned argCount() const { return argCount_; }
   unsigned availIntRegs() const { return availIntRegs_; }
   unsigned availSSERegs() const { return availSSERegs_; }
 
- private:
+private:
   unsigned availIntRegs_;
   unsigned availSSERegs_;
   unsigned argCount_;
@@ -488,7 +497,10 @@
     , fcnTypeForABI_(nullptr)
     , typeManager_(typeManager)
     , followsCabi_(followsCabi)
+    , ccID_(llvm::CallingConv::MaxID)
+    , cc_(nullptr)
 {
+  setCC();
   analyze();
 }
 
@@ -499,29 +511,47 @@
     , fcnTypeForABI_(nullptr)
     , typeManager_(typeManager)
     , followsCabi_(ft->followsCabi())
+    , ccID_(llvm::CallingConv::MaxID)
+    , cc_(nullptr)
 {
+  setCC();
   analyze();
 }
 
-bool CABIOracle::supported() const
+void CABIOracle::setCC()
 {
-  return tm()->callingConv() == llvm::CallingConv::X86_64_SysV;
+  assert(typeManager_ != nullptr);
+  ccID_ = typeManager_->callingConv();
+  // Supported architectures at present.
+  assert(ccID_ == llvm::CallingConv::X86_64_SysV);
+
+  if (cc_ != nullptr) {
+    return;
+  }
+  switch (ccID_) {
+  case llvm::CallingConv::X86_64_SysV:
+    cc_ = std::unique_ptr<CABIOracleArgumentAnalyzer>(new CABIOracleX86_64_SysV(typeManager_));
+    break;
+  default:
+    llvm::errs() << "unsupported llvm::CallingConv::ID " << ccID_ << "\n";
+    break;
+  }
 }
 
-const llvm::DataLayout *CABIOracle::datalayout() const
+TypeManager *CABIOracle::tm() const
 {
-  return typeManager_->datalayout();
+  return typeManager_;
 }
 
 llvm::FunctionType *CABIOracle::getFunctionTypeForABI()
 {
-  assert(supported());
+  assert(cc_ != nullptr);
   return fcnTypeForABI_;
 }
 
 const CABIParamInfo &CABIOracle::paramInfo(unsigned idx)
 {
-  assert(supported());
+  assert(cc_ != nullptr);
   // Slot 0: return info
   // Slot 1: static chain param
   // Slot 2: first argument / parameter
@@ -532,7 +562,7 @@
 
 const CABIParamInfo &CABIOracle::returnInfo()
 {
-  assert(supported());
+  assert(cc_ != nullptr);
   unsigned ridx = 0;
   assert(ridx < infov_.size());
   return infov_[ridx];
@@ -540,7 +570,7 @@
 
 const CABIParamInfo &CABIOracle::chainInfo()
 {
-  assert(supported());
+  assert(cc_ != nullptr);
   unsigned ridx = 1;
   assert(ridx < infov_.size());
   return infov_[ridx];
@@ -569,151 +599,6 @@
   }
 }
 
-// For full C++ (with long double, unions, vector types) the
-// rules here are a good deal more complicated, but for Go
-// it all boils down to the size of the type.
-
-CABIParamDisp CABIOracle::classifyArgType(Btype *btype)
-{
-  int64_t sz = tm()->typeSize(btype);
-  return (sz == 0 ? ParmIgnore : ((sz <= 16) ? ParmDirect : ParmIndirect));
-}
-
-CABIParamInfo CABIOracle::analyzeABIReturn(Btype *resultType, ABIState &state)
-{
-  llvm::Type *rtyp = resultType->type();
-  CABIParamDisp rdisp = (rtyp == tm()->llvmVoidType() ?
-                        ParmIgnore : classifyArgType(resultType));
-
-  if (rdisp == ParmIgnore) {
-    // 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 (rdisp == ParmIndirect) {
-    // 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);
-    state.addIndirectReturn();
-    return CABIParamInfo(ptrTyp, ParmIndirect, AttrStructReturn, 0);
-  }
-
-  // Figure out what to do in the direct case
-  assert(rdisp == ParmDirect);
-  EightByteInfo ebi(resultType, tm());
-  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);
-}
-
-// 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 + regsSSE == 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 CABIOracle::canPassDirectly(unsigned regsInt,
-                                 unsigned regsSSE,
-                                 ABIState &state)
-{
-  if (regsInt + regsSSE == 1) // see comment above
-    return true;
-  if (regsInt <= state.availIntRegs() && regsSSE <= state.availSSERegs())
-    return true;
-  return false;
-}
-
-CABIParamInfo CABIOracle::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)));
-
-  CABIParamDisp pdisp = classifyArgType(paramType);
-
-  if (pdisp == ParmIgnore) {
-    // Empty struct or array
-    llvm::Type *voidType = tm()->llvmVoidType();
-    return CABIParamInfo(voidType, ParmIgnore, AttrNone, -1);
-  }
-
-  int sigOff = state.argCount();
-
-  if (pdisp == ParmIndirect) {
-    // 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, AttrByVal, sigOff);
-  }
-
-  // Figure out what to do in the direct case
-  assert(pdisp == ParmDirect);
-  EightByteInfo ebi(paramType, tm());
-
-  // Figure out how many registers it would take to pass this parm directly
-  unsigned regsInt = 0, regsSSE = 0;
-  ebi.getRegisterRequirements(&regsInt, &regsSSE);
-
-  // Make direct/indirect decision
-  CABIParamAttr attr = AttrNone;
-  if (canPassDirectly(regsInt, regsSSE, state)) {
-    std::vector<llvm::Type *> abiTypes;
-    for (auto &ebr : ebi.regions()) {
-      abiTypes.push_back(ebr.abiDirectType);
-      if (ebr.attr != AttrNone) {
-        assert(attr == AttrNone || attr == ebr.attr);
-        attr = ebr.attr;
-      }
-      if (ebr.getRegionTypDisp() == FlavSSE)
-        state.addDirectSSEArg();
-      else
-        state.addDirectIntArg();
-    }
-    return CABIParamInfo(abiTypes, ParmDirect, attr, sigOff);
-  } else {
-    state.addIndirectArg();
-    llvm::Type *ptrTyp = llvm::PointerType::get(ptyp, 0);
-    return CABIParamInfo(ptrTyp, ParmIndirect, AttrByVal, sigOff);
-  }
-}
-
 // Fill in parameter / return / type information for a builtin function,
 // e.g. all values passed + returned directly, no static chain param.
 
@@ -746,10 +631,6 @@
   fcnTypeForABI_ = llvm::FunctionType::get(rtyp, elems, isVarargs);
 }
 
-// This driver function carries out the various classification steps
-// described in the AMD64 ABI Draft 0.99.8 document, section 3.2.3,
-// 4th page and thereabouts.
-
 void CABIOracle::analyze()
 {
   if (fcnTypeForABI_)
@@ -759,10 +640,11 @@
     return;
   }
 
-  ABIState state;
+  ABIState state(tm());
+  assert(cc_ != nullptr);
 
   // First slot in the info vector will be for the return.
-  infov_.push_back(analyzeABIReturn(fcnResultType_, state));
+  infov_.push_back(cc_->analyzeABIReturn(fcnResultType_, state));
 
   // Static chain parameter
   int sigOff = state.argCount();
@@ -773,7 +655,7 @@
   // Now process the params.
   for (unsigned idx = 0; idx < fcnParamTypes_.size(); ++idx) {
     Btype *pType = fcnParamTypes_[idx];
-    auto d = analyzeABIParam(pType, state);
+    auto d = cc_->analyzeABIParam(pType, state);
     infov_.push_back(d);
   }
 
@@ -794,3 +676,156 @@
   const bool isVarargs = false;
   fcnTypeForABI_ = llvm::FunctionType::get(rtyp, elems, isVarargs);
 }
+
+//......................................................................
+
+CABIOracleX86_64_SysV::CABIOracleX86_64_SysV(TypeManager *typeManager)
+    : CABIOracleArgumentAnalyzer(typeManager) {}
+
+// For full C++ (with long double, unions, vector types) the
+// rules here are a good deal more complicated, but for Go
+// it all boils down to the size of the type.
+
+CABIParamDisp CABIOracleX86_64_SysV::classifyArgType(Btype *btype)
+{
+  int64_t sz = tm_->typeSize(btype);
+  return (sz == 0 ? ParmIgnore : ((sz <= 16) ? ParmDirect : ParmIndirect));
+}
+
+// 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 + regsSSE == 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 CABIOracleX86_64_SysV::canPassDirectly(unsigned regsInt,
+                                 unsigned regsSSE,
+                                 ABIState &state)
+{
+  if (regsInt + regsSSE == 1) // see comment above
+    return true;
+  if (regsInt <= state.availIntRegs() && regsSSE <= state.availSSERegs())
+    return true;
+  return false;
+}
+
+CABIParamInfo CABIOracleX86_64_SysV::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)));
+
+  CABIParamDisp pdisp = classifyArgType(paramType);
+
+  if (pdisp == ParmIgnore) {
+    // Empty struct or array
+    llvm::Type *voidType = tm_->llvmVoidType();
+    return CABIParamInfo(voidType, ParmIgnore, AttrNone, -1);
+  }
+
+  int sigOff = state.argCount();
+
+  if (pdisp == ParmIndirect) {
+    // 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, AttrByVal, sigOff);
+  }
+
+  // Figure out what to do in the direct case
+  assert(pdisp == ParmDirect);
+  EightByteInfo ebi(paramType, tm_);
+
+  // Figure out how many registers it would take to pass this parm directly
+  unsigned regsInt = 0, regsSSE = 0;
+  ebi.getRegisterRequirements(&regsInt, &regsSSE);
+
+  // Make direct/indirect decision
+  CABIParamAttr attr = AttrNone;
+  if (canPassDirectly(regsInt, regsSSE, state)) {
+    std::vector<llvm::Type *> abiTypes;
+    for (auto &ebr : ebi.regions()) {
+      abiTypes.push_back(ebr.abiDirectType);
+      if (ebr.attr != AttrNone) {
+        assert(attr == AttrNone || attr == ebr.attr);
+        attr = ebr.attr;
+      }
+      if (ebr.getRegionTypDisp() == FlavSSE)
+        state.addDirectSSEArg();
+      else
+        state.addDirectIntArg();
+    }
+    return CABIParamInfo(abiTypes, ParmDirect, attr, sigOff);
+  } else {
+    state.addIndirectArg();
+    llvm::Type *ptrTyp = llvm::PointerType::get(ptyp, 0);
+    return CABIParamInfo(ptrTyp, ParmIndirect, AttrByVal, sigOff);
+  }
+}
+
+CABIParamInfo CABIOracleX86_64_SysV::analyzeABIReturn(Btype *resultType,
+                                                      ABIState &state) {
+  llvm::Type *rtyp = resultType->type();
+  CABIParamDisp rdisp =
+      (rtyp == tm_->llvmVoidType() ? ParmIgnore
+                                    : classifyArgType(resultType));
+
+  if (rdisp == ParmIgnore) {
+    // 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 (rdisp == ParmIndirect) {
+    // 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);
+    state.addIndirectReturn();
+    return CABIParamInfo(ptrTyp, ParmIndirect, AttrStructReturn, 0);
+  }
+
+  // Figure out what to do in the direct case
+  assert(rdisp == ParmDirect);
+  EightByteInfo ebi(resultType, tm_);
+  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 c995e6e..f146522 100644
--- a/bridge/go-llvm-cabi-oracle.h
+++ b/bridge/go-llvm-cabi-oracle.h
@@ -21,10 +21,12 @@
 #define LLVMGOFRONTEND_GO_LLVM_CABI_ORACLE_H
 
 #include "go-llvm-btype.h"
+#include "llvm/IR/CallingConv.h"
 
 class TypeManager;
 class EightByteInfo;
 class ABIState;
+class CABIOracleArgumentAnalyzer;
 
 namespace llvm {
 class DataLayout;
@@ -34,7 +36,7 @@
 
 // Disposition of a specific function argument or function return value.
 
-enum CABIParamDisp : uint8_t  {
+enum CABIParamDisp : uint8_t {
 
   // Pass argument directly (not in memory).
   ParmDirect,
@@ -50,7 +52,7 @@
 // Attributes on parameters. These correspond directly to the LLVM attrs
 // of the same name.
 
-enum CABIParamAttr : uint8_t  {
+enum CABIParamAttr : uint8_t {
   AttrNone=0,
   AttrStructReturn,
   AttrByVal,
@@ -128,6 +130,12 @@
   void dump();
   void osdump(llvm::raw_ostream &os);
 
+  // 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;
+
  private:
   std::vector<llvm::Type *> abiTypes_;
   CABIParamDisp disp_;
@@ -143,7 +151,6 @@
 
 class CABIOracle {
  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.
@@ -156,9 +163,6 @@
   CABIOracle(BFunctionType *ft,
              TypeManager *typeManager);
 
-  // Returns TRUE if this cc supported, FALSE otherwise.
-  bool supported() const;
-
   // Return the appropriate "cooked" LLVM function type for this
   // abstract function type.
   llvm::FunctionType *getFunctionTypeForABI();
@@ -174,7 +178,7 @@
   const CABIParamInfo &chainInfo();
 
   // Type manager used with this oracle.
-  TypeManager *tm() const { return typeManager_; }
+  TypeManager *tm() const;
 
   // Various dump methods.
   void dump();
@@ -188,13 +192,39 @@
   TypeManager *typeManager_;
   std::vector<CABIParamInfo> infov_;
   bool followsCabi_;
+  llvm::CallingConv::ID ccID_;
+  std::unique_ptr<CABIOracleArgumentAnalyzer> cc_;
 
+  // The main entry for cabi analysis.
   void analyze();
   void analyzeRaw();
-  CABIParamInfo analyzeABIReturn(Btype *resultType, ABIState &state);
+  // Set calling convention.
+  void setCC();
+};
+
+// This is a pure virtual class for architecture-independent interfaces.
+class CABIOracleArgumentAnalyzer {
+ public:
+  CABIOracleArgumentAnalyzer(TypeManager *tm) : tm_(tm) {}
+  virtual ~CABIOracleArgumentAnalyzer() {}
+  virtual CABIParamInfo analyzeABIReturn(Btype *resultType, ABIState &state) = 0;
+  virtual CABIParamInfo analyzeABIParam(Btype *pType, ABIState &state) = 0;
+ protected:
+  TypeManager *tm_;
+};
+
+// This class implements x86_64 SysV calling convention.
+class CABIOracleX86_64_SysV : 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.
+  CABIOracleX86_64_SysV(TypeManager *typeManager);
   CABIParamInfo analyzeABIParam(Btype *pType, ABIState &state);
+  CABIParamInfo analyzeABIReturn(Btype *resultType, ABIState &state);
+
+ private:
   bool canPassDirectly(unsigned regsInt, unsigned regsSSE, ABIState &state);
-  const llvm::DataLayout *datalayout() const;
   CABIParamDisp classifyArgType(Btype *btype);
 };
 
diff --git a/bridge/go-llvm-materialize.cpp b/bridge/go-llvm-materialize.cpp
index 4ed16ed..9147ab6 100644
--- a/bridge/go-llvm-materialize.cpp
+++ b/bridge/go-llvm-materialize.cpp
@@ -1259,8 +1259,9 @@
     }
 
     // This now corresponds to the case of passing the contents of
-    // a small structure via two pieces / params.
-    assert(paramInfo.abiTypes().size() == 2);
+    // a small structure via no more than CABIParamInfo::ABI_TYPES_MAX_SIZE
+    // pieces / params.
+    assert(paramInfo.abiTypes().size() <= CABIParamInfo::ABI_TYPES_MAX_SIZE);
     assert(paramInfo.attr() == AttrNone);
     assert(ctx == VE_lvalue);
 
@@ -1288,19 +1289,14 @@
         builder.CreatePointerBitCastOrAddrSpaceCast(val, ptst, tag);
 
     // Load up each field
-    std::string ftag0(namegen("field0"));
-    llvm::Value *field0gep =
-        builder.CreateConstInBoundsGEP2_32(llst, bitcast, 0, 0, ftag0);
-    std::string ltag0(namegen("ld"));
-    llvm::Value *ld0 = builder.CreateLoad(field0gep, ltag0);
-    state.llargs.push_back(ld0);
-
-    std::string ftag1(namegen("field1"));
-    llvm::Value *field1gep =
-        builder.CreateConstInBoundsGEP2_32(llst, bitcast, 0, 1, ftag1);
-    std::string ltag1(namegen("ld"));
-    llvm::Value *ld1 = builder.CreateLoad(field1gep, ltag1);
-    state.llargs.push_back(ld1);
+    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);
+      std::string ltag(namegen("ld"));
+      llvm::Value *ld = builder.CreateLoad(fieldgep, ltag);
+      state.llargs.push_back(ld);
+    }
   }
 }
 
diff --git a/bridge/go-llvm-typemanager.cpp b/bridge/go-llvm-typemanager.cpp
index 5ba97f3..a74ff99 100644
--- a/bridge/go-llvm-typemanager.cpp
+++ b/bridge/go-llvm-typemanager.cpp
@@ -331,6 +331,12 @@
   return lst;
 }
 
+llvm::Type *
+TypeManager::makeLLVMStructType(const std::vector<llvm::Type *> &fields) {
+  llvm::Type *lst = llvm::StructType::get(context_, fields);
+  return lst;
+}
+
 bool TypeManager::addPlaceholderRefs(Btype *btype)
 {
   bool rval = false;
diff --git a/bridge/go-llvm-typemanager.h b/bridge/go-llvm-typemanager.h
index 8eca95e..57d391f 100644
--- a/bridge/go-llvm-typemanager.h
+++ b/bridge/go-llvm-typemanager.h
@@ -165,6 +165,7 @@
   llvm::Type *makeLLVMTwoElementStructType(llvm::Type *f1, llvm::Type *f2);
   llvm::Type *makeLLVMPointerType(llvm::Type *toTy);
   llvm::Type *makeLLVMStructType(const std::vector<Btyped_identifier> &fields);
+  llvm::Type *makeLLVMStructType(const std::vector<llvm::Type *> &fields);
   llvm::Type *makeLLVMFunctionType(const std::vector<Btype *> &paramTypes,
                                    Btype *rbtype, bool followsCabi);
 
diff --git a/bridge/go-llvm.cpp b/bridge/go-llvm.cpp
index ee1c747..df92d6c 100644
--- a/bridge/go-llvm.cpp
+++ b/bridge/go-llvm.cpp
@@ -43,8 +43,9 @@
 Llvm_backend::Llvm_backend(llvm::LLVMContext &context,
                            llvm::Module *module,
                            Llvm_linemap *linemap,
-                           unsigned addrspace)
-    : TypeManager(context, llvm::CallingConv::X86_64_SysV, addrspace)
+                           unsigned addrspace,
+                           llvm::CallingConv::ID cconv)
+    : TypeManager(context, cconv, addrspace)
     , context_(context)
     , module_(module)
     , datalayout_(module ? &module->getDataLayout() : nullptr)
diff --git a/bridge/go-llvm.h b/bridge/go-llvm.h
index 0d4824b..947a13a 100644
--- a/bridge/go-llvm.h
+++ b/bridge/go-llvm.h
@@ -79,7 +79,9 @@
   Llvm_backend(llvm::LLVMContext &context,
                llvm::Module *module,
                Llvm_linemap *linemap,
-               unsigned addrspace);
+               unsigned addrspace,
+               /* Temporarily set the parameter as optional to workaround the unit tests. */
+               llvm::CallingConv::ID cconv=llvm::CallingConv::X86_64_SysV);
   ~Llvm_backend();
 
   // Types.
diff --git a/driver/CompileGo.cpp b/driver/CompileGo.cpp
index 5c64b4b..6875878 100644
--- a/driver/CompileGo.cpp
+++ b/driver/CompileGo.cpp
@@ -102,6 +102,7 @@
   Triple triple_;
   const ToolChain &toolchain_;
   Driver &driver_;
+  CallingConv::ID cconv_;
   LLVMContext context_;
   const char *progname_;
   std::string executablePath_;
@@ -127,6 +128,7 @@
   void createPasses(legacy::PassManager &MPM,
                     legacy::FunctionPassManager &FPM);
   void setupGoSearchPath();
+  void setCConv();
 
   // This routine emits output for -### and/or -v, then returns TRUE
   // of the compilation should be stubbed out (-###) or FALSE otherwise.
@@ -154,6 +156,7 @@
     : triple_(tc.driver().triple()),
       toolchain_(tc),
       driver_(tc.driver()),
+      cconv_(CallingConv::MaxID),
       progname_(tc.driver().progname()),
       executablePath_(executablePath),
       args_(tc.driver().args()),
@@ -346,6 +349,9 @@
   // Set triple.
   triple_ = driver_.triple();
 
+  // Set calling convention.
+  setCConv();
+
   // Get the target specific parser.
   std::string Error;
   const Target *TheTarget =
@@ -607,7 +613,7 @@
 
   // Now construct Llvm_backend helper.
   unsigned addrspace = enable_gc_ ? 1 : 0;
-  bridge_.reset(new Llvm_backend(context_, module_.get(), linemap_.get(), addrspace));
+  bridge_.reset(new Llvm_backend(context_, module_.get(), linemap_.get(), addrspace, cconv_));
 
   // Honor inline, tracelevel cmd line options
   llvm::Optional<unsigned> tl =
@@ -628,7 +634,6 @@
                                   true);
   bridge_->setNoFpElim(!omitFp);
 
-  // -f[no-]split-stack
   bool useSplitStack =
       driver_.reconcileOptionPair(gollvm::options::OPT_fsplit_stack,
                                   gollvm::options::OPT_fno_split_stack,
@@ -797,6 +802,21 @@
     go_add_search_path(dir.c_str());
 }
 
+// Set cconv according to the triple_ value.
+void CompileGoImpl::setCConv()
+{
+  assert(triple_.getArch() != Triple::UnknownArch);
+  switch (triple_.getArch()) {
+    case Triple::x86_64:
+      cconv_ = CallingConv::X86_64_SysV;
+      break;
+    default:
+      errs() << "currently Gollvm is not supported on architecture "
+             << triple_.getArchName().str()<< "\n";
+      break;
+  }
+}
+
 bool CompileGoImpl::invokeFrontEnd()
 {
   // Collect the input files and kick off the front end