Index: projects/clang360-import/contrib/llvm/lib/Target/AArch64/AArch64RegisterInfo.cpp
===================================================================
--- projects/clang360-import/contrib/llvm/lib/Target/AArch64/AArch64RegisterInfo.cpp	(revision 277777)
+++ projects/clang360-import/contrib/llvm/lib/Target/AArch64/AArch64RegisterInfo.cpp	(revision 277778)
@@ -1,404 +1,408 @@
 //===- AArch64RegisterInfo.cpp - AArch64 Register Information -------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the AArch64 implementation of the TargetRegisterInfo
 // class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "AArch64RegisterInfo.h"
 #include "AArch64FrameLowering.h"
 #include "AArch64InstrInfo.h"
 #include "AArch64Subtarget.h"
 #include "MCTargetDesc/AArch64AddressingModes.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/RegisterScavenging.h"
 #include "llvm/IR/Function.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetFrameLowering.h"
 #include "llvm/Target/TargetOptions.h"
 
 using namespace llvm;
 
 #define GET_REGINFO_TARGET_DESC
 #include "AArch64GenRegisterInfo.inc"
 
+static cl::opt<bool>
+ReserveX18("aarch64-reserve-x18", cl::Hidden,
+          cl::desc("Reserve X18, making it unavailable as GPR"));
+
 AArch64RegisterInfo::AArch64RegisterInfo(const AArch64InstrInfo *tii,
                                          const AArch64Subtarget *sti)
     : AArch64GenRegisterInfo(AArch64::LR), TII(tii), STI(sti) {}
 
 const MCPhysReg *
 AArch64RegisterInfo::getCalleeSavedRegs(const MachineFunction *MF) const {
   assert(MF && "Invalid MachineFunction pointer.");
   if (MF->getFunction()->getCallingConv() == CallingConv::AnyReg)
     return CSR_AArch64_AllRegs_SaveList;
   else
     return CSR_AArch64_AAPCS_SaveList;
 }
 
 const uint32_t *
 AArch64RegisterInfo::getCallPreservedMask(CallingConv::ID CC) const {
   if (CC == CallingConv::AnyReg)
     return CSR_AArch64_AllRegs_RegMask;
   else
     return CSR_AArch64_AAPCS_RegMask;
 }
 
 const uint32_t *AArch64RegisterInfo::getTLSCallPreservedMask() const {
   if (STI->isTargetDarwin())
     return CSR_AArch64_TLS_Darwin_RegMask;
 
   assert(STI->isTargetELF() && "only expect Darwin or ELF TLS");
   return CSR_AArch64_TLS_ELF_RegMask;
 }
 
 const uint32_t *
 AArch64RegisterInfo::getThisReturnPreservedMask(CallingConv::ID) const {
   // This should return a register mask that is the same as that returned by
   // getCallPreservedMask but that additionally preserves the register used for
   // the first i64 argument (which must also be the register used to return a
   // single i64 return value)
   //
   // In case that the calling convention does not use the same register for
   // both, the function should return NULL (does not currently apply)
   return CSR_AArch64_AAPCS_ThisReturn_RegMask;
 }
 
 BitVector
 AArch64RegisterInfo::getReservedRegs(const MachineFunction &MF) const {
   const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
 
   // FIXME: avoid re-calculating this every time.
   BitVector Reserved(getNumRegs());
   Reserved.set(AArch64::SP);
   Reserved.set(AArch64::XZR);
   Reserved.set(AArch64::WSP);
   Reserved.set(AArch64::WZR);
 
   if (TFI->hasFP(MF) || STI->isTargetDarwin()) {
     Reserved.set(AArch64::FP);
     Reserved.set(AArch64::W29);
   }
 
-  if (STI->isTargetDarwin()) {
+  if (STI->isTargetDarwin() || ReserveX18) {
     Reserved.set(AArch64::X18); // Platform register
     Reserved.set(AArch64::W18);
   }
 
   if (hasBasePointer(MF)) {
     Reserved.set(AArch64::X19);
     Reserved.set(AArch64::W19);
   }
 
   return Reserved;
 }
 
 bool AArch64RegisterInfo::isReservedReg(const MachineFunction &MF,
                                       unsigned Reg) const {
   const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
 
   switch (Reg) {
   default:
     break;
   case AArch64::SP:
   case AArch64::XZR:
   case AArch64::WSP:
   case AArch64::WZR:
     return true;
   case AArch64::X18:
   case AArch64::W18:
-    return STI->isTargetDarwin();
+    return STI->isTargetDarwin() || ReserveX18;
   case AArch64::FP:
   case AArch64::W29:
     return TFI->hasFP(MF) || STI->isTargetDarwin();
   case AArch64::W19:
   case AArch64::X19:
     return hasBasePointer(MF);
   }
 
   return false;
 }
 
 const TargetRegisterClass *
 AArch64RegisterInfo::getPointerRegClass(const MachineFunction &MF,
                                       unsigned Kind) const {
   return &AArch64::GPR64RegClass;
 }
 
 const TargetRegisterClass *
 AArch64RegisterInfo::getCrossCopyRegClass(const TargetRegisterClass *RC) const {
   if (RC == &AArch64::CCRRegClass)
     return &AArch64::GPR64RegClass; // Only MSR & MRS copy NZCV.
   return RC;
 }
 
 unsigned AArch64RegisterInfo::getBaseRegister() const { return AArch64::X19; }
 
 bool AArch64RegisterInfo::hasBasePointer(const MachineFunction &MF) const {
   const MachineFrameInfo *MFI = MF.getFrameInfo();
 
   // In the presence of variable sized objects, if the fixed stack size is
   // large enough that referencing from the FP won't result in things being
   // in range relatively often, we can use a base pointer to allow access
   // from the other direction like the SP normally works.
   if (MFI->hasVarSizedObjects()) {
     // Conservatively estimate whether the negative offset from the frame
     // pointer will be sufficient to reach. If a function has a smallish
     // frame, it's less likely to have lots of spills and callee saved
     // space, so it's all more likely to be within range of the frame pointer.
     // If it's wrong, we'll materialize the constant and still get to the
     // object; it's just suboptimal. Negative offsets use the unscaled
     // load/store instructions, which have a 9-bit signed immediate.
     if (MFI->getLocalFrameSize() < 256)
       return false;
     return true;
   }
 
   return false;
 }
 
 unsigned
 AArch64RegisterInfo::getFrameRegister(const MachineFunction &MF) const {
   const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
 
   return TFI->hasFP(MF) ? AArch64::FP : AArch64::SP;
 }
 
 bool AArch64RegisterInfo::requiresRegisterScavenging(
     const MachineFunction &MF) const {
   return true;
 }
 
 bool AArch64RegisterInfo::requiresVirtualBaseRegisters(
     const MachineFunction &MF) const {
   return true;
 }
 
 bool
 AArch64RegisterInfo::useFPForScavengingIndex(const MachineFunction &MF) const {
   const MachineFrameInfo *MFI = MF.getFrameInfo();
   // AArch64FrameLowering::resolveFrameIndexReference() can always fall back
   // to the stack pointer, so only put the emergency spill slot next to the
   // FP when there's no better way to access it (SP or base pointer).
   return MFI->hasVarSizedObjects() && !hasBasePointer(MF);
 }
 
 bool AArch64RegisterInfo::requiresFrameIndexScavenging(
     const MachineFunction &MF) const {
   return true;
 }
 
 bool
 AArch64RegisterInfo::cannotEliminateFrame(const MachineFunction &MF) const {
   const MachineFrameInfo *MFI = MF.getFrameInfo();
   // Only consider eliminating leaf frames.
   if (MFI->hasCalls() || (MF.getTarget().Options.DisableFramePointerElim(MF) &&
                           MFI->adjustsStack()))
     return true;
   return MFI->hasVarSizedObjects() || MFI->isFrameAddressTaken();
 }
 
 /// needsFrameBaseReg - Returns true if the instruction's frame index
 /// reference would be better served by a base register other than FP
 /// or SP. Used by LocalStackFrameAllocation to determine which frame index
 /// references it should create new base registers for.
 bool AArch64RegisterInfo::needsFrameBaseReg(MachineInstr *MI,
                                             int64_t Offset) const {
   for (unsigned i = 0; !MI->getOperand(i).isFI(); ++i)
     assert(i < MI->getNumOperands() &&
            "Instr doesn't have FrameIndex operand!");
 
   // It's the load/store FI references that cause issues, as it can be difficult
   // to materialize the offset if it won't fit in the literal field. Estimate
   // based on the size of the local frame and some conservative assumptions
   // about the rest of the stack frame (note, this is pre-regalloc, so
   // we don't know everything for certain yet) whether this offset is likely
   // to be out of range of the immediate. Return true if so.
 
   // We only generate virtual base registers for loads and stores, so
   // return false for everything else.
   if (!MI->mayLoad() && !MI->mayStore())
     return false;
 
   // Without a virtual base register, if the function has variable sized
   // objects, all fixed-size local references will be via the frame pointer,
   // Approximate the offset and see if it's legal for the instruction.
   // Note that the incoming offset is based on the SP value at function entry,
   // so it'll be negative.
   MachineFunction &MF = *MI->getParent()->getParent();
   const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
   MachineFrameInfo *MFI = MF.getFrameInfo();
 
   // Estimate an offset from the frame pointer.
   // Conservatively assume all GPR callee-saved registers get pushed.
   // FP, LR, X19-X28, D8-D15. 64-bits each.
   int64_t FPOffset = Offset - 16 * 20;
   // Estimate an offset from the stack pointer.
   // The incoming offset is relating to the SP at the start of the function,
   // but when we access the local it'll be relative to the SP after local
   // allocation, so adjust our SP-relative offset by that allocation size.
   Offset += MFI->getLocalFrameSize();
   // Assume that we'll have at least some spill slots allocated.
   // FIXME: This is a total SWAG number. We should run some statistics
   //        and pick a real one.
   Offset += 128; // 128 bytes of spill slots
 
   // If there is a frame pointer, try using it.
   // The FP is only available if there is no dynamic realignment. We
   // don't know for sure yet whether we'll need that, so we guess based
   // on whether there are any local variables that would trigger it.
   if (TFI->hasFP(MF) && isFrameOffsetLegal(MI, FPOffset))
     return false;
 
   // If we can reference via the stack pointer or base pointer, try that.
   // FIXME: This (and the code that resolves the references) can be improved
   //        to only disallow SP relative references in the live range of
   //        the VLA(s). In practice, it's unclear how much difference that
   //        would make, but it may be worth doing.
   if (isFrameOffsetLegal(MI, Offset))
     return false;
 
   // The offset likely isn't legal; we want to allocate a virtual base register.
   return true;
 }
 
 bool AArch64RegisterInfo::isFrameOffsetLegal(const MachineInstr *MI,
                                              int64_t Offset) const {
   assert(Offset <= INT_MAX && "Offset too big to fit in int.");
   assert(MI && "Unable to get the legal offset for nil instruction.");
   int SaveOffset = Offset;
   return isAArch64FrameOffsetLegal(*MI, SaveOffset) & AArch64FrameOffsetIsLegal;
 }
 
 /// Insert defining instruction(s) for BaseReg to be a pointer to FrameIdx
 /// at the beginning of the basic block.
 void AArch64RegisterInfo::materializeFrameBaseRegister(MachineBasicBlock *MBB,
                                                        unsigned BaseReg,
                                                        int FrameIdx,
                                                        int64_t Offset) const {
   MachineBasicBlock::iterator Ins = MBB->begin();
   DebugLoc DL; // Defaults to "unknown"
   if (Ins != MBB->end())
     DL = Ins->getDebugLoc();
 
   const MCInstrDesc &MCID = TII->get(AArch64::ADDXri);
   MachineRegisterInfo &MRI = MBB->getParent()->getRegInfo();
   const MachineFunction &MF = *MBB->getParent();
   MRI.constrainRegClass(BaseReg, TII->getRegClass(MCID, 0, this, MF));
   unsigned Shifter = AArch64_AM::getShifterImm(AArch64_AM::LSL, 0);
 
   BuildMI(*MBB, Ins, DL, MCID, BaseReg)
       .addFrameIndex(FrameIdx)
       .addImm(Offset)
       .addImm(Shifter);
 }
 
 void AArch64RegisterInfo::resolveFrameIndex(MachineInstr &MI, unsigned BaseReg,
                                             int64_t Offset) const {
   int Off = Offset; // ARM doesn't need the general 64-bit offsets
   unsigned i = 0;
 
   while (!MI.getOperand(i).isFI()) {
     ++i;
     assert(i < MI.getNumOperands() && "Instr doesn't have FrameIndex operand!");
   }
   bool Done = rewriteAArch64FrameIndex(MI, i, BaseReg, Off, TII);
   assert(Done && "Unable to resolve frame index!");
   (void)Done;
 }
 
 void AArch64RegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II,
                                               int SPAdj, unsigned FIOperandNum,
                                               RegScavenger *RS) const {
   assert(SPAdj == 0 && "Unexpected");
 
   MachineInstr &MI = *II;
   MachineBasicBlock &MBB = *MI.getParent();
   MachineFunction &MF = *MBB.getParent();
   const AArch64FrameLowering *TFI = static_cast<const AArch64FrameLowering *>(
       MF.getSubtarget().getFrameLowering());
 
   int FrameIndex = MI.getOperand(FIOperandNum).getIndex();
   unsigned FrameReg;
   int Offset;
 
   // Special handling of dbg_value, stackmap and patchpoint instructions.
   if (MI.isDebugValue() || MI.getOpcode() == TargetOpcode::STACKMAP ||
       MI.getOpcode() == TargetOpcode::PATCHPOINT) {
     Offset = TFI->resolveFrameIndexReference(MF, FrameIndex, FrameReg,
                                              /*PreferFP=*/true);
     Offset += MI.getOperand(FIOperandNum + 1).getImm();
     MI.getOperand(FIOperandNum).ChangeToRegister(FrameReg, false /*isDef*/);
     MI.getOperand(FIOperandNum + 1).ChangeToImmediate(Offset);
     return;
   }
 
   // Modify MI as necessary to handle as much of 'Offset' as possible
   Offset = TFI->resolveFrameIndexReference(MF, FrameIndex, FrameReg);
   if (rewriteAArch64FrameIndex(MI, FIOperandNum, FrameReg, Offset, TII))
     return;
 
   assert((!RS || !RS->isScavengingFrameIndex(FrameIndex)) &&
          "Emergency spill slot is out of reach");
 
   // If we get here, the immediate doesn't fit into the instruction.  We folded
   // as much as possible above.  Handle the rest, providing a register that is
   // SP+LargeImm.
   unsigned ScratchReg =
       MF.getRegInfo().createVirtualRegister(&AArch64::GPR64RegClass);
   emitFrameOffset(MBB, II, MI.getDebugLoc(), ScratchReg, FrameReg, Offset, TII);
   MI.getOperand(FIOperandNum).ChangeToRegister(ScratchReg, false, false, true);
 }
 
 namespace llvm {
 
 unsigned AArch64RegisterInfo::getRegPressureLimit(const TargetRegisterClass *RC,
                                                   MachineFunction &MF) const {
   const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
 
   switch (RC->getID()) {
   default:
     return 0;
   case AArch64::GPR32RegClassID:
   case AArch64::GPR32spRegClassID:
   case AArch64::GPR32allRegClassID:
   case AArch64::GPR64spRegClassID:
   case AArch64::GPR64allRegClassID:
   case AArch64::GPR64RegClassID:
   case AArch64::GPR32commonRegClassID:
   case AArch64::GPR64commonRegClassID:
     return 32 - 1                                      // XZR/SP
            - (TFI->hasFP(MF) || STI->isTargetDarwin()) // FP
-           - STI->isTargetDarwin() // X18 reserved as platform register
+           - (STI->isTargetDarwin() || ReserveX18) // X18 reserved as platform register
            - hasBasePointer(MF);   // X19
   case AArch64::FPR8RegClassID:
   case AArch64::FPR16RegClassID:
   case AArch64::FPR32RegClassID:
   case AArch64::FPR64RegClassID:
   case AArch64::FPR128RegClassID:
     return 32;
 
   case AArch64::DDRegClassID:
   case AArch64::DDDRegClassID:
   case AArch64::DDDDRegClassID:
   case AArch64::QQRegClassID:
   case AArch64::QQQRegClassID:
   case AArch64::QQQQRegClassID:
     return 32;
 
   case AArch64::FPR128_loRegClassID:
     return 16;
   }
 }
 
 } // namespace llvm
Index: projects/clang360-import/contrib/llvm/patches/patch-06-llvm-r226664-aarch64-x18.diff
===================================================================
--- projects/clang360-import/contrib/llvm/patches/patch-06-llvm-r226664-aarch64-x18.diff	(nonexistent)
+++ projects/clang360-import/contrib/llvm/patches/patch-06-llvm-r226664-aarch64-x18.diff	(revision 277778)
@@ -0,0 +1,83 @@
+Pull in r226664 from upstream llvm trunk (by Tim Northover):
+
+  AArch64: add backend option to reserve x18 (platform register)
+
+  AAPCS64 says that it's up to the platform to specify whether x18 is
+  reserved, and a first step on that way is to add a flag controlling
+  it.
+
+  From: Andrew Turner <andrew@fubar.geek.nz>
+
+Introduced here: http://svnweb.freebsd.org/changeset/base/277774
+
+Index: lib/Target/AArch64/AArch64RegisterInfo.cpp
+===================================================================
+--- lib/Target/AArch64/AArch64RegisterInfo.cpp
++++ lib/Target/AArch64/AArch64RegisterInfo.cpp
+@@ -33,6 +33,10 @@ using namespace llvm;
+ #define GET_REGINFO_TARGET_DESC
+ #include "AArch64GenRegisterInfo.inc"
+ 
++static cl::opt<bool>
++ReserveX18("aarch64-reserve-x18", cl::Hidden,
++          cl::desc("Reserve X18, making it unavailable as GPR"));
++
+ AArch64RegisterInfo::AArch64RegisterInfo(const AArch64InstrInfo *tii,
+                                          const AArch64Subtarget *sti)
+     : AArch64GenRegisterInfo(AArch64::LR), TII(tii), STI(sti) {}
+@@ -90,7 +94,7 @@ AArch64RegisterInfo::getReservedRegs(const Machine
+     Reserved.set(AArch64::W29);
+   }
+ 
+-  if (STI->isTargetDarwin()) {
++  if (STI->isTargetDarwin() || ReserveX18) {
+     Reserved.set(AArch64::X18); // Platform register
+     Reserved.set(AArch64::W18);
+   }
+@@ -117,7 +121,7 @@ bool AArch64RegisterInfo::isReservedReg(const Mach
+     return true;
+   case AArch64::X18:
+   case AArch64::W18:
+-    return STI->isTargetDarwin();
++    return STI->isTargetDarwin() || ReserveX18;
+   case AArch64::FP:
+   case AArch64::W29:
+     return TFI->hasFP(MF) || STI->isTargetDarwin();
+@@ -379,7 +383,7 @@ unsigned AArch64RegisterInfo::getRegPressureLimit(
+   case AArch64::GPR64commonRegClassID:
+     return 32 - 1                                      // XZR/SP
+            - (TFI->hasFP(MF) || STI->isTargetDarwin()) // FP
+-           - STI->isTargetDarwin() // X18 reserved as platform register
++           - (STI->isTargetDarwin() || ReserveX18) // X18 reserved as platform register
+            - hasBasePointer(MF);   // X19
+   case AArch64::FPR8RegClassID:
+   case AArch64::FPR16RegClassID:
+Index: test/CodeGen/AArch64/arm64-platform-reg.ll
+===================================================================
+--- test/CodeGen/AArch64/arm64-platform-reg.ll
++++ test/CodeGen/AArch64/arm64-platform-reg.ll
+@@ -1,4 +1,5 @@
+-; RUN: llc -mtriple=arm64-apple-ios -o - %s | FileCheck %s --check-prefix=CHECK-DARWIN
++; RUN: llc -mtriple=arm64-apple-ios -o - %s | FileCheck %s --check-prefix=CHECK-RESERVE-X18
++; RUN: llc -mtriple=arm64-freebsd-gnu -aarch64-reserve-x18 -o - %s | FileCheck %s --check-prefix=CHECK-RESERVE-X18
+ ; RUN: llc -mtriple=arm64-linux-gnu -o - %s | FileCheck %s
+ 
+ ; x18 is reserved as a platform register on Darwin but not on other
+@@ -16,11 +17,11 @@ define void @keep_live() {
+ ; CHECK: ldr x18
+ ; CHECK: str x18
+ 
+-; CHECK-DARWIN-NOT: ldr fp
+-; CHECK-DARWIN-NOT: ldr x18
+-; CHECK-DARWIN: Spill
+-; CHECK-DARWIN-NOT: ldr fp
+-; CHECK-DARWIN-NOT: ldr x18
+-; CHECK-DARWIN: ret
++; CHECK-RESERVE-X18-NOT: ldr fp
++; CHECK-RESERVE-X18-NOT: ldr x18
++; CHECK-RESERVE-X18: Spill
++; CHECK-RESERVE-X18-NOT: ldr fp
++; CHECK-RESERVE-X18-NOT: ldr x18
++; CHECK-RESERVE-X18: ret
+   ret void
+ }
Index: projects/clang360-import/contrib/llvm/patches/patch-07-clang-r227062-fixes-x18.diff
===================================================================
--- projects/clang360-import/contrib/llvm/patches/patch-07-clang-r227062-fixes-x18.diff	(nonexistent)
+++ projects/clang360-import/contrib/llvm/patches/patch-07-clang-r227062-fixes-x18.diff	(revision 277778)
@@ -0,0 +1,53 @@
+Pull in r227062 from upstream clang trunk (by Renato Golin):
+
+  Allows Clang to use LLVM's fixes-x18 option
+
+  This patch allows clang to have llvm reserve the x18
+  platform register on AArch64. FreeBSD will use this in the kernel for
+  per-cpu data but has no need to reserve this register in userland so
+  will need this flag to reserve it.
+
+  This uses llvm r226664 to allow this register to be reserved.
+
+  Patch by Andrew Turner.
+
+Introduced here: http://svnweb.freebsd.org/changeset/base/277775
+
+Index: tools/clang/include/clang/Driver/Options.td
+===================================================================
+--- tools/clang/include/clang/Driver/Options.td
++++ tools/clang/include/clang/Driver/Options.td
+@@ -1209,6 +1209,8 @@ def mfix_cortex_a53_835769 : Flag<["-"], "mfix-cor
+ def mno_fix_cortex_a53_835769 : Flag<["-"], "mno-fix-cortex-a53-835769">,
+   Group<m_aarch64_Features_Group>,
+   HelpText<"Don't workaround Cortex-A53 erratum 835769 (AArch64 only)">;
++def ffixed_x18 : Flag<["-"], "ffixed-x18">, Group<m_aarch64_Features_Group>,
++  HelpText<"Reserve the x18 register (AArch64 only)">;
+ 
+ def mvsx : Flag<["-"], "mvsx">, Group<m_ppc_Features_Group>;
+ def mno_vsx : Flag<["-"], "mno-vsx">, Group<m_ppc_Features_Group>;
+Index: tools/clang/lib/Driver/Tools.cpp
+===================================================================
+--- tools/clang/lib/Driver/Tools.cpp
++++ tools/clang/lib/Driver/Tools.cpp
+@@ -958,6 +958,11 @@ void Clang::AddAArch64TargetArgs(const ArgList &Ar
+     if (A->getOption().matches(options::OPT_mno_global_merge))
+       CmdArgs.push_back("-mno-global-merge");
+   }
++
++  if (Args.hasArg(options::OPT_ffixed_x18)) {
++    CmdArgs.push_back("-backend-option");
++    CmdArgs.push_back("-aarch64-reserve-x18");
++  }
+ }
+ 
+ // Get CPU and ABI names. They are not independent
+Index: tools/clang/test/Driver/aarch64-fixed-x18.c
+===================================================================
+--- tools/clang/test/Driver/aarch64-fixed-x18.c
++++ tools/clang/test/Driver/aarch64-fixed-x18.c
+@@ -0,0 +1,4 @@
++// RUN: %clang -target aarch64-none-gnu -ffixed-x18 -### %s 2> %t
++// RUN: FileCheck --check-prefix=CHECK-FIXED-X18 < %t %s
++
++// CHECK-FIXED-X18: "-backend-option" "-aarch64-reserve-x18"
Index: projects/clang360-import/contrib/llvm/tools/clang/include/clang/Driver/Options.td
===================================================================
--- projects/clang360-import/contrib/llvm/tools/clang/include/clang/Driver/Options.td	(revision 277777)
+++ projects/clang360-import/contrib/llvm/tools/clang/include/clang/Driver/Options.td	(revision 277778)
@@ -1,1864 +1,1866 @@
 //===--- Options.td - Options for clang -----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the options accepted by clang.
 //
 //===----------------------------------------------------------------------===//
 
 // Include the common option parsing interfaces.
 include "llvm/Option/OptParser.td"
 
 /////////
 // Flags
 
 // DriverOption - The option is a "driver" option, and should not be forwarded
 // to other tools.
 def DriverOption : OptionFlag;
 
 // LinkerInput - The option is a linker input.
 def LinkerInput : OptionFlag;
 
 // NoArgumentUnused - Don't report argument unused warnings for this option; this
 // is useful for options like -static or -dynamic which a user may always end up
 // passing, even if the platform defaults to (or only supports) that option.
 def NoArgumentUnused : OptionFlag;
 
 // Unsupported - The option is unsupported, and the driver will reject command
 // lines that use it.
 def Unsupported : OptionFlag;
 
 // CoreOption - This is considered a "core" Clang option, available in both
 // clang and clang-cl modes.
 def CoreOption : OptionFlag;
 
 // CLOption - This is a cl.exe compatibility option. Options with this flag
 // are made available when the driver is running in CL compatibility mode.
 def CLOption : OptionFlag;
 
 // CC1Option - This option should be accepted by clang -cc1.
 def CC1Option : OptionFlag;
 
 // CC1AsOption - This option should be accepted by clang -cc1as.
 def CC1AsOption : OptionFlag;
 
 // NoDriverOption - This option should not be accepted by the driver.
 def NoDriverOption : OptionFlag;
 
 /////////
 // Groups
 
 // Meta-group for options which are only used for compilation,
 // and not linking etc.
 def CompileOnly_Group     : OptionGroup<"<CompileOnly group>">;
 
 def Action_Group          : OptionGroup<"<action group>">;
 
 def I_Group               : OptionGroup<"<I group>">, Group<CompileOnly_Group>;
 def M_Group               : OptionGroup<"<M group>">, Group<CompileOnly_Group>;
 def T_Group               : OptionGroup<"<T group>">;
 def O_Group               : OptionGroup<"<O group>">, Group<CompileOnly_Group>;
 def R_Group               : OptionGroup<"<R group>">, Group<CompileOnly_Group>;
 def R_value_Group         : OptionGroup<"<R (with value) group>">, Group<R_Group>;
 def W_Group               : OptionGroup<"<W group>">, Group<CompileOnly_Group>;
 def W_value_Group         : OptionGroup<"<W (with value) group>">, Group<W_Group>;
 def d_Group               : OptionGroup<"<d group>">;
 def f_Group               : OptionGroup<"<f group>">, Group<CompileOnly_Group>;
 def f_clang_Group         : OptionGroup<"<f (clang-only) group>">, Group<CompileOnly_Group>;
 def g_Group               : OptionGroup<"<g group>">;
 def g_flags_Group         : OptionGroup<"<g flags group>">;
 def i_Group               : OptionGroup<"<i group>">, Group<CompileOnly_Group>;
 def clang_i_Group         : OptionGroup<"<clang i group>">, Group<i_Group>;
 def m_Group               : OptionGroup<"<m group>">, Group<CompileOnly_Group>;
 def m_x86_Features_Group  : OptionGroup<"<m x86 features group>">, Group<m_Group>, Flags<[CoreOption]>;
 def m_hexagon_Features_Group  : OptionGroup<"<m hexagon features group>">, Group<m_Group>;
 def m_arm_Features_Group  : OptionGroup<"<m arm features group>">, Group<m_Group>;
 def m_aarch64_Features_Group  : OptionGroup<"<m aarch64 features group>">, Group<m_Group>;
 def m_ppc_Features_Group  : OptionGroup<"<m ppc features group>">, Group<m_Group>;
 def m_libc_Group          : OptionGroup<"<m libc group>">, Group<m_Group>;
 def u_Group               : OptionGroup<"<u group>">;
 
 def pedantic_Group        : OptionGroup<"<pedantic group>">,
   Group<CompileOnly_Group>;
 def reserved_lib_Group   : OptionGroup<"<reserved libs group>">;
 
 // Temporary groups for clang options which we know we don't support,
 // but don't want to verbosely warn the user about.
 def clang_ignored_f_Group : OptionGroup<"<clang ignored f group>">,
   Group<f_Group>;
 def clang_ignored_m_Group : OptionGroup<"<clang ignored m group>">,
   Group<m_Group>;
 
 // Group that ignores all gcc optimizations that won't be implemented
 def clang_ignored_gcc_optimization_f_Group : OptionGroup<
   "<clang_ignored_gcc_optimization_f_Group>">, Group<f_Group>;
 
 /////////
 // Options
 
 // The internal option ID must be a valid C++ identifier and results in a
 // clang::driver::options::OPT_XX enum constant for XX.
 //
 // We want to unambiguously be able to refer to options from the driver source
 // code, for this reason the option name is mangled into an ID. This mangling
 // isn't guaranteed to have an inverse, but for practical purposes it does.
 //
 // The mangling scheme is to ignore the leading '-', and perform the following
 // substitutions:
 //   _ => __
 //   - => _
 //   / => _SLASH
 //   # => _HASH
 //   ? => _QUESTION
 //   , => _COMMA
 //   = => _EQ
 //   C++ => CXX
 //   . => _
 
 // Developer Driver Options
 
 def internal_Group : OptionGroup<"<clang internal options>">;
 def internal_driver_Group : OptionGroup<"<clang driver internal options>">,
   Group<internal_Group>, HelpText<"DRIVER OPTIONS">;
 def internal_debug_Group :
   OptionGroup<"<clang debug/development internal options>">,
   Group<internal_Group>, HelpText<"DEBUG/DEVELOPMENT OPTIONS">;
 
 class InternalDriverOpt : Group<internal_driver_Group>,
   Flags<[DriverOption, HelpHidden]>;
 def driver_mode : Joined<["--"], "driver-mode=">, Group<internal_driver_Group>,
   Flags<[CoreOption, DriverOption, HelpHidden]>,
   HelpText<"Set the driver mode to either 'gcc', 'g++', 'cpp', or 'cl'">;
 def ccc_gcc_name : Separate<["-"], "ccc-gcc-name">, InternalDriverOpt,
   HelpText<"Name for native GCC compiler">,
   MetaVarName<"<gcc-path>">;
 def ccc_pch_is_pch : Flag<["-"], "ccc-pch-is-pch">, InternalDriverOpt,
   HelpText<"Use lazy PCH for precompiled headers">;
 def ccc_pch_is_pth : Flag<["-"], "ccc-pch-is-pth">, InternalDriverOpt,
   HelpText<"Use pretokenized headers for precompiled headers">;
 
 class InternalDebugOpt : Group<internal_debug_Group>,
   Flags<[DriverOption, HelpHidden]>;
 def ccc_install_dir : Separate<["-"], "ccc-install-dir">, InternalDebugOpt,
   HelpText<"Simulate installation in the given directory">;
 def ccc_print_phases : Flag<["-"], "ccc-print-phases">, InternalDebugOpt,
   HelpText<"Dump list of actions to perform">;
 def ccc_print_bindings : Flag<["-"], "ccc-print-bindings">, InternalDebugOpt,
   HelpText<"Show bindings of tools to actions">;
 
 def ccc_arcmt_check : Flag<["-"], "ccc-arcmt-check">, InternalDriverOpt,
   HelpText<"Check for ARC migration issues that need manual handling">;
 def ccc_arcmt_modify : Flag<["-"], "ccc-arcmt-modify">, InternalDriverOpt,
   HelpText<"Apply modifications to files to conform to ARC">;
 def ccc_arcmt_migrate : Separate<["-"], "ccc-arcmt-migrate">, InternalDriverOpt,
   HelpText<"Apply modifications and produces temporary files that conform to ARC">;
 def arcmt_migrate_report_output : Separate<["-"], "arcmt-migrate-report-output">,
   HelpText<"Output path for the plist report">,  Flags<[CC1Option]>;
 def arcmt_migrate_emit_arc_errors : Flag<["-"], "arcmt-migrate-emit-errors">,
   HelpText<"Emit ARC errors even if the migrator can fix them">,
   Flags<[CC1Option]>;
 
 def _migrate : Flag<["--"], "migrate">, Flags<[DriverOption]>,
   HelpText<"Run the migrator">;
 def ccc_objcmt_migrate : Separate<["-"], "ccc-objcmt-migrate">,
   InternalDriverOpt,
   HelpText<"Apply modifications and produces temporary files to migrate to "
    "modern ObjC syntax">;
 def objcmt_migrate_literals : Flag<["-"], "objcmt-migrate-literals">, Flags<[CC1Option]>,
   HelpText<"Enable migration to modern ObjC literals">;
 def objcmt_migrate_subscripting : Flag<["-"], "objcmt-migrate-subscripting">, Flags<[CC1Option]>,
   HelpText<"Enable migration to modern ObjC subscripting">;
 def objcmt_migrate_property : Flag<["-"], "objcmt-migrate-property">, Flags<[CC1Option]>,
   HelpText<"Enable migration to modern ObjC property">;
 def objcmt_migrate_all : Flag<["-"], "objcmt-migrate-all">, Flags<[CC1Option]>,
   HelpText<"Enable migration to modern ObjC">;
 def objcmt_migrate_readonly_property : Flag<["-"], "objcmt-migrate-readonly-property">, Flags<[CC1Option]>,
   HelpText<"Enable migration to modern ObjC readonly property">;
 def objcmt_migrate_readwrite_property : Flag<["-"], "objcmt-migrate-readwrite-property">, Flags<[CC1Option]>,
   HelpText<"Enable migration to modern ObjC readwrite property">;
 def objcmt_migrate_property_dot_syntax : Flag<["-"], "objcmt-migrate-property-dot-syntax">, Flags<[CC1Option]>,
   HelpText<"Enable migration of setter/getter messages to property-dot syntax">;
 def objcmt_migrate_annotation : Flag<["-"], "objcmt-migrate-annotation">, Flags<[CC1Option]>,
   HelpText<"Enable migration to property and method annotations">;
 def objcmt_migrate_instancetype : Flag<["-"], "objcmt-migrate-instancetype">, Flags<[CC1Option]>,
   HelpText<"Enable migration to infer instancetype for method result type">;
 def objcmt_migrate_nsmacros : Flag<["-"], "objcmt-migrate-ns-macros">, Flags<[CC1Option]>,
   HelpText<"Enable migration to NS_ENUM/NS_OPTIONS macros">;
 def objcmt_migrate_protocol_conformance : Flag<["-"], "objcmt-migrate-protocol-conformance">, Flags<[CC1Option]>,
   HelpText<"Enable migration to add protocol conformance on classes">;
 def objcmt_atomic_property : Flag<["-"], "objcmt-atomic-property">, Flags<[CC1Option]>,
   HelpText<"Make migration to 'atomic' properties">;
 def objcmt_returns_innerpointer_property : Flag<["-"], "objcmt-returns-innerpointer-property">, Flags<[CC1Option]>,
   HelpText<"Enable migration to annotate property with NS_RETURNS_INNER_POINTER">;
 def objcmt_ns_nonatomic_iosonly: Flag<["-"], "objcmt-ns-nonatomic-iosonly">, Flags<[CC1Option]>,
   HelpText<"Enable migration to use NS_NONATOMIC_IOSONLY macro for setting property's 'atomic' attribute">;
 def objcmt_migrate_designated_init : Flag<["-"], "objcmt-migrate-designated-init">, Flags<[CC1Option]>,
   HelpText<"Enable migration to infer NS_DESIGNATED_INITIALIZER for initializer methods">;
 def objcmt_whitelist_dir_path: Joined<["-"], "objcmt-whitelist-dir-path=">, Flags<[CC1Option]>,
   HelpText<"Only modify files with a filename contained in the provided directory path">;
 // The misspelt "white-list" [sic] alias is due for removal.
 def : Joined<["-"], "objcmt-white-list-dir-path=">, Flags<[CC1Option]>,
     Alias<objcmt_whitelist_dir_path>;
 
 // Make sure all other -ccc- options are rejected.
 def ccc_ : Joined<["-"], "ccc-">, Group<internal_Group>, Flags<[Unsupported]>;
 
 // Standard Options
 
 def _HASH_HASH_HASH : Flag<["-"], "###">, Flags<[DriverOption, CoreOption]>,
     HelpText<"Print (but do not run) the commands to run for this compilation">;
 def _DASH_DASH : Option<["--"], "", KIND_REMAINING_ARGS>,
     Flags<[DriverOption, CoreOption]>;
 def A : JoinedOrSeparate<["-"], "A">, Flags<[RenderJoined]>;
 def B : JoinedOrSeparate<["-"], "B">;
 def CC : Flag<["-"], "CC">, Flags<[CC1Option]>;
 def C : Flag<["-"], "C">, Flags<[CC1Option]>;
 def D : JoinedOrSeparate<["-"], "D">, Group<CompileOnly_Group>, Flags<[CC1Option]>;
 def E : Flag<["-"], "E">, Flags<[DriverOption,CC1Option]>, Group<Action_Group>,
   HelpText<"Only run the preprocessor">;
 def F : JoinedOrSeparate<["-"], "F">, Flags<[RenderJoined,CC1Option]>,
     HelpText<"Add directory to framework include search path">;
 def G : JoinedOrSeparate<["-"], "G">, Flags<[DriverOption]>;
 def G_EQ : Joined<["-"], "G=">, Flags<[DriverOption]>;
 def H : Flag<["-"], "H">, Flags<[CC1Option]>,
     HelpText<"Show header includes and nesting depth">;
 def I_ : Flag<["-"], "I-">, Group<I_Group>;
 def I : JoinedOrSeparate<["-"], "I">, Group<I_Group>, Flags<[CC1Option,CC1AsOption]>,
     HelpText<"Add directory to include search path">;
 def L : JoinedOrSeparate<["-"], "L">, Flags<[RenderJoined]>;
 def MD : Flag<["-"], "MD">, Group<M_Group>,
     HelpText<"Write a depfile containing user and system headers">;
 def MMD : Flag<["-"], "MMD">, Group<M_Group>,
     HelpText<"Write a depfile containing user headers">;
 def M : Flag<["-"], "M">, Group<M_Group>,
     HelpText<"Like -MD, but also implies -E and writes to stdout by default">;
 def MM : Flag<["-"], "MM">, Group<M_Group>,
     HelpText<"Like -MMD, but also implies -E and writes to stdout by default">;
 def MF : JoinedOrSeparate<["-"], "MF">, Group<M_Group>,
     HelpText<"Write depfile output from -MMD, -MD, -MM, or -M to <file>">,
     MetaVarName<"<file>">;
 def MG : Flag<["-"], "MG">, Group<M_Group>, Flags<[CC1Option]>,
     HelpText<"Add missing headers to depfile">;
 def MP : Flag<["-"], "MP">, Group<M_Group>, Flags<[CC1Option]>,
     HelpText<"Create phony target for each dependency (other than main file)">;
 def MQ : JoinedOrSeparate<["-"], "MQ">, Group<M_Group>, Flags<[CC1Option]>,
     HelpText<"Specify name of main file output to quote in depfile">;
 def MT : JoinedOrSeparate<["-"], "MT">, Group<M_Group>, Flags<[CC1Option]>,
     HelpText<"Specify name of main file output in depfile">;
 def Mach : Flag<["-"], "Mach">;
 def O0 : Flag<["-"], "O0">, Group<O_Group>, Flags<[CC1Option]>;
 def O4 : Flag<["-"], "O4">, Group<O_Group>, Flags<[CC1Option]>;
 def ObjCXX : Flag<["-"], "ObjC++">, Flags<[DriverOption]>,
   HelpText<"Treat source input files as Objective-C++ inputs">;
 def ObjC : Flag<["-"], "ObjC">, Flags<[DriverOption]>,
   HelpText<"Treat source input files as Objective-C inputs">;
 def O : Joined<["-"], "O">, Group<O_Group>, Flags<[CC1Option]>;
 def O_flag : Flag<["-"], "O">, Flags<[CC1Option]>, Alias<O>, AliasArgs<["2"]>;
 def Ofast : Joined<["-"], "Ofast">, Group<O_Group>, Flags<[CC1Option]>;
 def P : Flag<["-"], "P">, Flags<[CC1Option]>,
   HelpText<"Disable linemarker output in -E mode">;
 def Qn : Flag<["-"], "Qn">;
 def Qunused_arguments : Flag<["-"], "Qunused-arguments">, Flags<[DriverOption, CoreOption]>,
   HelpText<"Don't emit warning for unused driver arguments">;
 def Q : Flag<["-"], "Q">;
 def Rpass_EQ : Joined<["-"], "Rpass=">, Group<R_value_Group>, Flags<[CC1Option]>,
   HelpText<"Report transformations performed by optimization passes whose "
            "name matches the given POSIX regular expression">;
 def Rpass_missed_EQ : Joined<["-"], "Rpass-missed=">, Group<R_value_Group>,
   Flags<[CC1Option]>,
   HelpText<"Report missed transformations by optimization passes whose "
            "name matches the given POSIX regular expression">;
 def Rpass_analysis_EQ : Joined<["-"], "Rpass-analysis=">, Group<R_value_Group>,
   Flags<[CC1Option]>,
   HelpText<"Report transformation analysis from optimization passes whose "
            "name matches the given POSIX regular expression">;
 def R_Joined : Joined<["-"], "R">, Group<R_Group>, Flags<[CC1Option, CoreOption]>,
   MetaVarName<"<remark>">, HelpText<"Enable the specified remark">;
 def S : Flag<["-"], "S">, Flags<[DriverOption,CC1Option]>, Group<Action_Group>,
   HelpText<"Only run preprocess and compilation steps">;
 def Tbss : JoinedOrSeparate<["-"], "Tbss">, Group<T_Group>;
 def Tdata : JoinedOrSeparate<["-"], "Tdata">, Group<T_Group>;
 def Ttext : JoinedOrSeparate<["-"], "Ttext">, Group<T_Group>;
 def T : JoinedOrSeparate<["-"], "T">, Group<T_Group>;
 def U : JoinedOrSeparate<["-"], "U">, Group<CompileOnly_Group>, Flags<[CC1Option]>;
 def V : JoinedOrSeparate<["-"], "V">, Flags<[DriverOption, Unsupported]>;
 def Wa_COMMA : CommaJoined<["-"], "Wa,">,
   HelpText<"Pass the comma separated arguments in <arg> to the assembler">,
   MetaVarName<"<arg>">;
 def Wall : Flag<["-"], "Wall">, Group<W_Group>, Flags<[CC1Option]>;
 def Wdeprecated : Flag<["-"], "Wdeprecated">, Group<W_Group>, Flags<[CC1Option]>;
 def Wno_deprecated : Flag<["-"], "Wno-deprecated">, Group<W_Group>, Flags<[CC1Option]>;
 def Wextra : Flag<["-"], "Wextra">, Group<W_Group>, Flags<[CC1Option]>;
 def Wl_COMMA : CommaJoined<["-"], "Wl,">, Flags<[LinkerInput, RenderAsInput]>,
   HelpText<"Pass the comma separated arguments in <arg> to the linker">,
   MetaVarName<"<arg>">;
 // FIXME: This is broken; these should not be Joined arguments.
 def Wno_nonportable_cfstrings : Joined<["-"], "Wno-nonportable-cfstrings">, Group<W_Group>,
   Flags<[CC1Option]>;
 def Wnonportable_cfstrings : Joined<["-"], "Wnonportable-cfstrings">, Group<W_Group>,
   Flags<[CC1Option]>;
 def Wp_COMMA : CommaJoined<["-"], "Wp,">,
   HelpText<"Pass the comma separated arguments in <arg> to the preprocessor">,
   MetaVarName<"<arg>">;
 def Wwrite_strings : Flag<["-"], "Wwrite-strings">, Group<W_Group>, Flags<[CC1Option]>;
 def Wno_write_strings : Flag<["-"], "Wno-write-strings">, Group<W_Group>, Flags<[CC1Option]>;
 def W_Joined : Joined<["-"], "W">, Group<W_Group>, Flags<[CC1Option, CoreOption]>,
   MetaVarName<"<warning>">, HelpText<"Enable the specified warning">;
 def Xanalyzer : Separate<["-"], "Xanalyzer">,
   HelpText<"Pass <arg> to the static analyzer">, MetaVarName<"<arg>">;
 def Xarch__ : JoinedAndSeparate<["-"], "Xarch_">, Flags<[DriverOption]>;
 def Xassembler : Separate<["-"], "Xassembler">,
   HelpText<"Pass <arg> to the assembler">, MetaVarName<"<arg>">;
 def Xclang : Separate<["-"], "Xclang">,
   HelpText<"Pass <arg> to the clang compiler">, MetaVarName<"<arg>">,
   Flags<[DriverOption, CoreOption]>;
 def z : Separate<["-"], "z">, Flags<[LinkerInput, RenderAsInput]>,
   HelpText<"Pass -z <arg> to the linker">, MetaVarName<"<arg>">;
 def Xlinker : Separate<["-"], "Xlinker">, Flags<[LinkerInput, RenderAsInput]>,
   HelpText<"Pass <arg> to the linker">, MetaVarName<"<arg>">;
 def Xpreprocessor : Separate<["-"], "Xpreprocessor">,
   HelpText<"Pass <arg> to the preprocessor">, MetaVarName<"<arg>">;
 def X_Flag : Flag<["-"], "X">;
 def X_Joined : Joined<["-"], "X">;
 def Z_Flag : Flag<["-"], "Z">;
 def Z_Joined : Joined<["-"], "Z">;
 def all__load : Flag<["-"], "all_load">;
 def allowable__client : Separate<["-"], "allowable_client">;
 def ansi : Flag<["-", "--"], "ansi">;
 def arch__errors__fatal : Flag<["-"], "arch_errors_fatal">;
 def arch : Separate<["-"], "arch">, Flags<[DriverOption]>;
 def arch__only : Separate<["-"], "arch_only">;
 def a : Joined<["-"], "a">;
 def bind__at__load : Flag<["-"], "bind_at_load">;
 def bundle__loader : Separate<["-"], "bundle_loader">;
 def bundle : Flag<["-"], "bundle">;
 def b : JoinedOrSeparate<["-"], "b">, Flags<[Unsupported]>;
 def client__name : JoinedOrSeparate<["-"], "client_name">;
 def combine : Flag<["-", "--"], "combine">, Flags<[DriverOption, Unsupported]>;
 def compatibility__version : JoinedOrSeparate<["-"], "compatibility_version">;
 def coverage : Flag<["-", "--"], "coverage">;
 def cpp_precomp : Flag<["-"], "cpp-precomp">, Group<clang_ignored_f_Group>;
 def current__version : JoinedOrSeparate<["-"], "current_version">;
 def cxx_isystem : JoinedOrSeparate<["-"], "cxx-isystem">, Group<clang_i_Group>,
   HelpText<"Add directory to the C++ SYSTEM include search path">, Flags<[CC1Option]>,
   MetaVarName<"<directory>">;
 def c : Flag<["-"], "c">, Flags<[DriverOption]>,
   HelpText<"Only run preprocess, compile, and assemble steps">;
 def dA : Flag<["-"], "dA">, Group<d_Group>;
 def dD : Flag<["-"], "dD">, Group<d_Group>, Flags<[CC1Option]>,
   HelpText<"Print macro definitions in -E mode in addition to normal output">;
 def dM : Flag<["-"], "dM">, Group<d_Group>, Flags<[CC1Option]>,
   HelpText<"Print macro definitions in -E mode instead of normal output">;
 def dead__strip : Flag<["-"], "dead_strip">;
 def dependency_file : Separate<["-"], "dependency-file">, Flags<[CC1Option]>,
   HelpText<"Filename (or -) to write dependency output to">;
 def dependency_dot : Separate<["-"], "dependency-dot">, Flags<[CC1Option]>,
   HelpText<"Filename to write DOT-formatted header dependencies to">;
 def module_dependency_dir : Separate<["-"], "module-dependency-dir">,
   Flags<[CC1Option]>, HelpText<"Directory to dump module dependencies to">;
 def dumpmachine : Flag<["-"], "dumpmachine">;
 def dumpspecs : Flag<["-"], "dumpspecs">, Flags<[Unsupported]>;
 def dumpversion : Flag<["-"], "dumpversion">;
 def dylib__file : Separate<["-"], "dylib_file">;
 def dylinker__install__name : JoinedOrSeparate<["-"], "dylinker_install_name">;
 def dylinker : Flag<["-"], "dylinker">;
 def dynamiclib : Flag<["-"], "dynamiclib">;
 def dynamic : Flag<["-"], "dynamic">, Flags<[NoArgumentUnused]>;
 def d_Flag : Flag<["-"], "d">, Group<d_Group>;
 def d_Joined : Joined<["-"], "d">, Group<d_Group>;
 def emit_ast : Flag<["-"], "emit-ast">,
   HelpText<"Emit Clang AST files for source inputs">;
 def emit_llvm : Flag<["-"], "emit-llvm">, Flags<[CC1Option]>, Group<Action_Group>,
   HelpText<"Use the LLVM representation for assembler and object files">;
 def exported__symbols__list : Separate<["-"], "exported_symbols_list">;
 def e : JoinedOrSeparate<["-"], "e">;
 def fPIC : Flag<["-"], "fPIC">, Group<f_Group>;
 def fno_PIC : Flag<["-"], "fno-PIC">, Group<f_Group>;
 def fPIE : Flag<["-"], "fPIE">, Group<f_Group>;
 def fno_PIE : Flag<["-"], "fno-PIE">, Group<f_Group>;
 def faccess_control : Flag<["-"], "faccess-control">, Group<f_Group>;
 def fallow_unsupported : Flag<["-"], "fallow-unsupported">, Group<f_Group>;
 def fapple_kext : Flag<["-"], "fapple-kext">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Use Apple's kernel extensions ABI">;
 def fapple_pragma_pack : Flag<["-"], "fapple-pragma-pack">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Enable Apple gcc-compatible #pragma pack handling">;
 def shared_libasan : Flag<["-"], "shared-libasan">;
 def fasm : Flag<["-"], "fasm">, Group<f_Group>;
 
 def fasm_blocks : Flag<["-"], "fasm-blocks">, Group<f_Group>, Flags<[CC1Option]>;
 def fno_asm_blocks : Flag<["-"], "fno-asm-blocks">, Group<f_Group>;
 
 def fassume_sane_operator_new : Flag<["-"], "fassume-sane-operator-new">, Group<f_Group>;
 def fastcp : Flag<["-"], "fastcp">, Group<f_Group>;
 def fastf : Flag<["-"], "fastf">, Group<f_Group>;
 def fast : Flag<["-"], "fast">, Group<f_Group>;
 def fasynchronous_unwind_tables : Flag<["-"], "fasynchronous-unwind-tables">, Group<f_Group>;
 
 def fautolink : Flag <["-"], "fautolink">, Group<f_Group>;
 def fno_autolink : Flag <["-"], "fno-autolink">, Group<f_Group>,
   Flags<[DriverOption, CC1Option]>,
   HelpText<"Disable generation of linker directives for automatic library linking">;
 
 def fprofile_sample_use_EQ : Joined<["-"], "fprofile-sample-use=">,
     Group<f_Group>, Flags<[DriverOption, CC1Option]>,
     HelpText<"Enable sample-based profile guided optimizations">;
 def fauto_profile_EQ : Joined<["-"], "fauto-profile=">,
     Alias<fprofile_sample_use_EQ>;
 def fprofile_instr_generate : Flag<["-"], "fprofile-instr-generate">,
     Group<f_Group>, Flags<[CC1Option]>,
     HelpText<"Generate instrumented code to collect execution counts">;
 def fprofile_instr_use : Flag<["-"], "fprofile-instr-use">, Group<f_Group>;
 def fprofile_instr_use_EQ : Joined<["-"], "fprofile-instr-use=">,
     Group<f_Group>, Flags<[CC1Option]>,
     HelpText<"Use instrumentation data for profile-guided optimization">;
 def fcoverage_mapping : Flag<["-"], "fcoverage-mapping">,
     Group<f_Group>, Flags<[CC1Option]>,
     HelpText<"Generate coverage mapping to enable code coverage analysis">;
 
 def fblocks : Flag<["-"], "fblocks">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Enable the 'blocks' language feature">;
 def fbootclasspath_EQ : Joined<["-"], "fbootclasspath=">, Group<f_Group>;
 def fborland_extensions : Flag<["-"], "fborland-extensions">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Accept non-standard constructs supported by the Borland compiler">;
 def fbuiltin : Flag<["-"], "fbuiltin">, Group<f_Group>;
 def fcaret_diagnostics : Flag<["-"], "fcaret-diagnostics">, Group<f_Group>;
 def fclasspath_EQ : Joined<["-"], "fclasspath=">, Group<f_Group>;
 def fcolor_diagnostics : Flag<["-"], "fcolor-diagnostics">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Use colors in diagnostics">;
 def fdiagnostics_color : Flag<["-"], "fdiagnostics-color">, Group<f_Group>;
 def fdiagnostics_color_EQ : Joined<["-"], "fdiagnostics-color=">, Group<f_Group>;
 def fansi_escape_codes : Flag<["-"], "fansi-escape-codes">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Use ANSI escape codes for diagnostics">;
 def fcomment_block_commands : CommaJoined<["-"], "fcomment-block-commands=">, Group<f_clang_Group>, Flags<[CC1Option]>,
   HelpText<"Treat each comma separated argument in <arg> as a documentation comment block command">,
   MetaVarName<"<arg>">;
 def fparse_all_comments : Flag<["-"], "fparse-all-comments">, Group<f_clang_Group>, Flags<[CC1Option]>;
 def fcommon : Flag<["-"], "fcommon">, Group<f_Group>;
 def fcompile_resource_EQ : Joined<["-"], "fcompile-resource=">, Group<f_Group>;
 def fconstant_cfstrings : Flag<["-"], "fconstant-cfstrings">, Group<f_Group>;
 def fconstant_string_class_EQ : Joined<["-"], "fconstant-string-class=">, Group<f_Group>;
 def fconstexpr_depth_EQ : Joined<["-"], "fconstexpr-depth=">, Group<f_Group>;
 def fconstexpr_steps_EQ : Joined<["-"], "fconstexpr-steps=">, Group<f_Group>;
 def fconstexpr_backtrace_limit_EQ : Joined<["-"], "fconstexpr-backtrace-limit=">,
                                     Group<f_Group>;
 def fno_crash_diagnostics : Flag<["-"], "fno-crash-diagnostics">, Group<f_clang_Group>, Flags<[NoArgumentUnused]>;
 def fcreate_profile : Flag<["-"], "fcreate-profile">, Group<f_Group>;
 def fcxx_exceptions: Flag<["-"], "fcxx-exceptions">, Group<f_Group>,
   HelpText<"Enable C++ exceptions">, Flags<[CC1Option]>;
 def fcxx_modules : Flag <["-"], "fcxx-modules">, Group<f_Group>,
   Flags<[DriverOption]>;
 def fdebug_pass_arguments : Flag<["-"], "fdebug-pass-arguments">, Group<f_Group>;
 def fdebug_pass_structure : Flag<["-"], "fdebug-pass-structure">, Group<f_Group>;
 def fdiagnostics_fixit_info : Flag<["-"], "fdiagnostics-fixit-info">, Group<f_clang_Group>;
 def fdiagnostics_parseable_fixits : Flag<["-"], "fdiagnostics-parseable-fixits">, Group<f_clang_Group>,
     Flags<[CC1Option]>, HelpText<"Print fix-its in machine parseable form">;
 def fdiagnostics_print_source_range_info : Flag<["-"], "fdiagnostics-print-source-range-info">,
     Group<f_clang_Group>,  Flags<[CC1Option]>,
     HelpText<"Print source range spans in numeric form">;
 def fdiagnostics_show_option : Flag<["-"], "fdiagnostics-show-option">, Group<f_Group>,
     Flags<[CC1Option]>, HelpText<"Print option name with mappable diagnostics">;
 def fdiagnostics_show_note_include_stack : Flag<["-"], "fdiagnostics-show-note-include-stack">,
     Group<f_Group>,  Flags<[CC1Option]>, HelpText<"Display include stacks for diagnostic notes">;
 def fdiagnostics_format_EQ : Joined<["-"], "fdiagnostics-format=">, Group<f_clang_Group>;
 def fdiagnostics_show_category_EQ : Joined<["-"], "fdiagnostics-show-category=">, Group<f_clang_Group>;
 def fdiagnostics_show_template_tree : Flag<["-"], "fdiagnostics-show-template-tree">,
     Group<f_Group>, Flags<[CC1Option]>,
     HelpText<"Print a template comparison tree for differing templates">;
 def fdollars_in_identifiers : Flag<["-"], "fdollars-in-identifiers">, Group<f_Group>,
   HelpText<"Allow '$' in identifiers">, Flags<[CC1Option]>;
 def fdwarf2_cfi_asm : Flag<["-"], "fdwarf2-cfi-asm">, Group<clang_ignored_f_Group>;
 def fno_dwarf2_cfi_asm : Flag<["-"], "fno-dwarf2-cfi-asm">, Group<clang_ignored_f_Group>;
 def fdwarf_directory_asm : Flag<["-"], "fdwarf-directory-asm">, Group<f_Group>;
 def fno_dwarf_directory_asm : Flag<["-"], "fno-dwarf-directory-asm">, Group<f_Group>, Flags<[CC1Option]>;
 def felide_constructors : Flag<["-"], "felide-constructors">, Group<f_Group>;
 def fno_elide_type : Flag<["-"], "fno-elide-type">, Group<f_Group>,
     Flags<[CC1Option]>,
     HelpText<"Do not elide types when printing diagnostics">;
 def feliminate_unused_debug_symbols : Flag<["-"], "feliminate-unused-debug-symbols">, Group<f_Group>;
 def femit_all_decls : Flag<["-"], "femit-all-decls">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Emit all declarations, even if unused">;
 def fencoding_EQ : Joined<["-"], "fencoding=">, Group<f_Group>;
 def ferror_limit_EQ : Joined<["-"], "ferror-limit=">, Group<f_Group>, Flags<[CoreOption]>;
 def fexceptions : Flag<["-"], "fexceptions">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Enable support for exception handling">;
 def fexcess_precision_EQ : Joined<["-"], "fexcess-precision=">,
     Group<clang_ignored_gcc_optimization_f_Group>;
 def : Flag<["-"], "fexpensive-optimizations">, Group<clang_ignored_gcc_optimization_f_Group>;
 def : Flag<["-"], "fno-expensive-optimizations">, Group<clang_ignored_gcc_optimization_f_Group>;
 def fextdirs_EQ : Joined<["-"], "fextdirs=">, Group<f_Group>;
 def : Flag<["-"], "fdefer-pop">, Group<clang_ignored_gcc_optimization_f_Group>;
 def : Flag<["-"], "fno-defer-pop">, Group<clang_ignored_gcc_optimization_f_Group>;
 def : Flag<["-"], "fextended-identifiers">, Group<clang_ignored_f_Group>;
 def : Flag<["-"], "fno-extended-identifiers">, Group<f_Group>, Flags<[Unsupported]>;
 def fhosted : Flag<["-"], "fhosted">, Group<f_Group>;
 def ffast_math : Flag<["-"], "ffast-math">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Enable the *frontend*'s 'fast-math' mode. This has no effect on "
            "optimizations, but provides a preprocessor macro __FAST_MATH__ the "
            "same as GCC's -ffast-math flag">;
 def fno_fast_math : Flag<["-"], "fno-fast-math">, Group<f_Group>;
 def fmath_errno : Flag<["-"], "fmath-errno">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Require math functions to indicate errors by setting errno">;
 def fno_math_errno : Flag<["-"], "fno-math-errno">, Group<f_Group>;
 def fbracket_depth_EQ : Joined<["-"], "fbracket-depth=">, Group<f_Group>;
 def fsignaling_math : Flag<["-"], "fsignaling-math">, Group<f_Group>;
 def fno_signaling_math : Flag<["-"], "fno-signaling-math">, Group<f_Group>;
 def fsanitize_EQ : CommaJoined<["-"], "fsanitize=">, Group<f_clang_Group>,
                    Flags<[CC1Option, CoreOption]>, MetaVarName<"<check>">,
                    HelpText<"Turn on runtime checks for various forms of undefined "
                             "or suspicious behavior. See user manual for available checks ">;
 def fno_sanitize_EQ : CommaJoined<["-"], "fno-sanitize=">, Group<f_clang_Group>;
 def fsanitize_blacklist : Joined<["-"], "fsanitize-blacklist=">,
                           Group<f_clang_Group>, Flags<[CC1Option, CoreOption]>,
                           HelpText<"Path to blacklist file for sanitizers">;
 def fno_sanitize_blacklist : Flag<["-"], "fno-sanitize-blacklist">,
                              Group<f_clang_Group>,
                              HelpText<"Don't use blacklist file for sanitizers">;
 def fsanitize_coverage : Joined<["-"], "fsanitize-coverage=">,
                                         Group<f_clang_Group>, Flags<[CC1Option]>,
                                         HelpText<"Enable coverage instrumentation for Sanitizers">;
 def fsanitize_memory_track_origins_EQ : Joined<["-"], "fsanitize-memory-track-origins=">,
                                         Group<f_clang_Group>, Flags<[CC1Option]>,
                                         HelpText<"Enable origins tracking in MemorySanitizer">;
 def fsanitize_memory_track_origins : Flag<["-"], "fsanitize-memory-track-origins">,
                                      Group<f_clang_Group>, Flags<[CC1Option]>,
                                      HelpText<"Enable origins tracking in MemorySanitizer">;
 def fno_sanitize_memory_track_origins : Flag<["-"], "fno-sanitize-memory-track-origins">,
                                         Group<f_clang_Group>, Flags<[CC1Option]>,
                                         HelpText<"Disable origins tracking in MemorySanitizer">;
 def fsanitize_address_field_padding : Joined<["-"], "fsanitize-address-field-padding=">,
                                         Group<f_clang_Group>, Flags<[CC1Option]>,
                                         HelpText<"Level of field padding for AddressSanitizer">;
 def fsanitize_recover : Flag<["-"], "fsanitize-recover">, Group<f_clang_Group>;
 def fno_sanitize_recover : Flag<["-"], "fno-sanitize-recover">,
                            Group<f_clang_Group>;
 def fsanitize_recover_EQ : CommaJoined<["-"], "fsanitize-recover=">,
                            Group<f_clang_Group>,
                            Flags<[CC1Option]>,
                            HelpText<"Enable recovery for specified sanitizers">;
 def fno_sanitize_recover_EQ
     : CommaJoined<["-"], "fno-sanitize-recover=">,
       Group<f_clang_Group>,
       HelpText<"Disable recovery for specified sanitizers">;
 def fsanitize_undefined_trap_on_error : Flag<["-"], "fsanitize-undefined-trap-on-error">,
                                         Group<f_clang_Group>, Flags<[CC1Option]>;
 def fno_sanitize_undefined_trap_on_error : Flag<["-"], "fno-sanitize-undefined-trap-on-error">,
                                            Group<f_clang_Group>;
 def fsanitize_link_cxx_runtime : Flag<["-"], "fsanitize-link-c++-runtime">,
                                  Group<f_clang_Group>;
 def funsafe_math_optimizations : Flag<["-"], "funsafe-math-optimizations">,
   Group<f_Group>;
 def fno_unsafe_math_optimizations : Flag<["-"], "fno-unsafe-math-optimizations">,
   Group<f_Group>;
 def fassociative_math : Flag<["-"], "fassociative-math">, Group<f_Group>;
 def fno_associative_math : Flag<["-"], "fno-associative-math">, Group<f_Group>;
 def freciprocal_math : Flag<["-"], "freciprocal-math">, Group<f_Group>;
 def fno_reciprocal_math : Flag<["-"], "fno-reciprocal-math">, Group<f_Group>;
 def ffinite_math_only : Flag<["-"], "ffinite-math-only">, Group<f_Group>, Flags<[CC1Option]>;
 def fno_finite_math_only : Flag<["-"], "fno-finite-math-only">, Group<f_Group>;
 def fsigned_zeros : Flag<["-"], "fsigned-zeros">, Group<f_Group>;
 def fno_signed_zeros : Flag<["-"], "fno-signed-zeros">, Group<f_Group>;
 def fhonor_nans : Flag<["-"], "fhonor-nans">, Group<f_Group>;
 def fno_honor_nans : Flag<["-"], "fno-honor-nans">, Group<f_Group>;
 def fhonor_infinities : Flag<["-"], "fhonor-infinities">, Group<f_Group>;
 def fno_honor_infinities : Flag<["-"], "fno-honor-infinities">, Group<f_Group>;
 // This option was originally misspelt "infinites" [sic].
 def : Flag<["-"], "fhonor-infinites">, Alias<fhonor_infinities>;
 def : Flag<["-"], "fno-honor-infinites">, Alias<fno_honor_infinities>;
 def ftrapping_math : Flag<["-"], "ftrapping-math">, Group<f_Group>;
 def fno_trapping_math : Flag<["-"], "fno-trapping-math">, Group<f_Group>;
 def ffp_contract : Joined<["-"], "ffp-contract=">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Form fused FP ops (e.g. FMAs): fast (everywhere)"
   " | on (according to FP_CONTRACT pragma, default) | off (never fuse)">;
 
 def ffor_scope : Flag<["-"], "ffor-scope">, Group<f_Group>;
 def fno_for_scope : Flag<["-"], "fno-for-scope">, Group<f_Group>;
 
 def frewrite_includes : Flag<["-"], "frewrite-includes">, Group<f_Group>,
   Flags<[CC1Option]>;
 def fno_rewrite_includes : Flag<["-"], "fno-rewrite-includes">, Group<f_Group>;
 
 def frewrite_map_file : Separate<["-"], "frewrite-map-file">,
                         Group<f_Group>,
                         Flags<[ DriverOption, CC1Option ]>;
 def frewrite_map_file_EQ : Joined<["-"], "frewrite-map-file=">,
                            Group<f_Group>,
                            Flags<[DriverOption]>;
 
 def ffreestanding : Flag<["-"], "ffreestanding">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Assert that the compilation takes place in a freestanding environment">;
 def fgnu_keywords : Flag<["-"], "fgnu-keywords">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Allow GNU-extension keywords regardless of language standard">;
 def fgnu89_inline : Flag<["-"], "fgnu89-inline">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Use the gnu89 inline semantics">;
 def fno_gnu89_inline : Flag<["-"], "fno-gnu89-inline">, Group<f_Group>;
 def fgnu_runtime : Flag<["-"], "fgnu-runtime">, Group<f_Group>,
   HelpText<"Generate output compatible with the standard GNU Objective-C runtime">;
 def fheinous_gnu_extensions : Flag<["-"], "fheinous-gnu-extensions">, Flags<[CC1Option]>;
 def filelist : Separate<["-"], "filelist">, Flags<[LinkerInput]>;
 def : Flag<["-"], "findirect-virtual-calls">, Alias<fapple_kext>;
 def finline_functions : Flag<["-"], "finline-functions">, Group<clang_ignored_gcc_optimization_f_Group>;
 def finline : Flag<["-"], "finline">, Group<clang_ignored_f_Group>;
 def finput_charset_EQ : Joined<["-"], "finput-charset=">, Group<f_Group>;
 def fexec_charset_EQ : Joined<["-"], "fexec-charset=">, Group<f_Group>;
 def finstrument_functions : Flag<["-"], "finstrument-functions">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Generate calls to instrument function entry and exit">;
 def flat__namespace : Flag<["-"], "flat_namespace">;
 def flax_vector_conversions : Flag<["-"], "flax-vector-conversions">, Group<f_Group>;
 def flimited_precision_EQ : Joined<["-"], "flimited-precision=">, Group<f_Group>;
 def flto_EQ : Joined<["-"], "flto=">, Group<clang_ignored_gcc_optimization_f_Group>;
 def flto : Flag<["-"], "flto">, Group<f_Group>;
 def fno_lto : Flag<["-"], "fno-lto">, Group<f_Group>;
 def fmacro_backtrace_limit_EQ : Joined<["-"], "fmacro-backtrace-limit=">,
                                 Group<f_Group>;
 def fmerge_all_constants : Flag<["-"], "fmerge-all-constants">, Group<f_Group>;
 def fmessage_length_EQ : Joined<["-"], "fmessage-length=">, Group<f_Group>;
 def fms_extensions : Flag<["-"], "fms-extensions">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Accept some non-standard constructs supported by the Microsoft compiler">;
 def fms_compatibility : Flag<["-"], "fms-compatibility">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Enable full Microsoft Visual C++ compatibility">;
 def fmsc_version : Joined<["-"], "fmsc-version=">, Group<f_Group>, Flags<[DriverOption, CoreOption]>,
   HelpText<"Microsoft compiler version number to report in _MSC_VER (0 = don't define it (default))">;
 def fms_compatibility_version
     : Joined<["-"], "fms-compatibility-version=">,
       Group<f_Group>,
       Flags<[ CC1Option, CoreOption ]>,
       HelpText<"Dot-separated value representing the Microsoft compiler "
                "version number to report in _MSC_VER (0 = don't define it "
                "(default))">;
 def fdelayed_template_parsing : Flag<["-"], "fdelayed-template-parsing">, Group<f_Group>,
   HelpText<"Parse templated function definitions at the end of the "
            "translation unit">,  Flags<[CC1Option]>;
 def fms_memptr_rep_EQ : Joined<["-"], "fms-memptr-rep=">, Group<f_Group>, Flags<[CC1Option]>;
 def fmodules_cache_path : Joined<["-"], "fmodules-cache-path=">, Group<i_Group>,
   Flags<[DriverOption, CC1Option]>, MetaVarName<"<directory>">,
   HelpText<"Specify the module cache path">;
 def fmodules_user_build_path : Separate<["-"], "fmodules-user-build-path">, Group<i_Group>,
   Flags<[DriverOption, CC1Option]>, MetaVarName<"<directory>">,
   HelpText<"Specify the module user build path">;
 def fmodules_prune_interval : Joined<["-"], "fmodules-prune-interval=">, Group<i_Group>,
   Flags<[CC1Option]>, MetaVarName<"<seconds>">,
   HelpText<"Specify the interval (in seconds) between attempts to prune the module cache">;
 def fmodules_prune_after : Joined<["-"], "fmodules-prune-after=">, Group<i_Group>,
   Flags<[CC1Option]>, MetaVarName<"<seconds>">,
   HelpText<"Specify the interval (in seconds) after which a module file will be considered unused">;
 def fmodules_search_all : Flag <["-"], "fmodules-search-all">, Group<f_Group>,
   Flags<[DriverOption, CC1Option]>,
   HelpText<"Search even non-imported modules to resolve references">;
 def fbuild_session_timestamp : Joined<["-"], "fbuild-session-timestamp=">,
   Group<i_Group>, Flags<[CC1Option]>, MetaVarName<"<time since Epoch in seconds>">,
   HelpText<"Time when the current build session started">;
 def fbuild_session_file : Joined<["-"], "fbuild-session-file=">,
   Group<i_Group>, MetaVarName<"<file>">,
   HelpText<"Use the last modification time of <file> as the build session timestamp">;
 def fmodules_validate_once_per_build_session : Flag<["-"], "fmodules-validate-once-per-build-session">,
   Group<i_Group>, Flags<[CC1Option]>,
   HelpText<"Don't verify input files for the modules if the module has been "
            "successfully validated or loaded during this build session">;
 def fmodules_validate_system_headers : Flag<["-"], "fmodules-validate-system-headers">,
   Group<i_Group>, Flags<[CC1Option]>,
   HelpText<"Validate the system headers that a module depends on when loading the module">;
 def fmodules : Flag <["-"], "fmodules">, Group<f_Group>,
   Flags<[DriverOption, CC1Option]>,
   HelpText<"Enable the 'modules' language feature">;
 def fmodule_maps : Flag <["-"], "fmodule-maps">, Group<f_Group>,
   Flags<[DriverOption,CC1Option]>,
   HelpText<"Read module maps to understand the structure of library headers">;
 def fmodule_name : JoinedOrSeparate<["-"], "fmodule-name=">, Group<f_Group>,
   Flags<[DriverOption,CC1Option]>, MetaVarName<"<name>">,
   HelpText<"Specify the name of the module to build">;
 def fmodule_map_file : Joined<["-"], "fmodule-map-file=">,
   Group<f_Group>, Flags<[DriverOption,CC1Option]>, MetaVarName<"<file>">,
   HelpText<"Load this module map file">;
 def fmodule_file : Joined<["-"], "fmodule-file=">,
   Group<f_Group>, Flags<[DriverOption,CC1Option]>,
   HelpText<"Load this precompiled module file">, MetaVarName<"<file>">;
 def fmodules_ignore_macro : Joined<["-"], "fmodules-ignore-macro=">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Ignore the definition of the given macro when building and loading modules">;
 def fmodules_decluse : Flag <["-"], "fmodules-decluse">, Group<f_Group>,
   Flags<[DriverOption,CC1Option]>,
   HelpText<"Require declaration of modules used within a module">;
 def fmodules_strict_decluse : Flag <["-"], "fmodules-strict-decluse">, Group<f_Group>,
   Flags<[DriverOption,CC1Option]>,
   HelpText<"Like -fmodules-decluse but requires all headers to be in modules">;
 def fno_modules_search_all : Flag <["-"], "fno-modules-search-all">, Group<f_Group>,
   Flags<[DriverOption, CC1Option]>;
 def fmodules_implicit_maps :
   Flag <["-"], "fmodules-implicit-maps">,
   Group<f_Group>, Flags<[DriverOption, CC1Option]>;
 def fno_modules_implicit_maps :
   Flag <["-"], "fno-modules-implicit-maps">,
   Group<f_Group>, Flags<[DriverOption, CC1Option]>;
 def fretain_comments_from_system_headers : Flag<["-"], "fretain-comments-from-system-headers">, Group<f_Group>, Flags<[CC1Option]>;
 
 def fmudflapth : Flag<["-"], "fmudflapth">, Group<f_Group>;
 def fmudflap : Flag<["-"], "fmudflap">, Group<f_Group>;
 def fnested_functions : Flag<["-"], "fnested-functions">, Group<f_Group>;
 def fnext_runtime : Flag<["-"], "fnext-runtime">, Group<f_Group>;
 def fno_access_control : Flag<["-"], "fno-access-control">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Disable C++ access control">;
 def fno_apple_pragma_pack : Flag<["-"], "fno-apple-pragma-pack">, Group<f_Group>;
 def fno_asm : Flag<["-"], "fno-asm">, Group<f_Group>;
 def fno_asynchronous_unwind_tables : Flag<["-"], "fno-asynchronous-unwind-tables">, Group<f_Group>;
 def fno_assume_sane_operator_new : Flag<["-"], "fno-assume-sane-operator-new">, Group<f_Group>,
   HelpText<"Don't assume that C++'s global operator new can't alias any pointer">,
   Flags<[CC1Option]>;
 def fno_blocks : Flag<["-"], "fno-blocks">, Group<f_Group>;
 def fno_borland_extensions : Flag<["-"], "fno-borland-extensions">, Group<f_Group>;
 def fno_builtin : Flag<["-"], "fno-builtin">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Disable implicit builtin knowledge of functions">;
 def fno_builtin_ : Joined<["-"], "fno-builtin-">, Group<clang_ignored_f_Group>,
   HelpText<"Disable implicit builtin knowledge of a specific function">;
 def fno_math_builtin : Flag<["-"], "fno-math-builtin">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Disable implicit builtin knowledge of math functions">;
 def fno_caret_diagnostics : Flag<["-"], "fno-caret-diagnostics">, Group<f_Group>,
  Flags<[CC1Option]>;
 def fno_color_diagnostics : Flag<["-"], "fno-color-diagnostics">, Group<f_Group>;
 def fno_diagnostics_color : Flag<["-"], "fno-diagnostics-color">, Group<f_Group>;
 def fno_common : Flag<["-"], "fno-common">, Group<f_Group>, Flags<[CC1Option]>,
     HelpText<"Compile common globals like normal definitions">;
 def fno_constant_cfstrings : Flag<["-"], "fno-constant-cfstrings">, Group<f_Group>,
   Flags<[CC1Option]>,
   HelpText<"Disable creation of CodeFoundation-type constant strings">;
 def fno_cxx_exceptions: Flag<["-"], "fno-cxx-exceptions">, Group<f_Group>;
 def fno_cxx_modules : Flag <["-"], "fno-cxx-modules">, Group<f_Group>,
   Flags<[DriverOption]>;
 def fno_diagnostics_fixit_info : Flag<["-"], "fno-diagnostics-fixit-info">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Do not include fixit information in diagnostics">;
 def fno_diagnostics_show_option : Flag<["-"], "fno-diagnostics-show-option">, Group<f_Group>;
 def fno_diagnostics_show_note_include_stack : Flag<["-"], "fno-diagnostics-show-note-include-stack">,
     Flags<[CC1Option]>, Group<f_Group>;
 def fno_dollars_in_identifiers : Flag<["-"], "fno-dollars-in-identifiers">, Group<f_Group>,
   HelpText<"Disallow '$' in identifiers">, Flags<[CC1Option]>;
 def fno_elide_constructors : Flag<["-"], "fno-elide-constructors">, Group<f_Group>,
   HelpText<"Disable C++ copy constructor elision">, Flags<[CC1Option]>;
 def fno_eliminate_unused_debug_symbols : Flag<["-"], "fno-eliminate-unused-debug-symbols">, Group<f_Group>;
 def fno_exceptions : Flag<["-"], "fno-exceptions">, Group<f_Group>;
 def fno_gnu_keywords : Flag<["-"], "fno-gnu-keywords">, Group<f_Group>, Flags<[CC1Option]>;
 def fno_inline_functions : Flag<["-"], "fno-inline-functions">, Group<f_clang_Group>, Flags<[CC1Option]>;
 def fno_inline : Flag<["-"], "fno-inline">, Group<f_clang_Group>, Flags<[CC1Option]>;
 def fno_lax_vector_conversions : Flag<["-"], "fno-lax-vector-conversions">, Group<f_Group>,
   HelpText<"Disallow implicit conversions between vectors with a different number of elements or different element types">, Flags<[CC1Option]>;
 def fno_merge_all_constants : Flag<["-"], "fno-merge-all-constants">, Group<f_Group>,
     Flags<[CC1Option]>, HelpText<"Disallow merging of constants">;
 def fno_modules : Flag <["-"], "fno-modules">, Group<f_Group>,
   Flags<[DriverOption]>;
 def fno_module_maps : Flag <["-"], "fno-module-maps">, Group<f_Group>,
   Flags<[DriverOption]>;
 def fno_modules_decluse : Flag <["-"], "fno-modules-decluse">, Group<f_Group>,
   Flags<[DriverOption]>;
 def fno_modules_strict_decluse : Flag <["-"], "fno-strict-modules-decluse">, Group<f_Group>,
   Flags<[DriverOption]>;
 def fno_ms_extensions : Flag<["-"], "fno-ms-extensions">, Group<f_Group>;
 def fno_ms_compatibility : Flag<["-"], "fno-ms-compatibility">, Group<f_Group>;
 def fno_delayed_template_parsing : Flag<["-"], "fno-delayed-template-parsing">, Group<f_Group>;
 def fno_objc_exceptions: Flag<["-"], "fno-objc-exceptions">, Group<f_Group>;
 def fno_objc_legacy_dispatch : Flag<["-"], "fno-objc-legacy-dispatch">, Group<f_Group>;
 def fno_omit_frame_pointer : Flag<["-"], "fno-omit-frame-pointer">, Group<f_Group>;
 def fno_operator_names : Flag<["-"], "fno-operator-names">, Group<f_Group>,
   HelpText<"Do not treat C++ operator name keywords as synonyms for operators">,
   Flags<[CC1Option]>;
 def fno_pascal_strings : Flag<["-"], "fno-pascal-strings">, Group<f_Group>;
 def fno_rtti : Flag<["-"], "fno-rtti">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Disable generation of rtti information">;
 def fno_short_enums : Flag<["-"], "fno-short-enums">, Group<f_Group>;
 def fno_show_column : Flag<["-"], "fno-show-column">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Do not include column number on diagnostics">;
 def fno_show_source_location : Flag<["-"], "fno-show-source-location">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Do not include source location information with diagnostics">;
 def fno_spell_checking : Flag<["-"], "fno-spell-checking">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Disable spell-checking">;
 def fno_stack_protector : Flag<["-"], "fno-stack-protector">, Group<f_Group>,
   HelpText<"Disable the use of stack protectors">;
 def fno_strict_aliasing : Flag<["-"], "fno-strict-aliasing">, Group<f_Group>,
   Flags<[DriverOption, CoreOption]>;
 def fstruct_path_tbaa : Flag<["-"], "fstruct-path-tbaa">, Group<f_Group>;
 def fno_struct_path_tbaa : Flag<["-"], "fno-struct-path-tbaa">, Group<f_Group>;
 def fno_strict_enums : Flag<["-"], "fno-strict-enums">, Group<f_Group>;
 def fno_strict_overflow : Flag<["-"], "fno-strict-overflow">, Group<f_Group>;
 def fno_threadsafe_statics : Flag<["-"], "fno-threadsafe-statics">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Do not emit code to make initialization of local statics thread safe">;
 def fno_use_cxa_atexit : Flag<["-"], "fno-use-cxa-atexit">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Don't use __cxa_atexit for calling destructors">;
 def fno_use_init_array : Flag<["-"], "fno-use-init-array">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Don't use .init_array instead of .ctors">;
 def fno_unit_at_a_time : Flag<["-"], "fno-unit-at-a-time">, Group<f_Group>;
 def fno_unwind_tables : Flag<["-"], "fno-unwind-tables">, Group<f_Group>;
 def fno_verbose_asm : Flag<["-"], "fno-verbose-asm">, Group<f_Group>;
 def fno_working_directory : Flag<["-"], "fno-working-directory">, Group<f_Group>;
 def fno_wrapv : Flag<["-"], "fno-wrapv">, Group<f_Group>;
 def fno_zero_initialized_in_bss : Flag<["-"], "fno-zero-initialized-in-bss">, Group<f_Group>;
 def fobjc_arc : Flag<["-"], "fobjc-arc">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Synthesize retain and release calls for Objective-C pointers">;
 def fno_objc_arc : Flag<["-"], "fno-objc-arc">, Group<f_Group>;
 def fobjc_arc_exceptions : Flag<["-"], "fobjc-arc-exceptions">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Use EH-safe code when synthesizing retains and releases in -fobjc-arc">;
 def fno_objc_arc_exceptions : Flag<["-"], "fno-objc-arc-exceptions">, Group<f_Group>;
 def fobjc_atdefs : Flag<["-"], "fobjc-atdefs">, Group<clang_ignored_f_Group>;
 def fobjc_call_cxx_cdtors : Flag<["-"], "fobjc-call-cxx-cdtors">, Group<clang_ignored_f_Group>;
 def fobjc_exceptions: Flag<["-"], "fobjc-exceptions">, Group<f_Group>,
   HelpText<"Enable Objective-C exceptions">, Flags<[CC1Option]>;
 
 def fobjc_gc_only : Flag<["-"], "fobjc-gc-only">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Use GC exclusively for Objective-C related memory management">;
 def fobjc_gc : Flag<["-"], "fobjc-gc">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Enable Objective-C garbage collection">;
 def fobjc_legacy_dispatch : Flag<["-"], "fobjc-legacy-dispatch">, Group<f_Group>;
 def fobjc_new_property : Flag<["-"], "fobjc-new-property">, Group<clang_ignored_f_Group>;
 def fobjc_infer_related_result_type : Flag<["-"], "fobjc-infer-related-result-type">, 
                                       Group<f_Group>;
 def fno_objc_infer_related_result_type : Flag<["-"],
   "fno-objc-infer-related-result-type">, Group<f_Group>,
   HelpText<
     "do not infer Objective-C related result type based on method family">,
   Flags<[CC1Option]>;
 def fobjc_link_runtime: Flag<["-"], "fobjc-link-runtime">, Group<f_Group>;
 
 // Objective-C ABI options.
 def fobjc_runtime_EQ : Joined<["-"], "fobjc-runtime=">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Specify the target Objective-C runtime kind and version">;
 def fobjc_abi_version_EQ : Joined<["-"], "fobjc-abi-version=">, Group<f_Group>;
 def fobjc_nonfragile_abi_version_EQ : Joined<["-"], "fobjc-nonfragile-abi-version=">, Group<f_Group>;
 def fobjc_nonfragile_abi : Flag<["-"], "fobjc-nonfragile-abi">, Group<f_Group>;
 def fno_objc_nonfragile_abi : Flag<["-"], "fno-objc-nonfragile-abi">, Group<f_Group>;
 
 def fobjc_sender_dependent_dispatch : Flag<["-"], "fobjc-sender-dependent-dispatch">, Group<f_Group>;
 def fomit_frame_pointer : Flag<["-"], "fomit-frame-pointer">, Group<f_Group>;
 def fopenmp : Flag<["-"], "fopenmp">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>;
 def fopenmp_EQ : Joined<["-"], "fopenmp=">, Group<f_Group>, Flags<[CC1Option]>;
 def fno_optimize_sibling_calls : Flag<["-"], "fno-optimize-sibling-calls">, Group<f_Group>;
 def foptimize_sibling_calls : Flag<["-"], "foptimize-sibling-calls">, Group<f_Group>;
 def force__cpusubtype__ALL : Flag<["-"], "force_cpusubtype_ALL">;
 def force__flat__namespace : Flag<["-"], "force_flat_namespace">;
 def force__load : Separate<["-"], "force_load">;
 def force_addr : Joined<["-"], "fforce-addr">, Group<clang_ignored_f_Group>;
 def foutput_class_dir_EQ : Joined<["-"], "foutput-class-dir=">, Group<f_Group>;
 def fpack_struct : Flag<["-"], "fpack-struct">, Group<f_Group>;
 def fno_pack_struct : Flag<["-"], "fno-pack-struct">, Group<f_Group>;
 def fpack_struct_EQ : Joined<["-"], "fpack-struct=">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Specify the default maximum struct packing alignment">;
 def fmax_type_align_EQ : Joined<["-"], "fmax-type-align=">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Specify the maximum alignment to enforce on pointers lacking an explicit alignment">;
 def fno_max_type_align : Flag<["-"], "fno-max-type-align">, Group<f_Group>;
 def fpascal_strings : Flag<["-"], "fpascal-strings">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Recognize and construct Pascal-style string literals">;
 def fpcc_struct_return : Flag<["-"], "fpcc-struct-return">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Override the default ABI to return all structs on the stack">;
 def fpch_preprocess : Flag<["-"], "fpch-preprocess">, Group<f_Group>;
 def fpic : Flag<["-"], "fpic">, Group<f_Group>;
 def fno_pic : Flag<["-"], "fno-pic">, Group<f_Group>;
 def fpie : Flag<["-"], "fpie">, Group<f_Group>;
 def fno_pie : Flag<["-"], "fno-pie">, Group<f_Group>;
 def fprofile_arcs : Flag<["-"], "fprofile-arcs">, Group<f_Group>;
 def fno_profile_arcs : Flag<["-"], "fno-profile-arcs">, Group<f_Group>;
 def fprofile_generate : Flag<["-"], "fprofile-generate">, Group<f_Group>;
 def framework : Separate<["-"], "framework">, Flags<[LinkerInput]>;
 def frandom_seed_EQ : Joined<["-"], "frandom-seed=">, Group<clang_ignored_f_Group>;
 def freg_struct_return : Flag<["-"], "freg-struct-return">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Override the default ABI to return small structs in registers">;
 def frtti : Flag<["-"], "frtti">, Group<f_Group>;
 def : Flag<["-"], "fsched-interblock">, Group<clang_ignored_f_Group>;
 def fshort_enums : Flag<["-"], "fshort-enums">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Allocate to an enum type only as many bytes as it needs for the declared range of possible values">;
 def fshort_wchar : Flag<["-"], "fshort-wchar">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Force wchar_t to be a short unsigned int">;
 def fno_short_wchar : Flag<["-"], "fno-short-wchar">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Force wchar_t to be an unsigned int">;
 def fshow_overloads_EQ : Joined<["-"], "fshow-overloads=">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Which overload candidates to show when overload resolution fails: "
            "best|all; defaults to all">;
 def fshow_column : Flag<["-"], "fshow-column">, Group<f_Group>, Flags<[CC1Option]>;
 def fshow_source_location : Flag<["-"], "fshow-source-location">, Group<f_Group>;
 def fspell_checking : Flag<["-"], "fspell-checking">, Group<f_Group>;
 def fspell_checking_limit_EQ : Joined<["-"], "fspell-checking-limit=">, Group<f_Group>;
 def fsigned_bitfields : Flag<["-"], "fsigned-bitfields">, Group<f_Group>;
 def fsigned_char : Flag<["-"], "fsigned-char">, Group<f_Group>;
 def fno_signed_char : Flag<["-"], "fno-signed-char">, Flags<[CC1Option]>,
     Group<clang_ignored_f_Group>, HelpText<"Char is unsigned">;
 def fsplit_stack : Flag<["-"], "fsplit-stack">, Group<f_Group>;
 def fstack_protector_all : Flag<["-"], "fstack-protector-all">, Group<f_Group>,
   HelpText<"Force the usage of stack protectors for all functions">;
 def fstack_protector_strong : Flag<["-"], "fstack-protector-strong">, Group<f_Group>,
   HelpText<"Use a strong heuristic to apply stack protectors to functions">;
 def fstack_protector : Flag<["-"], "fstack-protector">, Group<f_Group>,
   HelpText<"Enable stack protectors for functions potentially vulnerable to stack smashing">;
 def fstandalone_debug : Flag<["-"], "fstandalone-debug">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Emit full debug info for all types used by the program">;
 def fno_standalone_debug : Flag<["-"], "fno-standalone-debug">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Limit debug information produced to reduce size of debug binary">;
 def flimit_debug_info : Flag<["-"], "flimit-debug-info">, Alias<fno_standalone_debug>;
 def fno_limit_debug_info : Flag<["-"], "fno-limit-debug-info">, Alias<fstandalone_debug>;
 def fstrict_aliasing : Flag<["-"], "fstrict-aliasing">, Group<f_Group>,
   Flags<[DriverOption, CoreOption]>;
 def fstrict_enums : Flag<["-"], "fstrict-enums">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Enable optimizations based on the strict definition of an enum's "
            "value range">;
 def fstrict_overflow : Flag<["-"], "fstrict-overflow">, Group<f_Group>;
 def fsyntax_only : Flag<["-"], "fsyntax-only">, Flags<[DriverOption,CC1Option]>, Group<Action_Group>;
 def ftabstop_EQ : Joined<["-"], "ftabstop=">, Group<f_Group>;
 def ftemplate_depth_EQ : Joined<["-"], "ftemplate-depth=">, Group<f_Group>;
 def ftemplate_depth_ : Joined<["-"], "ftemplate-depth-">, Group<f_Group>;
 def ftemplate_backtrace_limit_EQ : Joined<["-"], "ftemplate-backtrace-limit=">,
                                    Group<f_Group>;
 def foperator_arrow_depth_EQ : Joined<["-"], "foperator-arrow-depth=">,
                                Group<f_Group>;
 def ftest_coverage : Flag<["-"], "ftest-coverage">, Group<f_Group>;
 def fvectorize : Flag<["-"], "fvectorize">, Group<f_Group>,
   HelpText<"Enable the loop vectorization passes">;
 def fno_vectorize : Flag<["-"], "fno-vectorize">, Group<f_Group>;
 def : Flag<["-"], "ftree-vectorize">, Alias<fvectorize>;
 def : Flag<["-"], "fno-tree-vectorize">, Alias<fno_vectorize>;
 def fslp_vectorize : Flag<["-"], "fslp-vectorize">, Group<f_Group>,
   HelpText<"Enable the superword-level parallelism vectorization passes">;
 def fno_slp_vectorize : Flag<["-"], "fno-slp-vectorize">, Group<f_Group>;
 def fslp_vectorize_aggressive : Flag<["-"], "fslp-vectorize-aggressive">, Group<f_Group>,
   HelpText<"Enable the BB vectorization passes">;
 def fno_slp_vectorize_aggressive : Flag<["-"], "fno-slp-vectorize-aggressive">, Group<f_Group>;
 def : Flag<["-"], "ftree-slp-vectorize">, Alias<fslp_vectorize>;
 def : Flag<["-"], "fno-tree-slp-vectorize">, Alias<fno_slp_vectorize>;
 def Wlarge_by_value_copy_def : Flag<["-"], "Wlarge-by-value-copy">,
   HelpText<"Warn if a function definition returns or accepts an object larger "
            "in bytes than a given value">, Flags<[HelpHidden]>;
 def Wlarge_by_value_copy_EQ : Joined<["-"], "Wlarge-by-value-copy=">, Flags<[CC1Option]>;
 
 // These "special" warning flags are effectively processed as f_Group flags by the driver:
 // Just silence warnings about -Wlarger-than for now.
 def Wlarger_than_EQ : Joined<["-"], "Wlarger-than=">, Group<clang_ignored_f_Group>;
 def Wlarger_than_ : Joined<["-"], "Wlarger-than-">, Alias<Wlarger_than_EQ>;
 def Wframe_larger_than_EQ : Joined<["-"], "Wframe-larger-than=">, Group<f_Group>, Flags<[DriverOption]>;
 
 def : Flag<["-"], "fterminated-vtables">, Alias<fapple_kext>;
 def fthreadsafe_statics : Flag<["-"], "fthreadsafe-statics">, Group<f_Group>;
 def ftime_report : Flag<["-"], "ftime-report">, Group<f_Group>, Flags<[CC1Option]>;
 def ftlsmodel_EQ : Joined<["-"], "ftls-model=">, Group<f_Group>, Flags<[CC1Option]>;
 def ftrapv : Flag<["-"], "ftrapv">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Trap on integer overflow">;
 def ftrapv_handler_EQ : Joined<["-"], "ftrapv-handler=">, Group<f_Group>,
   MetaVarName<"<function name>">,
   HelpText<"Specify the function to be called on overflow">;
 def ftrapv_handler : Separate<["-"], "ftrapv-handler">, Group<f_Group>, Flags<[CC1Option]>;
 def ftrap_function_EQ : Joined<["-"], "ftrap-function=">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Issue call to specified function rather than a trap instruction">;
 def funit_at_a_time : Flag<["-"], "funit-at-a-time">, Group<f_Group>;
 def funroll_loops : Flag<["-"], "funroll-loops">, Group<f_Group>,
   HelpText<"Turn on loop unroller">, Flags<[CC1Option]>;
 def fno_unroll_loops : Flag<["-"], "fno-unroll-loops">, Group<f_Group>,
   HelpText<"Turn off loop unroller">, Flags<[CC1Option]>;
 def freroll_loops : Flag<["-"], "freroll-loops">, Group<f_Group>,
   HelpText<"Turn on loop reroller">, Flags<[CC1Option]>;
 def fno_reroll_loops : Flag<["-"], "fno-reroll-loops">, Group<f_Group>,
   HelpText<"Turn off loop reroller">;
 def ftrigraphs : Flag<["-"], "ftrigraphs">, Group<f_Group>,
   HelpText<"Process trigraph sequences">, Flags<[CC1Option]>;
 def fno_trigraphs : Flag<["-"], "fno-trigraphs">, Group<f_Group>,
   HelpText<"Do not process trigraph sequences">, Flags<[CC1Option]>;
 def funsigned_bitfields : Flag<["-"], "funsigned-bitfields">, Group<f_Group>;
 def funsigned_char : Flag<["-"], "funsigned-char">, Group<f_Group>;
 def fno_unsigned_char : Flag<["-"], "fno-unsigned-char">, Group<clang_ignored_f_Group>;
 def funwind_tables : Flag<["-"], "funwind-tables">, Group<f_Group>;
 def fuse_cxa_atexit : Flag<["-"], "fuse-cxa-atexit">, Group<f_Group>;
 def fuse_init_array : Flag<["-"], "fuse-init-array">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Use .init_array instead of .ctors">;
 def fno_var_tracking : Flag<["-"], "fno-var-tracking">, Group<clang_ignored_f_Group>;
 def fverbose_asm : Flag<["-"], "fverbose-asm">, Group<f_Group>;
 def fvisibility_EQ : Joined<["-"], "fvisibility=">, Group<f_Group>,
   HelpText<"Set the default symbol visibility for all global declarations">;
 def fvisibility_inlines_hidden : Flag<["-"], "fvisibility-inlines-hidden">, Group<f_Group>,
   HelpText<"Give inline C++ member functions default visibility by default">,
   Flags<[CC1Option]>;
 def fvisibility_ms_compat : Flag<["-"], "fvisibility-ms-compat">, Group<f_Group>,
   HelpText<"Give global types 'default' visibility and global functions and "
            "variables 'hidden' visibility by default">;
 def fwrapv : Flag<["-"], "fwrapv">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Treat signed integer overflow as two's complement">;
 def fwritable_strings : Flag<["-"], "fwritable-strings">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Store string literals as writable data">;
 def fzero_initialized_in_bss : Flag<["-"], "fzero-initialized-in-bss">, Group<f_Group>;
 def ffunction_sections : Flag<["-"], "ffunction-sections">, Group<f_Group>,
   Flags<[CC1Option]>,
   HelpText<"Place each function in its own section (ELF Only)">;
 def fno_function_sections : Flag<["-"], "fno-function-sections">,
   Group<f_Group>, Flags<[CC1Option]>;
 def fdata_sections : Flag <["-"], "fdata-sections">, Group<f_Group>,
  Flags<[CC1Option]>, HelpText<"Place each data in its own section (ELF Only)">;
 def fno_data_sections : Flag <["-"], "fno-data-sections">, Group<f_Group>,
   Flags<[CC1Option]>;
 def fdebug_types_section: Flag <["-"], "fdebug-types-section">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Place debug types in their own section (ELF Only)">;
 def fno_debug_types_section: Flag<["-"], "fno-debug-types-section">, Group<f_Group>,
   Flags<[CC1Option]>;
 def g_Flag : Flag<["-"], "g">, Group<g_Group>,
   HelpText<"Generate source-level debug information">, Flags<[CC1Option,CC1AsOption]>;
 def gline_tables_only : Flag<["-"], "gline-tables-only">, Group<g_Group>,
   HelpText<"Emit debug line number tables only">, Flags<[CC1Option]>;
 def gmlt : Flag<["-"], "gmlt">, Alias<gline_tables_only>;
 def g0 : Flag<["-"], "g0">, Group<g_Group>;
 def g1 : Flag<["-"], "g1">, Group<g_Group>;
 def g2 : Flag<["-"], "g2">, Group<g_Group>;
 def g3 : Flag<["-"], "g3">, Group<g_Group>;
 def ggdb : Flag<["-"], "ggdb">, Group<g_Group>;
 def ggdb0 : Flag<["-"], "ggdb0">, Group<g_Group>;
 def ggdb1 : Flag<["-"], "ggdb1">, Group<g_Group>;
 def ggdb2 : Flag<["-"], "ggdb2">, Group<g_Group>;
 def ggdb3 : Flag<["-"], "ggdb3">, Group<g_Group>;
 def gdwarf_2 : Flag<["-"], "gdwarf-2">, Group<g_Group>,
   HelpText<"Generate source-level debug information with dwarf version 2">, Flags<[CC1Option,CC1AsOption]>;
 def gdwarf_3 : Flag<["-"], "gdwarf-3">, Group<g_Group>,
   HelpText<"Generate source-level debug information with dwarf version 3">, Flags<[CC1Option,CC1AsOption]>;
 def gdwarf_4 : Flag<["-"], "gdwarf-4">, Group<g_Group>,
   HelpText<"Generate source-level debug information with dwarf version 4">, Flags<[CC1Option,CC1AsOption]>;
 def gfull : Flag<["-"], "gfull">, Group<g_Group>;
 def gused : Flag<["-"], "gused">, Group<g_Group>;
 def gstabs : Joined<["-"], "gstabs">, Group<g_Group>, Flags<[Unsupported]>;
 def gcoff : Joined<["-"], "gcoff">, Group<g_Group>, Flags<[Unsupported]>;
 def gxcoff : Joined<["-"], "gxcoff">, Group<g_Group>, Flags<[Unsupported]>;
 def gvms : Joined<["-"], "gvms">, Group<g_Group>, Flags<[Unsupported]>;
 def gtoggle : Flag<["-"], "gtoggle">, Group<g_flags_Group>, Flags<[Unsupported]>;
 def grecord_gcc_switches : Flag<["-"], "grecord-gcc-switches">, Group<g_flags_Group>;
 def gno_record_gcc_switches : Flag<["-"], "gno-record-gcc-switches">,
   Group<g_flags_Group>;
 def gstrict_dwarf : Flag<["-"], "gstrict-dwarf">, Group<g_flags_Group>;
 def gno_strict_dwarf : Flag<["-"], "gno-strict-dwarf">, Group<g_flags_Group>;
 def gcolumn_info : Flag<["-"], "gcolumn-info">, Group<g_flags_Group>;
 def gno_column_info : Flag<["-"], "gno-column-info">, Group<g_flags_Group>;
 def gsplit_dwarf : Flag<["-"], "gsplit-dwarf">, Group<g_flags_Group>;
 def ggnu_pubnames : Flag<["-"], "ggnu-pubnames">, Group<g_flags_Group>;
 def gdwarf_aranges : Flag<["-"], "gdwarf-aranges">, Group<g_flags_Group>;
 def headerpad__max__install__names : Joined<["-"], "headerpad_max_install_names">;
 def help : Flag<["-", "--"], "help">, Flags<[CC1Option,CC1AsOption]>,
   HelpText<"Display available options">;
 def index_header_map : Flag<["-"], "index-header-map">, Flags<[CC1Option]>,
   HelpText<"Make the next included directory (-I or -F) an indexer header map">;
 def idirafter : JoinedOrSeparate<["-"], "idirafter">, Group<clang_i_Group>, Flags<[CC1Option]>,
   HelpText<"Add directory to AFTER include search path">;
 def iframework : JoinedOrSeparate<["-"], "iframework">, Group<clang_i_Group>, Flags<[CC1Option]>,
   HelpText<"Add directory to SYSTEM framework search path">;
 def imacros : JoinedOrSeparate<["-", "--"], "imacros">, Group<clang_i_Group>, Flags<[CC1Option]>,
   HelpText<"Include macros from file before parsing">, MetaVarName<"<file>">;
 def image__base : Separate<["-"], "image_base">;
 def include_ : JoinedOrSeparate<["-", "--"], "include">, Group<clang_i_Group>, EnumName<"include">,
     MetaVarName<"<file>">, HelpText<"Include file before parsing">, Flags<[CC1Option]>;
 def include_pch : Separate<["-"], "include-pch">, Group<clang_i_Group>, Flags<[CC1Option]>,
   HelpText<"Include precompiled header file">, MetaVarName<"<file>">;
 def relocatable_pch : Flag<["-", "--"], "relocatable-pch">, Flags<[CC1Option]>,
   HelpText<"Whether to build a relocatable precompiled header">;
 def verify_pch : Flag<["-"], "verify-pch">, Group<Action_Group>, Flags<[CC1Option]>,
   HelpText<"Load and verify that a pre-compiled header file is not stale">;
 def init : Separate<["-"], "init">;
 def install__name : Separate<["-"], "install_name">;
 def iprefix : JoinedOrSeparate<["-"], "iprefix">, Group<clang_i_Group>, Flags<[CC1Option]>,
   HelpText<"Set the -iwithprefix/-iwithprefixbefore prefix">, MetaVarName<"<dir>">;
 def iquote : JoinedOrSeparate<["-"], "iquote">, Group<clang_i_Group>, Flags<[CC1Option]>,
   HelpText<"Add directory to QUOTE include search path">, MetaVarName<"<directory>">;
 def isysroot : JoinedOrSeparate<["-"], "isysroot">, Group<clang_i_Group>, Flags<[CC1Option]>,
   HelpText<"Set the system root directory (usually /)">, MetaVarName<"<dir>">;
 def isystem : JoinedOrSeparate<["-"], "isystem">, Group<clang_i_Group>, Flags<[CC1Option]>,
   HelpText<"Add directory to SYSTEM include search path">, MetaVarName<"<directory>">;
 def iwithprefixbefore : JoinedOrSeparate<["-"], "iwithprefixbefore">, Group<clang_i_Group>,
   HelpText<"Set directory to include search path with prefix">, MetaVarName<"<dir>">,
   Flags<[CC1Option]>;
 def iwithprefix : JoinedOrSeparate<["-"], "iwithprefix">, Group<clang_i_Group>, Flags<[CC1Option]>,
   HelpText<"Set directory to SYSTEM include search path with prefix">, MetaVarName<"<dir>">;
 def iwithsysroot : JoinedOrSeparate<["-"], "iwithsysroot">, Group<clang_i_Group>,
   HelpText<"Add directory to SYSTEM include search path, "
            "absolute paths are relative to -isysroot">, MetaVarName<"<directory>">,
   Flags<[CC1Option]>;
 def ivfsoverlay : JoinedOrSeparate<["-"], "ivfsoverlay">, Group<clang_i_Group>, Flags<[CC1Option]>,
   HelpText<"Overlay the virtual filesystem described by file over the real file system">;
 def i : Joined<["-"], "i">, Group<i_Group>;
 def keep__private__externs : Flag<["-"], "keep_private_externs">;
 def l : JoinedOrSeparate<["-"], "l">, Flags<[LinkerInput, RenderJoined]>;
 def lazy__framework : Separate<["-"], "lazy_framework">, Flags<[LinkerInput]>;
 def lazy__library : Separate<["-"], "lazy_library">, Flags<[LinkerInput]>;
 def mlittle_endian : Flag<["-"], "mlittle-endian">, Flags<[DriverOption]>;
 def EL : Flag<["-"], "EL">, Alias<mlittle_endian>;
 def mbig_endian : Flag<["-"], "mbig-endian">, Flags<[DriverOption]>;
 def EB : Flag<["-"], "EB">, Alias<mbig_endian>;
 def m16 : Flag<["-"], "m16">, Group<m_Group>, Flags<[DriverOption, CoreOption]>;
 def m32 : Flag<["-"], "m32">, Group<m_Group>, Flags<[DriverOption, CoreOption]>;
 def mqdsp6_compat : Flag<["-"], "mqdsp6-compat">, Group<m_Group>, Flags<[DriverOption,CC1Option]>,
   HelpText<"Enable hexagon-qdsp6 backward compatibility">;
 def m3dnowa : Flag<["-"], "m3dnowa">, Group<m_x86_Features_Group>;
 def m3dnow : Flag<["-"], "m3dnow">, Group<m_x86_Features_Group>;
 def m64 : Flag<["-"], "m64">, Group<m_Group>, Flags<[DriverOption, CoreOption]>;
 def mx32 : Flag<["-"], "mx32">, Group<m_Group>, Flags<[DriverOption, CoreOption]>;
 def mabi_EQ : Joined<["-"], "mabi=">, Group<m_Group>;
 def malign_functions_EQ : Joined<["-"], "malign-functions=">, Group<clang_ignored_m_Group>;
 def malign_loops_EQ : Joined<["-"], "malign-loops=">, Group<clang_ignored_m_Group>;
 def malign_jumps_EQ : Joined<["-"], "malign-jumps=">, Group<clang_ignored_m_Group>;
 def mfancy_math_387 : Flag<["-"], "mfancy-math-387">, Group<clang_ignored_m_Group>;
 def march_EQ : Joined<["-"], "march=">, Group<m_Group>;
 def masm_EQ : Joined<["-"], "masm=">, Group<m_Group>, Flags<[DriverOption]>;
 def mcmodel_EQ : Joined<["-"], "mcmodel=">, Group<m_Group>;
 def mconstant_cfstrings : Flag<["-"], "mconstant-cfstrings">, Group<clang_ignored_m_Group>;
 def mcpu_EQ : Joined<["-"], "mcpu=">, Group<m_Group>;
 def mdynamic_no_pic : Joined<["-"], "mdynamic-no-pic">, Group<m_Group>;
 def mfix_and_continue : Flag<["-"], "mfix-and-continue">, Group<clang_ignored_m_Group>;
 def mieee_fp : Flag<["-"], "mieee-fp">, Group<clang_ignored_m_Group>;
 def minline_all_stringops : Flag<["-"], "minline-all-stringops">, Group<clang_ignored_m_Group>;
 def mno_inline_all_stringops : Flag<["-"], "mno-inline-all-stringops">, Group<clang_ignored_m_Group>;
 def mfloat_abi_EQ : Joined<["-"], "mfloat-abi=">, Group<m_Group>;
 def mfpmath_EQ : Joined<["-"], "mfpmath=">, Group<m_Group>;
 def mfpu_EQ : Joined<["-"], "mfpu=">, Group<m_Group>;
 def mhwdiv_EQ : Joined<["-"], "mhwdiv=">, Group<m_Group>;
 def mglobal_merge : Flag<["-"], "mglobal-merge">, Group<m_Group>;
 def mhard_float : Flag<["-"], "mhard-float">, Group<m_Group>;
 def miphoneos_version_min_EQ : Joined<["-"], "miphoneos-version-min=">, Group<m_Group>;
 def mios_version_min_EQ : Joined<["-"], "mios-version-min=">,
   Alias<miphoneos_version_min_EQ>, HelpText<"Set iOS deployment target">;
 def mios_simulator_version_min_EQ : Joined<["-"], "mios-simulator-version-min=">, Alias<miphoneos_version_min_EQ>;
 def mkernel : Flag<["-"], "mkernel">, Group<m_Group>;
 def mlinker_version_EQ : Joined<["-"], "mlinker-version=">,
   Flags<[DriverOption]>;
 def mllvm : Separate<["-"], "mllvm">, Flags<[CC1Option,CC1AsOption,CoreOption]>,
   HelpText<"Additional arguments to forward to LLVM's option processing">;
 def mmacosx_version_min_EQ : Joined<["-"], "mmacosx-version-min=">,
   Group<m_Group>, HelpText<"Set Mac OS X deployment target">;
 def mms_bitfields : Flag<["-"], "mms-bitfields">, Group<m_Group>, Flags<[CC1Option]>,
   HelpText<"Set the default structure layout to be compatible with the Microsoft compiler standard">;
 def mstackrealign : Flag<["-"], "mstackrealign">, Group<m_Group>, Flags<[CC1Option]>,
   HelpText<"Force realign the stack at entry to every function">;
 def mstack_alignment : Joined<["-"], "mstack-alignment=">, Group<m_Group>, Flags<[CC1Option]>,
   HelpText<"Set the stack alignment">;
 def mthread_model : Separate<["-"], "mthread-model">, Group<m_Group>, Flags<[CC1Option]>,
   HelpText<"The thread model to use, e.g. posix, single (posix by default)">;
 
 def mmmx : Flag<["-"], "mmmx">, Group<m_x86_Features_Group>;
 def mno_3dnowa : Flag<["-"], "mno-3dnowa">, Group<m_x86_Features_Group>;
 def mno_3dnow : Flag<["-"], "mno-3dnow">, Group<m_x86_Features_Group>;
 def mno_constant_cfstrings : Flag<["-"], "mno-constant-cfstrings">, Group<m_Group>;
 def mno_global_merge : Flag<["-"], "mno-global-merge">, Group<m_Group>, Flags<[CC1Option]>,
   HelpText<"Disable merging of globals">;
 def mno_mmx : Flag<["-"], "mno-mmx">, Group<m_x86_Features_Group>;
 def mno_pascal_strings : Flag<["-"], "mno-pascal-strings">,
   Alias<fno_pascal_strings>;
 def mno_red_zone : Flag<["-"], "mno-red-zone">, Group<m_Group>;
 def mno_relax_all : Flag<["-"], "mno-relax-all">, Group<m_Group>;
 def mno_rtd: Flag<["-"], "mno-rtd">, Group<m_Group>;
 def mno_soft_float : Flag<["-"], "mno-soft-float">, Group<m_Group>;
 def mno_stackrealign : Flag<["-"], "mno-stackrealign">, Group<m_Group>;
 def mno_sse2 : Flag<["-"], "mno-sse2">, Group<m_x86_Features_Group>;
 def mno_sse3 : Flag<["-"], "mno-sse3">, Group<m_x86_Features_Group>;
 def mno_sse4a : Flag<["-"], "mno-sse4a">, Group<m_x86_Features_Group>;
 def mno_sse4 : Flag<["-"], "mno-sse4">, Group<m_x86_Features_Group>;
 def mno_sse4_1 : Flag<["-"], "mno-sse4.1">, Group<m_x86_Features_Group>;
 def mno_sse4_2 : Flag<["-"], "mno-sse4.2">, Group<m_x86_Features_Group>;
 def mno_sse : Flag<["-"], "mno-sse">, Group<m_x86_Features_Group>;
 def mno_ssse3 : Flag<["-"], "mno-ssse3">, Group<m_x86_Features_Group>;
 def mno_aes : Flag<["-"], "mno-aes">, Group<m_x86_Features_Group>;
 def mno_avx : Flag<["-"], "mno-avx">, Group<m_x86_Features_Group>;
 def mno_avx2 : Flag<["-"], "mno-avx2">, Group<m_x86_Features_Group>;
 def mno_avx512f : Flag<["-"], "mno-avx512f">, Group<m_x86_Features_Group>;
 def mno_avx512cd : Flag<["-"], "mno-avx512cd">, Group<m_x86_Features_Group>;
 def mno_avx512er : Flag<["-"], "mno-avx512er">, Group<m_x86_Features_Group>;
 def mno_avx512pf : Flag<["-"], "mno-avx512pf">, Group<m_x86_Features_Group>;
 def mno_avx512dq : Flag<["-"], "mno-avx512dq">, Group<m_x86_Features_Group>;
 def mno_avx512bw : Flag<["-"], "mno-avx512bw">, Group<m_x86_Features_Group>;
 def mno_avx512vl : Flag<["-"], "mno-avx512vl">, Group<m_x86_Features_Group>;
 def mno_pclmul : Flag<["-"], "mno-pclmul">, Group<m_x86_Features_Group>;
 def mno_lzcnt : Flag<["-"], "mno-lzcnt">, Group<m_x86_Features_Group>;
 def mno_rdrnd : Flag<["-"], "mno-rdrnd">, Group<m_x86_Features_Group>;
 def mno_fsgsbase : Flag<["-"], "mno-fsgsbase">, Group<m_x86_Features_Group>;
 def mno_bmi : Flag<["-"], "mno-bmi">, Group<m_x86_Features_Group>;
 def mno_bmi2 : Flag<["-"], "mno-bmi2">, Group<m_x86_Features_Group>;
 def mno_popcnt : Flag<["-"], "mno-popcnt">, Group<m_x86_Features_Group>;
 def mno_tbm : Flag<["-"], "mno-tbm">, Group<m_x86_Features_Group>;
 def mno_fma4 : Flag<["-"], "mno-fma4">, Group<m_x86_Features_Group>;
 def mno_fma : Flag<["-"], "mno-fma">, Group<m_x86_Features_Group>;
 def mno_xop : Flag<["-"], "mno-xop">, Group<m_x86_Features_Group>;
 def mno_f16c : Flag<["-"], "mno-f16c">, Group<m_x86_Features_Group>;
 def mno_rtm : Flag<["-"], "mno-rtm">, Group<m_x86_Features_Group>;
 def mno_prfchw : Flag<["-"], "mno-prfchw">, Group<m_x86_Features_Group>;
 def mno_rdseed : Flag<["-"], "mno-rdseed">, Group<m_x86_Features_Group>;
 def mno_adx : Flag<["-"], "mno-adx">, Group<m_x86_Features_Group>;
 def mno_sha : Flag<["-"], "mno-sha">, Group<m_x86_Features_Group>;
 
 def munaligned_access : Flag<["-"], "munaligned-access">, Group<m_arm_Features_Group>,
   HelpText<"Allow memory accesses to be unaligned (AArch32/AArch64 only)">;
 def mno_unaligned_access : Flag<["-"], "mno-unaligned-access">, Group<m_arm_Features_Group>,
   HelpText<"Force all memory accesses to be aligned (AArch32/AArch64 only)">;
 def mstrict_align : Flag<["-"], "mstrict-align">, Alias<mno_unaligned_access>, Flags<[CC1Option,HelpHidden]>,
   HelpText<"Force all memory accesses to be aligned (same as mno-unaligned-access)">;
 def mno_thumb : Flag<["-"], "mno-thumb">, Group<m_arm_Features_Group>;
 def mrestrict_it: Flag<["-"], "mrestrict-it">, Group<m_arm_Features_Group>,
   HelpText<"Disallow generation of deprecated IT blocks for ARMv8. It is on by default for ARMv8 Thumb mode.">;
 def mno_restrict_it: Flag<["-"], "mno-restrict-it">, Group<m_arm_Features_Group>,
   HelpText<"Allow generation of deprecated IT blocks for ARMv8. It is off by default for ARMv8 Thumb mode">;
 def marm : Flag<["-"], "marm">, Alias<mno_thumb>;
 def ffixed_r9 : Flag<["-"], "ffixed-r9">, Group<m_arm_Features_Group>,
   HelpText<"Reserve the r9 register (ARM only)">;
 def mcrc : Flag<["-"], "mcrc">, Group<m_arm_Features_Group>,
   HelpText<"Allow use of CRC instructions (ARM only)">;
 def mnocrc : Flag<["-"], "mnocrc">, Group<m_arm_Features_Group>,
   HelpText<"Disallow use of CRC instructions (ARM only)">;
 def mlong_calls : Flag<["-"], "mlong-calls">, Group<m_arm_Features_Group>,
   HelpText<"Generate an indirect jump to enable jumps further than 64M">;
 def mno_long_calls : Flag<["-"], "mno-long-calls">, Group<m_arm_Features_Group>,
   HelpText<"Restore the default behaviour of not generating long calls">;
 
 def mgeneral_regs_only : Flag<["-"], "mgeneral-regs-only">, Group<m_aarch64_Features_Group>,
   HelpText<"Generate code which only uses the general purpose registers (AArch64 only)">;
 
 def mfix_cortex_a53_835769 : Flag<["-"], "mfix-cortex-a53-835769">,
   Group<m_aarch64_Features_Group>,
   HelpText<"Workaround Cortex-A53 erratum 835769 (AArch64 only)">;
 def mno_fix_cortex_a53_835769 : Flag<["-"], "mno-fix-cortex-a53-835769">,
   Group<m_aarch64_Features_Group>,
   HelpText<"Don't workaround Cortex-A53 erratum 835769 (AArch64 only)">;
+def ffixed_x18 : Flag<["-"], "ffixed-x18">, Group<m_aarch64_Features_Group>,
+  HelpText<"Reserve the x18 register (AArch64 only)">;
 
 def mvsx : Flag<["-"], "mvsx">, Group<m_ppc_Features_Group>;
 def mno_vsx : Flag<["-"], "mno-vsx">, Group<m_ppc_Features_Group>;
 def mpower8_vector : Flag<["-"], "mpower8-vector">,
     Group<m_ppc_Features_Group>;
 def mno_power8_vector : Flag<["-"], "mno-power8-vector">,
     Group<m_ppc_Features_Group>;
 def mfprnd : Flag<["-"], "mfprnd">, Group<m_ppc_Features_Group>;
 def mno_fprnd : Flag<["-"], "mno-fprnd">, Group<m_ppc_Features_Group>;
 def mcmpb : Flag<["-"], "mcmpb">, Group<m_ppc_Features_Group>;
 def mno_cmpb : Flag<["-"], "mno-cmpb">, Group<m_ppc_Features_Group>;
 def mmfcrf : Flag<["-"], "mmfcrf">, Group<m_ppc_Features_Group>;
 def mno_mfcrf : Flag<["-"], "mno-mfcrf">, Group<m_ppc_Features_Group>;
 def mpopcntd : Flag<["-"], "mpopcntd">, Group<m_ppc_Features_Group>;
 def mno_popcntd : Flag<["-"], "mno-popcntd">, Group<m_ppc_Features_Group>;
 def mqpx : Flag<["-"], "mqpx">, Group<m_ppc_Features_Group>;
 def mno_qpx : Flag<["-"], "mno-qpx">, Group<m_ppc_Features_Group>;
 def mcrbits : Flag<["-"], "mcrbits">, Group<m_ppc_Features_Group>;
 def mno_crbits : Flag<["-"], "mno-crbits">, Group<m_ppc_Features_Group>;
 
 def faltivec : Flag<["-"], "faltivec">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Enable AltiVec vector initializer syntax">;
 def fno_altivec : Flag<["-"], "fno-altivec">, Group<f_Group>, Flags<[CC1Option]>;
 def maltivec : Flag<["-"], "maltivec">, Alias<faltivec>;
 def mno_altivec : Flag<["-"], "mno-altivec">, Alias<fno_altivec>;
 
 def mno_warn_nonportable_cfstrings : Flag<["-"], "mno-warn-nonportable-cfstrings">, Group<m_Group>;
 def mno_omit_leaf_frame_pointer : Flag<["-"], "mno-omit-leaf-frame-pointer">, Group<m_Group>;
 def momit_leaf_frame_pointer : Flag<["-"], "momit-leaf-frame-pointer">, Group<m_Group>,
   HelpText<"Omit frame pointer setup for leaf functions">, Flags<[CC1Option]>;
 def moslib_EQ : Joined<["-"], "moslib=">, Group<m_Group>;
 def mpascal_strings : Flag<["-"], "mpascal-strings">, Alias<fpascal_strings>;
 def mred_zone : Flag<["-"], "mred-zone">, Group<m_Group>;
 def mregparm_EQ : Joined<["-"], "mregparm=">, Group<m_Group>;
 def mrelax_all : Flag<["-"], "mrelax-all">, Group<m_Group>, Flags<[CC1Option,CC1AsOption]>,
   HelpText<"(integrated-as) Relax all machine instructions">;
 def mrtd : Flag<["-"], "mrtd">, Group<m_Group>, Flags<[CC1Option]>,
   HelpText<"Make StdCall calling convention the default">;
 def msmall_data_threshold_EQ : Joined <["-"], "msmall-data-threshold=">, Group<m_Group>;
 def msoft_float : Flag<["-"], "msoft-float">, Group<m_Group>, Flags<[CC1Option]>,
   HelpText<"Use software floating point">;
 def mno_implicit_float : Flag<["-"], "mno-implicit-float">, Group<m_Group>,
   HelpText<"Don't generate implicit floating point instructions">;
 def mimplicit_float : Flag<["-"], "mimplicit-float">, Group<m_Group>;
 def msse2 : Flag<["-"], "msse2">, Group<m_x86_Features_Group>;
 def msse3 : Flag<["-"], "msse3">, Group<m_x86_Features_Group>;
 def msse4a : Flag<["-"], "msse4a">, Group<m_x86_Features_Group>;
 def msse4 : Flag<["-"], "msse4">, Group<m_x86_Features_Group>;
 def msse4_1 : Flag<["-"], "msse4.1">, Group<m_x86_Features_Group>;
 def msse4_2 : Flag<["-"], "msse4.2">, Group<m_x86_Features_Group>;
 def msse : Flag<["-"], "msse">, Group<m_x86_Features_Group>;
 def mssse3 : Flag<["-"], "mssse3">, Group<m_x86_Features_Group>;
 def maes : Flag<["-"], "maes">, Group<m_x86_Features_Group>;
 def mavx : Flag<["-"], "mavx">, Group<m_x86_Features_Group>;
 def mavx2 : Flag<["-"], "mavx2">, Group<m_x86_Features_Group>;
 def mavx512f : Flag<["-"], "mavx512f">, Group<m_x86_Features_Group>;
 def mavx512cd : Flag<["-"], "mavx512cd">, Group<m_x86_Features_Group>;
 def mavx512er : Flag<["-"], "mavx512er">, Group<m_x86_Features_Group>;
 def mavx512pf : Flag<["-"], "mavx512pf">, Group<m_x86_Features_Group>;
 def mavx512dq : Flag<["-"], "mavx512dq">, Group<m_x86_Features_Group>;
 def mavx512bw : Flag<["-"], "mavx512bw">, Group<m_x86_Features_Group>;
 def mavx512vl : Flag<["-"], "mavx512vl">, Group<m_x86_Features_Group>;
 def mpclmul : Flag<["-"], "mpclmul">, Group<m_x86_Features_Group>;
 def mlzcnt : Flag<["-"], "mlzcnt">, Group<m_x86_Features_Group>;
 def mrdrnd : Flag<["-"], "mrdrnd">, Group<m_x86_Features_Group>;
 def mfsgsbase : Flag<["-"], "mfsgsbase">, Group<m_x86_Features_Group>;
 def mbmi : Flag<["-"], "mbmi">, Group<m_x86_Features_Group>;
 def mbmi2 : Flag<["-"], "mbmi2">, Group<m_x86_Features_Group>;
 def mpopcnt : Flag<["-"], "mpopcnt">, Group<m_x86_Features_Group>;
 def mtbm : Flag<["-"], "mtbm">, Group<m_x86_Features_Group>;
 def mfma4 : Flag<["-"], "mfma4">, Group<m_x86_Features_Group>;
 def mfma : Flag<["-"], "mfma">, Group<m_x86_Features_Group>;
 def mxop : Flag<["-"], "mxop">, Group<m_x86_Features_Group>;
 def mf16c : Flag<["-"], "mf16c">, Group<m_x86_Features_Group>;
 def mrtm : Flag<["-"], "mrtm">, Group<m_x86_Features_Group>;
 def mprfchw : Flag<["-"], "mprfchw">, Group<m_x86_Features_Group>;
 def mrdseed : Flag<["-"], "mrdseed">, Group<m_x86_Features_Group>;
 def madx : Flag<["-"], "madx">, Group<m_x86_Features_Group>;
 def msha : Flag<["-"], "msha">, Group<m_x86_Features_Group>;
 def mcx16 : Flag<["-"], "mcx16">, Group<m_x86_Features_Group>;
 def mips16 : Flag<["-"], "mips16">, Group<m_Group>;
 def mno_mips16 : Flag<["-"], "mno-mips16">, Group<m_Group>;
 def mmicromips : Flag<["-"], "mmicromips">, Group<m_Group>;
 def mno_micromips : Flag<["-"], "mno-micromips">, Group<m_Group>;
 def mxgot : Flag<["-"], "mxgot">, Group<m_Group>;
 def mno_xgot : Flag<["-"], "mno-xgot">, Group<m_Group>;
 def mldc1_sdc1 : Flag<["-"], "mldc1-sdc1">, Group<m_Group>;
 def mno_ldc1_sdc1 : Flag<["-"], "mno-ldc1-sdc1">, Group<m_Group>;
 def mcheck_zero_division : Flag<["-"], "mcheck-zero-division">, Group<m_Group>;
 def mno_check_zero_division : Flag<["-"], "mno-check-zero-division">,
                               Group<m_Group>;
 def mdsp : Flag<["-"], "mdsp">, Group<m_Group>;
 def mno_dsp : Flag<["-"], "mno-dsp">, Group<m_Group>;
 def mdspr2 : Flag<["-"], "mdspr2">, Group<m_Group>;
 def mno_dspr2 : Flag<["-"], "mno-dspr2">, Group<m_Group>;
 def msingle_float : Flag<["-"], "msingle-float">, Group<m_Group>;
 def mdouble_float : Flag<["-"], "mdouble-float">, Group<m_Group>;
 def mmsa : Flag<["-"], "mmsa">, Group<m_Group>,
   HelpText<"Enable MSA ASE (MIPS only)">;
 def mno_msa : Flag<["-"], "mno-msa">, Group<m_Group>,
   HelpText<"Disable MSA ASE (MIPS only)">;
 def mfp64 : Flag<["-"], "mfp64">, Group<m_Group>,
   HelpText<"Use 64-bit floating point registers (MIPS only)">;
 def mfp32 : Flag<["-"], "mfp32">, Group<m_Group>,
   HelpText<"Use 32-bit floating point registers (MIPS only)">;
 def mnan_EQ : Joined<["-"], "mnan=">, Group<m_Group>;
 def mabicalls : Flag<["-"], "mabicalls">, Group<m_Group>,
   HelpText<"Enable SVR4-style position-independent code (Mips only)">;
 def mno_abicalls : Flag<["-"], "mno-abicalls">, Group<m_Group>,
   HelpText<"Disable SVR4-style position-independent code (Mips only)">;
 def mips1 : Flag<["-"], "mips1">,
   Alias<march_EQ>, AliasArgs<["mips1"]>,
   HelpText<"Equivalent to -march=mips1">, Flags<[HelpHidden]>;
 def mips2 : Flag<["-"], "mips2">,
   Alias<march_EQ>, AliasArgs<["mips2"]>,
   HelpText<"Equivalent to -march=mips2">, Flags<[HelpHidden]>;
 def mips3 : Flag<["-"], "mips3">,
   Alias<march_EQ>, AliasArgs<["mips3"]>,
   HelpText<"Equivalent to -march=mips3">, Flags<[HelpHidden]>;
 def mips4 : Flag<["-"], "mips4">,
   Alias<march_EQ>, AliasArgs<["mips4"]>,
   HelpText<"Equivalent to -march=mips4">, Flags<[HelpHidden]>;
 def mips5 : Flag<["-"], "mips5">,
   Alias<march_EQ>, AliasArgs<["mips5"]>,
   HelpText<"Equivalent to -march=mips5">, Flags<[HelpHidden]>;
 def mips32 : Flag<["-"], "mips32">,
   Alias<march_EQ>, AliasArgs<["mips32"]>,
   HelpText<"Equivalent to -march=mips32">, Flags<[HelpHidden]>;
 def mips32r2 : Flag<["-"], "mips32r2">,
   Alias<march_EQ>, AliasArgs<["mips32r2"]>,
   HelpText<"Equivalent to -march=mips32r2">, Flags<[HelpHidden]>;
 def mips32r6 : Flag<["-"], "mips32r6">,
   Alias<march_EQ>, AliasArgs<["mips32r6"]>,
   HelpText<"Equivalent to -march=mips32r6">, Flags<[HelpHidden]>;
 def mips64 : Flag<["-"], "mips64">,
   Alias<march_EQ>, AliasArgs<["mips64"]>,
   HelpText<"Equivalent to -march=mips64">, Flags<[HelpHidden]>;
 def mips64r2 : Flag<["-"], "mips64r2">,
   Alias<march_EQ>, AliasArgs<["mips64r2"]>,
   HelpText<"Equivalent to -march=mips64r2">, Flags<[HelpHidden]>;
 def mips64r6 : Flag<["-"], "mips64r6">,
   Alias<march_EQ>, AliasArgs<["mips64r6"]>,
   HelpText<"Equivalent to -march=mips64r6">, Flags<[HelpHidden]>;
 def mfpxx : Flag<["-"], "mfpxx">, Group<m_Group>,
   HelpText<"Avoid FPU mode dependent operations when used with the O32 ABI">,
   Flags<[HelpHidden]>;
 def modd_spreg : Flag<["-"], "modd-spreg">, Group<m_Group>,
   HelpText<"Enable odd single-precision floating point registers">,
   Flags<[HelpHidden]>;
 def mno_odd_spreg : Flag<["-"], "mno-odd-spreg">, Group<m_Group>,
   HelpText<"Disable odd single-precision floating point registers">,
   Flags<[HelpHidden]>;
 def mglibc : Flag<["-"], "mglibc">, Group<m_libc_Group>, Flags<[HelpHidden]>;
 def muclibc : Flag<["-"], "muclibc">, Group<m_libc_Group>, Flags<[HelpHidden]>;
 def module_file_info : Flag<["-"], "module-file-info">, Flags<[DriverOption,CC1Option]>, Group<Action_Group>;
 def mthumb : Flag<["-"], "mthumb">, Group<m_Group>;
 def mtune_EQ : Joined<["-"], "mtune=">, Group<m_Group>;
 def multi__module : Flag<["-"], "multi_module">;
 def multiply__defined__unused : Separate<["-"], "multiply_defined_unused">;
 def multiply__defined : Separate<["-"], "multiply_defined">;
 def mwarn_nonportable_cfstrings : Flag<["-"], "mwarn-nonportable-cfstrings">, Group<m_Group>;
 def no_canonical_prefixes : Flag<["-"], "no-canonical-prefixes">, Flags<[HelpHidden]>,
   HelpText<"Use relative instead of canonical paths">;
 def no_cpp_precomp : Flag<["-"], "no-cpp-precomp">, Group<clang_ignored_f_Group>;
 def no_integrated_cpp : Flag<["-", "--"], "no-integrated-cpp">, Flags<[DriverOption]>;
 def no_pedantic : Flag<["-", "--"], "no-pedantic">, Group<pedantic_Group>;
 def no__dead__strip__inits__and__terms : Flag<["-"], "no_dead_strip_inits_and_terms">;
 def nobuiltininc : Flag<["-"], "nobuiltininc">, Flags<[CC1Option]>,
   HelpText<"Disable builtin #include directories">;
 def nodefaultlibs : Flag<["-"], "nodefaultlibs">;
 def nofixprebinding : Flag<["-"], "nofixprebinding">;
 def nolibc : Flag<["-"], "nolibc">;
 def nomultidefs : Flag<["-"], "nomultidefs">;
 def nopie : Flag<["-"], "nopie">;
 def noprebind : Flag<["-"], "noprebind">;
 def noseglinkedit : Flag<["-"], "noseglinkedit">;
 def nostartfiles : Flag<["-"], "nostartfiles">;
 def nostdinc : Flag<["-"], "nostdinc">;
 def nostdlibinc : Flag<["-"], "nostdlibinc">;
 def nostdincxx : Flag<["-"], "nostdinc++">, Flags<[CC1Option]>,
   HelpText<"Disable standard #include directories for the C++ standard library">;
 def nostdlib : Flag<["-"], "nostdlib">;
 def object : Flag<["-"], "object">;
 def o : JoinedOrSeparate<["-"], "o">, Flags<[DriverOption, RenderAsInput, CC1Option, CC1AsOption]>,
   HelpText<"Write output to <file>">, MetaVarName<"<file>">;
 def pagezero__size : JoinedOrSeparate<["-"], "pagezero_size">;
 def pass_exit_codes : Flag<["-", "--"], "pass-exit-codes">, Flags<[Unsupported]>;
 def pedantic_errors : Flag<["-", "--"], "pedantic-errors">, Group<pedantic_Group>, Flags<[CC1Option]>;
 def pedantic : Flag<["-", "--"], "pedantic">, Group<pedantic_Group>, Flags<[CC1Option]>;
 def pg : Flag<["-"], "pg">, HelpText<"Enable mcount instrumentation">, Flags<[CC1Option]>;
 def pipe : Flag<["-", "--"], "pipe">,
   HelpText<"Use pipes between commands, when possible">;
 def prebind__all__twolevel__modules : Flag<["-"], "prebind_all_twolevel_modules">;
 def prebind : Flag<["-"], "prebind">;
 def preload : Flag<["-"], "preload">;
 def print_file_name_EQ : Joined<["-", "--"], "print-file-name=">,
   HelpText<"Print the full library path of <file>">, MetaVarName<"<file>">;
 def print_ivar_layout : Flag<["-"], "print-ivar-layout">, Flags<[CC1Option]>,
   HelpText<"Enable Objective-C Ivar layout bitmap print trace">;
 def print_libgcc_file_name : Flag<["-", "--"], "print-libgcc-file-name">,
   HelpText<"Print the library path for \"libgcc.a\"">;
 def print_multi_directory : Flag<["-", "--"], "print-multi-directory">;
 def print_multi_lib : Flag<["-", "--"], "print-multi-lib">;
 def print_multi_os_directory : Flag<["-", "--"], "print-multi-os-directory">;
 def print_prog_name_EQ : Joined<["-", "--"], "print-prog-name=">,
   HelpText<"Print the full program path of <name>">, MetaVarName<"<name>">;
 def print_search_dirs : Flag<["-", "--"], "print-search-dirs">,
   HelpText<"Print the paths used for finding libraries and programs">;
 def private__bundle : Flag<["-"], "private_bundle">;
 def pthreads : Flag<["-"], "pthreads">;
 def pthread : Flag<["-"], "pthread">, Flags<[CC1Option]>,
   HelpText<"Support POSIX threads in generated code">;
 def p : Flag<["-"], "p">;
 def pie : Flag<["-"], "pie">;
 def read__only__relocs : Separate<["-"], "read_only_relocs">;
 def remap : Flag<["-"], "remap">;
 def rewrite_objc : Flag<["-"], "rewrite-objc">, Flags<[DriverOption,CC1Option]>,
   HelpText<"Rewrite Objective-C source to C++">, Group<Action_Group>;
 def rewrite_legacy_objc : Flag<["-"], "rewrite-legacy-objc">, Flags<[DriverOption]>,
   HelpText<"Rewrite Legacy Objective-C source to C++">;
 def rdynamic : Flag<["-"], "rdynamic">;
 def resource_dir : Separate<["-"], "resource-dir">,
   Flags<[DriverOption, CC1Option, HelpHidden]>,
   HelpText<"The directory which holds the compiler resource files">;
 def resource_dir_EQ : Joined<["-"], "resource-dir=">, Flags<[DriverOption]>,
   Alias<resource_dir>;
 def rpath : Separate<["-"], "rpath">, Flags<[LinkerInput]>;
 def rtlib_EQ : Joined<["-", "--"], "rtlib=">;
 def r : Flag<["-"], "r">;
 def save_temps : Flag<["-", "--"], "save-temps">, Flags<[DriverOption]>,
   HelpText<"Save intermediate compilation results">;
 def via_file_asm : Flag<["-", "--"], "via-file-asm">, InternalDebugOpt,
   HelpText<"Write assembly to file for input to assemble jobs">;
 def sectalign : MultiArg<["-"], "sectalign", 3>;
 def sectcreate : MultiArg<["-"], "sectcreate", 3>;
 def sectobjectsymbols : MultiArg<["-"], "sectobjectsymbols", 2>;
 def sectorder : MultiArg<["-"], "sectorder", 3>;
 def seg1addr : JoinedOrSeparate<["-"], "seg1addr">;
 def seg__addr__table__filename : Separate<["-"], "seg_addr_table_filename">;
 def seg__addr__table : Separate<["-"], "seg_addr_table">;
 def segaddr : MultiArg<["-"], "segaddr", 2>;
 def segcreate : MultiArg<["-"], "segcreate", 3>;
 def seglinkedit : Flag<["-"], "seglinkedit">;
 def segprot : MultiArg<["-"], "segprot", 3>;
 def segs__read__only__addr : Separate<["-"], "segs_read_only_addr">;
 def segs__read__write__addr : Separate<["-"], "segs_read_write_addr">;
 def segs__read__ : Joined<["-"], "segs_read_">;
 def shared_libgcc : Flag<["-"], "shared-libgcc">;
 def shared : Flag<["-", "--"], "shared">;
 def single__module : Flag<["-"], "single_module">;
 def specs_EQ : Joined<["-", "--"], "specs=">;
 def specs : Separate<["-", "--"], "specs">, Flags<[Unsupported]>;
 def static_libgcc : Flag<["-"], "static-libgcc">;
 def static_libstdcxx : Flag<["-"], "static-libstdc++">;
 def static : Flag<["-", "--"], "static">, Flags<[NoArgumentUnused]>;
 def std_default_EQ : Joined<["-"], "std-default=">;
 def std_EQ : Joined<["-", "--"], "std=">, Flags<[CC1Option]>,
   Group<CompileOnly_Group>, HelpText<"Language standard to compile for">;
 def stdlib_EQ : Joined<["-", "--"], "stdlib=">, Flags<[CC1Option]>,
   HelpText<"C++ standard library to use">;
 def sub__library : JoinedOrSeparate<["-"], "sub_library">;
 def sub__umbrella : JoinedOrSeparate<["-"], "sub_umbrella">;
 def system_header_prefix : Joined<["--"], "system-header-prefix=">,
   Group<clang_i_Group>, Flags<[CC1Option]>, MetaVarName<"<prefix>">,
   HelpText<"Treat all #include paths starting with <prefix> as including a "
            "system header.">;
 def : Separate<["--"], "system-header-prefix">, Alias<system_header_prefix>;
 def no_system_header_prefix : Joined<["--"], "no-system-header-prefix=">,
   Group<clang_i_Group>, Flags<[CC1Option]>, MetaVarName<"<prefix>">,
   HelpText<"Treat all #include paths starting with <prefix> as not including a "
            "system header.">;
 def : Separate<["--"], "no-system-header-prefix">, Alias<no_system_header_prefix>;
 def s : Flag<["-"], "s">;
 def target : Joined<["--"], "target=">, Flags<[DriverOption, CoreOption]>,
   HelpText<"Generate code for the given target">;
 def gcc_toolchain : Joined<["--"], "gcc-toolchain=">, Flags<[DriverOption]>,
   HelpText<"Use the gcc toolchain at the given directory">;
 def time : Flag<["-"], "time">,
   HelpText<"Time individual commands">;
 def traditional_cpp : Flag<["-", "--"], "traditional-cpp">, Flags<[CC1Option]>,
   HelpText<"Enable some traditional CPP emulation">;
 def traditional : Flag<["-", "--"], "traditional">;
 def trigraphs : Flag<["-", "--"], "trigraphs">, Alias<ftrigraphs>,
   HelpText<"Process trigraph sequences">;
 def twolevel__namespace__hints : Flag<["-"], "twolevel_namespace_hints">;
 def twolevel__namespace : Flag<["-"], "twolevel_namespace">;
 def t : Flag<["-"], "t">;
 def umbrella : Separate<["-"], "umbrella">;
 def undefined : JoinedOrSeparate<["-"], "undefined">, Group<u_Group>;
 def undef : Flag<["-"], "undef">, Group<u_Group>, Flags<[CC1Option]>,
   HelpText<"undef all system defines">;
 def unexported__symbols__list : Separate<["-"], "unexported_symbols_list">;
 def u : JoinedOrSeparate<["-"], "u">, Group<u_Group>;
 def v : Flag<["-"], "v">, Flags<[CC1Option, CoreOption]>,
   HelpText<"Show commands to run and use verbose output">;
 def verify_debug_info : Flag<["--"], "verify-debug-info">, Flags<[DriverOption]>,
   HelpText<"Verify the binary representation of debug output">;
 def weak_l : Joined<["-"], "weak-l">, Flags<[LinkerInput]>;
 def weak__framework : Separate<["-"], "weak_framework">, Flags<[LinkerInput]>;
 def weak__library : Separate<["-"], "weak_library">, Flags<[LinkerInput]>;
 def weak__reference__mismatches : Separate<["-"], "weak_reference_mismatches">;
 def whatsloaded : Flag<["-"], "whatsloaded">;
 def whyload : Flag<["-"], "whyload">;
 def w : Flag<["-"], "w">, HelpText<"Suppress all warnings">, Flags<[CC1Option]>;
 def x : JoinedOrSeparate<["-"], "x">, Flags<[DriverOption,CC1Option]>,
   HelpText<"Treat subsequent input files as having type <language>">,
   MetaVarName<"<language>">;
 def y : Joined<["-"], "y">;
 
 def fintegrated_as : Flag<["-"], "fintegrated-as">, Flags<[DriverOption]>,
                      Group<f_Group>, HelpText<"Enable the integrated assembler">;
 def fno_integrated_as : Flag<["-"], "fno-integrated-as">,
                         Flags<[CC1Option, DriverOption]>, Group<f_Group>,
                         HelpText<"Disable the integrated assembler">;
 def : Flag<["-"], "integrated-as">, Alias<fintegrated_as>, Flags<[DriverOption]>;
 def : Flag<["-"], "no-integrated-as">, Alias<fno_integrated_as>,
       Flags<[CC1Option, DriverOption]>;
 
 def working_directory : JoinedOrSeparate<["-"], "working-directory">, Flags<[CC1Option]>,
   HelpText<"Resolve file paths relative to the specified directory">;
 def working_directory_EQ : Joined<["-"], "working-directory=">, Flags<[CC1Option]>,
   Alias<working_directory>;
 
 // Double dash options, which are usually an alias for one of the previous
 // options.
 
 def _mhwdiv_EQ : Joined<["--"], "mhwdiv=">, Alias<mhwdiv_EQ>;
 def _mhwdiv : Separate<["--"], "mhwdiv">, Alias<mhwdiv_EQ>;
 def _CLASSPATH_EQ : Joined<["--"], "CLASSPATH=">, Alias<fclasspath_EQ>;
 def _CLASSPATH : Separate<["--"], "CLASSPATH">, Alias<fclasspath_EQ>;
 def _all_warnings : Flag<["--"], "all-warnings">, Alias<Wall>;
 def _analyze_auto : Flag<["--"], "analyze-auto">, Flags<[DriverOption]>;
 def _analyzer_no_default_checks : Flag<["--"], "analyzer-no-default-checks">, Flags<[DriverOption]>;
 def _analyzer_output : JoinedOrSeparate<["--"], "analyzer-output">, Flags<[DriverOption]>;
 def _analyze : Flag<["--"], "analyze">, Flags<[DriverOption, CoreOption]>,
   HelpText<"Run the static analyzer">;
 def _assemble : Flag<["--"], "assemble">, Alias<S>;
 def _assert_EQ : Joined<["--"], "assert=">, Alias<A>;
 def _assert : Separate<["--"], "assert">, Alias<A>;
 def _bootclasspath_EQ : Joined<["--"], "bootclasspath=">, Alias<fbootclasspath_EQ>;
 def _bootclasspath : Separate<["--"], "bootclasspath">, Alias<fbootclasspath_EQ>;
 def _classpath_EQ : Joined<["--"], "classpath=">, Alias<fclasspath_EQ>;
 def _classpath : Separate<["--"], "classpath">, Alias<fclasspath_EQ>;
 def _comments_in_macros : Flag<["--"], "comments-in-macros">, Alias<CC>;
 def _comments : Flag<["--"], "comments">, Alias<C>;
 def _compile : Flag<["--"], "compile">, Alias<c>;
 def _constant_cfstrings : Flag<["--"], "constant-cfstrings">;
 def _debug_EQ : Joined<["--"], "debug=">, Alias<g_Flag>;
 def _debug : Flag<["--"], "debug">, Alias<g_Flag>;
 def _define_macro_EQ : Joined<["--"], "define-macro=">, Alias<D>;
 def _define_macro : Separate<["--"], "define-macro">, Alias<D>;
 def _dependencies : Flag<["--"], "dependencies">, Alias<M>;
 def _dyld_prefix_EQ : Joined<["--"], "dyld-prefix=">;
 def _dyld_prefix : Separate<["--"], "dyld-prefix">, Alias<_dyld_prefix_EQ>;
 def _encoding_EQ : Joined<["--"], "encoding=">, Alias<fencoding_EQ>;
 def _encoding : Separate<["--"], "encoding">, Alias<fencoding_EQ>;
 def _entry : Flag<["--"], "entry">, Alias<e>;
 def _extdirs_EQ : Joined<["--"], "extdirs=">, Alias<fextdirs_EQ>;
 def _extdirs : Separate<["--"], "extdirs">, Alias<fextdirs_EQ>;
 def _extra_warnings : Flag<["--"], "extra-warnings">, Alias<W_Joined>;
 def _for_linker_EQ : Joined<["--"], "for-linker=">, Alias<Xlinker>;
 def _for_linker : Separate<["--"], "for-linker">, Alias<Xlinker>;
 def _force_link_EQ : Joined<["--"], "force-link=">, Alias<u>;
 def _force_link : Separate<["--"], "force-link">, Alias<u>;
 def _help_hidden : Flag<["--"], "help-hidden">;
 def _imacros_EQ : Joined<["--"], "imacros=">, Alias<imacros>;
 def _include_barrier : Flag<["--"], "include-barrier">, Alias<I_>;
 def _include_directory_after_EQ : Joined<["--"], "include-directory-after=">, Alias<idirafter>;
 def _include_directory_after : Separate<["--"], "include-directory-after">, Alias<idirafter>;
 def _include_directory_EQ : Joined<["--"], "include-directory=">, Alias<I>;
 def _include_directory : Separate<["--"], "include-directory">, Alias<I>;
 def _include_prefix_EQ : Joined<["--"], "include-prefix=">, Alias<iprefix>;
 def _include_prefix : Separate<["--"], "include-prefix">, Alias<iprefix>;
 def _include_with_prefix_after_EQ : Joined<["--"], "include-with-prefix-after=">, Alias<iwithprefix>;
 def _include_with_prefix_after : Separate<["--"], "include-with-prefix-after">, Alias<iwithprefix>;
 def _include_with_prefix_before_EQ : Joined<["--"], "include-with-prefix-before=">, Alias<iwithprefixbefore>;
 def _include_with_prefix_before : Separate<["--"], "include-with-prefix-before">, Alias<iwithprefixbefore>;
 def _include_with_prefix_EQ : Joined<["--"], "include-with-prefix=">, Alias<iwithprefix>;
 def _include_with_prefix : Separate<["--"], "include-with-prefix">, Alias<iwithprefix>;
 def _include_EQ : Joined<["--"], "include=">, Alias<include_>;
 def _language_EQ : Joined<["--"], "language=">, Alias<x>;
 def _language : Separate<["--"], "language">, Alias<x>;
 def _library_directory_EQ : Joined<["--"], "library-directory=">, Alias<L>;
 def _library_directory : Separate<["--"], "library-directory">, Alias<L>;
 def _no_line_commands : Flag<["--"], "no-line-commands">, Alias<P>;
 def _no_standard_includes : Flag<["--"], "no-standard-includes">, Alias<nostdinc>;
 def _no_standard_libraries : Flag<["--"], "no-standard-libraries">, Alias<nostdlib>;
 def _no_undefined : Flag<["--"], "no-undefined">, Flags<[LinkerInput]>;
 def _no_warnings : Flag<["--"], "no-warnings">, Alias<w>;
 def _optimize_EQ : Joined<["--"], "optimize=">, Alias<O>;
 def _optimize : Flag<["--"], "optimize">, Alias<O>;
 def _output_class_directory_EQ : Joined<["--"], "output-class-directory=">, Alias<foutput_class_dir_EQ>;
 def _output_class_directory : Separate<["--"], "output-class-directory">, Alias<foutput_class_dir_EQ>;
 def _output_EQ : Joined<["--"], "output=">, Alias<o>;
 def _output : Separate<["--"], "output">, Alias<o>;
 def _param : Separate<["--"], "param">, Group<CompileOnly_Group>;
 def _param_EQ : Joined<["--"], "param=">, Alias<_param>;
 def _prefix_EQ : Joined<["--"], "prefix=">, Alias<B>;
 def _prefix : Separate<["--"], "prefix">, Alias<B>;
 def _preprocess : Flag<["--"], "preprocess">, Alias<E>;
 def _print_diagnostic_categories : Flag<["--"], "print-diagnostic-categories">;
 def _print_file_name : Separate<["--"], "print-file-name">, Alias<print_file_name_EQ>;
 def _print_missing_file_dependencies : Flag<["--"], "print-missing-file-dependencies">, Alias<MG>;
 def _print_prog_name : Separate<["--"], "print-prog-name">, Alias<print_prog_name_EQ>;
 def _profile_blocks : Flag<["--"], "profile-blocks">, Alias<a>;
 def _profile : Flag<["--"], "profile">, Alias<p>;
 def _resource_EQ : Joined<["--"], "resource=">, Alias<fcompile_resource_EQ>;
 def _resource : Separate<["--"], "resource">, Alias<fcompile_resource_EQ>;
 def _rtlib : Separate<["--"], "rtlib">, Alias<rtlib_EQ>;
 def _serialize_diags : Separate<["-", "--"], "serialize-diagnostics">, Flags<[DriverOption]>,
   HelpText<"Serialize compiler diagnostics to a file">;
 // We give --version different semantics from -version.
 def _version : Flag<["--"], "version">,  Flags<[CC1Option]>;
 def _signed_char : Flag<["--"], "signed-char">, Alias<fsigned_char>;
 def _std : Separate<["--"], "std">, Alias<std_EQ>;
 def _stdlib : Separate<["--"], "stdlib">, Alias<stdlib_EQ>;
 def _sysroot_EQ : Joined<["--"], "sysroot=">;
 def _sysroot : Separate<["--"], "sysroot">, Alias<_sysroot_EQ>;
 def _target_help : Flag<["--"], "target-help">;
 def _trace_includes : Flag<["--"], "trace-includes">, Alias<H>;
 def _undefine_macro_EQ : Joined<["--"], "undefine-macro=">, Alias<U>;
 def _undefine_macro : Separate<["--"], "undefine-macro">, Alias<U>;
 def _unsigned_char : Flag<["--"], "unsigned-char">, Alias<funsigned_char>;
 def _user_dependencies : Flag<["--"], "user-dependencies">, Alias<MM>;
 def _verbose : Flag<["--"], "verbose">, Alias<v>;
 def _warn__EQ : Joined<["--"], "warn-=">, Alias<W_Joined>;
 def _warn_ : Joined<["--"], "warn-">, Alias<W_Joined>;
 def _write_dependencies : Flag<["--"], "write-dependencies">, Alias<MD>;
 def _write_user_dependencies : Flag<["--"], "write-user-dependencies">, Alias<MMD>;
 def _ : Joined<["--"], "">, Flags<[Unsupported]>;
 def mieee_rnd_near : Flag<["-"], "mieee-rnd-near">, Group<m_hexagon_Features_Group>;
 def mv1 : Flag<["-"], "mv1">, Group<m_hexagon_Features_Group>, Alias<march_EQ>,
           AliasArgs<["v1"]>;
 def mv2 : Flag<["-"], "mv2">, Group<m_hexagon_Features_Group>, Alias<march_EQ>,
           AliasArgs<["v2"]>;
 def mv3 : Flag<["-"], "mv3">, Group<m_hexagon_Features_Group>, Alias<march_EQ>,
           AliasArgs<["v3"]>;
 def mv4 : Flag<["-"], "mv4">, Group<m_hexagon_Features_Group>, Alias<march_EQ>,
           AliasArgs<["v4"]>;
 def mv5 : Flag<["-"], "mv5">, Group<m_hexagon_Features_Group>, Alias<march_EQ>,
           AliasArgs<["v5"]>;
 
 // These are legacy user-facing driver-level option spellings. They are always
 // aliases for options that are spelled using the more common Unix / GNU flag
 // style of double-dash and equals-joined flags.
 def gcc_toolchain_legacy_spelling : Separate<["-"], "gcc-toolchain">, Alias<gcc_toolchain>;
 def target_legacy_spelling : Separate<["-"], "target">, Alias<target>;
 
 // Special internal option to handle -Xlinker --no-demangle.
 def Z_Xlinker__no_demangle : Flag<["-"], "Z-Xlinker-no-demangle">,
     Flags<[Unsupported, NoArgumentUnused]>;
 
 // Special internal option to allow forwarding arbitrary arguments to linker.
 def Zlinker_input : Separate<["-"], "Zlinker-input">,
     Flags<[Unsupported, NoArgumentUnused]>;
 
 // Reserved library options.
 def Z_reserved_lib_stdcxx : Flag<["-"], "Z-reserved-lib-stdc++">,
     Flags<[LinkerInput, NoArgumentUnused, Unsupported]>, Group<reserved_lib_Group>;
 def Z_reserved_lib_cckext : Flag<["-"], "Z-reserved-lib-cckext">,
     Flags<[LinkerInput, NoArgumentUnused, Unsupported]>, Group<reserved_lib_Group>;
 
 // Ignored options
 // FIXME: multiclasess produce suffixes, not prefixes. This is fine for now
 // since it is only used in ignored options.
 multiclass BooleanFFlag<string name> {
   def _f : Flag<["-"], "f"#name>;
   def _fno : Flag<["-"], "fno-"#name>;
 }
 
 defm : BooleanFFlag<"keep-inline-functions">, Group<clang_ignored_gcc_optimization_f_Group>;
 
 def fprofile_dir : Joined<["-"], "fprofile-dir=">, Group<clang_ignored_gcc_optimization_f_Group>;
 
 defm profile_use : BooleanFFlag<"profile-use">, Group<clang_ignored_gcc_optimization_f_Group>;
 def fprofile_use_EQ : Joined<["-"], "fprofile-use=">, Group<clang_ignored_gcc_optimization_f_Group>;
 def fuse_ld_EQ : Joined<["-"], "fuse-ld=">, Group<f_Group>;
 
 defm align_functions : BooleanFFlag<"align-functions">, Group<clang_ignored_gcc_optimization_f_Group>;
 def falign_functions_EQ : Joined<["-"], "falign-functions=">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm align_labels : BooleanFFlag<"align-labels">, Group<clang_ignored_gcc_optimization_f_Group>;
 def falign_labels_EQ : Joined<["-"], "falign-labels=">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm align_loops : BooleanFFlag<"align-loops">, Group<clang_ignored_gcc_optimization_f_Group>;
 def falign_loops_EQ : Joined<["-"], "falign-loops=">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm align_jumps : BooleanFFlag<"align-jumps">, Group<clang_ignored_gcc_optimization_f_Group>;
 def falign_jumps_EQ : Joined<["-"], "falign-jumps=">, Group<clang_ignored_gcc_optimization_f_Group>;
 
 // FIXME: This option should be supported and wired up to our diognostics, but
 // ignore it for now to avoid breaking builds that use it.
 def fdiagnostics_show_location_EQ : Joined<["-"], "fdiagnostics-show-location=">, Group<clang_ignored_f_Group>;
 
 defm fcheck_new : BooleanFFlag<"check-new">, Group<clang_ignored_f_Group>;
 defm caller_saves : BooleanFFlag<"caller-saves">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm reorder_blocks : BooleanFFlag<"reorder-blocks">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm eliminate_unused_debug_types : BooleanFFlag<"eliminate-unused-debug-types">, Group<clang_ignored_f_Group>;
 defm branch_count_reg : BooleanFFlag<"branch-count-reg">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm default_inline : BooleanFFlag<"default-inline">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm delete_null_pointer_checks : BooleanFFlag<"delete-null-pointer-checks">,
     Group<clang_ignored_gcc_optimization_f_Group>;
 defm fat_lto_objects : BooleanFFlag<"fat-lto-objects">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm float_store : BooleanFFlag<"float-store">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm friend_injection : BooleanFFlag<"friend-injection">, Group<clang_ignored_f_Group>;
 defm function_attribute_list : BooleanFFlag<"function-attribute-list">, Group<clang_ignored_f_Group>;
 defm gcse : BooleanFFlag<"gcse">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm gcse_after_reload: BooleanFFlag<"gcse-after-reload">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm gcse_las: BooleanFFlag<"gcse-las">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm gcse_sm: BooleanFFlag<"gcse-sm">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm gnu : BooleanFFlag<"gnu">, Group<clang_ignored_f_Group>;
 defm ident : BooleanFFlag<"ident">, Group<clang_ignored_f_Group>;
 defm implicit_templates : BooleanFFlag<"implicit-templates">, Group<clang_ignored_f_Group>;
 defm implement_inlines : BooleanFFlag<"implement-inlines">, Group<clang_ignored_f_Group>;
 defm merge_constants : BooleanFFlag<"merge-constants">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm modulo_sched : BooleanFFlag<"modulo-sched">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm modulo_sched_allow_regmoves : BooleanFFlag<"modulo-sched-allow-regmoves">,
     Group<clang_ignored_gcc_optimization_f_Group>;
 defm inline_functions_called_once : BooleanFFlag<"inline-functions-called-once">,
     Group<clang_ignored_gcc_optimization_f_Group>;
 def finline_limit_EQ : Joined<["-"], "finline-limit=">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm finline_limit : BooleanFFlag<"inline-limit">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm inline_small_functions : BooleanFFlag<"inline-small-functions">,
     Group<clang_ignored_gcc_optimization_f_Group>;
 defm ipa_cp : BooleanFFlag<"ipa-cp">,
     Group<clang_ignored_gcc_optimization_f_Group>;
 defm ivopts : BooleanFFlag<"ivopts">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm non_call_exceptions : BooleanFFlag<"non-call-exceptions">, Group<clang_ignored_f_Group>;
 defm peel_loops : BooleanFFlag<"peel-loops">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm permissive : BooleanFFlag<"permissive">, Group<clang_ignored_f_Group>;
 defm prefetch_loop_arrays : BooleanFFlag<"prefetch-loop-arrays">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm printf : BooleanFFlag<"printf">, Group<clang_ignored_f_Group>;
 defm profile : BooleanFFlag<"profile">, Group<clang_ignored_f_Group>;
 defm profile_correction : BooleanFFlag<"profile-correction">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm profile_generate_sampling : BooleanFFlag<"profile-generate-sampling">, Group<clang_ignored_f_Group>;
 defm profile_reusedist : BooleanFFlag<"profile-reusedist">, Group<clang_ignored_f_Group>;
 defm profile_values : BooleanFFlag<"profile-values">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm regs_graph : BooleanFFlag<"regs-graph">, Group<clang_ignored_f_Group>;
 defm rename_registers : BooleanFFlag<"rename-registers">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm ripa : BooleanFFlag<"ripa">, Group<clang_ignored_f_Group>;
 defm rounding_math : BooleanFFlag<"rounding-math">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm schedule_insns : BooleanFFlag<"schedule-insns">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm schedule_insns2 : BooleanFFlag<"schedule-insns2">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm see : BooleanFFlag<"see">, Group<clang_ignored_f_Group>;
 defm signaling_nans : BooleanFFlag<"signaling-nans">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm single_precision_constant : BooleanFFlag<"single-precision-constant">,
     Group<clang_ignored_gcc_optimization_f_Group>;
 defm spec_constr_count : BooleanFFlag<"spec-constr-count">, Group<clang_ignored_f_Group>;
 defm stack_check : BooleanFFlag<"stack-check">, Group<clang_ignored_f_Group>;
 defm strength_reduce :
     BooleanFFlag<"strength-reduce">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm tls_model : BooleanFFlag<"tls-model">, Group<clang_ignored_f_Group>;
 defm tracer : BooleanFFlag<"tracer">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm tree_dce : BooleanFFlag<"tree-dce">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm tree_loop_im : BooleanFFlag<"tree_loop_im">,  Group<clang_ignored_gcc_optimization_f_Group>;
 defm tree_loop_ivcanon : BooleanFFlag<"tree_loop_ivcanon">,  Group<clang_ignored_gcc_optimization_f_Group>;
 defm tree_loop_linear : BooleanFFlag<"tree_loop_linear">,  Group<clang_ignored_gcc_optimization_f_Group>;
 defm tree_salias : BooleanFFlag<"tree-salias">, Group<clang_ignored_f_Group>;
 defm tree_ter : BooleanFFlag<"tree-ter">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm tree_vectorizer_verbose : BooleanFFlag<"tree-vectorizer-verbose">, Group<clang_ignored_f_Group>;
 defm tree_vrp : BooleanFFlag<"tree-vrp">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm unroll_all_loops : BooleanFFlag<"unroll-all-loops">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm unsafe_loop_optimizations : BooleanFFlag<"unsafe-loop-optimizations">,
     Group<clang_ignored_gcc_optimization_f_Group>;
 defm unswitch_loops : BooleanFFlag<"unswitch-loops">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm use_linker_plugin : BooleanFFlag<"use-linker-plugin">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm vect_cost_model : BooleanFFlag<"vect-cost-model">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm variable_expansion_in_unroller : BooleanFFlag<"variable-expansion-in-unroller">,
     Group<clang_ignored_gcc_optimization_f_Group>;
 defm web : BooleanFFlag<"web">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm whole_program : BooleanFFlag<"whole-program">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm devirtualize : BooleanFFlag<"devirtualize">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm devirtualize_speculatively : BooleanFFlag<"devirtualize-speculatively">,
     Group<clang_ignored_gcc_optimization_f_Group>;
 
 // gfortran options that we recognize in the driver and pass along when
 // invoking GCC to compile Fortran code.
 def gfortran_Group : OptionGroup<"gfortran Group">;
 
 // Generic gfortran options.
 def A_DASH : Joined<["-"], "A-">, Group<gfortran_Group>;
 def J : JoinedOrSeparate<["-"], "J">, Flags<[RenderJoined]>, Group<gfortran_Group>;
 def cpp : Flag<["-"], "cpp">, Group<gfortran_Group>;
 def nocpp : Flag<["-"], "nocpp">, Group<gfortran_Group>;
 def static_libgfortran : Flag<["-"], "static-libgfortran">, Group<gfortran_Group>;
 
 // "f" options with values for gfortran.
 def fblas_matmul_limit_EQ : Joined<["-"], "fblas-matmul-limit=">, Group<gfortran_Group>;
 def fcheck_EQ : Joined<["-"], "fcheck=">, Group<gfortran_Group>;
 def fcoarray_EQ : Joined<["-"], "fcoarray=">, Group<gfortran_Group>;
 def fconvert_EQ : Joined<["-"], "fconvert=">, Group<gfortran_Group>;
 def ffixed_line_length_VALUE : Joined<["-"], "ffixed-line-length-">, Group<gfortran_Group>;
 def ffpe_trap_EQ : Joined<["-"], "ffpe-trap=">, Group<gfortran_Group>;
 def ffree_line_length_VALUE : Joined<["-"], "ffree-line-length-">, Group<gfortran_Group>;
 def finit_character_EQ : Joined<["-"], "finit-character=">, Group<gfortran_Group>;
 def finit_integer_EQ : Joined<["-"], "finit-integer=">, Group<gfortran_Group>;
 def finit_logical_EQ : Joined<["-"], "finit-logical=">, Group<gfortran_Group>;
 def finit_real_EQ : Joined<["-"], "finit-real=">, Group<gfortran_Group>;
 def fmax_array_constructor_EQ : Joined<["-"], "fmax-array-constructor=">, Group<gfortran_Group>;
 def fmax_errors_EQ : Joined<["-"], "fmax-errors=">, Group<gfortran_Group>;
 def fmax_stack_var_size_EQ : Joined<["-"], "fmax-stack-var-size=">, Group<gfortran_Group>;
 def fmax_subrecord_length_EQ : Joined<["-"], "fmax-subrecord-length=">, Group<gfortran_Group>;
 def frecord_marker_EQ : Joined<["-"], "frecord-marker=">, Group<gfortran_Group>;
 
 // "f" flags for gfortran.
 defm aggressive_function_elimination : BooleanFFlag<"aggressive-function-elimination">, Group<gfortran_Group>;
 defm align_commons : BooleanFFlag<"align-commons">, Group<gfortran_Group>;
 defm all_intrinsics : BooleanFFlag<"all-intrinsics">, Group<gfortran_Group>;
 defm automatic : BooleanFFlag<"automatic">, Group<gfortran_Group>;
 defm backslash : BooleanFFlag<"backslash">, Group<gfortran_Group>;
 defm backtrace : BooleanFFlag<"backtrace">, Group<gfortran_Group>;
 defm bounds_check : BooleanFFlag<"bounds-check">, Group<gfortran_Group>;
 defm check_array_temporaries : BooleanFFlag<"check-array-temporaries">, Group<gfortran_Group>;
 defm cray_pointer : BooleanFFlag<"cray-pointer">, Group<gfortran_Group>;
 defm d_lines_as_code : BooleanFFlag<"d-lines-as-code">, Group<gfortran_Group>;
 defm d_lines_as_comments : BooleanFFlag<"d-lines-as-comments">, Group<gfortran_Group>;
 defm default_double_8 : BooleanFFlag<"default-double-8">, Group<gfortran_Group>;
 defm default_integer_8 : BooleanFFlag<"default-integer-8">, Group<gfortran_Group>;
 defm default_real_8 : BooleanFFlag<"default-real-8">, Group<gfortran_Group>;
 defm dollar_ok : BooleanFFlag<"dollar-ok">, Group<gfortran_Group>;
 defm dump_fortran_optimized : BooleanFFlag<"dump-fortran-optimized">, Group<gfortran_Group>;
 defm dump_fortran_original : BooleanFFlag<"dump-fortran-original">, Group<gfortran_Group>;
 defm dump_parse_tree : BooleanFFlag<"dump-parse-tree">, Group<gfortran_Group>;
 defm external_blas : BooleanFFlag<"external-blas">, Group<gfortran_Group>;
 defm f2c : BooleanFFlag<"f2c">, Group<gfortran_Group>;
 defm fixed_form : BooleanFFlag<"fixed-form">, Group<gfortran_Group>;
 defm free_form : BooleanFFlag<"free-form">, Group<gfortran_Group>;
 defm frontend_optimize : BooleanFFlag<"frontend-optimize">, Group<gfortran_Group>;
 defm implicit_none : BooleanFFlag<"implicit-none">, Group<gfortran_Group>;
 defm init_local_zero : BooleanFFlag<"init-local-zero">, Group<gfortran_Group>;
 defm integer_4_integer_8 : BooleanFFlag<"integer-4-integer-8">, Group<gfortran_Group>;
 defm intrinsic_modules_path : BooleanFFlag<"intrinsic-modules-path">, Group<gfortran_Group>;
 defm max_identifier_length : BooleanFFlag<"max-identifier-length">, Group<gfortran_Group>;
 defm module_private : BooleanFFlag<"module-private">, Group<gfortran_Group>;
 defm pack_derived : BooleanFFlag<"pack-derived">, Group<gfortran_Group>;
 defm protect_parens : BooleanFFlag<"protect-parens">, Group<gfortran_Group>;
 defm range_check : BooleanFFlag<"range-check">, Group<gfortran_Group>;
 defm real_4_real_10 : BooleanFFlag<"real-4-real-10">, Group<gfortran_Group>;
 defm real_4_real_16 : BooleanFFlag<"real-4-real-16">, Group<gfortran_Group>;
 defm real_4_real_8 : BooleanFFlag<"real-4-real-8">, Group<gfortran_Group>;
 defm real_8_real_10 : BooleanFFlag<"real-8-real-10">, Group<gfortran_Group>;
 defm real_8_real_16 : BooleanFFlag<"real-8-real-16">, Group<gfortran_Group>;
 defm real_8_real_4 : BooleanFFlag<"real-8-real-4">, Group<gfortran_Group>;
 defm realloc_lhs : BooleanFFlag<"realloc-lhs">, Group<gfortran_Group>;
 defm recursive : BooleanFFlag<"recursive">, Group<gfortran_Group>;
 defm repack_arrays : BooleanFFlag<"repack-arrays">, Group<gfortran_Group>;
 defm second_underscore : BooleanFFlag<"second-underscore">, Group<gfortran_Group>;
 defm sign_zero : BooleanFFlag<"sign-zero">, Group<gfortran_Group>;
 defm stack_arrays : BooleanFFlag<"stack-arrays">, Group<gfortran_Group>;
 defm underscoring : BooleanFFlag<"underscoring">, Group<gfortran_Group>;
 defm whole_file : BooleanFFlag<"whole-file">, Group<gfortran_Group>;
 
 
 include "CC1Options.td"
 
 include "CLCompatOptions.td"
Index: projects/clang360-import/contrib/llvm/tools/clang/lib/Driver/Tools.cpp
===================================================================
--- projects/clang360-import/contrib/llvm/tools/clang/lib/Driver/Tools.cpp	(revision 277777)
+++ projects/clang360-import/contrib/llvm/tools/clang/lib/Driver/Tools.cpp	(revision 277778)
@@ -1,8361 +1,8366 @@
 //===--- Tools.cpp - Tools Implementations --------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Tools.h"
 #include "InputInfo.h"
 #include "ToolChains.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/ObjCRuntime.h"
 #include "clang/Basic/Version.h"
 #include "clang/Driver/Action.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Job.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/SanitizerArgs.h"
 #include "clang/Driver/ToolChain.h"
 #include "clang/Driver/Util.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
 static void addAssemblerKPIC(const ArgList &Args, ArgStringList &CmdArgs) {
   Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
                                     options::OPT_fpic, options::OPT_fno_pic,
                                     options::OPT_fPIE, options::OPT_fno_PIE,
                                     options::OPT_fpie, options::OPT_fno_pie);
   if (!LastPICArg)
     return;
   if (LastPICArg->getOption().matches(options::OPT_fPIC) ||
       LastPICArg->getOption().matches(options::OPT_fpic) ||
       LastPICArg->getOption().matches(options::OPT_fPIE) ||
       LastPICArg->getOption().matches(options::OPT_fpie)) {
     CmdArgs.push_back("-KPIC");
   }
 }
 
 /// CheckPreprocessingOptions - Perform some validation of preprocessing
 /// arguments that is shared with gcc.
 static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
   if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC)) {
     if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
         !Args.hasArg(options::OPT__SLASH_EP) && !D.CCCIsCPP()) {
       D.Diag(diag::err_drv_argument_only_allowed_with)
           << A->getBaseArg().getAsString(Args)
           << (D.IsCLMode() ? "/E, /P or /EP" : "-E");
     }
   }
 }
 
 /// CheckCodeGenerationOptions - Perform some validation of code generation
 /// arguments that is shared with gcc.
 static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
   // In gcc, only ARM checks this, but it seems reasonable to check universally.
   if (Args.hasArg(options::OPT_static))
     if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
                                        options::OPT_mdynamic_no_pic))
       D.Diag(diag::err_drv_argument_not_allowed_with)
         << A->getAsString(Args) << "-static";
 }
 
 // Add backslashes to escape spaces and other backslashes.
 // This is used for the space-separated argument list specified with
 // the -dwarf-debug-flags option.
 static void EscapeSpacesAndBackslashes(const char *Arg,
                                        SmallVectorImpl<char> &Res) {
   for ( ; *Arg; ++Arg) {
     switch (*Arg) {
     default: break;
     case ' ':
     case '\\':
       Res.push_back('\\');
       break;
     }
     Res.push_back(*Arg);
   }
 }
 
 // Quote target names for inclusion in GNU Make dependency files.
 // Only the characters '$', '#', ' ', '\t' are quoted.
 static void QuoteTarget(StringRef Target,
                         SmallVectorImpl<char> &Res) {
   for (unsigned i = 0, e = Target.size(); i != e; ++i) {
     switch (Target[i]) {
     case ' ':
     case '\t':
       // Escape the preceding backslashes
       for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
         Res.push_back('\\');
 
       // Escape the space/tab
       Res.push_back('\\');
       break;
     case '$':
       Res.push_back('$');
       break;
     case '#':
       Res.push_back('\\');
       break;
     default:
       break;
     }
 
     Res.push_back(Target[i]);
   }
 }
 
 static void addDirectoryList(const ArgList &Args,
                              ArgStringList &CmdArgs,
                              const char *ArgName,
                              const char *EnvVar) {
   const char *DirList = ::getenv(EnvVar);
   bool CombinedArg = false;
 
   if (!DirList)
     return; // Nothing to do.
 
   StringRef Name(ArgName);
   if (Name.equals("-I") || Name.equals("-L"))
     CombinedArg = true;
 
   StringRef Dirs(DirList);
   if (Dirs.empty()) // Empty string should not add '.'.
     return;
 
   StringRef::size_type Delim;
   while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {
     if (Delim == 0) { // Leading colon.
       if (CombinedArg) {
         CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
       } else {
         CmdArgs.push_back(ArgName);
         CmdArgs.push_back(".");
       }
     } else {
       if (CombinedArg) {
         CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
       } else {
         CmdArgs.push_back(ArgName);
         CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
       }
     }
     Dirs = Dirs.substr(Delim + 1);
   }
 
   if (Dirs.empty()) { // Trailing colon.
     if (CombinedArg) {
       CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
     } else {
       CmdArgs.push_back(ArgName);
       CmdArgs.push_back(".");
     }
   } else { // Add the last path.
     if (CombinedArg) {
       CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
     } else {
       CmdArgs.push_back(ArgName);
       CmdArgs.push_back(Args.MakeArgString(Dirs));
     }
   }
 }
 
 static void AddLinkerInputs(const ToolChain &TC,
                             const InputInfoList &Inputs, const ArgList &Args,
                             ArgStringList &CmdArgs) {
   const Driver &D = TC.getDriver();
 
   // Add extra linker input arguments which are not treated as inputs
   // (constructed via -Xarch_).
   Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
 
   for (const auto &II : Inputs) {
     if (!TC.HasNativeLLVMSupport()) {
       // Don't try to pass LLVM inputs unless we have native support.
       if (II.getType() == types::TY_LLVM_IR ||
           II.getType() == types::TY_LTO_IR ||
           II.getType() == types::TY_LLVM_BC ||
           II.getType() == types::TY_LTO_BC)
         D.Diag(diag::err_drv_no_linker_llvm_support)
           << TC.getTripleString();
     }
 
     // Add filenames immediately.
     if (II.isFilename()) {
       CmdArgs.push_back(II.getFilename());
       continue;
     }
 
     // Otherwise, this is a linker input argument.
     const Arg &A = II.getInputArg();
 
     // Handle reserved library options.
     if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx))
       TC.AddCXXStdlibLibArgs(Args, CmdArgs);
     else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext))
       TC.AddCCKextLibArgs(Args, CmdArgs);
     else if (A.getOption().matches(options::OPT_z)) {
       // Pass -z prefix for gcc linker compatibility.
       A.claim();
       A.render(Args, CmdArgs);
     } else {
        A.renderAsInput(Args, CmdArgs);
     }
   }
 
   // LIBRARY_PATH - included following the user specified library paths.
   //                and only supported on native toolchains.
   if (!TC.isCrossCompiling())
     addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
 }
 
 /// \brief Determine whether Objective-C automated reference counting is
 /// enabled.
 static bool isObjCAutoRefCount(const ArgList &Args) {
   return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
 }
 
 /// \brief Determine whether we are linking the ObjC runtime.
 static bool isObjCRuntimeLinked(const ArgList &Args) {
   if (isObjCAutoRefCount(Args)) {
     Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
     return true;
   }
   return Args.hasArg(options::OPT_fobjc_link_runtime);
 }
 
 static bool forwardToGCC(const Option &O) {
   // Don't forward inputs from the original command line.  They are added from
   // InputInfoList.
   return O.getKind() != Option::InputClass &&
          !O.hasFlag(options::DriverOption) &&
          !O.hasFlag(options::LinkerInput);
 }
 
 void Clang::AddPreprocessingOptions(Compilation &C,
                                     const JobAction &JA,
                                     const Driver &D,
                                     const ArgList &Args,
                                     ArgStringList &CmdArgs,
                                     const InputInfo &Output,
                                     const InputInfoList &Inputs) const {
   Arg *A;
 
   CheckPreprocessingOptions(D, Args);
 
   Args.AddLastArg(CmdArgs, options::OPT_C);
   Args.AddLastArg(CmdArgs, options::OPT_CC);
 
   // Handle dependency file generation.
   if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
       (A = Args.getLastArg(options::OPT_MD)) ||
       (A = Args.getLastArg(options::OPT_MMD))) {
     // Determine the output location.
     const char *DepFile;
     if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
       DepFile = MF->getValue();
       C.addFailureResultFile(DepFile, &JA);
     } else if (Output.getType() == types::TY_Dependencies) {
       DepFile = Output.getFilename();
     } else if (A->getOption().matches(options::OPT_M) ||
                A->getOption().matches(options::OPT_MM)) {
       DepFile = "-";
     } else {
       DepFile = getDependencyFileName(Args, Inputs);
       C.addFailureResultFile(DepFile, &JA);
     }
     CmdArgs.push_back("-dependency-file");
     CmdArgs.push_back(DepFile);
 
     // Add a default target if one wasn't specified.
     if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
       const char *DepTarget;
 
       // If user provided -o, that is the dependency target, except
       // when we are only generating a dependency file.
       Arg *OutputOpt = Args.getLastArg(options::OPT_o);
       if (OutputOpt && Output.getType() != types::TY_Dependencies) {
         DepTarget = OutputOpt->getValue();
       } else {
         // Otherwise derive from the base input.
         //
         // FIXME: This should use the computed output file location.
         SmallString<128> P(Inputs[0].getBaseInput());
         llvm::sys::path::replace_extension(P, "o");
         DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
       }
 
       CmdArgs.push_back("-MT");
       SmallString<128> Quoted;
       QuoteTarget(DepTarget, Quoted);
       CmdArgs.push_back(Args.MakeArgString(Quoted));
     }
 
     if (A->getOption().matches(options::OPT_M) ||
         A->getOption().matches(options::OPT_MD))
       CmdArgs.push_back("-sys-header-deps");
 
     if (isa<PrecompileJobAction>(JA))
       CmdArgs.push_back("-module-file-deps");
   }
 
   if (Args.hasArg(options::OPT_MG)) {
     if (!A || A->getOption().matches(options::OPT_MD) ||
               A->getOption().matches(options::OPT_MMD))
       D.Diag(diag::err_drv_mg_requires_m_or_mm);
     CmdArgs.push_back("-MG");
   }
 
   Args.AddLastArg(CmdArgs, options::OPT_MP);
 
   // Convert all -MQ <target> args to -MT <quoted target>
   for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
                                              options::OPT_MQ),
          ie = Args.filtered_end(); it != ie; ++it) {
     const Arg *A = *it;
     A->claim();
 
     if (A->getOption().matches(options::OPT_MQ)) {
       CmdArgs.push_back("-MT");
       SmallString<128> Quoted;
       QuoteTarget(A->getValue(), Quoted);
       CmdArgs.push_back(Args.MakeArgString(Quoted));
 
     // -MT flag - no change
     } else {
       A->render(Args, CmdArgs);
     }
   }
 
   // Add -i* options, and automatically translate to
   // -include-pch/-include-pth for transparent PCH support. It's
   // wonky, but we include looking for .gch so we can support seamless
   // replacement into a build system already set up to be generating
   // .gch files.
   bool RenderedImplicitInclude = false;
   for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
          ie = Args.filtered_end(); it != ie; ++it) {
     const Arg *A = it;
 
     if (A->getOption().matches(options::OPT_include)) {
       bool IsFirstImplicitInclude = !RenderedImplicitInclude;
       RenderedImplicitInclude = true;
 
       // Use PCH if the user requested it.
       bool UsePCH = D.CCCUsePCH;
 
       bool FoundPTH = false;
       bool FoundPCH = false;
       SmallString<128> P(A->getValue());
       // We want the files to have a name like foo.h.pch. Add a dummy extension
       // so that replace_extension does the right thing.
       P += ".dummy";
       if (UsePCH) {
         llvm::sys::path::replace_extension(P, "pch");
         if (llvm::sys::fs::exists(P.str()))
           FoundPCH = true;
       }
 
       if (!FoundPCH) {
         llvm::sys::path::replace_extension(P, "pth");
         if (llvm::sys::fs::exists(P.str()))
           FoundPTH = true;
       }
 
       if (!FoundPCH && !FoundPTH) {
         llvm::sys::path::replace_extension(P, "gch");
         if (llvm::sys::fs::exists(P.str())) {
           FoundPCH = UsePCH;
           FoundPTH = !UsePCH;
         }
       }
 
       if (FoundPCH || FoundPTH) {
         if (IsFirstImplicitInclude) {
           A->claim();
           if (UsePCH)
             CmdArgs.push_back("-include-pch");
           else
             CmdArgs.push_back("-include-pth");
           CmdArgs.push_back(Args.MakeArgString(P.str()));
           continue;
         } else {
           // Ignore the PCH if not first on command line and emit warning.
           D.Diag(diag::warn_drv_pch_not_first_include)
               << P.str() << A->getAsString(Args);
         }
       }
     }
 
     // Not translated, render as usual.
     A->claim();
     A->render(Args, CmdArgs);
   }
 
   Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
   Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
                   options::OPT_index_header_map);
 
   // Add -Wp, and -Xassembler if using the preprocessor.
 
   // FIXME: There is a very unfortunate problem here, some troubled
   // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
   // really support that we would have to parse and then translate
   // those options. :(
   Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
                        options::OPT_Xpreprocessor);
 
   // -I- is a deprecated GCC feature, reject it.
   if (Arg *A = Args.getLastArg(options::OPT_I_))
     D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
 
   // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
   // -isysroot to the CC1 invocation.
   StringRef sysroot = C.getSysRoot();
   if (sysroot != "") {
     if (!Args.hasArg(options::OPT_isysroot)) {
       CmdArgs.push_back("-isysroot");
       CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
     }
   }
 
   // Parse additional include paths from environment variables.
   // FIXME: We should probably sink the logic for handling these from the
   // frontend into the driver. It will allow deleting 4 otherwise unused flags.
   // CPATH - included following the user specified includes (but prior to
   // builtin and standard includes).
   addDirectoryList(Args, CmdArgs, "-I", "CPATH");
   // C_INCLUDE_PATH - system includes enabled when compiling C.
   addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
   // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
   addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
   // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
   addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
   // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
   addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
 
   // Add C++ include arguments, if needed.
   if (types::isCXX(Inputs[0].getType()))
     getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
 
   // Add system include arguments.
   getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
 }
 
 // FIXME: Move to target hook.
 static bool isSignedCharDefault(const llvm::Triple &Triple) {
   switch (Triple.getArch()) {
   default:
     return true;
 
   case llvm::Triple::aarch64:
   case llvm::Triple::aarch64_be:
   case llvm::Triple::arm:
   case llvm::Triple::armeb:
   case llvm::Triple::thumb:
   case llvm::Triple::thumbeb:
     if (Triple.isOSDarwin() || Triple.isOSWindows())
       return true;
     return false;
 
   case llvm::Triple::ppc:
   case llvm::Triple::ppc64:
     if (Triple.isOSDarwin())
       return true;
     return false;
 
   case llvm::Triple::ppc64le:
   case llvm::Triple::systemz:
   case llvm::Triple::xcore:
     return false;
   }
 }
 
 static bool isNoCommonDefault(const llvm::Triple &Triple) {
   switch (Triple.getArch()) {
   default:
     return false;
 
   case llvm::Triple::xcore:
     return true;
   }
 }
 
 // Handle -mhwdiv=.
 static void getARMHWDivFeatures(const Driver &D, const Arg *A,
                               const ArgList &Args,
                               std::vector<const char *> &Features) {
   StringRef HWDiv = A->getValue();
   if (HWDiv == "arm") {
     Features.push_back("+hwdiv-arm");
     Features.push_back("-hwdiv");
   } else if (HWDiv == "thumb") {
     Features.push_back("-hwdiv-arm");
     Features.push_back("+hwdiv");
   } else if (HWDiv == "arm,thumb" || HWDiv == "thumb,arm") {
     Features.push_back("+hwdiv-arm");
     Features.push_back("+hwdiv");
   } else if (HWDiv == "none") {
     Features.push_back("-hwdiv-arm");
     Features.push_back("-hwdiv");
   } else
     D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
 }
 
 // Handle -mfpu=.
 //
 // FIXME: Centralize feature selection, defaulting shouldn't be also in the
 // frontend target.
 static void getARMFPUFeatures(const Driver &D, const Arg *A,
                               const ArgList &Args,
                               std::vector<const char *> &Features) {
   StringRef FPU = A->getValue();
 
   // Set the target features based on the FPU.
   if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
     // Disable any default FPU support.
     Features.push_back("-vfp2");
     Features.push_back("-vfp3");
     Features.push_back("-neon");
   } else if (FPU == "vfp") {
     Features.push_back("+vfp2");
     Features.push_back("-neon");
   } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") {
     Features.push_back("+vfp3");
     Features.push_back("+d16");
     Features.push_back("-neon");
   } else if (FPU == "vfp3" || FPU == "vfpv3") {
     Features.push_back("+vfp3");
     Features.push_back("-neon");
   } else if (FPU == "vfp4-d16" || FPU == "vfpv4-d16") {
     Features.push_back("+vfp4");
     Features.push_back("+d16");
     Features.push_back("-neon");
   } else if (FPU == "vfp4" || FPU == "vfpv4") {
     Features.push_back("+vfp4");
     Features.push_back("-neon");
   } else if (FPU == "fp4-sp-d16" || FPU == "fpv4-sp-d16") {
     Features.push_back("+vfp4");
     Features.push_back("+d16");
     Features.push_back("+fp-only-sp");
     Features.push_back("-neon");
   } else if (FPU == "fp5-sp-d16" || FPU == "fpv5-sp-d16") {
     Features.push_back("+fp-armv8");
     Features.push_back("+fp-only-sp");
     Features.push_back("+d16");
     Features.push_back("-neon");
     Features.push_back("-crypto");
   } else if (FPU == "fp5-dp-d16" || FPU == "fpv5-dp-d16" ||
              FPU == "fp5-d16" || FPU == "fpv5-d16") {
     Features.push_back("+fp-armv8");
     Features.push_back("+d16");
     Features.push_back("-neon");
     Features.push_back("-crypto");
   } else if (FPU == "fp-armv8") {
     Features.push_back("+fp-armv8");
     Features.push_back("-neon");
     Features.push_back("-crypto");
   } else if (FPU == "neon-fp-armv8") {
     Features.push_back("+fp-armv8");
     Features.push_back("+neon");
     Features.push_back("-crypto");
   } else if (FPU == "crypto-neon-fp-armv8") {
     Features.push_back("+fp-armv8");
     Features.push_back("+neon");
     Features.push_back("+crypto");
   } else if (FPU == "neon") {
     Features.push_back("+neon");
   } else if (FPU == "neon-vfpv3") {
     Features.push_back("+vfp3");
     Features.push_back("+neon");
   } else if (FPU == "neon-vfpv4") {
     Features.push_back("+neon");
     Features.push_back("+vfp4");
   } else if (FPU == "none") {
     Features.push_back("-vfp2");
     Features.push_back("-vfp3");
     Features.push_back("-vfp4");
     Features.push_back("-fp-armv8");
     Features.push_back("-crypto");
     Features.push_back("-neon");
   } else
     D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
 }
 
 // Select the float ABI as determined by -msoft-float, -mhard-float, and
 // -mfloat-abi=.
 StringRef tools::arm::getARMFloatABI(const Driver &D, const ArgList &Args,
                                      const llvm::Triple &Triple) {
   StringRef FloatABI;
   if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
                                options::OPT_mhard_float,
                                options::OPT_mfloat_abi_EQ)) {
     if (A->getOption().matches(options::OPT_msoft_float))
       FloatABI = "soft";
     else if (A->getOption().matches(options::OPT_mhard_float))
       FloatABI = "hard";
     else {
       FloatABI = A->getValue();
       if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
         D.Diag(diag::err_drv_invalid_mfloat_abi)
           << A->getAsString(Args);
         FloatABI = "soft";
       }
     }
   }
 
   // If unspecified, choose the default based on the platform.
   if (FloatABI.empty()) {
     switch (Triple.getOS()) {
     case llvm::Triple::Darwin:
     case llvm::Triple::MacOSX:
     case llvm::Triple::IOS: {
       // Darwin defaults to "softfp" for v6 and v7.
       //
       // FIXME: Factor out an ARM class so we can cache the arch somewhere.
       std::string ArchName =
         arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
       if (StringRef(ArchName).startswith("v6") ||
           StringRef(ArchName).startswith("v7"))
         FloatABI = "softfp";
       else
         FloatABI = "soft";
       break;
     }
 
     // FIXME: this is invalid for WindowsCE
     case llvm::Triple::Win32:
       FloatABI = "hard";
       break;
 
     case llvm::Triple::FreeBSD:
       switch(Triple.getEnvironment()) {
       case llvm::Triple::GNUEABIHF:
         FloatABI = "hard";
         break;
       default:
         // FreeBSD defaults to soft float
         FloatABI = "soft";
         break;
       }
       break;
 
     default:
       switch(Triple.getEnvironment()) {
       case llvm::Triple::GNUEABIHF:
         FloatABI = "hard";
         break;
       case llvm::Triple::GNUEABI:
         FloatABI = "softfp";
         break;
       case llvm::Triple::EABIHF:
         FloatABI = "hard";
         break;
       case llvm::Triple::EABI:
         // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
         FloatABI = "softfp";
         break;
       case llvm::Triple::Android: {
         std::string ArchName =
           arm::getLLVMArchSuffixForARM(arm::getARMTargetCPU(Args, Triple));
         if (StringRef(ArchName).startswith("v7"))
           FloatABI = "softfp";
         else
           FloatABI = "soft";
         break;
       }
       default:
         // Assume "soft", but warn the user we are guessing.
         FloatABI = "soft";
         if (Triple.getOS() != llvm::Triple::UnknownOS ||
             !Triple.isOSBinFormatMachO())
           D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
         break;
       }
     }
   }
 
   return FloatABI;
 }
 
 static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple,
                                  const ArgList &Args,
                                  std::vector<const char *> &Features,
                                  bool ForAS) {
   StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
   if (!ForAS) {
     // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
     // yet (it uses the -mfloat-abi and -msoft-float options), and it is
     // stripped out by the ARM target. We should probably pass this a new
     // -target-option, which is handled by the -cc1/-cc1as invocation.
     //
     // FIXME2:  For consistency, it would be ideal if we set up the target
     // machine state the same when using the frontend or the assembler. We don't
     // currently do that for the assembler, we pass the options directly to the
     // backend and never even instantiate the frontend TargetInfo. If we did,
     // and used its handleTargetFeatures hook, then we could ensure the
     // assembler and the frontend behave the same.
 
     // Use software floating point operations?
     if (FloatABI == "soft")
       Features.push_back("+soft-float");
 
     // Use software floating point argument passing?
     if (FloatABI != "hard")
       Features.push_back("+soft-float-abi");
   }
 
   // Honor -mfpu=.
   if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
     getARMFPUFeatures(D, A, Args, Features);
   if (const Arg *A = Args.getLastArg(options::OPT_mhwdiv_EQ))
     getARMHWDivFeatures(D, A, Args, Features);
 
   // Setting -msoft-float effectively disables NEON because of the GCC
   // implementation, although the same isn't true of VFP or VFP3.
   if (FloatABI == "soft") {
     Features.push_back("-neon");
     // Also need to explicitly disable features which imply NEON.
     Features.push_back("-crypto");
   }
 
   // En/disable crc
   if (Arg *A = Args.getLastArg(options::OPT_mcrc,
                                options::OPT_mnocrc)) {
     if (A->getOption().matches(options::OPT_mcrc))
       Features.push_back("+crc");
     else
       Features.push_back("-crc");
   }
 }
 
 void Clang::AddARMTargetArgs(const ArgList &Args,
                              ArgStringList &CmdArgs,
                              bool KernelOrKext) const {
   const Driver &D = getToolChain().getDriver();
   // Get the effective triple, which takes into account the deployment target.
   std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
   llvm::Triple Triple(TripleStr);
   std::string CPUName = arm::getARMTargetCPU(Args, Triple);
 
   // Select the ABI to use.
   //
   // FIXME: Support -meabi.
   // FIXME: Parts of this are duplicated in the backend, unify this somehow.
   const char *ABIName = nullptr;
   if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
     ABIName = A->getValue();
   } else if (Triple.isOSBinFormatMachO()) {
     // The backend is hardwired to assume AAPCS for M-class processors, ensure
     // the frontend matches that.
     if (Triple.getEnvironment() == llvm::Triple::EABI ||
         Triple.getOS() == llvm::Triple::UnknownOS ||
         StringRef(CPUName).startswith("cortex-m")) {
       ABIName = "aapcs";
     } else {
       ABIName = "apcs-gnu";
     }
   } else if (Triple.isOSWindows()) {
     // FIXME: this is invalid for WindowsCE
     ABIName = "aapcs";
   } else {
     // Select the default based on the platform.
     switch(Triple.getEnvironment()) {
     case llvm::Triple::Android:
     case llvm::Triple::GNUEABI:
     case llvm::Triple::GNUEABIHF:
       ABIName = "aapcs-linux";
       break;
     case llvm::Triple::EABIHF:
     case llvm::Triple::EABI:
       ABIName = "aapcs";
       break;
     default:
       if (Triple.getOS() == llvm::Triple::NetBSD)
         ABIName = "apcs-gnu";
       else
         ABIName = "aapcs";
       break;
     }
   }
   CmdArgs.push_back("-target-abi");
   CmdArgs.push_back(ABIName);
 
   // Determine floating point ABI from the options & target defaults.
   StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
   if (FloatABI == "soft") {
     // Floating point operations and argument passing are soft.
     //
     // FIXME: This changes CPP defines, we need -target-soft-float.
     CmdArgs.push_back("-msoft-float");
     CmdArgs.push_back("-mfloat-abi");
     CmdArgs.push_back("soft");
   } else if (FloatABI == "softfp") {
     // Floating point operations are hard, but argument passing is soft.
     CmdArgs.push_back("-mfloat-abi");
     CmdArgs.push_back("soft");
   } else {
     // Floating point operations and argument passing are hard.
     assert(FloatABI == "hard" && "Invalid float abi!");
     CmdArgs.push_back("-mfloat-abi");
     CmdArgs.push_back("hard");
   }
 
   // Kernel code has more strict alignment requirements.
   if (KernelOrKext) {
     if (!Triple.isiOS() || Triple.isOSVersionLT(6)) {
       CmdArgs.push_back("-backend-option");
       CmdArgs.push_back("-arm-long-calls");
     }
 
     CmdArgs.push_back("-backend-option");
     CmdArgs.push_back("-arm-strict-align");
 
     // The kext linker doesn't know how to deal with movw/movt.
     CmdArgs.push_back("-backend-option");
     CmdArgs.push_back("-arm-use-movt=0");
   }
 
   // -mkernel implies -mstrict-align; don't add the redundant option.
   if (!KernelOrKext) {
     if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
                                  options::OPT_munaligned_access)) {
       CmdArgs.push_back("-backend-option");
       if (A->getOption().matches(options::OPT_mno_unaligned_access))
         CmdArgs.push_back("-arm-strict-align");
       else {
         if (Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v6m)
           D.Diag(diag::err_target_unsupported_unaligned) << "v6m";
         CmdArgs.push_back("-arm-no-strict-align");
       }
     }
   }
 
   // Setting -mno-global-merge disables the codegen global merge pass. Setting 
   // -mglobal-merge has no effect as the pass is enabled by default.
   if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
                                options::OPT_mno_global_merge)) {
     if (A->getOption().matches(options::OPT_mno_global_merge))
       CmdArgs.push_back("-mno-global-merge");
   }
 
   if (!Args.hasFlag(options::OPT_mimplicit_float,
                     options::OPT_mno_implicit_float,
                     true))
     CmdArgs.push_back("-no-implicit-float");
 
   // llvm does not support reserving registers in general. There is support
   // for reserving r9 on ARM though (defined as a platform-specific register
   // in ARM EABI).
   if (Args.hasArg(options::OPT_ffixed_r9)) {
     CmdArgs.push_back("-backend-option");
     CmdArgs.push_back("-arm-reserve-r9");
   }
 }
 
 /// getAArch64TargetCPU - Get the (LLVM) name of the AArch64 cpu we are
 /// targeting.
 static std::string getAArch64TargetCPU(const ArgList &Args) {
   Arg *A;
   std::string CPU;
   // If we have -mtune or -mcpu, use that.
   if ((A = Args.getLastArg(options::OPT_mtune_EQ))) {
     CPU = A->getValue();
   } else if ((A = Args.getLastArg(options::OPT_mcpu_EQ))) {
     StringRef Mcpu = A->getValue();
     CPU = Mcpu.split("+").first;
   }
 
   // Handle CPU name is 'native'.
   if (CPU == "native")
     return llvm::sys::getHostCPUName();
   else if (CPU.size())
     return CPU;
 
   // Make sure we pick "cyclone" if -arch is used.
   // FIXME: Should this be picked by checking the target triple instead?
   if (Args.getLastArg(options::OPT_arch))
     return "cyclone";
 
   return "generic";
 }
 
 void Clang::AddAArch64TargetArgs(const ArgList &Args,
                                  ArgStringList &CmdArgs) const {
   std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
   llvm::Triple Triple(TripleStr);
 
   if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
       Args.hasArg(options::OPT_mkernel) ||
       Args.hasArg(options::OPT_fapple_kext))
     CmdArgs.push_back("-disable-red-zone");
 
   if (!Args.hasFlag(options::OPT_mimplicit_float,
                     options::OPT_mno_implicit_float, true))
     CmdArgs.push_back("-no-implicit-float");
 
   const char *ABIName = nullptr;
   if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
     ABIName = A->getValue();
   else if (Triple.isOSDarwin())
     ABIName = "darwinpcs";
   else
     ABIName = "aapcs";
 
   CmdArgs.push_back("-target-abi");
   CmdArgs.push_back(ABIName);
 
   if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
                                options::OPT_munaligned_access)) {
     CmdArgs.push_back("-backend-option");
     if (A->getOption().matches(options::OPT_mno_unaligned_access))
       CmdArgs.push_back("-aarch64-strict-align");
     else
       CmdArgs.push_back("-aarch64-no-strict-align");
   }
 
   if (Arg *A = Args.getLastArg(options::OPT_mfix_cortex_a53_835769,
                                options::OPT_mno_fix_cortex_a53_835769)) {
     CmdArgs.push_back("-backend-option");
     if (A->getOption().matches(options::OPT_mfix_cortex_a53_835769))
       CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=1");
     else
       CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=0");
   } else if (Triple.getEnvironment() == llvm::Triple::Android) {
     // Enabled A53 errata (835769) workaround by default on android
     CmdArgs.push_back("-backend-option");
     CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=1");
   }
 
   // Setting -mno-global-merge disables the codegen global merge pass. Setting
   // -mglobal-merge has no effect as the pass is enabled by default.
   if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
                                options::OPT_mno_global_merge)) {
     if (A->getOption().matches(options::OPT_mno_global_merge))
       CmdArgs.push_back("-mno-global-merge");
   }
+
+  if (Args.hasArg(options::OPT_ffixed_x18)) {
+    CmdArgs.push_back("-backend-option");
+    CmdArgs.push_back("-aarch64-reserve-x18");
+  }
 }
 
 // Get CPU and ABI names. They are not independent
 // so we have to calculate them together.
 void mips::getMipsCPUAndABI(const ArgList &Args,
                             const llvm::Triple &Triple,
                             StringRef &CPUName,
                             StringRef &ABIName) {
   const char *DefMips32CPU = "mips32r2";
   const char *DefMips64CPU = "mips64r2";
 
   // MIPS32r6 is the default for mips(el)?-img-linux-gnu and MIPS64r6 is the
   // default for mips64(el)?-img-linux-gnu.
   if (Triple.getVendor() == llvm::Triple::ImaginationTechnologies &&
       Triple.getEnvironment() == llvm::Triple::GNU) {
     DefMips32CPU = "mips32r6";
     DefMips64CPU = "mips64r6";
   }
 
   // MIPS3 is the default for mips64*-unknown-openbsd.
   if (Triple.getOS() == llvm::Triple::OpenBSD)
     DefMips64CPU = "mips3";
 
   if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
                                options::OPT_mcpu_EQ))
     CPUName = A->getValue();
 
   if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
     ABIName = A->getValue();
     // Convert a GNU style Mips ABI name to the name
     // accepted by LLVM Mips backend.
     ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
       .Case("32", "o32")
       .Case("64", "n64")
       .Default(ABIName);
   }
 
   // Setup default CPU and ABI names.
   if (CPUName.empty() && ABIName.empty()) {
     switch (Triple.getArch()) {
     default:
       llvm_unreachable("Unexpected triple arch name");
     case llvm::Triple::mips:
     case llvm::Triple::mipsel:
       CPUName = DefMips32CPU;
       break;
     case llvm::Triple::mips64:
     case llvm::Triple::mips64el:
       CPUName = DefMips64CPU;
       break;
     }
   }
 
   if (ABIName.empty()) {
     // Deduce ABI name from the target triple.
     if (Triple.getArch() == llvm::Triple::mips ||
         Triple.getArch() == llvm::Triple::mipsel)
       ABIName = "o32";
     else
       ABIName = "n64";
   }
 
   if (CPUName.empty()) {
     // Deduce CPU name from ABI name.
     CPUName = llvm::StringSwitch<const char *>(ABIName)
       .Cases("o32", "eabi", DefMips32CPU)
       .Cases("n32", "n64", DefMips64CPU)
       .Default("");
   }
 
   // FIXME: Warn on inconsistent use of -march and -mabi.
 }
 
 // Convert ABI name to the GNU tools acceptable variant.
 static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
   return llvm::StringSwitch<llvm::StringRef>(ABI)
     .Case("o32", "32")
     .Case("n64", "64")
     .Default(ABI);
 }
 
 // Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
 // and -mfloat-abi=.
 static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
   StringRef FloatABI;
   if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
                                options::OPT_mhard_float,
                                options::OPT_mfloat_abi_EQ)) {
     if (A->getOption().matches(options::OPT_msoft_float))
       FloatABI = "soft";
     else if (A->getOption().matches(options::OPT_mhard_float))
       FloatABI = "hard";
     else {
       FloatABI = A->getValue();
       if (FloatABI != "soft" && FloatABI != "hard") {
         D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
         FloatABI = "hard";
       }
     }
   }
 
   // If unspecified, choose the default based on the platform.
   if (FloatABI.empty()) {
     // Assume "hard", because it's a default value used by gcc.
     // When we start to recognize specific target MIPS processors,
     // we will be able to select the default more correctly.
     FloatABI = "hard";
   }
 
   return FloatABI;
 }
 
 static void AddTargetFeature(const ArgList &Args,
                              std::vector<const char *> &Features,
                              OptSpecifier OnOpt, OptSpecifier OffOpt,
                              StringRef FeatureName) {
   if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
     if (A->getOption().matches(OnOpt))
       Features.push_back(Args.MakeArgString("+" + FeatureName));
     else
       Features.push_back(Args.MakeArgString("-" + FeatureName));
   }
 }
 
 static void getMIPSTargetFeatures(const Driver &D, const llvm::Triple &Triple,
                                   const ArgList &Args,
                                   std::vector<const char *> &Features) {
   StringRef CPUName;
   StringRef ABIName;
   mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
   ABIName = getGnuCompatibleMipsABIName(ABIName);
 
   // Always override the backend's default ABI.
   std::string ABIFeature = llvm::StringSwitch<StringRef>(ABIName)
                                .Case("32", "+o32")
                                .Case("n32", "+n32")
                                .Case("64", "+n64")
                                .Case("eabi", "+eabi")
                                .Default(("+" + ABIName).str());
   Features.push_back("-o32");
   Features.push_back("-n64");
   Features.push_back(Args.MakeArgString(ABIFeature));
 
   AddTargetFeature(Args, Features, options::OPT_mno_abicalls,
                    options::OPT_mabicalls, "noabicalls");
 
   StringRef FloatABI = getMipsFloatABI(D, Args);
   if (FloatABI == "soft") {
     // FIXME: Note, this is a hack. We need to pass the selected float
     // mode to the MipsTargetInfoBase to define appropriate macros there.
     // Now it is the only method.
     Features.push_back("+soft-float");
   }
 
   if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
     StringRef Val = StringRef(A->getValue());
     if (Val == "2008")
       Features.push_back("+nan2008");
     else if (Val == "legacy")
       Features.push_back("-nan2008");
     else
       D.Diag(diag::err_drv_unsupported_option_argument)
           << A->getOption().getName() << Val;
   }
 
   AddTargetFeature(Args, Features, options::OPT_msingle_float,
                    options::OPT_mdouble_float, "single-float");
   AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
                    "mips16");
   AddTargetFeature(Args, Features, options::OPT_mmicromips,
                    options::OPT_mno_micromips, "micromips");
   AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
                    "dsp");
   AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
                    "dspr2");
   AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
                    "msa");
 
   // Add the last -mfp32/-mfpxx/-mfp64 or if none are given and the ABI is O32
   // pass -mfpxx
   if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
                                options::OPT_mfp64)) {
     if (A->getOption().matches(options::OPT_mfp32))
       Features.push_back(Args.MakeArgString("-fp64"));
     else if (A->getOption().matches(options::OPT_mfpxx)) {
       Features.push_back(Args.MakeArgString("+fpxx"));
       Features.push_back(Args.MakeArgString("+nooddspreg"));
     } else
       Features.push_back(Args.MakeArgString("+fp64"));
   } else if (mips::isFPXXDefault(Triple, CPUName, ABIName)) {
     Features.push_back(Args.MakeArgString("+fpxx"));
     Features.push_back(Args.MakeArgString("+nooddspreg"));
   }
 
   AddTargetFeature(Args, Features, options::OPT_mno_odd_spreg,
                    options::OPT_modd_spreg, "nooddspreg");
 }
 
 void Clang::AddMIPSTargetArgs(const ArgList &Args,
                               ArgStringList &CmdArgs) const {
   const Driver &D = getToolChain().getDriver();
   StringRef CPUName;
   StringRef ABIName;
   const llvm::Triple &Triple = getToolChain().getTriple();
   mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
 
   CmdArgs.push_back("-target-abi");
   CmdArgs.push_back(ABIName.data());
 
   StringRef FloatABI = getMipsFloatABI(D, Args);
 
   if (FloatABI == "soft") {
     // Floating point operations and argument passing are soft.
     CmdArgs.push_back("-msoft-float");
     CmdArgs.push_back("-mfloat-abi");
     CmdArgs.push_back("soft");
   }
   else {
     // Floating point operations and argument passing are hard.
     assert(FloatABI == "hard" && "Invalid float abi!");
     CmdArgs.push_back("-mfloat-abi");
     CmdArgs.push_back("hard");
   }
 
   if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
     if (A->getOption().matches(options::OPT_mxgot)) {
       CmdArgs.push_back("-mllvm");
       CmdArgs.push_back("-mxgot");
     }
   }
 
   if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
                                options::OPT_mno_ldc1_sdc1)) {
     if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
       CmdArgs.push_back("-mllvm");
       CmdArgs.push_back("-mno-ldc1-sdc1");
     }
   }
 
   if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
                                options::OPT_mno_check_zero_division)) {
     if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
       CmdArgs.push_back("-mllvm");
       CmdArgs.push_back("-mno-check-zero-division");
     }
   }
 
   if (Arg *A = Args.getLastArg(options::OPT_G)) {
     StringRef v = A->getValue();
     CmdArgs.push_back("-mllvm");
     CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
     A->claim();
   }
 }
 
 /// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
 static std::string getPPCTargetCPU(const ArgList &Args) {
   if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
     StringRef CPUName = A->getValue();
 
     if (CPUName == "native") {
       std::string CPU = llvm::sys::getHostCPUName();
       if (!CPU.empty() && CPU != "generic")
         return CPU;
       else
         return "";
     }
 
     return llvm::StringSwitch<const char *>(CPUName)
       .Case("common", "generic")
       .Case("440", "440")
       .Case("440fp", "440")
       .Case("450", "450")
       .Case("601", "601")
       .Case("602", "602")
       .Case("603", "603")
       .Case("603e", "603e")
       .Case("603ev", "603ev")
       .Case("604", "604")
       .Case("604e", "604e")
       .Case("620", "620")
       .Case("630", "pwr3")
       .Case("G3", "g3")
       .Case("7400", "7400")
       .Case("G4", "g4")
       .Case("7450", "7450")
       .Case("G4+", "g4+")
       .Case("750", "750")
       .Case("970", "970")
       .Case("G5", "g5")
       .Case("a2", "a2")
       .Case("a2q", "a2q")
       .Case("e500mc", "e500mc")
       .Case("e5500", "e5500")
       .Case("power3", "pwr3")
       .Case("power4", "pwr4")
       .Case("power5", "pwr5")
       .Case("power5x", "pwr5x")
       .Case("power6", "pwr6")
       .Case("power6x", "pwr6x")
       .Case("power7", "pwr7")
       .Case("power8", "pwr8")
       .Case("pwr3", "pwr3")
       .Case("pwr4", "pwr4")
       .Case("pwr5", "pwr5")
       .Case("pwr5x", "pwr5x")
       .Case("pwr6", "pwr6")
       .Case("pwr6x", "pwr6x")
       .Case("pwr7", "pwr7")
       .Case("pwr8", "pwr8")
       .Case("powerpc", "ppc")
       .Case("powerpc64", "ppc64")
       .Case("powerpc64le", "ppc64le")
       .Default("");
   }
 
   return "";
 }
 
 static void getPPCTargetFeatures(const ArgList &Args,
                                  std::vector<const char *> &Features) {
   for (arg_iterator it = Args.filtered_begin(options::OPT_m_ppc_Features_Group),
                     ie = Args.filtered_end();
        it != ie; ++it) {
     StringRef Name = (*it)->getOption().getName();
     (*it)->claim();
 
     // Skip over "-m".
     assert(Name.startswith("m") && "Invalid feature name.");
     Name = Name.substr(1);
 
     bool IsNegative = Name.startswith("no-");
     if (IsNegative)
       Name = Name.substr(3);
 
     // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we
     // pass the correct option to the backend while calling the frontend
     // option the same.
     // TODO: Change the LLVM backend option maybe?
     if (Name == "mfcrf")
       Name = "mfocrf";
 
     Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
   }
 
   // Altivec is a bit weird, allow overriding of the Altivec feature here.
   AddTargetFeature(Args, Features, options::OPT_faltivec,
                    options::OPT_fno_altivec, "altivec");
 }
 
 void Clang::AddPPCTargetArgs(const ArgList &Args,
                              ArgStringList &CmdArgs) const {
   // Select the ABI to use.
   const char *ABIName = nullptr;
   if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
     ABIName = A->getValue();
   } else if (getToolChain().getTriple().isOSLinux())
     switch(getToolChain().getArch()) {
     case llvm::Triple::ppc64:
       ABIName = "elfv1";
       break;
     case llvm::Triple::ppc64le:
       ABIName = "elfv2";
       break;
     default:
       break;
   }
 
   if (ABIName) {
     CmdArgs.push_back("-target-abi");
     CmdArgs.push_back(ABIName);
   }
 }
 
 bool ppc::hasPPCAbiArg(const ArgList &Args, const char *Value) {
   Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
   return A && (A->getValue() == StringRef(Value));
 }
 
 /// Get the (LLVM) name of the R600 gpu we are targeting.
 static std::string getR600TargetGPU(const ArgList &Args) {
   if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
     const char *GPUName = A->getValue();
     return llvm::StringSwitch<const char *>(GPUName)
       .Cases("rv630", "rv635", "r600")
       .Cases("rv610", "rv620", "rs780", "rs880")
       .Case("rv740", "rv770")
       .Case("palm", "cedar")
       .Cases("sumo", "sumo2", "sumo")
       .Case("hemlock", "cypress")
       .Case("aruba", "cayman")
       .Default(GPUName);
   }
   return "";
 }
 
 static void getSparcTargetFeatures(const ArgList &Args,
                                    std::vector<const char *> &Features) {
   bool SoftFloatABI = true;
   if (Arg *A =
           Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
     if (A->getOption().matches(options::OPT_mhard_float))
       SoftFloatABI = false;
   }
   if (SoftFloatABI)
     Features.push_back("+soft-float");
 }
 
 void Clang::AddSparcTargetArgs(const ArgList &Args,
                              ArgStringList &CmdArgs) const {
   const Driver &D = getToolChain().getDriver();
 
   // Select the float ABI as determined by -msoft-float and -mhard-float.
   StringRef FloatABI;
   if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
                                options::OPT_mhard_float)) {
     if (A->getOption().matches(options::OPT_msoft_float))
       FloatABI = "soft";
     else if (A->getOption().matches(options::OPT_mhard_float))
       FloatABI = "hard";
   }
 
   // If unspecified, choose the default based on the platform.
   if (FloatABI.empty()) {
     // Assume "soft", but warn the user we are guessing.
     FloatABI = "soft";
     D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
   }
 
   if (FloatABI == "soft") {
     // Floating point operations and argument passing are soft.
     //
     // FIXME: This changes CPP defines, we need -target-soft-float.
     CmdArgs.push_back("-msoft-float");
   } else {
     assert(FloatABI == "hard" && "Invalid float abi!");
     CmdArgs.push_back("-mhard-float");
   }
 }
 
 static const char *getSystemZTargetCPU(const ArgList &Args) {
   if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
     return A->getValue();
   return "z10";
 }
 
 static const char *getX86TargetCPU(const ArgList &Args,
                                    const llvm::Triple &Triple) {
   if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
     if (StringRef(A->getValue()) != "native") {
       if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
         return "core-avx2";
 
       return A->getValue();
     }
 
     // FIXME: Reject attempts to use -march=native unless the target matches
     // the host.
     //
     // FIXME: We should also incorporate the detected target features for use
     // with -native.
     std::string CPU = llvm::sys::getHostCPUName();
     if (!CPU.empty() && CPU != "generic")
       return Args.MakeArgString(CPU);
   }
 
   // Select the default CPU if none was given (or detection failed).
 
   if (Triple.getArch() != llvm::Triple::x86_64 &&
       Triple.getArch() != llvm::Triple::x86)
     return nullptr; // This routine is only handling x86 targets.
 
   bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
 
   // FIXME: Need target hooks.
   if (Triple.isOSDarwin()) {
     if (Triple.getArchName() == "x86_64h")
       return "core-avx2";
     return Is64Bit ? "core2" : "yonah";
   }
 
   // On Android use targets compatible with gcc
   if (Triple.getEnvironment() == llvm::Triple::Android)
     return Is64Bit ? "x86-64" : "i686";
 
   // Everything else goes to x86-64 in 64-bit mode.
   if (Is64Bit)
     return "x86-64";
 
   switch (Triple.getOS()) {
   case llvm::Triple::FreeBSD:
   case llvm::Triple::NetBSD:
   case llvm::Triple::OpenBSD:
     return "i486";
   case llvm::Triple::Haiku:
     return "i586";
   case llvm::Triple::Bitrig:
     return "i686";
   default:
     // Fallback to p4.
     return "pentium4";
   }
 }
 
 static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
   switch(T.getArch()) {
   default:
     return "";
 
   case llvm::Triple::aarch64:
   case llvm::Triple::aarch64_be:
     return getAArch64TargetCPU(Args);
 
   case llvm::Triple::arm:
   case llvm::Triple::armeb:
   case llvm::Triple::thumb:
   case llvm::Triple::thumbeb:
     return arm::getARMTargetCPU(Args, T);
 
   case llvm::Triple::mips:
   case llvm::Triple::mipsel:
   case llvm::Triple::mips64:
   case llvm::Triple::mips64el: {
     StringRef CPUName;
     StringRef ABIName;
     mips::getMipsCPUAndABI(Args, T, CPUName, ABIName);
     return CPUName;
   }
 
   case llvm::Triple::ppc:
   case llvm::Triple::ppc64:
   case llvm::Triple::ppc64le: {
     std::string TargetCPUName = getPPCTargetCPU(Args);
     // LLVM may default to generating code for the native CPU,
     // but, like gcc, we default to a more generic option for
     // each architecture. (except on Darwin)
     if (TargetCPUName.empty() && !T.isOSDarwin()) {
       if (T.getArch() == llvm::Triple::ppc64)
         TargetCPUName = "ppc64";
       else if (T.getArch() == llvm::Triple::ppc64le)
         TargetCPUName = "ppc64le";
       else
         TargetCPUName = "ppc";
     }
     return TargetCPUName;
   }
 
   case llvm::Triple::sparc:
   case llvm::Triple::sparcv9:
     if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
       return A->getValue();
     return "";
 
   case llvm::Triple::x86:
   case llvm::Triple::x86_64:
     return getX86TargetCPU(Args, T);
 
   case llvm::Triple::hexagon:
     return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
 
   case llvm::Triple::systemz:
     return getSystemZTargetCPU(Args);
 
   case llvm::Triple::r600:
   case llvm::Triple::amdgcn:
     return getR600TargetGPU(Args);
   }
 }
 
 static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
                           ArgStringList &CmdArgs) {
   // Tell the linker to load the plugin. This has to come before AddLinkerInputs
   // as gold requires -plugin to come before any -plugin-opt that -Wl might
   // forward.
   CmdArgs.push_back("-plugin");
   std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
   CmdArgs.push_back(Args.MakeArgString(Plugin));
 
   // Try to pass driver level flags relevant to LTO code generation down to
   // the plugin.
 
   // Handle flags for selecting CPU variants.
   std::string CPU = getCPUName(Args, ToolChain.getTriple());
   if (!CPU.empty())
     CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
 }
 
 static void getX86TargetFeatures(const Driver & D,
                                  const llvm::Triple &Triple,
                                  const ArgList &Args,
                                  std::vector<const char *> &Features) {
   if (Triple.getArchName() == "x86_64h") {
     // x86_64h implies quite a few of the more modern subtarget features
     // for Haswell class CPUs, but not all of them. Opt-out of a few.
     Features.push_back("-rdrnd");
     Features.push_back("-aes");
     Features.push_back("-pclmul");
     Features.push_back("-rtm");
     Features.push_back("-hle");
     Features.push_back("-fsgsbase");
   }
 
   // Add features to comply with gcc on Android
   if (Triple.getEnvironment() == llvm::Triple::Android) {
     if (Triple.getArch() == llvm::Triple::x86_64) {
       Features.push_back("+sse4.2");
       Features.push_back("+popcnt");
     } else
       Features.push_back("+ssse3");
   }
 
   // Set features according to the -arch flag on MSVC
   if (Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
     StringRef Arch = A->getValue();
     bool ArchUsed = false;
     // First, look for flags that are shared in x86 and x86-64.
     if (Triple.getArch() == llvm::Triple::x86_64 ||
         Triple.getArch() == llvm::Triple::x86) {
       if (Arch == "AVX" || Arch == "AVX2") {
         ArchUsed = true;
         Features.push_back(Args.MakeArgString("+" + Arch.lower()));
       }
     }
     // Then, look for x86-specific flags.
     if (Triple.getArch() == llvm::Triple::x86) {
       if (Arch == "IA32") {
         ArchUsed = true;
       } else if (Arch == "SSE" || Arch == "SSE2") {
         ArchUsed = true;
         Features.push_back(Args.MakeArgString("+" + Arch.lower()));
       }
     }
     if (!ArchUsed)
       D.Diag(clang::diag::warn_drv_unused_argument) << A->getAsString(Args);
   }
 
   // Now add any that the user explicitly requested on the command line,
   // which may override the defaults.
   for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
                     ie = Args.filtered_end();
        it != ie; ++it) {
     StringRef Name = (*it)->getOption().getName();
     (*it)->claim();
 
     // Skip over "-m".
     assert(Name.startswith("m") && "Invalid feature name.");
     Name = Name.substr(1);
 
     bool IsNegative = Name.startswith("no-");
     if (IsNegative)
       Name = Name.substr(3);
 
     Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
   }
 }
 
 void Clang::AddX86TargetArgs(const ArgList &Args,
                              ArgStringList &CmdArgs) const {
   if (!Args.hasFlag(options::OPT_mred_zone,
                     options::OPT_mno_red_zone,
                     true) ||
       Args.hasArg(options::OPT_mkernel) ||
       Args.hasArg(options::OPT_fapple_kext))
     CmdArgs.push_back("-disable-red-zone");
 
   // Default to avoid implicit floating-point for kernel/kext code, but allow
   // that to be overridden with -mno-soft-float.
   bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
                           Args.hasArg(options::OPT_fapple_kext));
   if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
                                options::OPT_mno_soft_float,
                                options::OPT_mimplicit_float,
                                options::OPT_mno_implicit_float)) {
     const Option &O = A->getOption();
     NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
                        O.matches(options::OPT_msoft_float));
   }
   if (NoImplicitFloat)
     CmdArgs.push_back("-no-implicit-float");
 
   if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
     StringRef Value = A->getValue();
     if (Value == "intel" || Value == "att") {
       CmdArgs.push_back("-mllvm");
       CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
     } else {
       getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
           << A->getOption().getName() << Value;
     }
   }
 }
 
 static inline bool HasPICArg(const ArgList &Args) {
   return Args.hasArg(options::OPT_fPIC)
     || Args.hasArg(options::OPT_fpic);
 }
 
 static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) {
   return Args.getLastArg(options::OPT_G,
                          options::OPT_G_EQ,
                          options::OPT_msmall_data_threshold_EQ);
 }
 
 static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) {
   std::string value;
   if (HasPICArg(Args))
     value = "0";
   else if (Arg *A = GetLastSmallDataThresholdArg(Args)) {
     value = A->getValue();
     A->claim();
   }
   return value;
 }
 
 void Clang::AddHexagonTargetArgs(const ArgList &Args,
                                  ArgStringList &CmdArgs) const {
   CmdArgs.push_back("-fno-signed-char");
   CmdArgs.push_back("-mqdsp6-compat");
   CmdArgs.push_back("-Wreturn-type");
 
   std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
   if (!SmallDataThreshold.empty()) {
     CmdArgs.push_back ("-mllvm");
     CmdArgs.push_back(Args.MakeArgString(
                         "-hexagon-small-data-threshold=" + SmallDataThreshold));
   }
 
   if (!Args.hasArg(options::OPT_fno_short_enums))
     CmdArgs.push_back("-fshort-enums");
   if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
     CmdArgs.push_back ("-mllvm");
     CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
   }
   CmdArgs.push_back ("-mllvm");
   CmdArgs.push_back ("-machine-sink-split=0");
 }
 
 // Decode AArch64 features from string like +[no]featureA+[no]featureB+...
 static bool DecodeAArch64Features(const Driver &D, StringRef text,
                                   std::vector<const char *> &Features) {
   SmallVector<StringRef, 8> Split;
   text.split(Split, StringRef("+"), -1, false);
 
   for (unsigned I = 0, E = Split.size(); I != E; ++I) {
     const char *result = llvm::StringSwitch<const char *>(Split[I])
                              .Case("fp", "+fp-armv8")
                              .Case("simd", "+neon")
                              .Case("crc", "+crc")
                              .Case("crypto", "+crypto")
                              .Case("nofp", "-fp-armv8")
                              .Case("nosimd", "-neon")
                              .Case("nocrc", "-crc")
                              .Case("nocrypto", "-crypto")
                              .Default(nullptr);
     if (result)
       Features.push_back(result);
     else if (Split[I] == "neon" || Split[I] == "noneon")
       D.Diag(diag::err_drv_no_neon_modifier);
     else
       return false;
   }
   return true;
 }
 
 // Check if the CPU name and feature modifiers in -mcpu are legal. If yes,
 // decode CPU and feature.
 static bool DecodeAArch64Mcpu(const Driver &D, StringRef Mcpu, StringRef &CPU,
                               std::vector<const char *> &Features) {
   std::pair<StringRef, StringRef> Split = Mcpu.split("+");
   CPU = Split.first;
   if (CPU == "cyclone" || CPU == "cortex-a53" || CPU == "cortex-a57") {
     Features.push_back("+neon");
     Features.push_back("+crc");
     Features.push_back("+crypto");
   } else if (CPU == "generic") {
     Features.push_back("+neon");
   } else {
     return false;
   }
 
   if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
     return false;
 
   return true;
 }
 
 static bool
 getAArch64ArchFeaturesFromMarch(const Driver &D, StringRef March,
                                 const ArgList &Args,
                                 std::vector<const char *> &Features) {
   std::pair<StringRef, StringRef> Split = March.split("+");
   if (Split.first != "armv8-a")
     return false;
 
   if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
     return false;
 
   return true;
 }
 
 static bool
 getAArch64ArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
                                const ArgList &Args,
                                std::vector<const char *> &Features) {
   StringRef CPU;
   if (!DecodeAArch64Mcpu(D, Mcpu, CPU, Features))
     return false;
 
   return true;
 }
 
 static bool
 getAArch64MicroArchFeaturesFromMtune(const Driver &D, StringRef Mtune,
                                      const ArgList &Args,
                                      std::vector<const char *> &Features) {
   // Handle CPU name is 'native'.
   if (Mtune == "native")
     Mtune = llvm::sys::getHostCPUName();
   if (Mtune == "cyclone") {
     Features.push_back("+zcm");
     Features.push_back("+zcz");
   }
   return true;
 }
 
 static bool
 getAArch64MicroArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
                                     const ArgList &Args,
                                     std::vector<const char *> &Features) {
   StringRef CPU;
   std::vector<const char *> DecodedFeature;
   if (!DecodeAArch64Mcpu(D, Mcpu, CPU, DecodedFeature))
     return false;
 
   return getAArch64MicroArchFeaturesFromMtune(D, CPU, Args, Features);
 }
 
 static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
                                      std::vector<const char *> &Features) {
   Arg *A;
   bool success = true;
   // Enable NEON by default.
   Features.push_back("+neon");
   if ((A = Args.getLastArg(options::OPT_march_EQ)))
     success = getAArch64ArchFeaturesFromMarch(D, A->getValue(), Args, Features);
   else if ((A = Args.getLastArg(options::OPT_mcpu_EQ)))
     success = getAArch64ArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
   else if (Args.hasArg(options::OPT_arch))
     success = getAArch64ArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args), Args,
                                              Features);
 
   if (success && (A = Args.getLastArg(options::OPT_mtune_EQ)))
     success =
         getAArch64MicroArchFeaturesFromMtune(D, A->getValue(), Args, Features);
   else if (success && (A = Args.getLastArg(options::OPT_mcpu_EQ)))
     success =
         getAArch64MicroArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
   else if (Args.hasArg(options::OPT_arch))
     success = getAArch64MicroArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args),
                                                   Args, Features);
 
   if (!success)
     D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
 
   if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
     Features.push_back("-fp-armv8");
     Features.push_back("-crypto");
     Features.push_back("-neon");
   }
 
   // En/disable crc
   if (Arg *A = Args.getLastArg(options::OPT_mcrc,
                                options::OPT_mnocrc)) {
     if (A->getOption().matches(options::OPT_mcrc))
       Features.push_back("+crc");
     else
       Features.push_back("-crc");
   }
 }
 
 static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
                               const ArgList &Args, ArgStringList &CmdArgs,
                               bool ForAS) {
   std::vector<const char *> Features;
   switch (Triple.getArch()) {
   default:
     break;
   case llvm::Triple::mips:
   case llvm::Triple::mipsel:
   case llvm::Triple::mips64:
   case llvm::Triple::mips64el:
     getMIPSTargetFeatures(D, Triple, Args, Features);
     break;
 
   case llvm::Triple::arm:
   case llvm::Triple::armeb:
   case llvm::Triple::thumb:
   case llvm::Triple::thumbeb:
     getARMTargetFeatures(D, Triple, Args, Features, ForAS);
     break;
 
   case llvm::Triple::ppc:
   case llvm::Triple::ppc64:
   case llvm::Triple::ppc64le:
     getPPCTargetFeatures(Args, Features);
     break;
   case llvm::Triple::sparc:
   case llvm::Triple::sparcv9:
     getSparcTargetFeatures(Args, Features);
     break;
   case llvm::Triple::aarch64:
   case llvm::Triple::aarch64_be:
     getAArch64TargetFeatures(D, Args, Features);
     break;
   case llvm::Triple::x86:
   case llvm::Triple::x86_64:
     getX86TargetFeatures(D, Triple, Args, Features);
     break;
   }
 
   // Find the last of each feature.
   llvm::StringMap<unsigned> LastOpt;
   for (unsigned I = 0, N = Features.size(); I < N; ++I) {
     const char *Name = Features[I];
     assert(Name[0] == '-' || Name[0] == '+');
     LastOpt[Name + 1] = I;
   }
 
   for (unsigned I = 0, N = Features.size(); I < N; ++I) {
     // If this feature was overridden, ignore it.
     const char *Name = Features[I];
     llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
     assert(LastI != LastOpt.end());
     unsigned Last = LastI->second;
     if (Last != I)
       continue;
 
     CmdArgs.push_back("-target-feature");
     CmdArgs.push_back(Name);
   }
 }
 
 static bool
 shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
                                           const llvm::Triple &Triple) {
   // We use the zero-cost exception tables for Objective-C if the non-fragile
   // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
   // later.
   if (runtime.isNonFragile())
     return true;
 
   if (!Triple.isMacOSX())
     return false;
 
   return (!Triple.isMacOSXVersionLT(10,5) &&
           (Triple.getArch() == llvm::Triple::x86_64 ||
            Triple.getArch() == llvm::Triple::arm));
 }
 
 // exceptionSettings() exists to share the logic between -cc1 and linker
 // invocations.
 static bool exceptionSettings(const ArgList &Args, const llvm::Triple &Triple) {
   if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
                                options::OPT_fno_exceptions))
     if (A->getOption().matches(options::OPT_fexceptions))
       return true;
 
   return false;
 }
 
 /// addExceptionArgs - Adds exception related arguments to the driver command
 /// arguments. There's a master flag, -fexceptions and also language specific
 /// flags to enable/disable C++ and Objective-C exceptions.
 /// This makes it possible to for example disable C++ exceptions but enable
 /// Objective-C exceptions.
 static void addExceptionArgs(const ArgList &Args, types::ID InputType,
                              const llvm::Triple &Triple,
                              bool KernelOrKext,
                              const ObjCRuntime &objcRuntime,
                              ArgStringList &CmdArgs) {
   if (KernelOrKext) {
     // -mkernel and -fapple-kext imply no exceptions, so claim exception related
     // arguments now to avoid warnings about unused arguments.
     Args.ClaimAllArgs(options::OPT_fexceptions);
     Args.ClaimAllArgs(options::OPT_fno_exceptions);
     Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
     Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
     Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
     Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
     return;
   }
 
   // Gather the exception settings from the command line arguments.
   bool EH = exceptionSettings(Args, Triple);
 
   // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
   // is not necessarily sensible, but follows GCC.
   if (types::isObjC(InputType) &&
       Args.hasFlag(options::OPT_fobjc_exceptions,
                    options::OPT_fno_objc_exceptions,
                    true)) {
     CmdArgs.push_back("-fobjc-exceptions");
 
     EH |= shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
   }
 
   if (types::isCXX(InputType)) {
     bool CXXExceptionsEnabled = Triple.getArch() != llvm::Triple::xcore;
     if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
                                  options::OPT_fno_cxx_exceptions,
                                  options::OPT_fexceptions,
                                  options::OPT_fno_exceptions))
       CXXExceptionsEnabled =
           A->getOption().matches(options::OPT_fcxx_exceptions) ||
           A->getOption().matches(options::OPT_fexceptions);
 
     if (CXXExceptionsEnabled) {
       CmdArgs.push_back("-fcxx-exceptions");
 
       EH = true;
     }
   }
 
   if (EH)
     CmdArgs.push_back("-fexceptions");
 }
 
 static bool ShouldDisableAutolink(const ArgList &Args,
                              const ToolChain &TC) {
   bool Default = true;
   if (TC.getTriple().isOSDarwin()) {
     // The native darwin assembler doesn't support the linker_option directives,
     // so we disable them if we think the .s file will be passed to it.
     Default = TC.useIntegratedAs();
   }
   return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
                        Default);
 }
 
 static bool ShouldDisableDwarfDirectory(const ArgList &Args,
                                         const ToolChain &TC) {
   bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
                                         options::OPT_fno_dwarf_directory_asm,
                                         TC.useIntegratedAs());
   return !UseDwarfDirectory;
 }
 
 /// \brief Check whether the given input tree contains any compilation actions.
 static bool ContainsCompileAction(const Action *A) {
   if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
     return true;
 
   for (const auto &Act : *A)
     if (ContainsCompileAction(Act))
       return true;
 
   return false;
 }
 
 /// \brief Check if -relax-all should be passed to the internal assembler.
 /// This is done by default when compiling non-assembler source with -O0.
 static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
   bool RelaxDefault = true;
 
   if (Arg *A = Args.getLastArg(options::OPT_O_Group))
     RelaxDefault = A->getOption().matches(options::OPT_O0);
 
   if (RelaxDefault) {
     RelaxDefault = false;
     for (const auto &Act : C.getActions()) {
       if (ContainsCompileAction(Act)) {
         RelaxDefault = true;
         break;
       }
     }
   }
 
   return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
     RelaxDefault);
 }
 
 static void CollectArgsForIntegratedAssembler(Compilation &C,
                                               const ArgList &Args,
                                               ArgStringList &CmdArgs,
                                               const Driver &D) {
     if (UseRelaxAll(C, Args))
       CmdArgs.push_back("-mrelax-all");
 
     // When passing -I arguments to the assembler we sometimes need to
     // unconditionally take the next argument.  For example, when parsing
     // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
     // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
     // arg after parsing the '-I' arg.
     bool TakeNextArg = false;
 
     // When using an integrated assembler, translate -Wa, and -Xassembler
     // options.
     bool CompressDebugSections = false;
     for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
                                                options::OPT_Xassembler),
            ie = Args.filtered_end(); it != ie; ++it) {
       const Arg *A = *it;
       A->claim();
 
       for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
         StringRef Value = A->getValue(i);
         if (TakeNextArg) {
           CmdArgs.push_back(Value.data());
           TakeNextArg = false;
           continue;
         }
 
         if (Value == "-force_cpusubtype_ALL") {
           // Do nothing, this is the default and we don't support anything else.
         } else if (Value == "-L") {
           CmdArgs.push_back("-msave-temp-labels");
         } else if (Value == "--fatal-warnings") {
           CmdArgs.push_back("-massembler-fatal-warnings");
         } else if (Value == "--noexecstack") {
           CmdArgs.push_back("-mnoexecstack");
         } else if (Value == "-compress-debug-sections" ||
                    Value == "--compress-debug-sections") {
           CompressDebugSections = true;
         } else if (Value == "-nocompress-debug-sections" ||
                    Value == "--nocompress-debug-sections") {
           CompressDebugSections = false;
         } else if (Value.startswith("-I")) {
           CmdArgs.push_back(Value.data());
           // We need to consume the next argument if the current arg is a plain
           // -I. The next arg will be the include directory.
           if (Value == "-I")
             TakeNextArg = true;
         } else if (Value.startswith("-gdwarf-")) {
           CmdArgs.push_back(Value.data());
         } else {
           D.Diag(diag::err_drv_unsupported_option_argument)
             << A->getOption().getName() << Value;
         }
       }
     }
     if (CompressDebugSections) {
       if (llvm::zlib::isAvailable())
         CmdArgs.push_back("-compress-debug-sections");
       else
         D.Diag(diag::warn_debug_compression_unavailable);
     }
 }
 
 // Until ARM libraries are build separately, we have them all in one library
 static StringRef getArchNameForCompilerRTLib(const ToolChain &TC) {
   // FIXME: handle 64-bit
   if (TC.getTriple().isOSWindows() &&
       !TC.getTriple().isWindowsItaniumEnvironment())
     return "i386";
   if (TC.getArch() == llvm::Triple::arm || TC.getArch() == llvm::Triple::armeb)
     return "arm";
   return TC.getArchName();
 }
 
 static SmallString<128> getCompilerRTLibDir(const ToolChain &TC) {
   // The runtimes are located in the OS-specific resource directory.
   SmallString<128> Res(TC.getDriver().ResourceDir);
   const llvm::Triple &Triple = TC.getTriple();
   // TC.getOS() yield "freebsd10.0" whereas "freebsd" is expected.
   StringRef OSLibName =
       (Triple.getOS() == llvm::Triple::FreeBSD) ? "freebsd" : TC.getOS();
   llvm::sys::path::append(Res, "lib", OSLibName);
   return Res;
 }
 
 static SmallString<128> getCompilerRT(const ToolChain &TC, StringRef Component,
                                       bool Shared = false,
                                       const char *Env = "") {
   bool IsOSWindows = TC.getTriple().isOSWindows();
   StringRef Arch = getArchNameForCompilerRTLib(TC);
   const char *Prefix = IsOSWindows ? "" : "lib";
   const char *Suffix =
       Shared ? (IsOSWindows ? ".dll" : ".so") : (IsOSWindows ? ".lib" : ".a");
 
   SmallString<128> Path = getCompilerRTLibDir(TC);
   llvm::sys::path::append(Path, Prefix + Twine("clang_rt.") + Component + "-" +
                                     Arch + Env + Suffix);
 
   return Path;
 }
 
 // This adds the static libclang_rt.builtins-arch.a directly to the command line
 // FIXME: Make sure we can also emit shared objects if they're requested
 // and available, check for possible errors, etc.
 static void addClangRT(const ToolChain &TC, const ArgList &Args,
                        ArgStringList &CmdArgs) {
   CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "builtins")));
 
   if (!TC.getTriple().isOSWindows()) {
     // FIXME: why do we link against gcc when we are using compiler-rt?
     CmdArgs.push_back("-lgcc_s");
     if (TC.getDriver().CCCIsCXX())
       CmdArgs.push_back("-lgcc_eh");
   }
 }
 
 static void addProfileRT(const ToolChain &TC, const ArgList &Args,
                          ArgStringList &CmdArgs) {
   if (!(Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
                      false) ||
         Args.hasArg(options::OPT_fprofile_generate) ||
         Args.hasArg(options::OPT_fprofile_instr_generate) ||
         Args.hasArg(options::OPT_fcreate_profile) ||
         Args.hasArg(options::OPT_coverage)))
     return;
 
   CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "profile")));
 }
 
 static void addSanitizerRuntime(const ToolChain &TC, const ArgList &Args,
                                 ArgStringList &CmdArgs, StringRef Sanitizer,
                                 bool IsShared) {
   const char *Env = TC.getTriple().getEnvironment() == llvm::Triple::Android
                         ? "-android"
                         : "";
 
   // Static runtimes must be forced into executable, so we wrap them in
   // whole-archive.
   if (!IsShared)
     CmdArgs.push_back("-whole-archive");
   CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Sanitizer, IsShared,
                                                      Env)));
   if (!IsShared)
     CmdArgs.push_back("-no-whole-archive");
 }
 
 // Tries to use a file with the list of dynamic symbols that need to be exported
 // from the runtime library. Returns true if the file was found.
 static bool addSanitizerDynamicList(const ToolChain &TC, const ArgList &Args,
                                     ArgStringList &CmdArgs,
                                     StringRef Sanitizer) {
   SmallString<128> SanRT = getCompilerRT(TC, Sanitizer);
   if (llvm::sys::fs::exists(SanRT + ".syms")) {
     CmdArgs.push_back(Args.MakeArgString("--dynamic-list=" + SanRT + ".syms"));
     return true;
   }
   return false;
 }
 
 static void linkSanitizerRuntimeDeps(const ToolChain &TC,
                                      ArgStringList &CmdArgs) {
   // Force linking against the system libraries sanitizers depends on
   // (see PR15823 why this is necessary).
   CmdArgs.push_back("--no-as-needed");
   CmdArgs.push_back("-lpthread");
   CmdArgs.push_back("-lrt");
   CmdArgs.push_back("-lm");
   // There's no libdl on FreeBSD.
   if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
     CmdArgs.push_back("-ldl");
 }
 
 static void
 collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
                          SmallVectorImpl<StringRef> &SharedRuntimes,
                          SmallVectorImpl<StringRef> &StaticRuntimes,
                          SmallVectorImpl<StringRef> &HelperStaticRuntimes) {
   const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
   // Collect shared runtimes.
   if (SanArgs.needsAsanRt() && SanArgs.needsSharedAsanRt()) {
     SharedRuntimes.push_back("asan");
   }
 
   // Collect static runtimes.
   if (Args.hasArg(options::OPT_shared) ||
       (TC.getTriple().getEnvironment() == llvm::Triple::Android)) {
     // Don't link static runtimes into DSOs or if compiling for Android.
     return;
   }
   if (SanArgs.needsAsanRt()) {
     if (SanArgs.needsSharedAsanRt()) {
       HelperStaticRuntimes.push_back("asan-preinit");
     } else {
       StaticRuntimes.push_back("asan");
       if (SanArgs.linkCXXRuntimes())
         StaticRuntimes.push_back("asan_cxx");
     }
   }
   if (SanArgs.needsDfsanRt())
     StaticRuntimes.push_back("dfsan");
   if (SanArgs.needsLsanRt())
     StaticRuntimes.push_back("lsan");
   if (SanArgs.needsMsanRt())
     StaticRuntimes.push_back("msan");
   if (SanArgs.needsTsanRt())
     StaticRuntimes.push_back("tsan");
   // WARNING: UBSan should always go last.
   if (SanArgs.needsUbsanRt()) {
     // If UBSan is not combined with another sanitizer, we need to pull in
     // sanitizer_common explicitly.
     if (StaticRuntimes.empty())
       HelperStaticRuntimes.push_back("san");
     StaticRuntimes.push_back("ubsan");
     if (SanArgs.linkCXXRuntimes())
       StaticRuntimes.push_back("ubsan_cxx");
   }
 }
 
 // Should be called before we add system libraries (C++ ABI, libstdc++/libc++,
 // C runtime, etc). Returns true if sanitizer system deps need to be linked in.
 static bool addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
                                  ArgStringList &CmdArgs) {
   SmallVector<StringRef, 4> SharedRuntimes, StaticRuntimes,
       HelperStaticRuntimes;
   collectSanitizerRuntimes(TC, Args, SharedRuntimes, StaticRuntimes,
                            HelperStaticRuntimes);
   for (auto RT : SharedRuntimes)
     addSanitizerRuntime(TC, Args, CmdArgs, RT, true);
   for (auto RT : HelperStaticRuntimes)
     addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
   bool AddExportDynamic = false;
   for (auto RT : StaticRuntimes) {
     addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
     AddExportDynamic |= !addSanitizerDynamicList(TC, Args, CmdArgs, RT);
   }
   // If there is a static runtime with no dynamic list, force all the symbols
   // to be dynamic to be sure we export sanitizer interface functions.
   if (AddExportDynamic)
     CmdArgs.push_back("-export-dynamic");
   return !StaticRuntimes.empty();
 }
 
 static bool shouldUseFramePointerForTarget(const ArgList &Args,
                                            const llvm::Triple &Triple) {
   switch (Triple.getArch()) {
   // Don't use a frame pointer on linux if optimizing for certain targets.
   case llvm::Triple::mips64:
   case llvm::Triple::mips64el:
   case llvm::Triple::mips:
   case llvm::Triple::mipsel:
   case llvm::Triple::systemz:
   case llvm::Triple::x86:
   case llvm::Triple::x86_64:
     if (Triple.isOSLinux())
       if (Arg *A = Args.getLastArg(options::OPT_O_Group))
         if (!A->getOption().matches(options::OPT_O0))
           return false;
     return true;
   case llvm::Triple::xcore:
     return false;
   default:
     return true;
   }
 }
 
 static bool shouldUseFramePointer(const ArgList &Args,
                                   const llvm::Triple &Triple) {
   if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
                                options::OPT_fomit_frame_pointer))
     return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
 
   return shouldUseFramePointerForTarget(Args, Triple);
 }
 
 static bool shouldUseLeafFramePointer(const ArgList &Args,
                                       const llvm::Triple &Triple) {
   if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
                                options::OPT_momit_leaf_frame_pointer))
     return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
 
   return shouldUseFramePointerForTarget(Args, Triple);
 }
 
 /// Add a CC1 option to specify the debug compilation directory.
 static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
   SmallString<128> cwd;
   if (!llvm::sys::fs::current_path(cwd)) {
     CmdArgs.push_back("-fdebug-compilation-dir");
     CmdArgs.push_back(Args.MakeArgString(cwd));
   }
 }
 
 static const char *SplitDebugName(const ArgList &Args,
                                   const InputInfoList &Inputs) {
   Arg *FinalOutput = Args.getLastArg(options::OPT_o);
   if (FinalOutput && Args.hasArg(options::OPT_c)) {
     SmallString<128> T(FinalOutput->getValue());
     llvm::sys::path::replace_extension(T, "dwo");
     return Args.MakeArgString(T);
   } else {
     // Use the compilation dir.
     SmallString<128> T(
         Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
     SmallString<128> F(llvm::sys::path::stem(Inputs[0].getBaseInput()));
     llvm::sys::path::replace_extension(F, "dwo");
     T += F;
     return Args.MakeArgString(F);
   }
 }
 
 static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
                            const Tool &T, const JobAction &JA,
                            const ArgList &Args, const InputInfo &Output,
                            const char *OutFile) {
   ArgStringList ExtractArgs;
   ExtractArgs.push_back("--extract-dwo");
 
   ArgStringList StripArgs;
   StripArgs.push_back("--strip-dwo");
 
   // Grabbing the output of the earlier compile step.
   StripArgs.push_back(Output.getFilename());
   ExtractArgs.push_back(Output.getFilename());
   ExtractArgs.push_back(OutFile);
 
   const char *Exec =
     Args.MakeArgString(TC.GetProgramPath("objcopy"));
 
   // First extract the dwo sections.
   C.addCommand(llvm::make_unique<Command>(JA, T, Exec, ExtractArgs));
 
   // Then remove them from the original .o file.
   C.addCommand(llvm::make_unique<Command>(JA, T, Exec, StripArgs));
 }
 
 /// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
 /// For -Oz the loop vectorizer is disable, while the slp vectorizer is enabled.
 static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
   if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
     if (A->getOption().matches(options::OPT_O4) ||
         A->getOption().matches(options::OPT_Ofast))
       return true;
 
     if (A->getOption().matches(options::OPT_O0))
       return false;
 
     assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
 
     // Vectorize -Os.
     StringRef S(A->getValue());
     if (S == "s")
       return true;
 
     // Don't vectorize -Oz, unless it's the slp vectorizer.
     if (S == "z")
       return isSlpVec;
 
     unsigned OptLevel = 0;
     if (S.getAsInteger(10, OptLevel))
       return false;
 
     return OptLevel > 1;
   }
 
   return false;
 }
 
 /// Add -x lang to \p CmdArgs for \p Input.
 static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
                              ArgStringList &CmdArgs) {
   // When using -verify-pch, we don't want to provide the type
   // 'precompiled-header' if it was inferred from the file extension
   if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
     return;
 
   CmdArgs.push_back("-x");
   if (Args.hasArg(options::OPT_rewrite_objc))
     CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
   else
     CmdArgs.push_back(types::getTypeName(Input.getType()));
 }
 
 static std::string getMSCompatibilityVersion(const char *VersionStr) {
   unsigned Version;
   if (StringRef(VersionStr).getAsInteger(10, Version))
     return "0";
 
   if (Version < 100)
     return llvm::utostr_32(Version) + ".0";
 
   if (Version < 10000)
     return llvm::utostr_32(Version / 100) + "." +
         llvm::utostr_32(Version % 100);
 
   unsigned Build = 0, Factor = 1;
   for ( ; Version > 10000; Version = Version / 10, Factor = Factor * 10)
     Build = Build + (Version % 10) * Factor;
   return llvm::utostr_32(Version / 100) + "." +
       llvm::utostr_32(Version % 100) + "." +
       llvm::utostr_32(Build);
 }
 
 // Claim options we don't want to warn if they are unused. We do this for
 // options that build systems might add but are unused when assembling or only
 // running the preprocessor for example.
 static void claimNoWarnArgs(const ArgList &Args) {
   // Don't warn about unused -f(no-)?lto.  This can happen when we're
   // preprocessing, precompiling or assembling.
   Args.ClaimAllArgs(options::OPT_flto);
   Args.ClaimAllArgs(options::OPT_fno_lto);
 }
 
 void Clang::ConstructJob(Compilation &C, const JobAction &JA,
                          const InputInfo &Output,
                          const InputInfoList &Inputs,
                          const ArgList &Args,
                          const char *LinkingOutput) const {
   bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
                                   options::OPT_fapple_kext);
   const Driver &D = getToolChain().getDriver();
   ArgStringList CmdArgs;
 
   bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
   bool IsWindowsCygnus =
       getToolChain().getTriple().isWindowsCygwinEnvironment();
   bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
 
   assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
 
   // Invoke ourselves in -cc1 mode.
   //
   // FIXME: Implement custom jobs for internal actions.
   CmdArgs.push_back("-cc1");
 
   // Add the "effective" target triple.
   CmdArgs.push_back("-triple");
   std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
   CmdArgs.push_back(Args.MakeArgString(TripleStr));
 
   const llvm::Triple TT(TripleStr);
   if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
                            TT.getArch() == llvm::Triple::thumb)) {
     unsigned Offset = TT.getArch() == llvm::Triple::arm ? 4 : 6;
     unsigned Version;
     TT.getArchName().substr(Offset).getAsInteger(10, Version);
     if (Version < 7)
       D.Diag(diag::err_target_unsupported_arch) << TT.getArchName()
                                                 << TripleStr;
   }
 
   // Push all default warning arguments that are specific to
   // the given target.  These come before user provided warning options
   // are provided.
   getToolChain().addClangWarningOptions(CmdArgs);
 
   // Select the appropriate action.
   RewriteKind rewriteKind = RK_None;
   
   if (isa<AnalyzeJobAction>(JA)) {
     assert(JA.getType() == types::TY_Plist && "Invalid output type.");
     CmdArgs.push_back("-analyze");
   } else if (isa<MigrateJobAction>(JA)) {
     CmdArgs.push_back("-migrate");
   } else if (isa<PreprocessJobAction>(JA)) {
     if (Output.getType() == types::TY_Dependencies)
       CmdArgs.push_back("-Eonly");
     else {
       CmdArgs.push_back("-E");
       if (Args.hasArg(options::OPT_rewrite_objc) &&
           !Args.hasArg(options::OPT_g_Group))
         CmdArgs.push_back("-P");
     }
   } else if (isa<AssembleJobAction>(JA)) {
     CmdArgs.push_back("-emit-obj");
 
     CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
 
     // Also ignore explicit -force_cpusubtype_ALL option.
     (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
   } else if (isa<PrecompileJobAction>(JA)) {
     // Use PCH if the user requested it.
     bool UsePCH = D.CCCUsePCH;
 
     if (JA.getType() == types::TY_Nothing)
       CmdArgs.push_back("-fsyntax-only");
     else if (UsePCH)
       CmdArgs.push_back("-emit-pch");
     else
       CmdArgs.push_back("-emit-pth");
   } else if (isa<VerifyPCHJobAction>(JA)) {
     CmdArgs.push_back("-verify-pch");
   } else {
     assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
            "Invalid action for clang tool.");
 
     if (JA.getType() == types::TY_Nothing) {
       CmdArgs.push_back("-fsyntax-only");
     } else if (JA.getType() == types::TY_LLVM_IR ||
                JA.getType() == types::TY_LTO_IR) {
       CmdArgs.push_back("-emit-llvm");
     } else if (JA.getType() == types::TY_LLVM_BC ||
                JA.getType() == types::TY_LTO_BC) {
       CmdArgs.push_back("-emit-llvm-bc");
     } else if (JA.getType() == types::TY_PP_Asm) {
       CmdArgs.push_back("-S");
     } else if (JA.getType() == types::TY_AST) {
       CmdArgs.push_back("-emit-pch");
     } else if (JA.getType() == types::TY_ModuleFile) {
       CmdArgs.push_back("-module-file-info");
     } else if (JA.getType() == types::TY_RewrittenObjC) {
       CmdArgs.push_back("-rewrite-objc");
       rewriteKind = RK_NonFragile;
     } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
       CmdArgs.push_back("-rewrite-objc");
       rewriteKind = RK_Fragile;
     } else {
       assert(JA.getType() == types::TY_PP_Asm &&
              "Unexpected output type!");
     }
   }
 
   // We normally speed up the clang process a bit by skipping destructors at
   // exit, but when we're generating diagnostics we can rely on some of the
   // cleanup.
   if (!C.isForDiagnostics())
     CmdArgs.push_back("-disable-free");
 
   // Disable the verification pass in -asserts builds.
 #ifdef NDEBUG
   CmdArgs.push_back("-disable-llvm-verifier");
 #endif
 
   // Set the main file name, so that debug info works even with
   // -save-temps.
   CmdArgs.push_back("-main-file-name");
   CmdArgs.push_back(getBaseInputName(Args, Inputs));
 
   // Some flags which affect the language (via preprocessor
   // defines).
   if (Args.hasArg(options::OPT_static))
     CmdArgs.push_back("-static-define");
 
   if (isa<AnalyzeJobAction>(JA)) {
     // Enable region store model by default.
     CmdArgs.push_back("-analyzer-store=region");
 
     // Treat blocks as analysis entry points.
     CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
 
     CmdArgs.push_back("-analyzer-eagerly-assume");
 
     // Add default argument set.
     if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
       CmdArgs.push_back("-analyzer-checker=core");
 
       if (!IsWindowsMSVC)
         CmdArgs.push_back("-analyzer-checker=unix");
 
       if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
         CmdArgs.push_back("-analyzer-checker=osx");
       
       CmdArgs.push_back("-analyzer-checker=deadcode");
       
       if (types::isCXX(Inputs[0].getType()))
         CmdArgs.push_back("-analyzer-checker=cplusplus");
 
       // Enable the following experimental checkers for testing.
       CmdArgs.push_back(
           "-analyzer-checker=security.insecureAPI.UncheckedReturn");
       CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
       CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
       CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");      
       CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
       CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
     }
 
     // Set the output format. The default is plist, for (lame) historical
     // reasons.
     CmdArgs.push_back("-analyzer-output");
     if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
       CmdArgs.push_back(A->getValue());
     else
       CmdArgs.push_back("plist");
 
     // Disable the presentation of standard compiler warnings when
     // using --analyze.  We only want to show static analyzer diagnostics
     // or frontend errors.
     CmdArgs.push_back("-w");
 
     // Add -Xanalyzer arguments when running as analyzer.
     Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
   }
 
   CheckCodeGenerationOptions(D, Args);
 
   bool PIE = getToolChain().isPIEDefault();
   bool PIC = PIE || getToolChain().isPICDefault();
   bool IsPICLevelTwo = PIC;
 
   // Android-specific defaults for PIC/PIE
   if (getToolChain().getTriple().getEnvironment() == llvm::Triple::Android) {
     switch (getToolChain().getTriple().getArch()) {
     case llvm::Triple::arm:
     case llvm::Triple::armeb:
     case llvm::Triple::thumb:
     case llvm::Triple::thumbeb:
     case llvm::Triple::aarch64:
     case llvm::Triple::mips:
     case llvm::Triple::mipsel:
     case llvm::Triple::mips64:
     case llvm::Triple::mips64el:
       PIC = true; // "-fpic"
       break;
 
     case llvm::Triple::x86:
     case llvm::Triple::x86_64:
       PIC = true; // "-fPIC"
       IsPICLevelTwo = true;
       break;
 
     default:
       break;
     }
   }
 
   // OpenBSD-specific defaults for PIE
   if (getToolChain().getTriple().getOS() == llvm::Triple::OpenBSD) {
     switch (getToolChain().getTriple().getArch()) {
     case llvm::Triple::mips64:
     case llvm::Triple::mips64el:
     case llvm::Triple::sparc:
     case llvm::Triple::x86:
     case llvm::Triple::x86_64:
       IsPICLevelTwo = false; // "-fpie"
       break;
 
     case llvm::Triple::ppc:
     case llvm::Triple::sparcv9:
       IsPICLevelTwo = true; // "-fPIE"
       break;
 
     default:
       break;
     }
   }
 
   // For the PIC and PIE flag options, this logic is different from the
   // legacy logic in very old versions of GCC, as that logic was just
   // a bug no one had ever fixed. This logic is both more rational and
   // consistent with GCC's new logic now that the bugs are fixed. The last
   // argument relating to either PIC or PIE wins, and no other argument is
   // used. If the last argument is any flavor of the '-fno-...' arguments,
   // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
   // at the same level.
   Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
                                  options::OPT_fpic, options::OPT_fno_pic,
                                  options::OPT_fPIE, options::OPT_fno_PIE,
                                  options::OPT_fpie, options::OPT_fno_pie);
   // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
   // is forced, then neither PIC nor PIE flags will have no effect.
   if (!getToolChain().isPICDefaultForced()) {
     if (LastPICArg) {
       Option O = LastPICArg->getOption();
       if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
           O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
         PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
         PIC = PIE || O.matches(options::OPT_fPIC) ||
               O.matches(options::OPT_fpic);
         IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
                         O.matches(options::OPT_fPIC);
       } else {
         PIE = PIC = false;
       }
     }
   }
 
   // Introduce a Darwin-specific hack. If the default is PIC but the flags
   // specified while enabling PIC enabled level 1 PIC, just force it back to
   // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
   // informal testing).
   if (PIC && getToolChain().getTriple().isOSDarwin())
     IsPICLevelTwo |= getToolChain().isPICDefault();
 
   // Note that these flags are trump-cards. Regardless of the order w.r.t. the
   // PIC or PIE options above, if these show up, PIC is disabled.
   llvm::Triple Triple(TripleStr);
   if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6)))
     PIC = PIE = false;
   if (Args.hasArg(options::OPT_static))
     PIC = PIE = false;
 
   if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
     // This is a very special mode. It trumps the other modes, almost no one
     // uses it, and it isn't even valid on any OS but Darwin.
     if (!getToolChain().getTriple().isOSDarwin())
       D.Diag(diag::err_drv_unsupported_opt_for_target)
         << A->getSpelling() << getToolChain().getTriple().str();
 
     // FIXME: Warn when this flag trumps some other PIC or PIE flag.
 
     CmdArgs.push_back("-mrelocation-model");
     CmdArgs.push_back("dynamic-no-pic");
 
     // Only a forced PIC mode can cause the actual compile to have PIC defines
     // etc., no flags are sufficient. This behavior was selected to closely
     // match that of llvm-gcc and Apple GCC before that.
     if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
       CmdArgs.push_back("-pic-level");
       CmdArgs.push_back("2");
     }
   } else {
     // Currently, LLVM only knows about PIC vs. static; the PIE differences are
     // handled in Clang's IRGen by the -pie-level flag.
     CmdArgs.push_back("-mrelocation-model");
     CmdArgs.push_back(PIC ? "pic" : "static");
 
     if (PIC) {
       CmdArgs.push_back("-pic-level");
       CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
       if (PIE) {
         CmdArgs.push_back("-pie-level");
         CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
       }
     }
   }
 
   CmdArgs.push_back("-mthread-model");
   if (Arg *A = Args.getLastArg(options::OPT_mthread_model))
     CmdArgs.push_back(A->getValue());
   else
     CmdArgs.push_back(Args.MakeArgString(getToolChain().getThreadModel()));
 
   if (!Args.hasFlag(options::OPT_fmerge_all_constants,
                     options::OPT_fno_merge_all_constants))
     CmdArgs.push_back("-fno-merge-all-constants");
 
   // LLVM Code Generator Options.
 
   if (Args.hasArg(options::OPT_frewrite_map_file) ||
       Args.hasArg(options::OPT_frewrite_map_file_EQ)) {
     for (arg_iterator
              MFI = Args.filtered_begin(options::OPT_frewrite_map_file,
                                        options::OPT_frewrite_map_file_EQ),
              MFE = Args.filtered_end();
          MFI != MFE; ++MFI) {
       CmdArgs.push_back("-frewrite-map-file");
       CmdArgs.push_back((*MFI)->getValue());
       (*MFI)->claim();
     }
   }
 
   if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
     StringRef v = A->getValue();
     CmdArgs.push_back("-mllvm");
     CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
     A->claim();
   }
 
   if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
     CmdArgs.push_back("-mregparm");
     CmdArgs.push_back(A->getValue());
   }
 
   if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
                                options::OPT_freg_struct_return)) {
     if (getToolChain().getArch() != llvm::Triple::x86) {
       D.Diag(diag::err_drv_unsupported_opt_for_target)
         << A->getSpelling() << getToolChain().getTriple().str();
     } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
       CmdArgs.push_back("-fpcc-struct-return");
     } else {
       assert(A->getOption().matches(options::OPT_freg_struct_return));
       CmdArgs.push_back("-freg-struct-return");
     }
   }
 
   if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
     CmdArgs.push_back("-mrtd");
 
   if (shouldUseFramePointer(Args, getToolChain().getTriple()))
     CmdArgs.push_back("-mdisable-fp-elim");
   if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
                     options::OPT_fno_zero_initialized_in_bss))
     CmdArgs.push_back("-mno-zero-initialized-in-bss");
 
   bool OFastEnabled = isOptimizationLevelFast(Args);
   // If -Ofast is the optimization level, then -fstrict-aliasing should be
   // enabled.  This alias option is being used to simplify the hasFlag logic.
   OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
     options::OPT_fstrict_aliasing;
   // We turn strict aliasing off by default if we're in CL mode, since MSVC
   // doesn't do any TBAA.
   bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
   if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
                     options::OPT_fno_strict_aliasing, TBAAOnByDefault))
     CmdArgs.push_back("-relaxed-aliasing");
   if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
                     options::OPT_fno_struct_path_tbaa))
     CmdArgs.push_back("-no-struct-path-tbaa");
   if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
                    false))
     CmdArgs.push_back("-fstrict-enums");
   if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
                     options::OPT_fno_optimize_sibling_calls))
     CmdArgs.push_back("-mdisable-tail-calls");
 
   // Handle segmented stacks.
   if (Args.hasArg(options::OPT_fsplit_stack))
     CmdArgs.push_back("-split-stacks");
 
   // If -Ofast is the optimization level, then -ffast-math should be enabled.
   // This alias option is being used to simplify the getLastArg logic.
   OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
     options::OPT_ffast_math;
   
   // Handle various floating point optimization flags, mapping them to the
   // appropriate LLVM code generation flags. The pattern for all of these is to
   // default off the codegen optimizations, and if any flag enables them and no
   // flag disables them after the flag enabling them, enable the codegen
   // optimization. This is complicated by several "umbrella" flags.
   if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
                                options::OPT_fno_fast_math,
                                options::OPT_ffinite_math_only,
                                options::OPT_fno_finite_math_only,
                                options::OPT_fhonor_infinities,
                                options::OPT_fno_honor_infinities))
     if (A->getOption().getID() != options::OPT_fno_fast_math &&
         A->getOption().getID() != options::OPT_fno_finite_math_only &&
         A->getOption().getID() != options::OPT_fhonor_infinities)
       CmdArgs.push_back("-menable-no-infs");
   if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
                                options::OPT_fno_fast_math,
                                options::OPT_ffinite_math_only,
                                options::OPT_fno_finite_math_only,
                                options::OPT_fhonor_nans,
                                options::OPT_fno_honor_nans))
     if (A->getOption().getID() != options::OPT_fno_fast_math &&
         A->getOption().getID() != options::OPT_fno_finite_math_only &&
         A->getOption().getID() != options::OPT_fhonor_nans)
       CmdArgs.push_back("-menable-no-nans");
 
   // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
   bool MathErrno = getToolChain().IsMathErrnoDefault();
   if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
                                options::OPT_fno_fast_math,
                                options::OPT_fmath_errno,
                                options::OPT_fno_math_errno)) {
     // Turning on -ffast_math (with either flag) removes the need for MathErrno.
     // However, turning *off* -ffast_math merely restores the toolchain default
     // (which may be false).
     if (A->getOption().getID() == options::OPT_fno_math_errno ||
         A->getOption().getID() == options::OPT_ffast_math ||
         A->getOption().getID() == options::OPT_Ofast)
       MathErrno = false;
     else if (A->getOption().getID() == options::OPT_fmath_errno)
       MathErrno = true;
   }
   if (MathErrno)
     CmdArgs.push_back("-fmath-errno");
 
   // There are several flags which require disabling very specific
   // optimizations. Any of these being disabled forces us to turn off the
   // entire set of LLVM optimizations, so collect them through all the flag
   // madness.
   bool AssociativeMath = false;
   if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
                                options::OPT_fno_fast_math,
                                options::OPT_funsafe_math_optimizations,
                                options::OPT_fno_unsafe_math_optimizations,
                                options::OPT_fassociative_math,
                                options::OPT_fno_associative_math))
     if (A->getOption().getID() != options::OPT_fno_fast_math &&
         A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
         A->getOption().getID() != options::OPT_fno_associative_math)
       AssociativeMath = true;
   bool ReciprocalMath = false;
   if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
                                options::OPT_fno_fast_math,
                                options::OPT_funsafe_math_optimizations,
                                options::OPT_fno_unsafe_math_optimizations,
                                options::OPT_freciprocal_math,
                                options::OPT_fno_reciprocal_math))
     if (A->getOption().getID() != options::OPT_fno_fast_math &&
         A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
         A->getOption().getID() != options::OPT_fno_reciprocal_math)
       ReciprocalMath = true;
   bool SignedZeros = true;
   if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
                                options::OPT_fno_fast_math,
                                options::OPT_funsafe_math_optimizations,
                                options::OPT_fno_unsafe_math_optimizations,
                                options::OPT_fsigned_zeros,
                                options::OPT_fno_signed_zeros))
     if (A->getOption().getID() != options::OPT_fno_fast_math &&
         A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
         A->getOption().getID() != options::OPT_fsigned_zeros)
       SignedZeros = false;
   bool TrappingMath = true;
   if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
                                options::OPT_fno_fast_math,
                                options::OPT_funsafe_math_optimizations,
                                options::OPT_fno_unsafe_math_optimizations,
                                options::OPT_ftrapping_math,
                                options::OPT_fno_trapping_math))
     if (A->getOption().getID() != options::OPT_fno_fast_math &&
         A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
         A->getOption().getID() != options::OPT_ftrapping_math)
       TrappingMath = false;
   if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
       !TrappingMath)
     CmdArgs.push_back("-menable-unsafe-fp-math");
 
 
   // Validate and pass through -fp-contract option. 
   if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
                                options::OPT_fno_fast_math,
                                options::OPT_ffp_contract)) {
     if (A->getOption().getID() == options::OPT_ffp_contract) {
       StringRef Val = A->getValue();
       if (Val == "fast" || Val == "on" || Val == "off") {
         CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
       } else {
         D.Diag(diag::err_drv_unsupported_option_argument)
           << A->getOption().getName() << Val;
       }
     } else if (A->getOption().matches(options::OPT_ffast_math) ||
                (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
       // If fast-math is set then set the fp-contract mode to fast.
       CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
     }
   }
 
   // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
   // and if we find them, tell the frontend to provide the appropriate
   // preprocessor macros. This is distinct from enabling any optimizations as
   // these options induce language changes which must survive serialization
   // and deserialization, etc.
   if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
                                options::OPT_fno_fast_math))
       if (!A->getOption().matches(options::OPT_fno_fast_math))
         CmdArgs.push_back("-ffast-math");
   if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
                                options::OPT_fno_fast_math))
     if (A->getOption().matches(options::OPT_ffinite_math_only))
       CmdArgs.push_back("-ffinite-math-only");
 
   // Decide whether to use verbose asm. Verbose assembly is the default on
   // toolchains which have the integrated assembler on by default.
   bool IsIntegratedAssemblerDefault =
       getToolChain().IsIntegratedAssemblerDefault();
   if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
                    IsIntegratedAssemblerDefault) ||
       Args.hasArg(options::OPT_dA))
     CmdArgs.push_back("-masm-verbose");
 
   if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
                     IsIntegratedAssemblerDefault))
     CmdArgs.push_back("-no-integrated-as");
 
   if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
     CmdArgs.push_back("-mdebug-pass");
     CmdArgs.push_back("Structure");
   }
   if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
     CmdArgs.push_back("-mdebug-pass");
     CmdArgs.push_back("Arguments");
   }
 
   // Enable -mconstructor-aliases except on darwin, where we have to
   // work around a linker bug;  see <rdar://problem/7651567>.
   if (!getToolChain().getTriple().isOSDarwin())
     CmdArgs.push_back("-mconstructor-aliases");
 
   // Darwin's kernel doesn't support guard variables; just die if we
   // try to use them.
   if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
     CmdArgs.push_back("-fforbid-guard-variables");
 
   if (Args.hasArg(options::OPT_mms_bitfields)) {
     CmdArgs.push_back("-mms-bitfields");
   }
 
   // This is a coarse approximation of what llvm-gcc actually does, both
   // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
   // complicated ways.
   bool AsynchronousUnwindTables =
       Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
                    options::OPT_fno_asynchronous_unwind_tables,
                    (getToolChain().IsUnwindTablesDefault() ||
                     getToolChain().getSanitizerArgs().needsUnwindTables()) &&
                        !KernelOrKext);
   if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
                    AsynchronousUnwindTables))
     CmdArgs.push_back("-munwind-tables");
 
   getToolChain().addClangTargetOptions(Args, CmdArgs);
 
   if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
     CmdArgs.push_back("-mlimit-float-precision");
     CmdArgs.push_back(A->getValue());
   }
 
   // FIXME: Handle -mtune=.
   (void) Args.hasArg(options::OPT_mtune_EQ);
 
   if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
     CmdArgs.push_back("-mcode-model");
     CmdArgs.push_back(A->getValue());
   }
 
   // Add the target cpu
   std::string ETripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
   llvm::Triple ETriple(ETripleStr);
   std::string CPU = getCPUName(Args, ETriple);
   if (!CPU.empty()) {
     CmdArgs.push_back("-target-cpu");
     CmdArgs.push_back(Args.MakeArgString(CPU));
   }
 
   if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
     CmdArgs.push_back("-mfpmath");
     CmdArgs.push_back(A->getValue());
   }
 
   // Add the target features
   getTargetFeatures(D, ETriple, Args, CmdArgs, false);
 
   // Add target specific flags.
   switch(getToolChain().getArch()) {
   default:
     break;
 
   case llvm::Triple::arm:
   case llvm::Triple::armeb:
   case llvm::Triple::thumb:
   case llvm::Triple::thumbeb:
     AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
     break;
 
   case llvm::Triple::aarch64:
   case llvm::Triple::aarch64_be:
     AddAArch64TargetArgs(Args, CmdArgs);
     break;
 
   case llvm::Triple::mips:
   case llvm::Triple::mipsel:
   case llvm::Triple::mips64:
   case llvm::Triple::mips64el:
     AddMIPSTargetArgs(Args, CmdArgs);
     break;
 
   case llvm::Triple::ppc:
   case llvm::Triple::ppc64:
   case llvm::Triple::ppc64le:
     AddPPCTargetArgs(Args, CmdArgs);
     break;
 
   case llvm::Triple::sparc:
   case llvm::Triple::sparcv9:
     AddSparcTargetArgs(Args, CmdArgs);
     break;
 
   case llvm::Triple::x86:
   case llvm::Triple::x86_64:
     AddX86TargetArgs(Args, CmdArgs);
     break;
 
   case llvm::Triple::hexagon:
     AddHexagonTargetArgs(Args, CmdArgs);
     break;
   }
 
   // Add clang-cl arguments.
   if (getToolChain().getDriver().IsCLMode())
     AddClangCLArgs(Args, CmdArgs);
 
   // Pass the linker version in use.
   if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
     CmdArgs.push_back("-target-linker-version");
     CmdArgs.push_back(A->getValue());
   }
 
   if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
     CmdArgs.push_back("-momit-leaf-frame-pointer");
 
   // Explicitly error on some things we know we don't support and can't just
   // ignore.
   types::ID InputType = Inputs[0].getType();
   if (!Args.hasArg(options::OPT_fallow_unsupported)) {
     Arg *Unsupported;
     if (types::isCXX(InputType) &&
         getToolChain().getTriple().isOSDarwin() &&
         getToolChain().getArch() == llvm::Triple::x86) {
       if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
           (Unsupported = Args.getLastArg(options::OPT_mkernel)))
         D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
           << Unsupported->getOption().getName();
     }
   }
 
   Args.AddAllArgs(CmdArgs, options::OPT_v);
   Args.AddLastArg(CmdArgs, options::OPT_H);
   if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
     CmdArgs.push_back("-header-include-file");
     CmdArgs.push_back(D.CCPrintHeadersFilename ?
                       D.CCPrintHeadersFilename : "-");
   }
   Args.AddLastArg(CmdArgs, options::OPT_P);
   Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
 
   if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
     CmdArgs.push_back("-diagnostic-log-file");
     CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
                       D.CCLogDiagnosticsFilename : "-");
   }
 
   // Use the last option from "-g" group. "-gline-tables-only" and "-gdwarf-x"
   // are preserved, all other debug options are substituted with "-g".
   Args.ClaimAllArgs(options::OPT_g_Group);
   if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
     if (A->getOption().matches(options::OPT_gline_tables_only) ||
         A->getOption().matches(options::OPT_g1)) {
       // FIXME: we should support specifying dwarf version with
       // -gline-tables-only.
       CmdArgs.push_back("-gline-tables-only");
       // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.
       const llvm::Triple &Triple = getToolChain().getTriple();
       if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
           Triple.getOS() == llvm::Triple::FreeBSD ||
           Triple.getOS() == llvm::Triple::Solaris)
         CmdArgs.push_back("-gdwarf-2");
     } else if (A->getOption().matches(options::OPT_gdwarf_2))
       CmdArgs.push_back("-gdwarf-2");
     else if (A->getOption().matches(options::OPT_gdwarf_3))
       CmdArgs.push_back("-gdwarf-3");
     else if (A->getOption().matches(options::OPT_gdwarf_4))
       CmdArgs.push_back("-gdwarf-4");
     else if (!A->getOption().matches(options::OPT_g0) &&
              !A->getOption().matches(options::OPT_ggdb0)) {
       // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.
       const llvm::Triple &Triple = getToolChain().getTriple();
       if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
           Triple.getOS() == llvm::Triple::FreeBSD ||
           Triple.getOS() == llvm::Triple::Solaris)
         CmdArgs.push_back("-gdwarf-2");
       else
         CmdArgs.push_back("-g");
     }
   }
 
   // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
   Args.ClaimAllArgs(options::OPT_g_flags_Group);
   if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
                    /*Default*/ true))
     CmdArgs.push_back("-dwarf-column-info");
 
   // FIXME: Move backend command line options to the module.
   // -gsplit-dwarf should turn on -g and enable the backend dwarf
   // splitting and extraction.
   // FIXME: Currently only works on Linux.
   if (getToolChain().getTriple().isOSLinux() &&
       Args.hasArg(options::OPT_gsplit_dwarf)) {
     CmdArgs.push_back("-g");
     CmdArgs.push_back("-backend-option");
     CmdArgs.push_back("-split-dwarf=Enable");
   }
 
   // -ggnu-pubnames turns on gnu style pubnames in the backend.
   if (Args.hasArg(options::OPT_ggnu_pubnames)) {
     CmdArgs.push_back("-backend-option");
     CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
   }
 
   // -gdwarf-aranges turns on the emission of the aranges section in the
   // backend.
   if (Args.hasArg(options::OPT_gdwarf_aranges)) {
     CmdArgs.push_back("-backend-option");
     CmdArgs.push_back("-generate-arange-section");
   }
 
   if (Args.hasFlag(options::OPT_fdebug_types_section,
                    options::OPT_fno_debug_types_section, false)) {
     CmdArgs.push_back("-backend-option");
     CmdArgs.push_back("-generate-type-units");
   }
 
   if (Args.hasFlag(options::OPT_ffunction_sections,
                    options::OPT_fno_function_sections, false)) {
     CmdArgs.push_back("-ffunction-sections");
   }
 
   if (Args.hasFlag(options::OPT_fdata_sections,
                    options::OPT_fno_data_sections, false)) {
     CmdArgs.push_back("-fdata-sections");
   }
 
   Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
 
   if (Args.hasArg(options::OPT_fprofile_instr_generate) &&
       (Args.hasArg(options::OPT_fprofile_instr_use) ||
        Args.hasArg(options::OPT_fprofile_instr_use_EQ)))
     D.Diag(diag::err_drv_argument_not_allowed_with)
       << "-fprofile-instr-generate" << "-fprofile-instr-use";
 
   Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
 
   if (Arg *A = Args.getLastArg(options::OPT_fprofile_instr_use_EQ))
     A->render(Args, CmdArgs);
   else if (Args.hasArg(options::OPT_fprofile_instr_use))
     CmdArgs.push_back("-fprofile-instr-use=pgo-data");
 
   if (Args.hasArg(options::OPT_ftest_coverage) ||
       Args.hasArg(options::OPT_coverage))
     CmdArgs.push_back("-femit-coverage-notes");
   if (Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
                    false) ||
       Args.hasArg(options::OPT_coverage))
     CmdArgs.push_back("-femit-coverage-data");
 
   if (Args.hasArg(options::OPT_fcoverage_mapping) &&
       !Args.hasArg(options::OPT_fprofile_instr_generate))
     D.Diag(diag::err_drv_argument_only_allowed_with)
       << "-fcoverage-mapping" << "-fprofile-instr-generate";
 
   if (Args.hasArg(options::OPT_fcoverage_mapping))
     CmdArgs.push_back("-fcoverage-mapping");
 
   if (C.getArgs().hasArg(options::OPT_c) ||
       C.getArgs().hasArg(options::OPT_S)) {
     if (Output.isFilename()) {
       CmdArgs.push_back("-coverage-file");
       SmallString<128> CoverageFilename;
       if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) {
         CoverageFilename = FinalOutput->getValue();
       } else {
         CoverageFilename = llvm::sys::path::filename(Output.getBaseInput());
       }
       if (llvm::sys::path::is_relative(CoverageFilename.str())) {
         SmallString<128> Pwd;
         if (!llvm::sys::fs::current_path(Pwd)) {
           llvm::sys::path::append(Pwd, CoverageFilename.str());
           CoverageFilename.swap(Pwd);
         }
       }
       CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
     }
   }
 
   // Pass options for controlling the default header search paths.
   if (Args.hasArg(options::OPT_nostdinc)) {
     CmdArgs.push_back("-nostdsysteminc");
     CmdArgs.push_back("-nobuiltininc");
   } else {
     if (Args.hasArg(options::OPT_nostdlibinc))
         CmdArgs.push_back("-nostdsysteminc");
     Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
     Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
   }
 
   // Pass the path to compiler resource files.
   CmdArgs.push_back("-resource-dir");
   CmdArgs.push_back(D.ResourceDir.c_str());
 
   Args.AddLastArg(CmdArgs, options::OPT_working_directory);
 
   bool ARCMTEnabled = false;
   if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
     if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
                                        options::OPT_ccc_arcmt_modify,
                                        options::OPT_ccc_arcmt_migrate)) {
       ARCMTEnabled = true;
       switch (A->getOption().getID()) {
       default:
         llvm_unreachable("missed a case");
       case options::OPT_ccc_arcmt_check:
         CmdArgs.push_back("-arcmt-check");
         break;
       case options::OPT_ccc_arcmt_modify:
         CmdArgs.push_back("-arcmt-modify");
         break;
       case options::OPT_ccc_arcmt_migrate:
         CmdArgs.push_back("-arcmt-migrate");
         CmdArgs.push_back("-mt-migrate-directory");
         CmdArgs.push_back(A->getValue());
 
         Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
         Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
         break;
       }
     }
   } else {
     Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
     Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
     Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
   }
 
   if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
     if (ARCMTEnabled) {
       D.Diag(diag::err_drv_argument_not_allowed_with)
         << A->getAsString(Args) << "-ccc-arcmt-migrate";
     }
     CmdArgs.push_back("-mt-migrate-directory");
     CmdArgs.push_back(A->getValue());
 
     if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
                      options::OPT_objcmt_migrate_subscripting,
                      options::OPT_objcmt_migrate_property)) {
       // None specified, means enable them all.
       CmdArgs.push_back("-objcmt-migrate-literals");
       CmdArgs.push_back("-objcmt-migrate-subscripting");
       CmdArgs.push_back("-objcmt-migrate-property");
     } else {
       Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
       Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
       Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
     }
   } else {
     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
     Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
     Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
     Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
     Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
   }
 
   // Add preprocessing options like -I, -D, etc. if we are using the
   // preprocessor.
   //
   // FIXME: Support -fpreprocessed
   if (types::getPreprocessedType(InputType) != types::TY_INVALID)
     AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
 
   // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
   // that "The compiler can only warn and ignore the option if not recognized".
   // When building with ccache, it will pass -D options to clang even on
   // preprocessed inputs and configure concludes that -fPIC is not supported.
   Args.ClaimAllArgs(options::OPT_D);
 
   // Manually translate -O4 to -O3; let clang reject others.
   if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
     if (A->getOption().matches(options::OPT_O4)) {
       CmdArgs.push_back("-O3");
       D.Diag(diag::warn_O4_is_O3);
     } else {
       A->render(Args, CmdArgs);
     }
   }
 
   // Warn about ignored options to clang.
   for (arg_iterator it = Args.filtered_begin(
        options::OPT_clang_ignored_gcc_optimization_f_Group),
        ie = Args.filtered_end(); it != ie; ++it) {
     D.Diag(diag::warn_ignored_gcc_optimization) << (*it)->getAsString(Args);
   }
 
   claimNoWarnArgs(Args);
 
   Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
   Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
   if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
     CmdArgs.push_back("-pedantic");
   Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
   Args.AddLastArg(CmdArgs, options::OPT_w);
 
   // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
   // (-ansi is equivalent to -std=c89 or -std=c++98).
   //
   // If a std is supplied, only add -trigraphs if it follows the
   // option.
   if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
     if (Std->getOption().matches(options::OPT_ansi))
       if (types::isCXX(InputType))
         CmdArgs.push_back("-std=c++98");
       else
         CmdArgs.push_back("-std=c89");
     else
       Std->render(Args, CmdArgs);
 
     // If -f(no-)trigraphs appears after the language standard flag, honor it.
     if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
                                  options::OPT_ftrigraphs,
                                  options::OPT_fno_trigraphs))
       if (A != Std)
         A->render(Args, CmdArgs);
   } else {
     // Honor -std-default.
     //
     // FIXME: Clang doesn't correctly handle -std= when the input language
     // doesn't match. For the time being just ignore this for C++ inputs;
     // eventually we want to do all the standard defaulting here instead of
     // splitting it between the driver and clang -cc1.
     if (!types::isCXX(InputType))
       Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
                                 "-std=", /*Joined=*/true);
     else if (IsWindowsMSVC)
       CmdArgs.push_back("-std=c++11");
 
     Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
                     options::OPT_fno_trigraphs);
   }
 
   // GCC's behavior for -Wwrite-strings is a bit strange:
   //  * In C, this "warning flag" changes the types of string literals from
   //    'char[N]' to 'const char[N]', and thus triggers an unrelated warning
   //    for the discarded qualifier.
   //  * In C++, this is just a normal warning flag.
   //
   // Implementing this warning correctly in C is hard, so we follow GCC's
   // behavior for now. FIXME: Directly diagnose uses of a string literal as
   // a non-const char* in C, rather than using this crude hack.
   if (!types::isCXX(InputType)) {
     // FIXME: This should behave just like a warning flag, and thus should also
     // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
     Arg *WriteStrings =
         Args.getLastArg(options::OPT_Wwrite_strings,
                         options::OPT_Wno_write_strings, options::OPT_w);
     if (WriteStrings &&
         WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
       CmdArgs.push_back("-fconst-strings");
   }
 
   // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
   // during C++ compilation, which it is by default. GCC keeps this define even
   // in the presence of '-w', match this behavior bug-for-bug.
   if (types::isCXX(InputType) &&
       Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
                    true)) {
     CmdArgs.push_back("-fdeprecated-macro");
   }
 
   // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
   if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
     if (Asm->getOption().matches(options::OPT_fasm))
       CmdArgs.push_back("-fgnu-keywords");
     else
       CmdArgs.push_back("-fno-gnu-keywords");
   }
 
   if (ShouldDisableDwarfDirectory(Args, getToolChain()))
     CmdArgs.push_back("-fno-dwarf-directory-asm");
 
   if (ShouldDisableAutolink(Args, getToolChain()))
     CmdArgs.push_back("-fno-autolink");
 
   // Add in -fdebug-compilation-dir if necessary.
   addDebugCompDirArg(Args, CmdArgs);
 
   if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
                                options::OPT_ftemplate_depth_EQ)) {
     CmdArgs.push_back("-ftemplate-depth");
     CmdArgs.push_back(A->getValue());
   }
 
   if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
     CmdArgs.push_back("-foperator-arrow-depth");
     CmdArgs.push_back(A->getValue());
   }
 
   if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
     CmdArgs.push_back("-fconstexpr-depth");
     CmdArgs.push_back(A->getValue());
   }
 
   if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
     CmdArgs.push_back("-fconstexpr-steps");
     CmdArgs.push_back(A->getValue());
   }
 
   if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
     CmdArgs.push_back("-fbracket-depth");
     CmdArgs.push_back(A->getValue());
   }
 
   if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
                                options::OPT_Wlarge_by_value_copy_def)) {
     if (A->getNumValues()) {
       StringRef bytes = A->getValue();
       CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
     } else
       CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
   }
 
 
   if (Args.hasArg(options::OPT_relocatable_pch))
     CmdArgs.push_back("-relocatable-pch");
 
   if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
     CmdArgs.push_back("-fconstant-string-class");
     CmdArgs.push_back(A->getValue());
   }
 
   if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
     CmdArgs.push_back("-ftabstop");
     CmdArgs.push_back(A->getValue());
   }
 
   CmdArgs.push_back("-ferror-limit");
   if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
     CmdArgs.push_back(A->getValue());
   else
     CmdArgs.push_back("19");
 
   if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
     CmdArgs.push_back("-fmacro-backtrace-limit");
     CmdArgs.push_back(A->getValue());
   }
 
   if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
     CmdArgs.push_back("-ftemplate-backtrace-limit");
     CmdArgs.push_back(A->getValue());
   }
 
   if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
     CmdArgs.push_back("-fconstexpr-backtrace-limit");
     CmdArgs.push_back(A->getValue());
   }
 
   if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) {
     CmdArgs.push_back("-fspell-checking-limit");
     CmdArgs.push_back(A->getValue());
   }
 
   // Pass -fmessage-length=.
   CmdArgs.push_back("-fmessage-length");
   if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
     CmdArgs.push_back(A->getValue());
   } else {
     // If -fmessage-length=N was not specified, determine whether this is a
     // terminal and, if so, implicitly define -fmessage-length appropriately.
     unsigned N = llvm::sys::Process::StandardErrColumns();
     CmdArgs.push_back(Args.MakeArgString(Twine(N)));
   }
 
   // -fvisibility= and -fvisibility-ms-compat are of a piece.
   if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
                                      options::OPT_fvisibility_ms_compat)) {
     if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
       CmdArgs.push_back("-fvisibility");
       CmdArgs.push_back(A->getValue());
     } else {
       assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
       CmdArgs.push_back("-fvisibility");
       CmdArgs.push_back("hidden");
       CmdArgs.push_back("-ftype-visibility");
       CmdArgs.push_back("default");
     }
   }
 
   Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
 
   Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
 
   // -fhosted is default.
   if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
       KernelOrKext)
     CmdArgs.push_back("-ffreestanding");
 
   // Forward -f (flag) options which we can pass directly.
   Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
   Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
   Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
   Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
   Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
   // AltiVec language extensions aren't relevant for assembling.
   if (!isa<PreprocessJobAction>(JA) || 
       Output.getType() != types::TY_PP_Asm)
     Args.AddLastArg(CmdArgs, options::OPT_faltivec);
   Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
   Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
 
   const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
   Sanitize.addArgs(Args, CmdArgs);
 
   // Report an error for -faltivec on anything other than PowerPC.
   if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
     if (!(getToolChain().getArch() == llvm::Triple::ppc ||
           getToolChain().getArch() == llvm::Triple::ppc64 ||
           getToolChain().getArch() == llvm::Triple::ppc64le))
       D.Diag(diag::err_drv_argument_only_allowed_with)
         << A->getAsString(Args) << "ppc/ppc64/ppc64le";
 
   if (getToolChain().SupportsProfiling())
     Args.AddLastArg(CmdArgs, options::OPT_pg);
 
   // -flax-vector-conversions is default.
   if (!Args.hasFlag(options::OPT_flax_vector_conversions,
                     options::OPT_fno_lax_vector_conversions))
     CmdArgs.push_back("-fno-lax-vector-conversions");
 
   if (Args.getLastArg(options::OPT_fapple_kext))
     CmdArgs.push_back("-fapple-kext");
 
   Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
   Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
   Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
   Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
   Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
 
   if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
     CmdArgs.push_back("-ftrapv-handler");
     CmdArgs.push_back(A->getValue());
   }
 
   Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
 
   // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
   // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
   if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
                                options::OPT_fno_wrapv)) {
     if (A->getOption().matches(options::OPT_fwrapv))
       CmdArgs.push_back("-fwrapv");
   } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
                                       options::OPT_fno_strict_overflow)) {
     if (A->getOption().matches(options::OPT_fno_strict_overflow))
       CmdArgs.push_back("-fwrapv");
   }
 
   if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
                                options::OPT_fno_reroll_loops))
     if (A->getOption().matches(options::OPT_freroll_loops))
       CmdArgs.push_back("-freroll-loops");
 
   Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
   Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
                   options::OPT_fno_unroll_loops);
 
   Args.AddLastArg(CmdArgs, options::OPT_pthread);
 
 
   // -stack-protector=0 is default.
   unsigned StackProtectorLevel = 0;
   if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
                                options::OPT_fstack_protector_all,
                                options::OPT_fstack_protector_strong,
                                options::OPT_fstack_protector)) {
     if (A->getOption().matches(options::OPT_fstack_protector)) {
       StackProtectorLevel = std::max<unsigned>(LangOptions::SSPOn,
         getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
     } else if (A->getOption().matches(options::OPT_fstack_protector_strong))
       StackProtectorLevel = LangOptions::SSPStrong;
     else if (A->getOption().matches(options::OPT_fstack_protector_all))
       StackProtectorLevel = LangOptions::SSPReq;
   } else {
     StackProtectorLevel =
       getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
   }
   if (StackProtectorLevel) {
     CmdArgs.push_back("-stack-protector");
     CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
   }
 
   // --param ssp-buffer-size=
   for (arg_iterator it = Args.filtered_begin(options::OPT__param),
        ie = Args.filtered_end(); it != ie; ++it) {
     StringRef Str((*it)->getValue());
     if (Str.startswith("ssp-buffer-size=")) {
       if (StackProtectorLevel) {
         CmdArgs.push_back("-stack-protector-buffer-size");
         // FIXME: Verify the argument is a valid integer.
         CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
       }
       (*it)->claim();
     }
   }
 
   // Translate -mstackrealign
   if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
                    false)) {
     CmdArgs.push_back("-backend-option");
     CmdArgs.push_back("-force-align-stack");
   }
   if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
                    false)) {
     CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
   }
 
   if (Args.hasArg(options::OPT_mstack_alignment)) {
     StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
     CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
   }
 
   if (getToolChain().getTriple().getArch() == llvm::Triple::aarch64 ||
       getToolChain().getTriple().getArch() == llvm::Triple::aarch64_be)
     CmdArgs.push_back("-fallow-half-arguments-and-returns");
 
   if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
                                options::OPT_mno_restrict_it)) {
     if (A->getOption().matches(options::OPT_mrestrict_it)) {
       CmdArgs.push_back("-backend-option");
       CmdArgs.push_back("-arm-restrict-it");
     } else {
       CmdArgs.push_back("-backend-option");
       CmdArgs.push_back("-arm-no-restrict-it");
     }
   } else if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
                                   TT.getArch() == llvm::Triple::thumb)) {
     // Windows on ARM expects restricted IT blocks
     CmdArgs.push_back("-backend-option");
     CmdArgs.push_back("-arm-restrict-it");
   }
 
   if (TT.getArch() == llvm::Triple::arm ||
       TT.getArch() == llvm::Triple::thumb) {
     if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
                                  options::OPT_mno_long_calls)) {
       if (A->getOption().matches(options::OPT_mlong_calls)) {
         CmdArgs.push_back("-backend-option");
         CmdArgs.push_back("-arm-long-calls");
       }
     }
   }
 
   // Forward -f options with positive and negative forms; we translate
   // these by hand.
   if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
     StringRef fname = A->getValue();
     if (!llvm::sys::fs::exists(fname))
       D.Diag(diag::err_drv_no_such_file) << fname;
     else
       A->render(Args, CmdArgs);
   }
 
   if (Args.hasArg(options::OPT_mkernel)) {
     if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
       CmdArgs.push_back("-fapple-kext");
     if (!Args.hasArg(options::OPT_fbuiltin))
       CmdArgs.push_back("-fno-builtin");
     Args.ClaimAllArgs(options::OPT_fno_builtin);
   }
   // -fbuiltin is default.
   else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
     CmdArgs.push_back("-fno-builtin");
 
   if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
                     options::OPT_fno_assume_sane_operator_new))
     CmdArgs.push_back("-fno-assume-sane-operator-new");
 
   // -fblocks=0 is default.
   if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
                    getToolChain().IsBlocksDefault()) ||
         (Args.hasArg(options::OPT_fgnu_runtime) &&
          Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
          !Args.hasArg(options::OPT_fno_blocks))) {
     CmdArgs.push_back("-fblocks");
 
     if (!Args.hasArg(options::OPT_fgnu_runtime) && 
         !getToolChain().hasBlocksRuntime())
       CmdArgs.push_back("-fblocks-runtime-optional");
   }
 
   // -fmodules enables modules (off by default).
   // Users can pass -fno-cxx-modules to turn off modules support for
   // C++/Objective-C++ programs, which is a little less mature.
   bool HaveModules = false;
   if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
     bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules, 
                                      options::OPT_fno_cxx_modules, 
                                      true);
     if (AllowedInCXX || !types::isCXX(InputType)) {
       CmdArgs.push_back("-fmodules");
       HaveModules = true;
     }
   }
 
   // -fmodule-maps enables module map processing (off by default) for header
   // checking.  It is implied by -fmodules.
   if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
                    false)) {
     CmdArgs.push_back("-fmodule-maps");
   }
 
   // -fmodules-decluse checks that modules used are declared so (off by
   // default).
   if (Args.hasFlag(options::OPT_fmodules_decluse,
                    options::OPT_fno_modules_decluse,
                    false)) {
     CmdArgs.push_back("-fmodules-decluse");
   }
 
   // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that
   // all #included headers are part of modules.
   if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
                    options::OPT_fno_modules_strict_decluse,
                    false)) {
     CmdArgs.push_back("-fmodules-strict-decluse");
   }
 
   // -fmodule-name specifies the module that is currently being built (or
   // used for header checking by -fmodule-maps).
   Args.AddLastArg(CmdArgs, options::OPT_fmodule_name);
 
   // -fmodule-map-file can be used to specify files containing module
   // definitions.
   Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
 
   // -fmodule-file can be used to specify files containing precompiled modules.
   Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
 
   // -fmodule-cache-path specifies where our implicitly-built module files
   // should be written.
   SmallString<128> ModuleCachePath;
   if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
     ModuleCachePath = A->getValue();
   if (HaveModules) {
     if (C.isForDiagnostics()) {
       // When generating crash reports, we want to emit the modules along with
       // the reproduction sources, so we ignore any provided module path.
       ModuleCachePath = Output.getFilename();
       llvm::sys::path::replace_extension(ModuleCachePath, ".cache");
       llvm::sys::path::append(ModuleCachePath, "modules");
     } else if (ModuleCachePath.empty()) {
       // No module path was provided: use the default.
       llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
                                              ModuleCachePath);
       llvm::sys::path::append(ModuleCachePath, "org.llvm.clang");
       llvm::sys::path::append(ModuleCachePath, "ModuleCache");
     }
     const char Arg[] = "-fmodules-cache-path=";
     ModuleCachePath.insert(ModuleCachePath.begin(), Arg, Arg + strlen(Arg));
     CmdArgs.push_back(Args.MakeArgString(ModuleCachePath));
   }
 
   // When building modules and generating crashdumps, we need to dump a module
   // dependency VFS alongside the output.
   if (HaveModules && C.isForDiagnostics()) {
     SmallString<128> VFSDir(Output.getFilename());
     llvm::sys::path::replace_extension(VFSDir, ".cache");
     // Add the cache directory as a temp so the crash diagnostics pick it up.
     C.addTempFile(Args.MakeArgString(VFSDir));
 
     llvm::sys::path::append(VFSDir, "vfs");
     CmdArgs.push_back("-module-dependency-dir");
     CmdArgs.push_back(Args.MakeArgString(VFSDir));
   }
 
   if (HaveModules)
     Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
 
   // Pass through all -fmodules-ignore-macro arguments.
   Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
   Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
   Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
 
   Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
 
   if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
     if (Args.hasArg(options::OPT_fbuild_session_timestamp))
       D.Diag(diag::err_drv_argument_not_allowed_with)
           << A->getAsString(Args) << "-fbuild-session-timestamp";
 
     llvm::sys::fs::file_status Status;
     if (llvm::sys::fs::status(A->getValue(), Status))
       D.Diag(diag::err_drv_no_such_file) << A->getValue();
     char TimeStamp[48];
     snprintf(TimeStamp, sizeof(TimeStamp), "-fbuild-session-timestamp=%" PRIu64,
              (uint64_t)Status.getLastModificationTime().toEpochTime());
     CmdArgs.push_back(Args.MakeArgString(TimeStamp));
   }
 
   if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
     if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
                          options::OPT_fbuild_session_file))
       D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
 
     Args.AddLastArg(CmdArgs,
                     options::OPT_fmodules_validate_once_per_build_session);
   }
 
   Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
 
   // -faccess-control is default.
   if (Args.hasFlag(options::OPT_fno_access_control,
                    options::OPT_faccess_control,
                    false))
     CmdArgs.push_back("-fno-access-control");
 
   // -felide-constructors is the default.
   if (Args.hasFlag(options::OPT_fno_elide_constructors,
                    options::OPT_felide_constructors,
                    false))
     CmdArgs.push_back("-fno-elide-constructors");
 
   // -frtti is default.
   if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
       KernelOrKext) {
     CmdArgs.push_back("-fno-rtti");
 
     // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
     if (Sanitize.sanitizesVptr()) {
       std::string NoRttiArg =
         Args.getLastArg(options::OPT_mkernel,
                         options::OPT_fapple_kext,
                         options::OPT_fno_rtti)->getAsString(Args);
       D.Diag(diag::err_drv_argument_not_allowed_with)
         << "-fsanitize=vptr" << NoRttiArg;
     }
   }
 
   // -fshort-enums=0 is default for all architectures except Hexagon.
   if (Args.hasFlag(options::OPT_fshort_enums,
                    options::OPT_fno_short_enums,
                    getToolChain().getArch() ==
                    llvm::Triple::hexagon))
     CmdArgs.push_back("-fshort-enums");
 
   // -fsigned-char is default.
   if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
                     isSignedCharDefault(getToolChain().getTriple())))
     CmdArgs.push_back("-fno-signed-char");
 
   // -fthreadsafe-static is default.
   if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
                     options::OPT_fno_threadsafe_statics))
     CmdArgs.push_back("-fno-threadsafe-statics");
 
   // -fuse-cxa-atexit is default.
   if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
                     options::OPT_fno_use_cxa_atexit,
                     !IsWindowsCygnus && !IsWindowsGNU &&
                     getToolChain().getArch() != llvm::Triple::hexagon &&
                     getToolChain().getArch() != llvm::Triple::xcore) ||
       KernelOrKext)
     CmdArgs.push_back("-fno-use-cxa-atexit");
 
   // -fms-extensions=0 is default.
   if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
                    IsWindowsMSVC))
     CmdArgs.push_back("-fms-extensions");
 
   // -fms-compatibility=0 is default.
   if (Args.hasFlag(options::OPT_fms_compatibility, 
                    options::OPT_fno_ms_compatibility,
                    (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
                                                   options::OPT_fno_ms_extensions,
                                                   true))))
     CmdArgs.push_back("-fms-compatibility");
 
   // -fms-compatibility-version=17.00 is default.
   if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
                    IsWindowsMSVC) || Args.hasArg(options::OPT_fmsc_version) ||
       Args.hasArg(options::OPT_fms_compatibility_version)) {
     const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);
     const Arg *MSCompatibilityVersion =
       Args.getLastArg(options::OPT_fms_compatibility_version);
 
     if (MSCVersion && MSCompatibilityVersion)
       D.Diag(diag::err_drv_argument_not_allowed_with)
           << MSCVersion->getAsString(Args)
           << MSCompatibilityVersion->getAsString(Args);
 
     std::string Ver;
     if (MSCompatibilityVersion)
       Ver = Args.getLastArgValue(options::OPT_fms_compatibility_version);
     else if (MSCVersion)
       Ver = getMSCompatibilityVersion(MSCVersion->getValue());
 
     if (Ver.empty())
       CmdArgs.push_back("-fms-compatibility-version=17.00");
     else
       CmdArgs.push_back(Args.MakeArgString("-fms-compatibility-version=" + Ver));
   }
 
   // -fno-borland-extensions is default.
   if (Args.hasFlag(options::OPT_fborland_extensions,
                    options::OPT_fno_borland_extensions, false))
     CmdArgs.push_back("-fborland-extensions");
 
   // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
   // needs it.
   if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
                    options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
     CmdArgs.push_back("-fdelayed-template-parsing");
 
   // -fgnu-keywords default varies depending on language; only pass if
   // specified.
   if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
                                options::OPT_fno_gnu_keywords))
     A->render(Args, CmdArgs);
 
   if (Args.hasFlag(options::OPT_fgnu89_inline,
                    options::OPT_fno_gnu89_inline,
                    false))
     CmdArgs.push_back("-fgnu89-inline");
 
   if (Args.hasArg(options::OPT_fno_inline))
     CmdArgs.push_back("-fno-inline");
 
   if (Args.hasArg(options::OPT_fno_inline_functions))
     CmdArgs.push_back("-fno-inline-functions");
 
   ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
 
   // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
   // legacy is the default. Except for deployment taget of 10.5,
   // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
   // gets ignored silently.
   if (objcRuntime.isNonFragile()) {
     if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
                       options::OPT_fno_objc_legacy_dispatch,
                       objcRuntime.isLegacyDispatchDefaultForArch(
                         getToolChain().getArch()))) {
       if (getToolChain().UseObjCMixedDispatch())
         CmdArgs.push_back("-fobjc-dispatch-method=mixed");
       else
         CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
     }
   }
 
   // When ObjectiveC legacy runtime is in effect on MacOSX,
   // turn on the option to do Array/Dictionary subscripting
   // by default.
   if (getToolChain().getTriple().getArch() == llvm::Triple::x86 &&
       getToolChain().getTriple().isMacOSX() &&
       !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
       objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
       objcRuntime.isNeXTFamily())
     CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
   
   // -fencode-extended-block-signature=1 is default.
   if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
     CmdArgs.push_back("-fencode-extended-block-signature");
   }
   
   // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
   // NOTE: This logic is duplicated in ToolChains.cpp.
   bool ARC = isObjCAutoRefCount(Args);
   if (ARC) {
     getToolChain().CheckObjCARC();
 
     CmdArgs.push_back("-fobjc-arc");
 
     // FIXME: It seems like this entire block, and several around it should be
     // wrapped in isObjC, but for now we just use it here as this is where it
     // was being used previously.
     if (types::isCXX(InputType) && types::isObjC(InputType)) {
       if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
         CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
       else
         CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
     }
 
     // Allow the user to enable full exceptions code emission.
     // We define off for Objective-CC, on for Objective-C++.
     if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
                      options::OPT_fno_objc_arc_exceptions,
                      /*default*/ types::isCXX(InputType)))
       CmdArgs.push_back("-fobjc-arc-exceptions");
   }
 
   // -fobjc-infer-related-result-type is the default, except in the Objective-C
   // rewriter.
   if (rewriteKind != RK_None)
     CmdArgs.push_back("-fno-objc-infer-related-result-type");
 
   // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
   // takes precedence.
   const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
   if (!GCArg)
     GCArg = Args.getLastArg(options::OPT_fobjc_gc);
   if (GCArg) {
     if (ARC) {
       D.Diag(diag::err_drv_objc_gc_arr)
         << GCArg->getAsString(Args);
     } else if (getToolChain().SupportsObjCGC()) {
       GCArg->render(Args, CmdArgs);
     } else {
       // FIXME: We should move this to a hard error.
       D.Diag(diag::warn_drv_objc_gc_unsupported)
         << GCArg->getAsString(Args);
     }
   }
 
   // Handle GCC-style exception args.
   if (!C.getDriver().IsCLMode())
     addExceptionArgs(Args, InputType, getToolChain().getTriple(), KernelOrKext,
                      objcRuntime, CmdArgs);
 
   if (getToolChain().UseSjLjExceptions())
     CmdArgs.push_back("-fsjlj-exceptions");
 
   // C++ "sane" operator new.
   if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
                     options::OPT_fno_assume_sane_operator_new))
     CmdArgs.push_back("-fno-assume-sane-operator-new");
 
   // -fconstant-cfstrings is default, and may be subject to argument translation
   // on Darwin.
   if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
                     options::OPT_fno_constant_cfstrings) ||
       !Args.hasFlag(options::OPT_mconstant_cfstrings,
                     options::OPT_mno_constant_cfstrings))
     CmdArgs.push_back("-fno-constant-cfstrings");
 
   // -fshort-wchar default varies depending on platform; only
   // pass if specified.
   if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
                                options::OPT_fno_short_wchar))
     A->render(Args, CmdArgs);
 
   // -fno-pascal-strings is default, only pass non-default.
   if (Args.hasFlag(options::OPT_fpascal_strings,
                    options::OPT_fno_pascal_strings,
                    false))
     CmdArgs.push_back("-fpascal-strings");
 
   // Honor -fpack-struct= and -fpack-struct, if given. Note that
   // -fno-pack-struct doesn't apply to -fpack-struct=.
   if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
     std::string PackStructStr = "-fpack-struct=";
     PackStructStr += A->getValue();
     CmdArgs.push_back(Args.MakeArgString(PackStructStr));
   } else if (Args.hasFlag(options::OPT_fpack_struct,
                           options::OPT_fno_pack_struct, false)) {
     CmdArgs.push_back("-fpack-struct=1");
   }
 
   // Handle -fmax-type-align=N and -fno-type-align
   bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
   if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
     if (!SkipMaxTypeAlign) {
       std::string MaxTypeAlignStr = "-fmax-type-align=";
       MaxTypeAlignStr += A->getValue();
       CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
     }
   } else if (getToolChain().getTriple().isOSDarwin()) {
     if (!SkipMaxTypeAlign) {
       std::string MaxTypeAlignStr = "-fmax-type-align=16";
       CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
     }
   }
 
   if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
     if (!Args.hasArg(options::OPT_fcommon))
       CmdArgs.push_back("-fno-common");
     Args.ClaimAllArgs(options::OPT_fno_common);
   }
 
   // -fcommon is default, only pass non-default.
   else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
     CmdArgs.push_back("-fno-common");
 
   // -fsigned-bitfields is default, and clang doesn't yet support
   // -funsigned-bitfields.
   if (!Args.hasFlag(options::OPT_fsigned_bitfields,
                     options::OPT_funsigned_bitfields))
     D.Diag(diag::warn_drv_clang_unsupported)
       << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
 
   // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
   if (!Args.hasFlag(options::OPT_ffor_scope,
                     options::OPT_fno_for_scope))
     D.Diag(diag::err_drv_clang_unsupported)
       << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
 
   // -finput_charset=UTF-8 is default. Reject others
   if (Arg *inputCharset = Args.getLastArg(
           options::OPT_finput_charset_EQ)) {
       StringRef value = inputCharset->getValue();
       if (value != "UTF-8")
           D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args) << value;
   }
 
   // -fexec_charset=UTF-8 is default. Reject others
   if (Arg *execCharset = Args.getLastArg(
           options::OPT_fexec_charset_EQ)) {
       StringRef value = execCharset->getValue();
       if (value != "UTF-8")
           D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args) << value;
   }
 
   // -fcaret-diagnostics is default.
   if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
                     options::OPT_fno_caret_diagnostics, true))
     CmdArgs.push_back("-fno-caret-diagnostics");
 
   // -fdiagnostics-fixit-info is default, only pass non-default.
   if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
                     options::OPT_fno_diagnostics_fixit_info))
     CmdArgs.push_back("-fno-diagnostics-fixit-info");
 
   // Enable -fdiagnostics-show-option by default.
   if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
                    options::OPT_fno_diagnostics_show_option))
     CmdArgs.push_back("-fdiagnostics-show-option");
 
   if (const Arg *A =
         Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
     CmdArgs.push_back("-fdiagnostics-show-category");
     CmdArgs.push_back(A->getValue());
   }
 
   if (const Arg *A =
         Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
     CmdArgs.push_back("-fdiagnostics-format");
     CmdArgs.push_back(A->getValue());
   }
 
   if (Arg *A = Args.getLastArg(
       options::OPT_fdiagnostics_show_note_include_stack,
       options::OPT_fno_diagnostics_show_note_include_stack)) {
     if (A->getOption().matches(
         options::OPT_fdiagnostics_show_note_include_stack))
       CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
     else
       CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
   }
 
   // Color diagnostics are the default, unless the terminal doesn't support
   // them.
   // Support both clang's -f[no-]color-diagnostics and gcc's
   // -f[no-]diagnostics-colors[=never|always|auto].
   enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
   for (const auto &Arg : Args) {
     const Option &O = Arg->getOption();
     if (!O.matches(options::OPT_fcolor_diagnostics) &&
         !O.matches(options::OPT_fdiagnostics_color) &&
         !O.matches(options::OPT_fno_color_diagnostics) &&
         !O.matches(options::OPT_fno_diagnostics_color) &&
         !O.matches(options::OPT_fdiagnostics_color_EQ))
       continue;
 
     Arg->claim();
     if (O.matches(options::OPT_fcolor_diagnostics) ||
         O.matches(options::OPT_fdiagnostics_color)) {
       ShowColors = Colors_On;
     } else if (O.matches(options::OPT_fno_color_diagnostics) ||
                O.matches(options::OPT_fno_diagnostics_color)) {
       ShowColors = Colors_Off;
     } else {
       assert(O.matches(options::OPT_fdiagnostics_color_EQ));
       StringRef value(Arg->getValue());
       if (value == "always")
         ShowColors = Colors_On;
       else if (value == "never")
         ShowColors = Colors_Off;
       else if (value == "auto")
         ShowColors = Colors_Auto;
       else
         getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
           << ("-fdiagnostics-color=" + value).str();
     }
   }
   if (ShowColors == Colors_On ||
       (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
     CmdArgs.push_back("-fcolor-diagnostics");
 
   if (Args.hasArg(options::OPT_fansi_escape_codes))
     CmdArgs.push_back("-fansi-escape-codes");
 
   if (!Args.hasFlag(options::OPT_fshow_source_location,
                     options::OPT_fno_show_source_location))
     CmdArgs.push_back("-fno-show-source-location");
 
   if (!Args.hasFlag(options::OPT_fshow_column,
                     options::OPT_fno_show_column,
                     true))
     CmdArgs.push_back("-fno-show-column");
 
   if (!Args.hasFlag(options::OPT_fspell_checking,
                     options::OPT_fno_spell_checking))
     CmdArgs.push_back("-fno-spell-checking");
 
 
   // -fno-asm-blocks is default.
   if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
                    false))
     CmdArgs.push_back("-fasm-blocks");
 
   // Enable vectorization per default according to the optimization level
   // selected. For optimization levels that want vectorization we use the alias
   // option to simplify the hasFlag logic.
   bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
   OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
     options::OPT_fvectorize;
   if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
                    options::OPT_fno_vectorize, EnableVec))
     CmdArgs.push_back("-vectorize-loops");
 
   // -fslp-vectorize is enabled based on the optimization level selected.
   bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
   OptSpecifier SLPVectAliasOption = EnableSLPVec ? options::OPT_O_Group :
     options::OPT_fslp_vectorize;
   if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
                    options::OPT_fno_slp_vectorize, EnableSLPVec))
     CmdArgs.push_back("-vectorize-slp");
 
   // -fno-slp-vectorize-aggressive is default.
   if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
                    options::OPT_fno_slp_vectorize_aggressive, false))
     CmdArgs.push_back("-vectorize-slp-aggressive");
 
   if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
     A->render(Args, CmdArgs);
 
   // -fdollars-in-identifiers default varies depending on platform and
   // language; only pass if specified.
   if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
                                options::OPT_fno_dollars_in_identifiers)) {
     if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
       CmdArgs.push_back("-fdollars-in-identifiers");
     else
       CmdArgs.push_back("-fno-dollars-in-identifiers");
   }
 
   // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
   // practical purposes.
   if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
                                options::OPT_fno_unit_at_a_time)) {
     if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
       D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
   }
 
   if (Args.hasFlag(options::OPT_fapple_pragma_pack,
                    options::OPT_fno_apple_pragma_pack, false))
     CmdArgs.push_back("-fapple-pragma-pack");
 
   // le32-specific flags: 
   //  -fno-math-builtin: clang should not convert math builtins to intrinsics
   //                     by default.
   if (getToolChain().getArch() == llvm::Triple::le32) {
     CmdArgs.push_back("-fno-math-builtin");
   }
 
   // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
   //
   // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
 #if 0
   if (getToolChain().getTriple().isOSDarwin() &&
       (getToolChain().getArch() == llvm::Triple::arm ||
        getToolChain().getArch() == llvm::Triple::thumb)) {
     if (!Args.hasArg(options::OPT_fbuiltin_strcat))
       CmdArgs.push_back("-fno-builtin-strcat");
     if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
       CmdArgs.push_back("-fno-builtin-strcpy");
   }
 #endif
 
   // Enable rewrite includes if the user's asked for it or if we're generating
   // diagnostics.
   // TODO: Once -module-dependency-dir works with -frewrite-includes it'd be
   // nice to enable this when doing a crashdump for modules as well.
   if (Args.hasFlag(options::OPT_frewrite_includes,
                    options::OPT_fno_rewrite_includes, false) ||
       (C.isForDiagnostics() && !HaveModules))
     CmdArgs.push_back("-frewrite-includes");
 
   // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
   if (Arg *A = Args.getLastArg(options::OPT_traditional,
                                options::OPT_traditional_cpp)) {
     if (isa<PreprocessJobAction>(JA))
       CmdArgs.push_back("-traditional-cpp");
     else
       D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
   }
 
   Args.AddLastArg(CmdArgs, options::OPT_dM);
   Args.AddLastArg(CmdArgs, options::OPT_dD);
   
   // Handle serialized diagnostics.
   if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
     CmdArgs.push_back("-serialize-diagnostic-file");
     CmdArgs.push_back(Args.MakeArgString(A->getValue()));
   }
 
   if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
     CmdArgs.push_back("-fretain-comments-from-system-headers");
 
   // Forward -fcomment-block-commands to -cc1.
   Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
   // Forward -fparse-all-comments to -cc1.
   Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
 
   // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
   // parser.
   Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
   bool OptDisabled = false;
   for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
          ie = Args.filtered_end(); it != ie; ++it) {
     (*it)->claim();
 
     // We translate this by hand to the -cc1 argument, since nightly test uses
     // it and developers have been trained to spell it with -mllvm.
     if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns") {
       CmdArgs.push_back("-disable-llvm-optzns");
       OptDisabled = true;
     } else
       (*it)->render(Args, CmdArgs);
   }
 
   // With -save-temps, we want to save the unoptimized bitcode output from the
   // CompileJobAction, so disable optimizations if they are not already
   // disabled.
   if (Args.hasArg(options::OPT_save_temps) && !OptDisabled &&
       isa<CompileJobAction>(JA))
     CmdArgs.push_back("-disable-llvm-optzns");
 
   if (Output.getType() == types::TY_Dependencies) {
     // Handled with other dependency code.
   } else if (Output.isFilename()) {
     CmdArgs.push_back("-o");
     CmdArgs.push_back(Output.getFilename());
   } else {
     assert(Output.isNothing() && "Invalid output.");
   }
 
   for (const auto &II : Inputs) {
     addDashXForInput(Args, II, CmdArgs);
 
     if (II.isFilename())
       CmdArgs.push_back(II.getFilename());
     else
       II.getInputArg().renderAsInput(Args, CmdArgs);
   }
 
   Args.AddAllArgs(CmdArgs, options::OPT_undef);
 
   const char *Exec = getToolChain().getDriver().getClangProgramPath();
 
   // Optionally embed the -cc1 level arguments into the debug info, for build
   // analysis.
   if (getToolChain().UseDwarfDebugFlags()) {
     ArgStringList OriginalArgs;
     for (const auto &Arg : Args)
       Arg->render(Args, OriginalArgs);
 
     SmallString<256> Flags;
     Flags += Exec;
     for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
       SmallString<128> EscapedArg;
       EscapeSpacesAndBackslashes(OriginalArgs[i], EscapedArg);
       Flags += " ";
       Flags += EscapedArg;
     }
     CmdArgs.push_back("-dwarf-debug-flags");
     CmdArgs.push_back(Args.MakeArgString(Flags.str()));
   }
 
   // Add the split debug info name to the command lines here so we
   // can propagate it to the backend.
   bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
     getToolChain().getTriple().isOSLinux() &&
     (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
      isa<BackendJobAction>(JA));
   const char *SplitDwarfOut;
   if (SplitDwarf) {
     CmdArgs.push_back("-split-dwarf-file");
     SplitDwarfOut = SplitDebugName(Args, Inputs);
     CmdArgs.push_back(SplitDwarfOut);
   }
 
   // Finally add the compile command to the compilation.
   if (Args.hasArg(options::OPT__SLASH_fallback) &&
       Output.getType() == types::TY_Object &&
       (InputType == types::TY_C || InputType == types::TY_CXX)) {
     auto CLCommand =
         getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput);
     C.addCommand(llvm::make_unique<FallbackCommand>(JA, *this, Exec, CmdArgs,
                                                     std::move(CLCommand)));
   } else {
     C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
   }
 
 
   // Handle the debug info splitting at object creation time if we're
   // creating an object.
   // TODO: Currently only works on linux with newer objcopy.
   if (SplitDwarf && !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA))
     SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
 
   if (Arg *A = Args.getLastArg(options::OPT_pg))
     if (Args.hasArg(options::OPT_fomit_frame_pointer))
       D.Diag(diag::err_drv_argument_not_allowed_with)
         << "-fomit-frame-pointer" << A->getAsString(Args);
 
   // Claim some arguments which clang supports automatically.
 
   // -fpch-preprocess is used with gcc to add a special marker in the output to
   // include the PCH file. Clang's PTH solution is completely transparent, so we
   // do not need to deal with it at all.
   Args.ClaimAllArgs(options::OPT_fpch_preprocess);
 
   // Claim some arguments which clang doesn't support, but we don't
   // care to warn the user about.
   Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
   Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
 
   // Disable warnings for clang -E -emit-llvm foo.c
   Args.ClaimAllArgs(options::OPT_emit_llvm);
 }
 
 /// Add options related to the Objective-C runtime/ABI.
 ///
 /// Returns true if the runtime is non-fragile.
 ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
                                       ArgStringList &cmdArgs,
                                       RewriteKind rewriteKind) const {
   // Look for the controlling runtime option.
   Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
                                     options::OPT_fgnu_runtime,
                                     options::OPT_fobjc_runtime_EQ);
 
   // Just forward -fobjc-runtime= to the frontend.  This supercedes
   // options about fragility.
   if (runtimeArg &&
       runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
     ObjCRuntime runtime;
     StringRef value = runtimeArg->getValue();
     if (runtime.tryParse(value)) {
       getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
         << value;
     }
 
     runtimeArg->render(args, cmdArgs);
     return runtime;
   }
 
   // Otherwise, we'll need the ABI "version".  Version numbers are
   // slightly confusing for historical reasons:
   //   1 - Traditional "fragile" ABI
   //   2 - Non-fragile ABI, version 1
   //   3 - Non-fragile ABI, version 2
   unsigned objcABIVersion = 1;
   // If -fobjc-abi-version= is present, use that to set the version.
   if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
     StringRef value = abiArg->getValue();
     if (value == "1")
       objcABIVersion = 1;
     else if (value == "2")
       objcABIVersion = 2;
     else if (value == "3")
       objcABIVersion = 3;
     else
       getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
         << value;
   } else {
     // Otherwise, determine if we are using the non-fragile ABI.
     bool nonFragileABIIsDefault = 
       (rewriteKind == RK_NonFragile || 
        (rewriteKind == RK_None &&
         getToolChain().IsObjCNonFragileABIDefault()));
     if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
                      options::OPT_fno_objc_nonfragile_abi,
                      nonFragileABIIsDefault)) {
       // Determine the non-fragile ABI version to use.
 #ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
       unsigned nonFragileABIVersion = 1;
 #else
       unsigned nonFragileABIVersion = 2;
 #endif
 
       if (Arg *abiArg = args.getLastArg(
             options::OPT_fobjc_nonfragile_abi_version_EQ)) {
         StringRef value = abiArg->getValue();
         if (value == "1")
           nonFragileABIVersion = 1;
         else if (value == "2")
           nonFragileABIVersion = 2;
         else
           getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
             << value;
       }
 
       objcABIVersion = 1 + nonFragileABIVersion;
     } else {
       objcABIVersion = 1;
     }
   }
 
   // We don't actually care about the ABI version other than whether
   // it's non-fragile.
   bool isNonFragile = objcABIVersion != 1;
 
   // If we have no runtime argument, ask the toolchain for its default runtime.
   // However, the rewriter only really supports the Mac runtime, so assume that.
   ObjCRuntime runtime;
   if (!runtimeArg) {
     switch (rewriteKind) {
     case RK_None:
       runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
       break;
     case RK_Fragile:
       runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
       break;
     case RK_NonFragile:
       runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
       break;
     }
 
   // -fnext-runtime
   } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
     // On Darwin, make this use the default behavior for the toolchain.
     if (getToolChain().getTriple().isOSDarwin()) {
       runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
 
     // Otherwise, build for a generic macosx port.
     } else {
       runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
     }
 
   // -fgnu-runtime
   } else {
     assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
     // Legacy behaviour is to target the gnustep runtime if we are i
     // non-fragile mode or the GCC runtime in fragile mode.
     if (isNonFragile)
       runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
     else
       runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
   }
 
   cmdArgs.push_back(args.MakeArgString(
                                  "-fobjc-runtime=" + runtime.getAsString()));
   return runtime;
 }
 
 static bool maybeConsumeDash(const std::string &EH, size_t &I) {
   bool HaveDash = (I + 1 < EH.size() && EH[I + 1] == '-');
   I += HaveDash;
   return !HaveDash;
 }
 
 struct EHFlags {
   EHFlags() : Synch(false), Asynch(false), NoExceptC(false) {}
   bool Synch;
   bool Asynch;
   bool NoExceptC;
 };
 
 /// /EH controls whether to run destructor cleanups when exceptions are
 /// thrown.  There are three modifiers:
 /// - s: Cleanup after "synchronous" exceptions, aka C++ exceptions.
 /// - a: Cleanup after "asynchronous" exceptions, aka structured exceptions.
 ///      The 'a' modifier is unimplemented and fundamentally hard in LLVM IR.
 /// - c: Assume that extern "C" functions are implicitly noexcept.  This
 ///      modifier is an optimization, so we ignore it for now.
 /// The default is /EHs-c-, meaning cleanups are disabled.
 static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) {
   EHFlags EH;
   std::vector<std::string> EHArgs = Args.getAllArgValues(options::OPT__SLASH_EH);
   for (auto EHVal : EHArgs) {
     for (size_t I = 0, E = EHVal.size(); I != E; ++I) {
       switch (EHVal[I]) {
       case 'a': EH.Asynch = maybeConsumeDash(EHVal, I); continue;
       case 'c': EH.NoExceptC = maybeConsumeDash(EHVal, I); continue;
       case 's': EH.Synch = maybeConsumeDash(EHVal, I); continue;
       default: break;
       }
       D.Diag(clang::diag::err_drv_invalid_value) << "/EH" << EHVal;
       break;
     }
   }
   return EH;
 }
 
 void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
   unsigned RTOptionID = options::OPT__SLASH_MT;
 
   if (Args.hasArg(options::OPT__SLASH_LDd))
     // The /LDd option implies /MTd. The dependent lib part can be overridden,
     // but defining _DEBUG is sticky.
     RTOptionID = options::OPT__SLASH_MTd;
 
   if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
     RTOptionID = A->getOption().getID();
 
   switch(RTOptionID) {
     case options::OPT__SLASH_MD:
       if (Args.hasArg(options::OPT__SLASH_LDd))
         CmdArgs.push_back("-D_DEBUG");
       CmdArgs.push_back("-D_MT");
       CmdArgs.push_back("-D_DLL");
       CmdArgs.push_back("--dependent-lib=msvcrt");
       break;
     case options::OPT__SLASH_MDd:
       CmdArgs.push_back("-D_DEBUG");
       CmdArgs.push_back("-D_MT");
       CmdArgs.push_back("-D_DLL");
       CmdArgs.push_back("--dependent-lib=msvcrtd");
       break;
     case options::OPT__SLASH_MT:
       if (Args.hasArg(options::OPT__SLASH_LDd))
         CmdArgs.push_back("-D_DEBUG");
       CmdArgs.push_back("-D_MT");
       CmdArgs.push_back("--dependent-lib=libcmt");
       break;
     case options::OPT__SLASH_MTd:
       CmdArgs.push_back("-D_DEBUG");
       CmdArgs.push_back("-D_MT");
       CmdArgs.push_back("--dependent-lib=libcmtd");
       break;
     default:
       llvm_unreachable("Unexpected option ID.");
   }
 
   // This provides POSIX compatibility (maps 'open' to '_open'), which most
   // users want.  The /Za flag to cl.exe turns this off, but it's not
   // implemented in clang.
   CmdArgs.push_back("--dependent-lib=oldnames");
 
   // Both /showIncludes and /E (and /EP) write to stdout. Allowing both
   // would produce interleaved output, so ignore /showIncludes in such cases.
   if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_EP))
     if (Arg *A = Args.getLastArg(options::OPT_show_includes))
       A->render(Args, CmdArgs);
 
   // This controls whether or not we emit RTTI data for polymorphic types.
   if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
                    /*default=*/false))
     CmdArgs.push_back("-fno-rtti-data");
 
   const Driver &D = getToolChain().getDriver();
   EHFlags EH = parseClangCLEHFlags(D, Args);
   // FIXME: Do something with NoExceptC.
   if (EH.Synch || EH.Asynch) {
     CmdArgs.push_back("-fexceptions");
     CmdArgs.push_back("-fcxx-exceptions");
   }
 
   // /EP should expand to -E -P.
   if (Args.hasArg(options::OPT__SLASH_EP)) {
     CmdArgs.push_back("-E");
     CmdArgs.push_back("-P");
   }
 
   Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
   Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
   if (MostGeneralArg && BestCaseArg)
     D.Diag(clang::diag::err_drv_argument_not_allowed_with)
         << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
 
   if (MostGeneralArg) {
     Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
     Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
     Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
 
     Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
     Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
     if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
       D.Diag(clang::diag::err_drv_argument_not_allowed_with)
           << FirstConflict->getAsString(Args)
           << SecondConflict->getAsString(Args);
 
     if (SingleArg)
       CmdArgs.push_back("-fms-memptr-rep=single");
     else if (MultipleArg)
       CmdArgs.push_back("-fms-memptr-rep=multiple");
     else
       CmdArgs.push_back("-fms-memptr-rep=virtual");
   }
 
   if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
     A->render(Args, CmdArgs);
 
   if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
     CmdArgs.push_back("-fdiagnostics-format");
     if (Args.hasArg(options::OPT__SLASH_fallback))
       CmdArgs.push_back("msvc-fallback");
     else
       CmdArgs.push_back("msvc");
   }
 }
 
 visualstudio::Compile *Clang::getCLFallback() const {
   if (!CLFallback)
     CLFallback.reset(new visualstudio::Compile(getToolChain()));
   return CLFallback.get();
 }
 
 void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
                            const InputInfo &Output,
                            const InputInfoList &Inputs,
                            const ArgList &Args,
                            const char *LinkingOutput) const {
   ArgStringList CmdArgs;
 
   assert(Inputs.size() == 1 && "Unexpected number of inputs.");
   const InputInfo &Input = Inputs[0];
 
   // Don't warn about "clang -w -c foo.s"
   Args.ClaimAllArgs(options::OPT_w);
   // and "clang -emit-llvm -c foo.s"
   Args.ClaimAllArgs(options::OPT_emit_llvm);
 
   claimNoWarnArgs(Args);
 
   // Invoke ourselves in -cc1as mode.
   //
   // FIXME: Implement custom jobs for internal actions.
   CmdArgs.push_back("-cc1as");
 
   // Add the "effective" target triple.
   CmdArgs.push_back("-triple");
   std::string TripleStr = 
     getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
   CmdArgs.push_back(Args.MakeArgString(TripleStr));
 
   // Set the output mode, we currently only expect to be used as a real
   // assembler.
   CmdArgs.push_back("-filetype");
   CmdArgs.push_back("obj");
 
   // Set the main file name, so that debug info works even with
   // -save-temps or preprocessed assembly.
   CmdArgs.push_back("-main-file-name");
   CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
 
   // Add the target cpu
   const llvm::Triple &Triple = getToolChain().getTriple();
   std::string CPU = getCPUName(Args, Triple);
   if (!CPU.empty()) {
     CmdArgs.push_back("-target-cpu");
     CmdArgs.push_back(Args.MakeArgString(CPU));
   }
 
   // Add the target features
   const Driver &D = getToolChain().getDriver();
   getTargetFeatures(D, Triple, Args, CmdArgs, true);
 
   // Ignore explicit -force_cpusubtype_ALL option.
   (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
 
   // Determine the original source input.
   const Action *SourceAction = &JA;
   while (SourceAction->getKind() != Action::InputClass) {
     assert(!SourceAction->getInputs().empty() && "unexpected root action!");
     SourceAction = SourceAction->getInputs()[0];
   }
 
   // Forward -g and handle debug info related flags, assuming we are dealing
   // with an actual assembly file.
   if (SourceAction->getType() == types::TY_Asm ||
       SourceAction->getType() == types::TY_PP_Asm) {
     Args.ClaimAllArgs(options::OPT_g_Group);
     if (Arg *A = Args.getLastArg(options::OPT_g_Group))
       if (!A->getOption().matches(options::OPT_g0))
         CmdArgs.push_back("-g");
 
     if (Args.hasArg(options::OPT_gdwarf_2))
       CmdArgs.push_back("-gdwarf-2");
     if (Args.hasArg(options::OPT_gdwarf_3))
       CmdArgs.push_back("-gdwarf-3");
     if (Args.hasArg(options::OPT_gdwarf_4))
       CmdArgs.push_back("-gdwarf-4");
 
     // Add the -fdebug-compilation-dir flag if needed.
     addDebugCompDirArg(Args, CmdArgs);
 
     // Set the AT_producer to the clang version when using the integrated
     // assembler on assembly source files.
     CmdArgs.push_back("-dwarf-debug-producer");
     CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
   }
 
   // Optionally embed the -cc1as level arguments into the debug info, for build
   // analysis.
   if (getToolChain().UseDwarfDebugFlags()) {
     ArgStringList OriginalArgs;
     for (const auto &Arg : Args)
       Arg->render(Args, OriginalArgs);
 
     SmallString<256> Flags;
     const char *Exec = getToolChain().getDriver().getClangProgramPath();
     Flags += Exec;
     for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
       SmallString<128> EscapedArg;
       EscapeSpacesAndBackslashes(OriginalArgs[i], EscapedArg);
       Flags += " ";
       Flags += EscapedArg;
     }
     CmdArgs.push_back("-dwarf-debug-flags");
     CmdArgs.push_back(Args.MakeArgString(Flags.str()));
   }
 
   // FIXME: Add -static support, once we have it.
 
   // Consume all the warning flags. Usually this would be handled more
   // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
   // doesn't handle that so rather than warning about unused flags that are
   // actually used, we'll lie by omission instead.
   // FIXME: Stop lying and consume only the appropriate driver flags
   for (arg_iterator it = Args.filtered_begin(options::OPT_W_Group),
                     ie = Args.filtered_end();
        it != ie; ++it)
     (*it)->claim();
 
   CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
                                     getToolChain().getDriver());
 
   Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
 
   assert(Output.isFilename() && "Unexpected lipo output.");
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   assert(Input.isFilename() && "Invalid input.");
   CmdArgs.push_back(Input.getFilename());
 
   const char *Exec = getToolChain().getDriver().getClangProgramPath();
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 
   // Handle the debug info splitting at object creation time if we're
   // creating an object.
   // TODO: Currently only works on linux with newer objcopy.
   if (Args.hasArg(options::OPT_gsplit_dwarf) &&
       getToolChain().getTriple().isOSLinux())
     SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
                    SplitDebugName(Args, Inputs));
 }
 
 void GnuTool::anchor() {}
 
 void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
                                const InputInfo &Output,
                                const InputInfoList &Inputs,
                                const ArgList &Args,
                                const char *LinkingOutput) const {
   const Driver &D = getToolChain().getDriver();
   ArgStringList CmdArgs;
 
   for (const auto &A : Args) {
     if (forwardToGCC(A->getOption())) {
       // Don't forward any -g arguments to assembly steps.
       if (isa<AssembleJobAction>(JA) &&
           A->getOption().matches(options::OPT_g_Group))
         continue;
 
       // Don't forward any -W arguments to assembly and link steps.
       if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
           A->getOption().matches(options::OPT_W_Group))
         continue;
 
       // It is unfortunate that we have to claim here, as this means
       // we will basically never report anything interesting for
       // platforms using a generic gcc, even if we are just using gcc
       // to get to the assembler.
       A->claim();
       A->render(Args, CmdArgs);
     }
   }
 
   RenderExtraToolArgs(JA, CmdArgs);
 
   // If using a driver driver, force the arch.
   if (getToolChain().getTriple().isOSDarwin()) {
     CmdArgs.push_back("-arch");
     CmdArgs.push_back(
       Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
   }
 
   // Try to force gcc to match the tool chain we want, if we recognize
   // the arch.
   //
   // FIXME: The triple class should directly provide the information we want
   // here.
   llvm::Triple::ArchType Arch = getToolChain().getArch();
   if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
     CmdArgs.push_back("-m32");
   else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
            Arch == llvm::Triple::ppc64le)
     CmdArgs.push_back("-m64");
 
   if (Output.isFilename()) {
     CmdArgs.push_back("-o");
     CmdArgs.push_back(Output.getFilename());
   } else {
     assert(Output.isNothing() && "Unexpected output");
     CmdArgs.push_back("-fsyntax-only");
   }
 
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
                        options::OPT_Xassembler);
 
   // Only pass -x if gcc will understand it; otherwise hope gcc
   // understands the suffix correctly. The main use case this would go
   // wrong in is for linker inputs if they happened to have an odd
   // suffix; really the only way to get this to happen is a command
   // like '-x foobar a.c' which will treat a.c like a linker input.
   //
   // FIXME: For the linker case specifically, can we safely convert
   // inputs into '-Wl,' options?
   for (const auto &II : Inputs) {
     // Don't try to pass LLVM or AST inputs to a generic gcc.
     if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
         II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
       D.Diag(diag::err_drv_no_linker_llvm_support)
         << getToolChain().getTripleString();
     else if (II.getType() == types::TY_AST)
       D.Diag(diag::err_drv_no_ast_support)
         << getToolChain().getTripleString();
     else if (II.getType() == types::TY_ModuleFile)
       D.Diag(diag::err_drv_no_module_support)
         << getToolChain().getTripleString();
 
     if (types::canTypeBeUserSpecified(II.getType())) {
       CmdArgs.push_back("-x");
       CmdArgs.push_back(types::getTypeName(II.getType()));
     }
 
     if (II.isFilename())
       CmdArgs.push_back(II.getFilename());
     else {
       const Arg &A = II.getInputArg();
 
       // Reverse translate some rewritten options.
       if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
         CmdArgs.push_back("-lstdc++");
         continue;
       }
 
       // Don't render as input, we need gcc to do the translations.
       A.render(Args, CmdArgs);
     }
   }
 
   const std::string customGCCName = D.getCCCGenericGCCName();
   const char *GCCName;
   if (!customGCCName.empty())
     GCCName = customGCCName.c_str();
   else if (D.CCCIsCXX()) {
     GCCName = "g++";
   } else
     GCCName = "gcc";
 
   const char *Exec =
     Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
                                           ArgStringList &CmdArgs) const {
   CmdArgs.push_back("-E");
 }
 
 void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
                                        ArgStringList &CmdArgs) const {
   const Driver &D = getToolChain().getDriver();
 
   // If -flto, etc. are present then make sure not to force assembly output.
   if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
       JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
     CmdArgs.push_back("-c");
   else {
     if (JA.getType() != types::TY_PP_Asm)
       D.Diag(diag::err_drv_invalid_gcc_output_type)
         << getTypeName(JA.getType());
 
     CmdArgs.push_back("-S");
   }
 }
 
 void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
                                     ArgStringList &CmdArgs) const {
   // The types are (hopefully) good enough.
 }
 
 // Hexagon tools start.
 void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
                                         ArgStringList &CmdArgs) const {
 
 }
 void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
                                const InputInfo &Output,
                                const InputInfoList &Inputs,
                                const ArgList &Args,
                                const char *LinkingOutput) const {
   claimNoWarnArgs(Args);
 
   const Driver &D = getToolChain().getDriver();
   ArgStringList CmdArgs;
 
   std::string MarchString = "-march=";
   MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
   CmdArgs.push_back(Args.MakeArgString(MarchString));
 
   RenderExtraToolArgs(JA, CmdArgs);
 
   if (Output.isFilename()) {
     CmdArgs.push_back("-o");
     CmdArgs.push_back(Output.getFilename());
   } else {
     assert(Output.isNothing() && "Unexpected output");
     CmdArgs.push_back("-fsyntax-only");
   }
 
   std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
   if (!SmallDataThreshold.empty())
     CmdArgs.push_back(
       Args.MakeArgString(std::string("-G") + SmallDataThreshold));
 
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
                        options::OPT_Xassembler);
 
   // Only pass -x if gcc will understand it; otherwise hope gcc
   // understands the suffix correctly. The main use case this would go
   // wrong in is for linker inputs if they happened to have an odd
   // suffix; really the only way to get this to happen is a command
   // like '-x foobar a.c' which will treat a.c like a linker input.
   //
   // FIXME: For the linker case specifically, can we safely convert
   // inputs into '-Wl,' options?
   for (const auto &II : Inputs) {
     // Don't try to pass LLVM or AST inputs to a generic gcc.
     if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
         II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
       D.Diag(clang::diag::err_drv_no_linker_llvm_support)
         << getToolChain().getTripleString();
     else if (II.getType() == types::TY_AST)
       D.Diag(clang::diag::err_drv_no_ast_support)
         << getToolChain().getTripleString();
     else if (II.getType() == types::TY_ModuleFile)
       D.Diag(diag::err_drv_no_module_support)
       << getToolChain().getTripleString();
 
     if (II.isFilename())
       CmdArgs.push_back(II.getFilename());
     else
       // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
       II.getInputArg().render(Args, CmdArgs);
   }
 
   const char *GCCName = "hexagon-as";
   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
                                     ArgStringList &CmdArgs) const {
   // The types are (hopefully) good enough.
 }
 
 void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
                                const InputInfo &Output,
                                const InputInfoList &Inputs,
                                const ArgList &Args,
                                const char *LinkingOutput) const {
 
   const toolchains::Hexagon_TC& ToolChain =
     static_cast<const toolchains::Hexagon_TC&>(getToolChain());
   const Driver &D = ToolChain.getDriver();
 
   ArgStringList CmdArgs;
 
   //----------------------------------------------------------------------------
   //
   //----------------------------------------------------------------------------
   bool hasStaticArg = Args.hasArg(options::OPT_static);
   bool buildingLib = Args.hasArg(options::OPT_shared);
   bool buildPIE = Args.hasArg(options::OPT_pie);
   bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
   bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
   bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
   bool useShared = buildingLib && !hasStaticArg;
 
   //----------------------------------------------------------------------------
   // Silence warnings for various options
   //----------------------------------------------------------------------------
 
   Args.ClaimAllArgs(options::OPT_g_Group);
   Args.ClaimAllArgs(options::OPT_emit_llvm);
   Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
                                      // handled somewhere else.
   Args.ClaimAllArgs(options::OPT_static_libgcc);
 
   //----------------------------------------------------------------------------
   //
   //----------------------------------------------------------------------------
   for (const auto &Opt : ToolChain.ExtraOpts)
     CmdArgs.push_back(Opt.c_str());
 
   std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
   CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
 
   if (buildingLib) {
     CmdArgs.push_back("-shared");
     CmdArgs.push_back("-call_shared"); // should be the default, but doing as
                                        // hexagon-gcc does
   }
 
   if (hasStaticArg)
     CmdArgs.push_back("-static");
 
   if (buildPIE && !buildingLib)
     CmdArgs.push_back("-pie");
 
   std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
   if (!SmallDataThreshold.empty()) {
     CmdArgs.push_back(
       Args.MakeArgString(std::string("-G") + SmallDataThreshold));
   }
 
   //----------------------------------------------------------------------------
   //
   //----------------------------------------------------------------------------
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   const std::string MarchSuffix = "/" + MarchString;
   const std::string G0Suffix = "/G0";
   const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
   const std::string RootDir =
       toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir, Args) + "/";
   const std::string StartFilesDir = RootDir
                                     + "hexagon/lib"
                                     + (buildingLib
                                        ? MarchG0Suffix : MarchSuffix);
 
   //----------------------------------------------------------------------------
   // moslib
   //----------------------------------------------------------------------------
   std::vector<std::string> oslibs;
   bool hasStandalone= false;
 
   for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
          ie = Args.filtered_end(); it != ie; ++it) {
     (*it)->claim();
     oslibs.push_back((*it)->getValue());
     hasStandalone = hasStandalone || (oslibs.back() == "standalone");
   }
   if (oslibs.empty()) {
     oslibs.push_back("standalone");
     hasStandalone = true;
   }
 
   //----------------------------------------------------------------------------
   // Start Files
   //----------------------------------------------------------------------------
   if (incStdLib && incStartFiles) {
 
     if (!buildingLib) {
       if (hasStandalone) {
         CmdArgs.push_back(
           Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
       }
       CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
     }
     std::string initObj = useShared ? "/initS.o" : "/init.o";
     CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
   }
 
   //----------------------------------------------------------------------------
   // Library Search Paths
   //----------------------------------------------------------------------------
   const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
   for (const auto &LibPath : LibPaths)
     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
 
   //----------------------------------------------------------------------------
   //
   //----------------------------------------------------------------------------
   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
   Args.AddAllArgs(CmdArgs, options::OPT_e);
   Args.AddAllArgs(CmdArgs, options::OPT_s);
   Args.AddAllArgs(CmdArgs, options::OPT_t);
   Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
 
   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
 
   //----------------------------------------------------------------------------
   // Libraries
   //----------------------------------------------------------------------------
   if (incStdLib && incDefLibs) {
     if (D.CCCIsCXX()) {
       ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
       CmdArgs.push_back("-lm");
     }
 
     CmdArgs.push_back("--start-group");
 
     if (!buildingLib) {
       for(std::vector<std::string>::iterator i = oslibs.begin(),
             e = oslibs.end(); i != e; ++i)
         CmdArgs.push_back(Args.MakeArgString("-l" + *i));
       CmdArgs.push_back("-lc");
     }
     CmdArgs.push_back("-lgcc");
 
     CmdArgs.push_back("--end-group");
   }
 
   //----------------------------------------------------------------------------
   // End files
   //----------------------------------------------------------------------------
   if (incStdLib && incStartFiles) {
     std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
     CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
   }
 
   std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
   C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
                                           CmdArgs));
 }
 // Hexagon tools end.
 
 /// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
 const char *arm::getARMCPUForMArch(const ArgList &Args,
                                    const llvm::Triple &Triple) {
   StringRef MArch;
   if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
     // Otherwise, if we have -march= choose the base CPU for that arch.
     MArch = A->getValue();
   } else {
     // Otherwise, use the Arch from the triple.
     MArch = Triple.getArchName();
   }
 
   // Handle -march=native.
   if (MArch == "native") {
     std::string CPU = llvm::sys::getHostCPUName();
     if (CPU != "generic") {
       // Translate the native cpu into the architecture. The switch below will
       // then chose the minimum cpu for that arch.
       MArch = std::string("arm") + arm::getLLVMArchSuffixForARM(CPU);
     }
   }
 
   return Triple.getARMCPUForArch(MArch);
 }
 
 /// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
 StringRef arm::getARMTargetCPU(const ArgList &Args,
                                const llvm::Triple &Triple) {
   // FIXME: Warn on inconsistent use of -mcpu and -march.
   // If we have -mcpu=, use that.
   if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
     StringRef MCPU = A->getValue();
     // Handle -mcpu=native.
     if (MCPU == "native")
       return llvm::sys::getHostCPUName();
     else
       return MCPU;
   }
 
   return getARMCPUForMArch(Args, Triple);
 }
 
 /// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
 /// CPU.
 //
 // FIXME: This is redundant with -mcpu, why does LLVM use this.
 // FIXME: tblgen this, or kill it!
 const char *arm::getLLVMArchSuffixForARM(StringRef CPU) {
   return llvm::StringSwitch<const char *>(CPU)
     .Case("strongarm", "v4")
     .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
     .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
     .Cases("arm920", "arm920t", "arm922t", "v4t")
     .Cases("arm940t", "ep9312","v4t")
     .Cases("arm10tdmi",  "arm1020t", "v5")
     .Cases("arm9e",  "arm926ej-s",  "arm946e-s", "v5e")
     .Cases("arm966e-s",  "arm968e-s",  "arm10e", "v5e")
     .Cases("arm1020e",  "arm1022e",  "xscale", "iwmmxt", "v5e")
     .Cases("arm1136j-s",  "arm1136jf-s",  "arm1176jz-s", "v6")
     .Cases("arm1176jzf-s",  "mpcorenovfp",  "mpcore", "v6")
     .Cases("arm1156t2-s",  "arm1156t2f-s", "v6t2")
     .Cases("cortex-a5", "cortex-a7", "cortex-a8", "v7")
     .Cases("cortex-a9", "cortex-a12", "cortex-a15", "cortex-a17", "krait", "v7")
     .Cases("cortex-r4", "cortex-r5", "v7r")
     .Case("cortex-m0", "v6m")
     .Case("cortex-m3", "v7m")
     .Cases("cortex-m4", "cortex-m7", "v7em")
     .Case("swift", "v7s")
     .Case("cyclone", "v8")
     .Cases("cortex-a53", "cortex-a57", "v8")
     .Default("");
 }
 
 bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
   Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
   return A && (A->getValue() == StringRef(Value));
 }
 
 bool mips::isUCLibc(const ArgList &Args) {
   Arg *A = Args.getLastArg(options::OPT_m_libc_Group);
   return A && A->getOption().matches(options::OPT_muclibc);
 }
 
 bool mips::isNaN2008(const ArgList &Args, const llvm::Triple &Triple) {
   if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ))
     return llvm::StringSwitch<bool>(NaNArg->getValue())
                .Case("2008", true)
                .Case("legacy", false)
                .Default(false);
 
   // NaN2008 is the default for MIPS32r6/MIPS64r6.
   return llvm::StringSwitch<bool>(getCPUName(Args, Triple))
              .Cases("mips32r6", "mips64r6", true)
              .Default(false);
 
   return false;
 }
 
 bool mips::isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName,
                          StringRef ABIName) {
   if (Triple.getVendor() != llvm::Triple::ImaginationTechnologies &&
       Triple.getVendor() != llvm::Triple::MipsTechnologies)
     return false;
 
   if (ABIName != "32")
     return false;
 
   return llvm::StringSwitch<bool>(CPUName)
              .Cases("mips2", "mips3", "mips4", "mips5", true)
              .Cases("mips32", "mips32r2", true)
              .Cases("mips64", "mips64r2", true)
              .Default(false);
 }
 
 llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
   // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
   // archs which Darwin doesn't use.
 
   // The matching this routine does is fairly pointless, since it is neither the
   // complete architecture list, nor a reasonable subset. The problem is that
   // historically the driver driver accepts this and also ties its -march=
   // handling to the architecture name, so we need to be careful before removing
   // support for it.
 
   // This code must be kept in sync with Clang's Darwin specific argument
   // translation.
 
   return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
     .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
     .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
     .Case("ppc64", llvm::Triple::ppc64)
     .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
     .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
            llvm::Triple::x86)
     .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
     // This is derived from the driver driver.
     .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
     .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
     .Cases("armv7s", "xscale", llvm::Triple::arm)
     .Case("arm64", llvm::Triple::aarch64)
     .Case("r600", llvm::Triple::r600)
     .Case("amdgcn", llvm::Triple::amdgcn)
     .Case("nvptx", llvm::Triple::nvptx)
     .Case("nvptx64", llvm::Triple::nvptx64)
     .Case("amdil", llvm::Triple::amdil)
     .Case("spir", llvm::Triple::spir)
     .Default(llvm::Triple::UnknownArch);
 }
 
 void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
   llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
   T.setArch(Arch);
 
   if (Str == "x86_64h")
     T.setArchName(Str);
   else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
     T.setOS(llvm::Triple::UnknownOS);
     T.setObjectFormat(llvm::Triple::MachO);
   }
 }
 
 const char *Clang::getBaseInputName(const ArgList &Args,
                                     const InputInfoList &Inputs) {
   return Args.MakeArgString(
     llvm::sys::path::filename(Inputs[0].getBaseInput()));
 }
 
 const char *Clang::getBaseInputStem(const ArgList &Args,
                                     const InputInfoList &Inputs) {
   const char *Str = getBaseInputName(Args, Inputs);
 
   if (const char *End = strrchr(Str, '.'))
     return Args.MakeArgString(std::string(Str, End));
 
   return Str;
 }
 
 const char *Clang::getDependencyFileName(const ArgList &Args,
                                          const InputInfoList &Inputs) {
   // FIXME: Think about this more.
   std::string Res;
 
   if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
     std::string Str(OutputOpt->getValue());
     Res = Str.substr(0, Str.rfind('.'));
   } else {
     Res = getBaseInputStem(Args, Inputs);
   }
   return Args.MakeArgString(Res + ".d");
 }
 
 void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
                                     const InputInfo &Output,
                                     const InputInfoList &Inputs,
                                     const ArgList &Args,
                                     const char *LinkingOutput) const {
   ArgStringList CmdArgs;
 
   assert(Inputs.size() == 1 && "Unexpected number of inputs.");
   const InputInfo &Input = Inputs[0];
 
   // Determine the original source input.
   const Action *SourceAction = &JA;
   while (SourceAction->getKind() != Action::InputClass) {
     assert(!SourceAction->getInputs().empty() && "unexpected root action!");
     SourceAction = SourceAction->getInputs()[0];
   }
 
   // If -fno_integrated_as is used add -Q to the darwin assember driver to make
   // sure it runs its system assembler not clang's integrated assembler.
   // Applicable to darwin11+ and Xcode 4+.  darwin<10 lacked integrated-as.
   // FIXME: at run-time detect assembler capabilities or rely on version
   // information forwarded by -target-assembler-version (future)
   if (Args.hasArg(options::OPT_fno_integrated_as)) {
     const llvm::Triple &T(getToolChain().getTriple());
     if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
       CmdArgs.push_back("-Q");
   }
 
   // Forward -g, assuming we are dealing with an actual assembly file.
   if (SourceAction->getType() == types::TY_Asm ||
       SourceAction->getType() == types::TY_PP_Asm) {
     if (Args.hasArg(options::OPT_gstabs))
       CmdArgs.push_back("--gstabs");
     else if (Args.hasArg(options::OPT_g_Group))
       CmdArgs.push_back("-g");
   }
 
   // Derived from asm spec.
   AddMachOArch(Args, CmdArgs);
 
   // Use -force_cpusubtype_ALL on x86 by default.
   if (getToolChain().getArch() == llvm::Triple::x86 ||
       getToolChain().getArch() == llvm::Triple::x86_64 ||
       Args.hasArg(options::OPT_force__cpusubtype__ALL))
     CmdArgs.push_back("-force_cpusubtype_ALL");
 
   if (getToolChain().getArch() != llvm::Triple::x86_64 &&
       (((Args.hasArg(options::OPT_mkernel) ||
          Args.hasArg(options::OPT_fapple_kext)) &&
         getMachOToolChain().isKernelStatic()) ||
        Args.hasArg(options::OPT_static)))
     CmdArgs.push_back("-static");
 
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
                        options::OPT_Xassembler);
 
   assert(Output.isFilename() && "Unexpected lipo output.");
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   assert(Input.isFilename() && "Invalid input.");
   CmdArgs.push_back(Input.getFilename());
 
   // asm_final spec is empty.
 
   const char *Exec =
     Args.MakeArgString(getToolChain().GetProgramPath("as"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 void darwin::MachOTool::anchor() {}
 
 void darwin::MachOTool::AddMachOArch(const ArgList &Args,
                                      ArgStringList &CmdArgs) const {
   StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
 
   // Derived from darwin_arch spec.
   CmdArgs.push_back("-arch");
   CmdArgs.push_back(Args.MakeArgString(ArchName));
 
   // FIXME: Is this needed anymore?
   if (ArchName == "arm")
     CmdArgs.push_back("-force_cpusubtype_ALL");
 }
 
 bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
   // We only need to generate a temp path for LTO if we aren't compiling object
   // files. When compiling source files, we run 'dsymutil' after linking. We
   // don't run 'dsymutil' when compiling object files.
   for (const auto &Input : Inputs)
     if (Input.getType() != types::TY_Object)
       return true;
 
   return false;
 }
 
 void darwin::Link::AddLinkArgs(Compilation &C,
                                const ArgList &Args,
                                ArgStringList &CmdArgs,
                                const InputInfoList &Inputs) const {
   const Driver &D = getToolChain().getDriver();
   const toolchains::MachO &MachOTC = getMachOToolChain();
 
   unsigned Version[3] = { 0, 0, 0 };
   if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
     bool HadExtra;
     if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
                                    Version[1], Version[2], HadExtra) ||
         HadExtra)
       D.Diag(diag::err_drv_invalid_version_number)
         << A->getAsString(Args);
   }
 
   // Newer linkers support -demangle. Pass it if supported and not disabled by
   // the user.
   if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
     CmdArgs.push_back("-demangle");
 
   if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
     CmdArgs.push_back("-export_dynamic");
 
   // If we are using LTO, then automatically create a temporary file path for
   // the linker to use, so that it's lifetime will extend past a possible
   // dsymutil step.
   if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
     const char *TmpPath = C.getArgs().MakeArgString(
       D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
     C.addTempFile(TmpPath);
     CmdArgs.push_back("-object_path_lto");
     CmdArgs.push_back(TmpPath);
   }
 
   // Derived from the "link" spec.
   Args.AddAllArgs(CmdArgs, options::OPT_static);
   if (!Args.hasArg(options::OPT_static))
     CmdArgs.push_back("-dynamic");
   if (Args.hasArg(options::OPT_fgnu_runtime)) {
     // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
     // here. How do we wish to handle such things?
   }
 
   if (!Args.hasArg(options::OPT_dynamiclib)) {
     AddMachOArch(Args, CmdArgs);
     // FIXME: Why do this only on this path?
     Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
 
     Args.AddLastArg(CmdArgs, options::OPT_bundle);
     Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
     Args.AddAllArgs(CmdArgs, options::OPT_client__name);
 
     Arg *A;
     if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
         (A = Args.getLastArg(options::OPT_current__version)) ||
         (A = Args.getLastArg(options::OPT_install__name)))
       D.Diag(diag::err_drv_argument_only_allowed_with)
         << A->getAsString(Args) << "-dynamiclib";
 
     Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
     Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
     Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
   } else {
     CmdArgs.push_back("-dylib");
 
     Arg *A;
     if ((A = Args.getLastArg(options::OPT_bundle)) ||
         (A = Args.getLastArg(options::OPT_bundle__loader)) ||
         (A = Args.getLastArg(options::OPT_client__name)) ||
         (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
         (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
         (A = Args.getLastArg(options::OPT_private__bundle)))
       D.Diag(diag::err_drv_argument_not_allowed_with)
         << A->getAsString(Args) << "-dynamiclib";
 
     Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
                               "-dylib_compatibility_version");
     Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
                               "-dylib_current_version");
 
     AddMachOArch(Args, CmdArgs);
 
     Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
                               "-dylib_install_name");
   }
 
   Args.AddLastArg(CmdArgs, options::OPT_all__load);
   Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
   Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
   if (MachOTC.isTargetIOSBased())
     Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
   Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
   Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
   Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
   Args.AddLastArg(CmdArgs, options::OPT_dynamic);
   Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
   Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
   Args.AddAllArgs(CmdArgs, options::OPT_force__load);
   Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
   Args.AddAllArgs(CmdArgs, options::OPT_image__base);
   Args.AddAllArgs(CmdArgs, options::OPT_init);
 
   // Add the deployment target.
   MachOTC.addMinVersionArgs(Args, CmdArgs);
 
   Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
   Args.AddLastArg(CmdArgs, options::OPT_multi__module);
   Args.AddLastArg(CmdArgs, options::OPT_single__module);
   Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
   Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
 
   if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
                                      options::OPT_fno_pie,
                                      options::OPT_fno_PIE)) {
     if (A->getOption().matches(options::OPT_fpie) ||
         A->getOption().matches(options::OPT_fPIE))
       CmdArgs.push_back("-pie");
     else
       CmdArgs.push_back("-no_pie");
   }
 
   Args.AddLastArg(CmdArgs, options::OPT_prebind);
   Args.AddLastArg(CmdArgs, options::OPT_noprebind);
   Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
   Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
   Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
   Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
   Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
   Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
   Args.AddAllArgs(CmdArgs, options::OPT_segprot);
   Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
   Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
   Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
   Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
   Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
   Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
   Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
 
   // Give --sysroot= preference, over the Apple specific behavior to also use
   // --isysroot as the syslibroot.
   StringRef sysroot = C.getSysRoot();
   if (sysroot != "") {
     CmdArgs.push_back("-syslibroot");
     CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
   } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
     CmdArgs.push_back("-syslibroot");
     CmdArgs.push_back(A->getValue());
   }
 
   Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
   Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
   Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
   Args.AddAllArgs(CmdArgs, options::OPT_undefined);
   Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
   Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
   Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
   Args.AddAllArgs(CmdArgs, options::OPT_y);
   Args.AddLastArg(CmdArgs, options::OPT_w);
   Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
   Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
   Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
   Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
   Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
   Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
   Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
   Args.AddLastArg(CmdArgs, options::OPT_whyload);
   Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
   Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
   Args.AddLastArg(CmdArgs, options::OPT_dylinker);
   Args.AddLastArg(CmdArgs, options::OPT_Mach);
 }
 
 enum LibOpenMP {
   LibUnknown,
   LibGOMP,
   LibIOMP5
 };
 
 void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
                                 const InputInfo &Output,
                                 const InputInfoList &Inputs,
                                 const ArgList &Args,
                                 const char *LinkingOutput) const {
   assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
 
   // If the number of arguments surpasses the system limits, we will encode the
   // input files in a separate file, shortening the command line. To this end,
   // build a list of input file names that can be passed via a file with the
   // -filelist linker option.
   llvm::opt::ArgStringList InputFileList;
 
   // The logic here is derived from gcc's behavior; most of which
   // comes from specs (starting with link_command). Consult gcc for
   // more information.
   ArgStringList CmdArgs;
 
   /// Hack(tm) to ignore linking errors when we are doing ARC migration.
   if (Args.hasArg(options::OPT_ccc_arcmt_check,
                   options::OPT_ccc_arcmt_migrate)) {
     for (const auto &Arg : Args)
       Arg->claim();
     const char *Exec =
       Args.MakeArgString(getToolChain().GetProgramPath("touch"));
     CmdArgs.push_back(Output.getFilename());
     C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
     return;
   }
 
   // I'm not sure why this particular decomposition exists in gcc, but
   // we follow suite for ease of comparison.
   AddLinkArgs(C, Args, CmdArgs, Inputs);
 
   Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
   Args.AddAllArgs(CmdArgs, options::OPT_s);
   Args.AddAllArgs(CmdArgs, options::OPT_t);
   Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
   Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
   Args.AddLastArg(CmdArgs, options::OPT_e);
   Args.AddAllArgs(CmdArgs, options::OPT_r);
 
   // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
   // members of static archive libraries which implement Objective-C classes or
   // categories.
   if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
     CmdArgs.push_back("-ObjC");
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nostartfiles))
     getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
 
   Args.AddAllArgs(CmdArgs, options::OPT_L);
 
   LibOpenMP UsedOpenMPLib = LibUnknown;
   if (Args.hasArg(options::OPT_fopenmp)) {
     UsedOpenMPLib = LibGOMP;
   } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
     UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
         .Case("libgomp",  LibGOMP)
         .Case("libiomp5", LibIOMP5)
         .Default(LibUnknown);
     if (UsedOpenMPLib == LibUnknown)
       getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
         << A->getOption().getName() << A->getValue();
   }
   switch (UsedOpenMPLib) {
   case LibGOMP:
     CmdArgs.push_back("-lgomp");
     break;
   case LibIOMP5:
     CmdArgs.push_back("-liomp5");
     break;
   case LibUnknown:
     break;
   }
 
   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
   // Build the input file for -filelist (list of linker input files) in case we
   // need it later
   for (const auto &II : Inputs) {
     if (!II.isFilename()) {
       // This is a linker input argument.
       // We cannot mix input arguments and file names in a -filelist input, thus
       // we prematurely stop our list (remaining files shall be passed as
       // arguments).
       if (InputFileList.size() > 0)
         break;
 
       continue;
     }
 
     InputFileList.push_back(II.getFilename());
   }
 
   if (isObjCRuntimeLinked(Args) &&
       !Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nodefaultlibs)) {
     // We use arclite library for both ARC and subscripting support.
     getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
 
     CmdArgs.push_back("-framework");
     CmdArgs.push_back("Foundation");
     // Link libobj.
     CmdArgs.push_back("-lobjc");
   }
 
   if (LinkingOutput) {
     CmdArgs.push_back("-arch_multiple");
     CmdArgs.push_back("-final_output");
     CmdArgs.push_back(LinkingOutput);
   }
 
   if (Args.hasArg(options::OPT_fnested_functions))
     CmdArgs.push_back("-allow_stack_execute");
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nodefaultlibs)) {
     if (getToolChain().getDriver().CCCIsCXX())
       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
 
     // link_ssp spec is empty.
 
     // Let the tool chain choose which runtime library to link.
     getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
   }
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nostartfiles)) {
     // endfile_spec is empty.
   }
 
   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
   Args.AddAllArgs(CmdArgs, options::OPT_F);
 
   const char *Exec =
     Args.MakeArgString(getToolChain().GetLinkerPath());
   std::unique_ptr<Command> Cmd =
     llvm::make_unique<Command>(JA, *this, Exec, CmdArgs);
   Cmd->setInputFileList(std::move(InputFileList));
   C.addCommand(std::move(Cmd));
 }
 
 void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
                                 const InputInfo &Output,
                                 const InputInfoList &Inputs,
                                 const ArgList &Args,
                                 const char *LinkingOutput) const {
   ArgStringList CmdArgs;
 
   CmdArgs.push_back("-create");
   assert(Output.isFilename() && "Unexpected lipo output.");
 
   CmdArgs.push_back("-output");
   CmdArgs.push_back(Output.getFilename());
 
   for (const auto &II : Inputs) {
     assert(II.isFilename() && "Unexpected lipo input.");
     CmdArgs.push_back(II.getFilename());
   }
 
   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
                                     const InputInfo &Output,
                                     const InputInfoList &Inputs,
                                     const ArgList &Args,
                                     const char *LinkingOutput) const {
   ArgStringList CmdArgs;
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
   const InputInfo &Input = Inputs[0];
   assert(Input.isFilename() && "Unexpected dsymutil input.");
   CmdArgs.push_back(Input.getFilename());
 
   const char *Exec =
     Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
                                        const InputInfo &Output,
                                        const InputInfoList &Inputs,
                                        const ArgList &Args,
                                        const char *LinkingOutput) const {
   ArgStringList CmdArgs;
   CmdArgs.push_back("--verify");
   CmdArgs.push_back("--debug-info");
   CmdArgs.push_back("--eh-frame");
   CmdArgs.push_back("--quiet");
 
   assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
   const InputInfo &Input = Inputs[0];
   assert(Input.isFilename() && "Unexpected verify input");
 
   // Grabbing the output of the earlier dsymutil run.
   CmdArgs.push_back(Input.getFilename());
 
   const char *Exec =
     Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
                                       const InputInfo &Output,
                                       const InputInfoList &Inputs,
                                       const ArgList &Args,
                                       const char *LinkingOutput) const {
   claimNoWarnArgs(Args);
   ArgStringList CmdArgs;
 
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
                        options::OPT_Xassembler);
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   for (const auto &II : Inputs)
     CmdArgs.push_back(II.getFilename());
 
   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
                                   const InputInfo &Output,
                                   const InputInfoList &Inputs,
                                   const ArgList &Args,
                                   const char *LinkingOutput) const {
   // FIXME: Find a real GCC, don't hard-code versions here
   std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
   const llvm::Triple &T = getToolChain().getTriple();
   std::string LibPath = "/usr/lib/";
   llvm::Triple::ArchType Arch = T.getArch();
   switch (Arch) {
   case llvm::Triple::x86:
     GCCLibPath +=
         ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
     break;
   case llvm::Triple::x86_64:
     GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
     GCCLibPath += "/4.5.2/amd64/";
     LibPath += "amd64/";
     break;
   default:
     llvm_unreachable("Unsupported architecture");
   }
 
   ArgStringList CmdArgs;
 
   // Demangle C++ names in errors
   CmdArgs.push_back("-C");
 
   if ((!Args.hasArg(options::OPT_nostdlib)) &&
       (!Args.hasArg(options::OPT_shared))) {
     CmdArgs.push_back("-e");
     CmdArgs.push_back("_start");
   }
 
   if (Args.hasArg(options::OPT_static)) {
     CmdArgs.push_back("-Bstatic");
     CmdArgs.push_back("-dn");
   } else {
     CmdArgs.push_back("-Bdynamic");
     if (Args.hasArg(options::OPT_shared)) {
       CmdArgs.push_back("-shared");
     } else {
       CmdArgs.push_back("--dynamic-linker");
       CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
     }
   }
 
   if (Output.isFilename()) {
     CmdArgs.push_back("-o");
     CmdArgs.push_back(Output.getFilename());
   } else {
     assert(Output.isNothing() && "Invalid output.");
   }
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nostartfiles)) {
     if (!Args.hasArg(options::OPT_shared)) {
       CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
       CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
       CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
       CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
     } else {
       CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
       CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
       CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
     }
     if (getToolChain().getDriver().CCCIsCXX())
       CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
   }
 
   CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
 
   Args.AddAllArgs(CmdArgs, options::OPT_L);
   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
   Args.AddAllArgs(CmdArgs, options::OPT_e);
   Args.AddAllArgs(CmdArgs, options::OPT_r);
 
   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nodefaultlibs)) {
     if (getToolChain().getDriver().CCCIsCXX())
       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
     CmdArgs.push_back("-lgcc_s");
     if (!Args.hasArg(options::OPT_shared)) {
       CmdArgs.push_back("-lgcc");
       CmdArgs.push_back("-lc");
       CmdArgs.push_back("-lm");
     }
   }
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nostartfiles)) {
     CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
   }
   CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
 
   addProfileRT(getToolChain(), Args, CmdArgs);
 
   const char *Exec =
     Args.MakeArgString(getToolChain().GetLinkerPath());
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
                                      const InputInfo &Output,
                                      const InputInfoList &Inputs,
                                      const ArgList &Args,
                                      const char *LinkingOutput) const {
   claimNoWarnArgs(Args);
   ArgStringList CmdArgs;
   bool NeedsKPIC = false;
 
   switch (getToolChain().getArch()) {
   case llvm::Triple::x86:
     // When building 32-bit code on OpenBSD/amd64, we have to explicitly
     // instruct as in the base system to assemble 32-bit code.
     CmdArgs.push_back("--32");
     break;
 
   case llvm::Triple::ppc:
     CmdArgs.push_back("-mppc");
     CmdArgs.push_back("-many");
     break;
 
   case llvm::Triple::sparc:
     CmdArgs.push_back("-32");
     NeedsKPIC = true;
     break;
 
   case llvm::Triple::sparcv9:
     CmdArgs.push_back("-64");
     CmdArgs.push_back("-Av9a");
     NeedsKPIC = true;
     break;
 
   case llvm::Triple::mips64:
   case llvm::Triple::mips64el: {
     StringRef CPUName;
     StringRef ABIName;
     mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
 
     CmdArgs.push_back("-mabi");
     CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
 
     if (getToolChain().getArch() == llvm::Triple::mips64)
       CmdArgs.push_back("-EB");
     else
       CmdArgs.push_back("-EL");
 
     NeedsKPIC = true;
     break;
   }
 
   default:
     break;
   }
 
   if (NeedsKPIC)
     addAssemblerKPIC(Args, CmdArgs);
 
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
                        options::OPT_Xassembler);
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   for (const auto &II : Inputs)
     CmdArgs.push_back(II.getFilename());
 
   const char *Exec =
     Args.MakeArgString(getToolChain().GetProgramPath("as"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
                                  const InputInfo &Output,
                                  const InputInfoList &Inputs,
                                  const ArgList &Args,
                                  const char *LinkingOutput) const {
   const Driver &D = getToolChain().getDriver();
   ArgStringList CmdArgs;
 
   // Silence warning for "clang -g foo.o -o foo"
   Args.ClaimAllArgs(options::OPT_g_Group);
   // and "clang -emit-llvm foo.o -o foo"
   Args.ClaimAllArgs(options::OPT_emit_llvm);
   // and for "clang -w foo.o -o foo". Other warning options are already
   // handled somewhere else.
   Args.ClaimAllArgs(options::OPT_w);
 
   if (getToolChain().getArch() == llvm::Triple::mips64)
     CmdArgs.push_back("-EB");
   else if (getToolChain().getArch() == llvm::Triple::mips64el)
     CmdArgs.push_back("-EL");
 
   if ((!Args.hasArg(options::OPT_nostdlib)) &&
       (!Args.hasArg(options::OPT_shared))) {
     CmdArgs.push_back("-e");
     CmdArgs.push_back("__start");
   }
 
   if (Args.hasArg(options::OPT_static)) {
     CmdArgs.push_back("-Bstatic");
   } else {
     if (Args.hasArg(options::OPT_rdynamic))
       CmdArgs.push_back("-export-dynamic");
     CmdArgs.push_back("--eh-frame-hdr");
     CmdArgs.push_back("-Bdynamic");
     if (Args.hasArg(options::OPT_shared)) {
       CmdArgs.push_back("-shared");
     } else {
       CmdArgs.push_back("-dynamic-linker");
       CmdArgs.push_back("/usr/libexec/ld.so");
     }
   }
 
   if (Args.hasArg(options::OPT_nopie))
     CmdArgs.push_back("-nopie");
 
   if (Output.isFilename()) {
     CmdArgs.push_back("-o");
     CmdArgs.push_back(Output.getFilename());
   } else {
     assert(Output.isNothing() && "Invalid output.");
   }
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nostartfiles)) {
     if (!Args.hasArg(options::OPT_shared)) {
       if (Args.hasArg(options::OPT_pg))  
         CmdArgs.push_back(Args.MakeArgString(
                                 getToolChain().GetFilePath("gcrt0.o")));
       else
         CmdArgs.push_back(Args.MakeArgString(
                                 getToolChain().GetFilePath("crt0.o")));
       CmdArgs.push_back(Args.MakeArgString(
                               getToolChain().GetFilePath("crtbegin.o")));
     } else {
       CmdArgs.push_back(Args.MakeArgString(
                               getToolChain().GetFilePath("crtbeginS.o")));
     }
   }
 
   std::string Triple = getToolChain().getTripleString();
   if (Triple.substr(0, 6) == "x86_64")
     Triple.replace(0, 6, "amd64");
   CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
                                        "/4.2.1"));
 
   Args.AddAllArgs(CmdArgs, options::OPT_L);
   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
   Args.AddAllArgs(CmdArgs, options::OPT_e);
   Args.AddAllArgs(CmdArgs, options::OPT_s);
   Args.AddAllArgs(CmdArgs, options::OPT_t);
   Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
   Args.AddAllArgs(CmdArgs, options::OPT_r);
 
   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nodefaultlibs)) {
     if (D.CCCIsCXX()) {
       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
       if (Args.hasArg(options::OPT_pg)) 
         CmdArgs.push_back("-lm_p");
       else
         CmdArgs.push_back("-lm");
     }
 
     // FIXME: For some reason GCC passes -lgcc before adding
     // the default system libraries. Just mimic this for now.
     CmdArgs.push_back("-lgcc");
 
     if (Args.hasArg(options::OPT_pthread)) {
       if (!Args.hasArg(options::OPT_shared) &&
           Args.hasArg(options::OPT_pg))
          CmdArgs.push_back("-lpthread_p");
       else
          CmdArgs.push_back("-lpthread");
     }
 
     if (!Args.hasArg(options::OPT_shared)) {
       if (Args.hasArg(options::OPT_pg))
          CmdArgs.push_back("-lc_p");
       else
          CmdArgs.push_back("-lc");
     }
 
     CmdArgs.push_back("-lgcc");
   }
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nostartfiles)) {
     if (!Args.hasArg(options::OPT_shared))
       CmdArgs.push_back(Args.MakeArgString(
                               getToolChain().GetFilePath("crtend.o")));
     else
       CmdArgs.push_back(Args.MakeArgString(
                               getToolChain().GetFilePath("crtendS.o")));
   }
 
   const char *Exec =
     Args.MakeArgString(getToolChain().GetLinkerPath());
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
                                     const InputInfo &Output,
                                     const InputInfoList &Inputs,
                                     const ArgList &Args,
                                     const char *LinkingOutput) const {
   claimNoWarnArgs(Args);
   ArgStringList CmdArgs;
 
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
                        options::OPT_Xassembler);
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   for (const auto &II : Inputs)
     CmdArgs.push_back(II.getFilename());
 
   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
                                 const InputInfo &Output,
                                 const InputInfoList &Inputs,
                                 const ArgList &Args,
                                 const char *LinkingOutput) const {
   const Driver &D = getToolChain().getDriver();
   ArgStringList CmdArgs;
 
   if ((!Args.hasArg(options::OPT_nostdlib)) &&
       (!Args.hasArg(options::OPT_shared))) {
     CmdArgs.push_back("-e");
     CmdArgs.push_back("__start");
   }
 
   if (Args.hasArg(options::OPT_static)) {
     CmdArgs.push_back("-Bstatic");
   } else {
     if (Args.hasArg(options::OPT_rdynamic))
       CmdArgs.push_back("-export-dynamic");
     CmdArgs.push_back("--eh-frame-hdr");
     CmdArgs.push_back("-Bdynamic");
     if (Args.hasArg(options::OPT_shared)) {
       CmdArgs.push_back("-shared");
     } else {
       CmdArgs.push_back("-dynamic-linker");
       CmdArgs.push_back("/usr/libexec/ld.so");
     }
   }
 
   if (Output.isFilename()) {
     CmdArgs.push_back("-o");
     CmdArgs.push_back(Output.getFilename());
   } else {
     assert(Output.isNothing() && "Invalid output.");
   }
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nostartfiles)) {
     if (!Args.hasArg(options::OPT_shared)) {
       if (Args.hasArg(options::OPT_pg))
         CmdArgs.push_back(Args.MakeArgString(
                                 getToolChain().GetFilePath("gcrt0.o")));
       else
         CmdArgs.push_back(Args.MakeArgString(
                                 getToolChain().GetFilePath("crt0.o")));
       CmdArgs.push_back(Args.MakeArgString(
                               getToolChain().GetFilePath("crtbegin.o")));
     } else {
       CmdArgs.push_back(Args.MakeArgString(
                               getToolChain().GetFilePath("crtbeginS.o")));
     }
   }
 
   Args.AddAllArgs(CmdArgs, options::OPT_L);
   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
   Args.AddAllArgs(CmdArgs, options::OPT_e);
 
   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nodefaultlibs)) {
     if (D.CCCIsCXX()) {
       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
       if (Args.hasArg(options::OPT_pg))
         CmdArgs.push_back("-lm_p");
       else
         CmdArgs.push_back("-lm");
     }
 
     if (Args.hasArg(options::OPT_pthread)) {
       if (!Args.hasArg(options::OPT_shared) &&
           Args.hasArg(options::OPT_pg))
         CmdArgs.push_back("-lpthread_p");
       else
         CmdArgs.push_back("-lpthread");
     }
 
     if (!Args.hasArg(options::OPT_shared)) {
       if (Args.hasArg(options::OPT_pg))
         CmdArgs.push_back("-lc_p");
       else
         CmdArgs.push_back("-lc");
     }
 
     StringRef MyArch;
     switch (getToolChain().getTriple().getArch()) {
     case llvm::Triple::arm:
       MyArch = "arm";
       break;
     case llvm::Triple::x86:
       MyArch = "i386";
       break;
     case llvm::Triple::x86_64:
       MyArch = "amd64";
       break;
     default:
       llvm_unreachable("Unsupported architecture");
     }
     CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
   }
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nostartfiles)) {
     if (!Args.hasArg(options::OPT_shared))
       CmdArgs.push_back(Args.MakeArgString(
                               getToolChain().GetFilePath("crtend.o")));
     else
       CmdArgs.push_back(Args.MakeArgString(
                               getToolChain().GetFilePath("crtendS.o")));
   }
 
   const char *Exec =
     Args.MakeArgString(getToolChain().GetLinkerPath());
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
                                      const InputInfo &Output,
                                      const InputInfoList &Inputs,
                                      const ArgList &Args,
                                      const char *LinkingOutput) const {
   claimNoWarnArgs(Args);
   ArgStringList CmdArgs;
 
   // When building 32-bit code on FreeBSD/amd64, we have to explicitly
   // instruct as in the base system to assemble 32-bit code.
   if (getToolChain().getArch() == llvm::Triple::x86)
     CmdArgs.push_back("--32");
   else if (getToolChain().getArch() == llvm::Triple::ppc)
     CmdArgs.push_back("-a32");
   else if (getToolChain().getArch() == llvm::Triple::mips ||
            getToolChain().getArch() == llvm::Triple::mipsel ||
            getToolChain().getArch() == llvm::Triple::mips64 ||
            getToolChain().getArch() == llvm::Triple::mips64el) {
     StringRef CPUName;
     StringRef ABIName;
     mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
 
     CmdArgs.push_back("-march");
     CmdArgs.push_back(CPUName.data());
 
     CmdArgs.push_back("-mabi");
     CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
 
     if (getToolChain().getArch() == llvm::Triple::mips ||
         getToolChain().getArch() == llvm::Triple::mips64)
       CmdArgs.push_back("-EB");
     else
       CmdArgs.push_back("-EL");
 
     addAssemblerKPIC(Args, CmdArgs);
   } else if (getToolChain().getArch() == llvm::Triple::arm ||
              getToolChain().getArch() == llvm::Triple::armeb ||
              getToolChain().getArch() == llvm::Triple::thumb ||
              getToolChain().getArch() == llvm::Triple::thumbeb) {
     const Driver &D = getToolChain().getDriver();
     const llvm::Triple &Triple = getToolChain().getTriple();
     StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
 
     if (FloatABI == "hard") {
       CmdArgs.push_back("-mfpu=vfp");
     } else {
       CmdArgs.push_back("-mfpu=softvfp");
     }
 
     switch(getToolChain().getTriple().getEnvironment()) {
     case llvm::Triple::GNUEABIHF:
     case llvm::Triple::GNUEABI:
     case llvm::Triple::EABI:
       CmdArgs.push_back("-meabi=5");
       break;
 
     default:
       CmdArgs.push_back("-matpcs");
     }
   } else if (getToolChain().getArch() == llvm::Triple::sparc ||
              getToolChain().getArch() == llvm::Triple::sparcv9) {
     if (getToolChain().getArch() == llvm::Triple::sparc)
       CmdArgs.push_back("-Av8plusa");
     else
       CmdArgs.push_back("-Av9a");
 
     addAssemblerKPIC(Args, CmdArgs);
   }
 
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
                        options::OPT_Xassembler);
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   for (const auto &II : Inputs)
     CmdArgs.push_back(II.getFilename());
 
   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
                                  const InputInfo &Output,
                                  const InputInfoList &Inputs,
                                  const ArgList &Args,
                                  const char *LinkingOutput) const {
   const toolchains::FreeBSD& ToolChain = 
     static_cast<const toolchains::FreeBSD&>(getToolChain());
   const Driver &D = ToolChain.getDriver();
   const bool IsPIE =
     !Args.hasArg(options::OPT_shared) &&
     (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
   ArgStringList CmdArgs;
 
   // Silence warning for "clang -g foo.o -o foo"
   Args.ClaimAllArgs(options::OPT_g_Group);
   // and "clang -emit-llvm foo.o -o foo"
   Args.ClaimAllArgs(options::OPT_emit_llvm);
   // and for "clang -w foo.o -o foo". Other warning options are already
   // handled somewhere else.
   Args.ClaimAllArgs(options::OPT_w);
 
   if (!D.SysRoot.empty())
     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
 
   if (IsPIE)
     CmdArgs.push_back("-pie");
 
   if (Args.hasArg(options::OPT_static)) {
     CmdArgs.push_back("-Bstatic");
   } else {
     if (Args.hasArg(options::OPT_rdynamic))
       CmdArgs.push_back("-export-dynamic");
     CmdArgs.push_back("--eh-frame-hdr");
     if (Args.hasArg(options::OPT_shared)) {
       CmdArgs.push_back("-Bshareable");
     } else {
       CmdArgs.push_back("-dynamic-linker");
       CmdArgs.push_back("/libexec/ld-elf.so.1");
     }
     if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
       llvm::Triple::ArchType Arch = ToolChain.getArch();
       if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
           Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
         CmdArgs.push_back("--hash-style=both");
       }
     }
     CmdArgs.push_back("--enable-new-dtags");
   }
 
   // When building 32-bit code on FreeBSD/amd64, we have to explicitly
   // instruct ld in the base system to link 32-bit code.
   if (ToolChain.getArch() == llvm::Triple::x86) {
     CmdArgs.push_back("-m");
     CmdArgs.push_back("elf_i386_fbsd");
   }
 
   if (ToolChain.getArch() == llvm::Triple::ppc) {
     CmdArgs.push_back("-m");
     CmdArgs.push_back("elf32ppc_fbsd");
   }
 
   if (Arg *A = Args.getLastArg(options::OPT_G)) {
     if (ToolChain.getArch() == llvm::Triple::mips ||
       ToolChain.getArch() == llvm::Triple::mipsel ||
       ToolChain.getArch() == llvm::Triple::mips64 ||
       ToolChain.getArch() == llvm::Triple::mips64el) {
       StringRef v = A->getValue();
       CmdArgs.push_back(Args.MakeArgString("-G" + v));
       A->claim();
     }
   }
 
   if (Output.isFilename()) {
     CmdArgs.push_back("-o");
     CmdArgs.push_back(Output.getFilename());
   } else {
     assert(Output.isNothing() && "Invalid output.");
   }
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nostartfiles)) {
     const char *crt1 = nullptr;
     if (!Args.hasArg(options::OPT_shared)) {
       if (Args.hasArg(options::OPT_pg))
         crt1 = "gcrt1.o";
       else if (IsPIE)
         crt1 = "Scrt1.o";
       else
         crt1 = "crt1.o";
     }
     if (crt1)
       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
 
     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
 
     const char *crtbegin = nullptr;
     if (Args.hasArg(options::OPT_static))
       crtbegin = "crtbeginT.o";
     else if (Args.hasArg(options::OPT_shared) || IsPIE)
       crtbegin = "crtbeginS.o";
     else
       crtbegin = "crtbegin.o";
 
     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
   }
 
   Args.AddAllArgs(CmdArgs, options::OPT_L);
   const ToolChain::path_list &Paths = ToolChain.getFilePaths();
   for (const auto &Path : Paths)
     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
   Args.AddAllArgs(CmdArgs, options::OPT_e);
   Args.AddAllArgs(CmdArgs, options::OPT_s);
   Args.AddAllArgs(CmdArgs, options::OPT_t);
   Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
   Args.AddAllArgs(CmdArgs, options::OPT_r);
 
   if (D.IsUsingLTO(Args))
     AddGoldPlugin(ToolChain, Args, CmdArgs);
 
   bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nodefaultlibs)) {
     if (D.CCCIsCXX()) {
       ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
       if (Args.hasArg(options::OPT_pg))
         CmdArgs.push_back("-lm_p");
       else
         CmdArgs.push_back("-lm");
     }
     if (NeedsSanitizerDeps)
       linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
     // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
     // the default system libraries. Just mimic this for now.
     if (Args.hasArg(options::OPT_pg))
       CmdArgs.push_back("-lgcc_p");
     else
       CmdArgs.push_back("-lgcc");
     if (Args.hasArg(options::OPT_static)) {
       CmdArgs.push_back("-lgcc_eh");
     } else if (Args.hasArg(options::OPT_pg)) {
       CmdArgs.push_back("-lgcc_eh_p");
     } else {
       CmdArgs.push_back("--as-needed");
       CmdArgs.push_back("-lgcc_s");
       CmdArgs.push_back("--no-as-needed");
     }
 
     if (Args.hasArg(options::OPT_pthread)) {
       if (Args.hasArg(options::OPT_pg))
         CmdArgs.push_back("-lpthread_p");
       else
         CmdArgs.push_back("-lpthread");
     }
 
     if (Args.hasArg(options::OPT_pg)) {
       if (Args.hasArg(options::OPT_shared))
         CmdArgs.push_back("-lc");
       else
         CmdArgs.push_back("-lc_p");
       CmdArgs.push_back("-lgcc_p");
     } else {
       CmdArgs.push_back("-lc");
       CmdArgs.push_back("-lgcc");
     }
 
     if (Args.hasArg(options::OPT_static)) {
       CmdArgs.push_back("-lgcc_eh");
     } else if (Args.hasArg(options::OPT_pg)) {
       CmdArgs.push_back("-lgcc_eh_p");
     } else {
       CmdArgs.push_back("--as-needed");
       CmdArgs.push_back("-lgcc_s");
       CmdArgs.push_back("--no-as-needed");
     }
   }
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nostartfiles)) {
     if (Args.hasArg(options::OPT_shared) || IsPIE)
       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
     else
       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
   }
 
   addProfileRT(ToolChain, Args, CmdArgs);
 
   const char *Exec =
     Args.MakeArgString(getToolChain().GetLinkerPath());
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
                                      const InputInfo &Output,
                                      const InputInfoList &Inputs,
                                      const ArgList &Args,
                                      const char *LinkingOutput) const {
   claimNoWarnArgs(Args);
   ArgStringList CmdArgs;
 
   // GNU as needs different flags for creating the correct output format
   // on architectures with different ABIs or optional feature sets.
   switch (getToolChain().getArch()) {
   case llvm::Triple::x86:
     CmdArgs.push_back("--32");
     break;
   case llvm::Triple::arm:
   case llvm::Triple::armeb:
   case llvm::Triple::thumb:
   case llvm::Triple::thumbeb: {
     std::string MArch(arm::getARMTargetCPU(Args, getToolChain().getTriple()));
     CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
     break;
   }
 
   case llvm::Triple::mips:
   case llvm::Triple::mipsel:
   case llvm::Triple::mips64:
   case llvm::Triple::mips64el: {
     StringRef CPUName;
     StringRef ABIName;
     mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
 
     CmdArgs.push_back("-march");
     CmdArgs.push_back(CPUName.data());
 
     CmdArgs.push_back("-mabi");
     CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
 
     if (getToolChain().getArch() == llvm::Triple::mips ||
         getToolChain().getArch() == llvm::Triple::mips64)
       CmdArgs.push_back("-EB");
     else
       CmdArgs.push_back("-EL");
 
     addAssemblerKPIC(Args, CmdArgs);
     break;
   }
 
   case llvm::Triple::sparc:
     CmdArgs.push_back("-32");
     addAssemblerKPIC(Args, CmdArgs);
     break;
 
   case llvm::Triple::sparcv9:
     CmdArgs.push_back("-64");
     CmdArgs.push_back("-Av9");
     addAssemblerKPIC(Args, CmdArgs);
     break;
 
   default:
     break;  
   }
 
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
                        options::OPT_Xassembler);
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   for (const auto &II : Inputs)
     CmdArgs.push_back(II.getFilename());
 
   const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
                                  const InputInfo &Output,
                                  const InputInfoList &Inputs,
                                  const ArgList &Args,
                                  const char *LinkingOutput) const {
   const Driver &D = getToolChain().getDriver();
   ArgStringList CmdArgs;
 
   if (!D.SysRoot.empty())
     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
 
   CmdArgs.push_back("--eh-frame-hdr");
   if (Args.hasArg(options::OPT_static)) {
     CmdArgs.push_back("-Bstatic");
   } else {
     if (Args.hasArg(options::OPT_rdynamic))
       CmdArgs.push_back("-export-dynamic");
     if (Args.hasArg(options::OPT_shared)) {
       CmdArgs.push_back("-Bshareable");
     } else {
       CmdArgs.push_back("-dynamic-linker");
       CmdArgs.push_back("/libexec/ld.elf_so");
     }
   }
 
   // Many NetBSD architectures support more than one ABI.
   // Determine the correct emulation for ld.
   switch (getToolChain().getArch()) {
   case llvm::Triple::x86:
     CmdArgs.push_back("-m");
     CmdArgs.push_back("elf_i386");
     break;
   case llvm::Triple::arm:
   case llvm::Triple::thumb:
     CmdArgs.push_back("-m");
     switch (getToolChain().getTriple().getEnvironment()) {
     case llvm::Triple::EABI:
     case llvm::Triple::GNUEABI:
       CmdArgs.push_back("armelf_nbsd_eabi");
       break;
     case llvm::Triple::EABIHF:
     case llvm::Triple::GNUEABIHF:
       CmdArgs.push_back("armelf_nbsd_eabihf");
       break;
     default:
       CmdArgs.push_back("armelf_nbsd");
       break;
     }
     break;
   case llvm::Triple::armeb:
   case llvm::Triple::thumbeb:
     CmdArgs.push_back("-m");
     switch (getToolChain().getTriple().getEnvironment()) {
     case llvm::Triple::EABI:
     case llvm::Triple::GNUEABI:
       CmdArgs.push_back("armelfb_nbsd_eabi");
       break;
     case llvm::Triple::EABIHF:
     case llvm::Triple::GNUEABIHF:
       CmdArgs.push_back("armelfb_nbsd_eabihf");
       break;
     default:
       CmdArgs.push_back("armelfb_nbsd");
       break;
     }
     break;
   case llvm::Triple::mips64:
   case llvm::Triple::mips64el:
     if (mips::hasMipsAbiArg(Args, "32")) {
       CmdArgs.push_back("-m");
       if (getToolChain().getArch() == llvm::Triple::mips64)
         CmdArgs.push_back("elf32btsmip");
       else
         CmdArgs.push_back("elf32ltsmip");
    } else if (mips::hasMipsAbiArg(Args, "64")) {
      CmdArgs.push_back("-m");
      if (getToolChain().getArch() == llvm::Triple::mips64)
        CmdArgs.push_back("elf64btsmip");
      else
        CmdArgs.push_back("elf64ltsmip");
    }
    break;
   case llvm::Triple::ppc:
     CmdArgs.push_back("-m");
     CmdArgs.push_back("elf32ppc_nbsd");
     break;
 
   case llvm::Triple::ppc64:
   case llvm::Triple::ppc64le:
     CmdArgs.push_back("-m");
     CmdArgs.push_back("elf64ppc");
     break;
 
   case llvm::Triple::sparc:
     CmdArgs.push_back("-m");
     CmdArgs.push_back("elf32_sparc");
     break;
 
   case llvm::Triple::sparcv9:
     CmdArgs.push_back("-m");
     CmdArgs.push_back("elf64_sparc");
     break;
 
   default:
     break;
   }
 
   if (Output.isFilename()) {
     CmdArgs.push_back("-o");
     CmdArgs.push_back(Output.getFilename());
   } else {
     assert(Output.isNothing() && "Invalid output.");
   }
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nostartfiles)) {
     if (!Args.hasArg(options::OPT_shared)) {
       CmdArgs.push_back(Args.MakeArgString(
                               getToolChain().GetFilePath("crt0.o")));
       CmdArgs.push_back(Args.MakeArgString(
                               getToolChain().GetFilePath("crti.o")));
       CmdArgs.push_back(Args.MakeArgString(
                               getToolChain().GetFilePath("crtbegin.o")));
     } else {
       CmdArgs.push_back(Args.MakeArgString(
                               getToolChain().GetFilePath("crti.o")));
       CmdArgs.push_back(Args.MakeArgString(
                               getToolChain().GetFilePath("crtbeginS.o")));
     }
   }
 
   Args.AddAllArgs(CmdArgs, options::OPT_L);
   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
   Args.AddAllArgs(CmdArgs, options::OPT_e);
   Args.AddAllArgs(CmdArgs, options::OPT_s);
   Args.AddAllArgs(CmdArgs, options::OPT_t);
   Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
   Args.AddAllArgs(CmdArgs, options::OPT_r);
 
   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
 
   unsigned Major, Minor, Micro;
   getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
   bool useLibgcc = true;
   if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 49) || Major == 0) {
     switch(getToolChain().getArch()) {
     case llvm::Triple::aarch64:
     case llvm::Triple::arm:
     case llvm::Triple::armeb:
     case llvm::Triple::thumb:
     case llvm::Triple::thumbeb:
     case llvm::Triple::ppc:
     case llvm::Triple::ppc64:
     case llvm::Triple::ppc64le:
     case llvm::Triple::x86:
     case llvm::Triple::x86_64:
       useLibgcc = false;
       break;
     default:
       break;
     }
   }
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nodefaultlibs)) {
     if (D.CCCIsCXX()) {
       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
       CmdArgs.push_back("-lm");
     }
     if (Args.hasArg(options::OPT_pthread))
       CmdArgs.push_back("-lpthread");
     CmdArgs.push_back("-lc");
 
     if (useLibgcc) {
       if (Args.hasArg(options::OPT_static)) {
         // libgcc_eh depends on libc, so resolve as much as possible,
         // pull in any new requirements from libc and then get the rest
         // of libgcc.
         CmdArgs.push_back("-lgcc_eh");
         CmdArgs.push_back("-lc");
         CmdArgs.push_back("-lgcc");
       } else {
         CmdArgs.push_back("-lgcc");
         CmdArgs.push_back("--as-needed");
         CmdArgs.push_back("-lgcc_s");
         CmdArgs.push_back("--no-as-needed");
       }
     }
   }
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nostartfiles)) {
     if (!Args.hasArg(options::OPT_shared))
       CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
                                                                   "crtend.o")));
     else
       CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
                                                                  "crtendS.o")));
     CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
                                                                     "crtn.o")));
   }
 
   addProfileRT(getToolChain(), Args, CmdArgs);
 
   const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
                                       const InputInfo &Output,
                                       const InputInfoList &Inputs,
                                       const ArgList &Args,
                                       const char *LinkingOutput) const {
   claimNoWarnArgs(Args);
 
   ArgStringList CmdArgs;
   bool NeedsKPIC = false;
 
   // Add --32/--64 to make sure we get the format we want.
   // This is incomplete
   if (getToolChain().getArch() == llvm::Triple::x86) {
     CmdArgs.push_back("--32");
   } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
     if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
       CmdArgs.push_back("--x32");
     else
       CmdArgs.push_back("--64");
   } else if (getToolChain().getArch() == llvm::Triple::ppc) {
     CmdArgs.push_back("-a32");
     CmdArgs.push_back("-mppc");
     CmdArgs.push_back("-many");
   } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
     CmdArgs.push_back("-a64");
     CmdArgs.push_back("-mppc64");
     CmdArgs.push_back("-many");
   } else if (getToolChain().getArch() == llvm::Triple::ppc64le) {
     CmdArgs.push_back("-a64");
     CmdArgs.push_back("-mppc64");
     CmdArgs.push_back("-many");
     CmdArgs.push_back("-mlittle-endian");
   } else if (getToolChain().getArch() == llvm::Triple::sparc) {
     CmdArgs.push_back("-32");
     CmdArgs.push_back("-Av8plusa");
     NeedsKPIC = true;
   } else if (getToolChain().getArch() == llvm::Triple::sparcv9) {
     CmdArgs.push_back("-64");
     CmdArgs.push_back("-Av9a");
     NeedsKPIC = true;
   } else if (getToolChain().getArch() == llvm::Triple::arm ||
              getToolChain().getArch() == llvm::Triple::armeb) {
     StringRef MArch = getToolChain().getArchName();
     if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
       CmdArgs.push_back("-mfpu=neon");
     if (MArch == "armv8" || MArch == "armv8a" || MArch == "armv8-a" ||
         MArch == "armebv8" || MArch == "armebv8a" || MArch == "armebv8-a")
       CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
 
     StringRef ARMFloatABI = tools::arm::getARMFloatABI(
         getToolChain().getDriver(), Args, getToolChain().getTriple());
     CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
 
     Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
 
     // FIXME: remove krait check when GNU tools support krait cpu
     // for now replace it with -march=armv7-a  to avoid a lower
     // march from being picked in the absence of a cpu flag.
     Arg *A;
     if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
       StringRef(A->getValue()) == "krait")
         CmdArgs.push_back("-march=armv7-a");
     else
       Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
     Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
   } else if (getToolChain().getArch() == llvm::Triple::mips ||
              getToolChain().getArch() == llvm::Triple::mipsel ||
              getToolChain().getArch() == llvm::Triple::mips64 ||
              getToolChain().getArch() == llvm::Triple::mips64el) {
     StringRef CPUName;
     StringRef ABIName;
     mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
     ABIName = getGnuCompatibleMipsABIName(ABIName);
 
     CmdArgs.push_back("-march");
     CmdArgs.push_back(CPUName.data());
 
     CmdArgs.push_back("-mabi");
     CmdArgs.push_back(ABIName.data());
 
     // -mno-shared should be emitted unless -fpic, -fpie, -fPIC, -fPIE,
     // or -mshared (not implemented) is in effect.
     bool IsPicOrPie = false;
     if (Arg *A = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
                                  options::OPT_fpic, options::OPT_fno_pic,
                                  options::OPT_fPIE, options::OPT_fno_PIE,
                                  options::OPT_fpie, options::OPT_fno_pie)) {
       if (A->getOption().matches(options::OPT_fPIC) ||
           A->getOption().matches(options::OPT_fpic) ||
           A->getOption().matches(options::OPT_fPIE) ||
           A->getOption().matches(options::OPT_fpie))
         IsPicOrPie = true;
     }
     if (!IsPicOrPie)
       CmdArgs.push_back("-mno-shared");
 
     // LLVM doesn't support -mplt yet and acts as if it is always given.
     // However, -mplt has no effect with the N64 ABI.
     CmdArgs.push_back(ABIName == "64" ? "-KPIC" : "-call_nonpic");
 
     if (getToolChain().getArch() == llvm::Triple::mips ||
         getToolChain().getArch() == llvm::Triple::mips64)
       CmdArgs.push_back("-EB");
     else
       CmdArgs.push_back("-EL");
 
     if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
       if (StringRef(A->getValue()) == "2008")
         CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
     }
 
     // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default.
     if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
                                  options::OPT_mfp64)) {
       A->claim();
       A->render(Args, CmdArgs);
     } else if (mips::isFPXXDefault(getToolChain().getTriple(), CPUName,
                                    ABIName))
       CmdArgs.push_back("-mfpxx");
 
     // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of
     // -mno-mips16 is actually -no-mips16.
     if (Arg *A = Args.getLastArg(options::OPT_mips16,
                                  options::OPT_mno_mips16)) {
       if (A->getOption().matches(options::OPT_mips16)) {
         A->claim();
         A->render(Args, CmdArgs);
       } else {
         A->claim();
         CmdArgs.push_back("-no-mips16");
       }
     }
 
     Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
                     options::OPT_mno_micromips);
     Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
     Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
 
     if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
       // Do not use AddLastArg because not all versions of MIPS assembler
       // support -mmsa / -mno-msa options.
       if (A->getOption().matches(options::OPT_mmsa))
         CmdArgs.push_back(Args.MakeArgString("-mmsa"));
     }
 
     Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
                     options::OPT_msoft_float);
 
     Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
                     options::OPT_mno_odd_spreg);
 
     NeedsKPIC = true;
   } else if (getToolChain().getArch() == llvm::Triple::systemz) {
     // Always pass an -march option, since our default of z10 is later
     // than the GNU assembler's default.
     StringRef CPUName = getSystemZTargetCPU(Args);
     CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
   }
 
   if (NeedsKPIC)
     addAssemblerKPIC(Args, CmdArgs);
 
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
                        options::OPT_Xassembler);
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   for (const auto &II : Inputs)
     CmdArgs.push_back(II.getFilename());
 
   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 
   // Handle the debug info splitting at object creation time if we're
   // creating an object.
   // TODO: Currently only works on linux with newer objcopy.
   if (Args.hasArg(options::OPT_gsplit_dwarf) &&
       getToolChain().getTriple().isOSLinux())
     SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
                    SplitDebugName(Args, Inputs));
 }
 
 static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
                       ArgStringList &CmdArgs, const ArgList &Args) {
   bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
   bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
                       Args.hasArg(options::OPT_static);
   if (!D.CCCIsCXX())
     CmdArgs.push_back("-lgcc");
 
   if (StaticLibgcc || isAndroid) {
     if (D.CCCIsCXX())
       CmdArgs.push_back("-lgcc");
   } else {
     if (!D.CCCIsCXX())
       CmdArgs.push_back("--as-needed");
     CmdArgs.push_back("-lgcc_s");
     if (!D.CCCIsCXX())
       CmdArgs.push_back("--no-as-needed");
   }
 
   if (StaticLibgcc && !isAndroid)
     CmdArgs.push_back("-lgcc_eh");
   else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
     CmdArgs.push_back("-lgcc");
 
   // According to Android ABI, we have to link with libdl if we are
   // linking with non-static libgcc.
   //
   // NOTE: This fixes a link error on Android MIPS as well.  The non-static
   // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
   if (isAndroid && !StaticLibgcc)
     CmdArgs.push_back("-ldl");
 }
 
 static std::string getLinuxDynamicLinker(const ArgList &Args,
                                          const toolchains::Linux &ToolChain) {
   if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) {
     if (ToolChain.getTriple().isArch64Bit())
       return "/system/bin/linker64";
     else
       return "/system/bin/linker";
   } else if (ToolChain.getArch() == llvm::Triple::x86 ||
              ToolChain.getArch() == llvm::Triple::sparc)
     return "/lib/ld-linux.so.2";
   else if (ToolChain.getArch() == llvm::Triple::aarch64)
     return "/lib/ld-linux-aarch64.so.1";
   else if (ToolChain.getArch() == llvm::Triple::aarch64_be)
     return "/lib/ld-linux-aarch64_be.so.1";
   else if (ToolChain.getArch() == llvm::Triple::arm ||
            ToolChain.getArch() == llvm::Triple::thumb) {
     if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
       return "/lib/ld-linux-armhf.so.3";
     else
       return "/lib/ld-linux.so.3";
   } else if (ToolChain.getArch() == llvm::Triple::armeb ||
              ToolChain.getArch() == llvm::Triple::thumbeb) {
     if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
       return "/lib/ld-linux-armhf.so.3";        /* TODO: check which dynamic linker name.  */
     else
       return "/lib/ld-linux.so.3";              /* TODO: check which dynamic linker name.  */
   } else if (ToolChain.getArch() == llvm::Triple::mips ||
              ToolChain.getArch() == llvm::Triple::mipsel ||
              ToolChain.getArch() == llvm::Triple::mips64 ||
              ToolChain.getArch() == llvm::Triple::mips64el) {
     StringRef CPUName;
     StringRef ABIName;
     mips::getMipsCPUAndABI(Args, ToolChain.getTriple(), CPUName, ABIName);
     bool IsNaN2008 = mips::isNaN2008(Args, ToolChain.getTriple());
 
     StringRef LibDir = llvm::StringSwitch<llvm::StringRef>(ABIName)
                            .Case("o32", "/lib")
                            .Case("n32", "/lib32")
                            .Case("n64", "/lib64")
                            .Default("/lib");
     StringRef LibName;
     if (mips::isUCLibc(Args))
       LibName = IsNaN2008 ? "ld-uClibc-mipsn8.so.0" : "ld-uClibc.so.0";
     else
       LibName = IsNaN2008 ? "ld-linux-mipsn8.so.1" : "ld.so.1";
 
     return (LibDir + "/" + LibName).str();
   } else if (ToolChain.getArch() == llvm::Triple::ppc)
     return "/lib/ld.so.1";
   else if (ToolChain.getArch() == llvm::Triple::ppc64) {
     if (ppc::hasPPCAbiArg(Args, "elfv2"))
       return "/lib64/ld64.so.2";
     return "/lib64/ld64.so.1";
   } else if (ToolChain.getArch() == llvm::Triple::ppc64le) {
     if (ppc::hasPPCAbiArg(Args, "elfv1"))
       return "/lib64/ld64.so.1";
     return "/lib64/ld64.so.2";
   } else if (ToolChain.getArch() == llvm::Triple::systemz)
     return "/lib64/ld64.so.1";
   else if (ToolChain.getArch() == llvm::Triple::sparcv9)
     return "/lib64/ld-linux.so.2";
   else if (ToolChain.getArch() == llvm::Triple::x86_64 &&
            ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUX32)
     return "/libx32/ld-linux-x32.so.2";
   else
     return "/lib64/ld-linux-x86-64.so.2";
 }
 
 static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
                            ArgStringList &CmdArgs, const ArgList &Args) {
   // Make use of compiler-rt if --rtlib option is used
   ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
 
   switch (RLT) {
   case ToolChain::RLT_CompilerRT:
     switch (TC.getTriple().getOS()) {
     default: llvm_unreachable("unsupported OS");
     case llvm::Triple::Win32:
     case llvm::Triple::Linux:
       addClangRT(TC, Args, CmdArgs);
       break;
     }
     break;
   case ToolChain::RLT_Libgcc:
     AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
     break;
   }
 }
 
 static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) {
   switch (T.getArch()) {
   case llvm::Triple::x86:
     return "elf_i386";
   case llvm::Triple::aarch64:
     return "aarch64linux";
   case llvm::Triple::aarch64_be:
     return "aarch64_be_linux";
   case llvm::Triple::arm:
   case llvm::Triple::thumb:
     return "armelf_linux_eabi";
   case llvm::Triple::armeb:
   case llvm::Triple::thumbeb:
     return "armebelf_linux_eabi"; /* TODO: check which NAME.  */
   case llvm::Triple::ppc:
     return "elf32ppclinux";
   case llvm::Triple::ppc64:
     return "elf64ppc";
   case llvm::Triple::ppc64le:
     return "elf64lppc";
   case llvm::Triple::sparc:
     return "elf32_sparc";
   case llvm::Triple::sparcv9:
     return "elf64_sparc";
   case llvm::Triple::mips:
     return "elf32btsmip";
   case llvm::Triple::mipsel:
     return "elf32ltsmip";
   case llvm::Triple::mips64:
     if (mips::hasMipsAbiArg(Args, "n32"))
       return "elf32btsmipn32";
     return "elf64btsmip";
   case llvm::Triple::mips64el:
     if (mips::hasMipsAbiArg(Args, "n32"))
       return "elf32ltsmipn32";
     return "elf64ltsmip";
   case llvm::Triple::systemz:
     return "elf64_s390";
   case llvm::Triple::x86_64:
     if (T.getEnvironment() == llvm::Triple::GNUX32)
       return "elf32_x86_64";
     return "elf_x86_64";
   default:
     llvm_unreachable("Unexpected arch");
   }
 }
 
 void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
                                   const InputInfo &Output,
                                   const InputInfoList &Inputs,
                                   const ArgList &Args,
                                   const char *LinkingOutput) const {
   const toolchains::Linux& ToolChain =
     static_cast<const toolchains::Linux&>(getToolChain());
   const Driver &D = ToolChain.getDriver();
   const bool isAndroid =
     ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
   const bool IsPIE =
     !Args.hasArg(options::OPT_shared) &&
     !Args.hasArg(options::OPT_static) &&
     (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault() ||
      // On Android every code is PIC so every executable is PIE
      // Cannot use isPIEDefault here since otherwise
      // PIE only logic will be enabled during compilation
      isAndroid);
 
   ArgStringList CmdArgs;
 
   // Silence warning for "clang -g foo.o -o foo"
   Args.ClaimAllArgs(options::OPT_g_Group);
   // and "clang -emit-llvm foo.o -o foo"
   Args.ClaimAllArgs(options::OPT_emit_llvm);
   // and for "clang -w foo.o -o foo". Other warning options are already
   // handled somewhere else.
   Args.ClaimAllArgs(options::OPT_w);
 
   if (!D.SysRoot.empty())
     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
 
   if (IsPIE)
     CmdArgs.push_back("-pie");
 
   if (Args.hasArg(options::OPT_rdynamic))
     CmdArgs.push_back("-export-dynamic");
 
   if (Args.hasArg(options::OPT_s))
     CmdArgs.push_back("-s");
 
   for (const auto &Opt : ToolChain.ExtraOpts)
     CmdArgs.push_back(Opt.c_str());
 
   if (!Args.hasArg(options::OPT_static)) {
     CmdArgs.push_back("--eh-frame-hdr");
   }
 
   CmdArgs.push_back("-m");
   CmdArgs.push_back(getLDMOption(ToolChain.getTriple(), Args));
 
   if (Args.hasArg(options::OPT_static)) {
     if (ToolChain.getArch() == llvm::Triple::arm ||
         ToolChain.getArch() == llvm::Triple::armeb ||
         ToolChain.getArch() == llvm::Triple::thumb ||
         ToolChain.getArch() == llvm::Triple::thumbeb)
       CmdArgs.push_back("-Bstatic");
     else
       CmdArgs.push_back("-static");
   } else if (Args.hasArg(options::OPT_shared)) {
     CmdArgs.push_back("-shared");
   }
 
   if (ToolChain.getArch() == llvm::Triple::arm ||
       ToolChain.getArch() == llvm::Triple::armeb ||
       ToolChain.getArch() == llvm::Triple::thumb ||
       ToolChain.getArch() == llvm::Triple::thumbeb ||
       (!Args.hasArg(options::OPT_static) &&
        !Args.hasArg(options::OPT_shared))) {
     CmdArgs.push_back("-dynamic-linker");
     CmdArgs.push_back(Args.MakeArgString(
         D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
   }
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nostartfiles)) {
     if (!isAndroid) {
       const char *crt1 = nullptr;
       if (!Args.hasArg(options::OPT_shared)){
         if (Args.hasArg(options::OPT_pg))
           crt1 = "gcrt1.o";
         else if (IsPIE)
           crt1 = "Scrt1.o";
         else
           crt1 = "crt1.o";
       }
       if (crt1)
         CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
 
       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
     }
 
     const char *crtbegin;
     if (Args.hasArg(options::OPT_static))
       crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
     else if (Args.hasArg(options::OPT_shared))
       crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
     else if (IsPIE)
       crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
     else
       crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
 
     // Add crtfastmath.o if available and fast math is enabled.
     ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
   }
 
   Args.AddAllArgs(CmdArgs, options::OPT_L);
   Args.AddAllArgs(CmdArgs, options::OPT_u);
 
   const ToolChain::path_list &Paths = ToolChain.getFilePaths();
 
   for (const auto &Path : Paths)
     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
 
   if (D.IsUsingLTO(Args))
     AddGoldPlugin(ToolChain, Args, CmdArgs);
 
   if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
     CmdArgs.push_back("--no-demangle");
 
   bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
   // The profile runtime also needs access to system libraries.
   addProfileRT(getToolChain(), Args, CmdArgs);
 
   if (D.CCCIsCXX() &&
       !Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nodefaultlibs)) {
     bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
       !Args.hasArg(options::OPT_static);
     if (OnlyLibstdcxxStatic)
       CmdArgs.push_back("-Bstatic");
     ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
     if (OnlyLibstdcxxStatic)
       CmdArgs.push_back("-Bdynamic");
     CmdArgs.push_back("-lm");
   }
 
   if (!Args.hasArg(options::OPT_nostdlib)) {
     if (!Args.hasArg(options::OPT_nodefaultlibs)) {
       if (Args.hasArg(options::OPT_static))
         CmdArgs.push_back("--start-group");
 
       if (NeedsSanitizerDeps)
         linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
 
       LibOpenMP UsedOpenMPLib = LibUnknown;
       if (Args.hasArg(options::OPT_fopenmp)) {
         UsedOpenMPLib = LibGOMP;
       } else if (const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ)) {
         UsedOpenMPLib = llvm::StringSwitch<LibOpenMP>(A->getValue())
             .Case("libgomp",  LibGOMP)
             .Case("libiomp5", LibIOMP5)
             .Default(LibUnknown);
         if (UsedOpenMPLib == LibUnknown)
           D.Diag(diag::err_drv_unsupported_option_argument)
             << A->getOption().getName() << A->getValue();
       }
       switch (UsedOpenMPLib) {
       case LibGOMP:
         CmdArgs.push_back("-lgomp");
 
         // FIXME: Exclude this for platforms with libgomp that don't require
         // librt. Most modern Linux platforms require it, but some may not.
         CmdArgs.push_back("-lrt");
         break;
       case LibIOMP5:
         CmdArgs.push_back("-liomp5");
         break;
       case LibUnknown:
         break;
       }
       AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
 
       if ((Args.hasArg(options::OPT_pthread) ||
            Args.hasArg(options::OPT_pthreads) || UsedOpenMPLib != LibUnknown) &&
           !isAndroid)
         CmdArgs.push_back("-lpthread");
 
       CmdArgs.push_back("-lc");
 
       if (Args.hasArg(options::OPT_static))
         CmdArgs.push_back("--end-group");
       else
         AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
     }
 
     if (!Args.hasArg(options::OPT_nostartfiles)) {
       const char *crtend;
       if (Args.hasArg(options::OPT_shared))
         crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
       else if (IsPIE)
         crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
       else
         crtend = isAndroid ? "crtend_android.o" : "crtend.o";
 
       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
       if (!isAndroid)
         CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
     }
   }
 
   C.addCommand(
       llvm::make_unique<Command>(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
 }
 
 void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
                                    const InputInfo &Output,
                                    const InputInfoList &Inputs,
                                    const ArgList &Args,
                                    const char *LinkingOutput) const {
   claimNoWarnArgs(Args);
   ArgStringList CmdArgs;
 
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   for (const auto &II : Inputs)
     CmdArgs.push_back(II.getFilename());
 
   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
                                const InputInfo &Output,
                                const InputInfoList &Inputs,
                                const ArgList &Args,
                                const char *LinkingOutput) const {
   const Driver &D = getToolChain().getDriver();
   ArgStringList CmdArgs;
 
   if (Output.isFilename()) {
     CmdArgs.push_back("-o");
     CmdArgs.push_back(Output.getFilename());
   } else {
     assert(Output.isNothing() && "Invalid output.");
   }
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nostartfiles)) {
       CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
       CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
       CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
       CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
   }
 
   Args.AddAllArgs(CmdArgs, options::OPT_L);
   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
   Args.AddAllArgs(CmdArgs, options::OPT_e);
 
   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
 
   addProfileRT(getToolChain(), Args, CmdArgs);
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nodefaultlibs)) {
     if (D.CCCIsCXX()) {
       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
       CmdArgs.push_back("-lm");
     }
   }
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nostartfiles)) {
     if (Args.hasArg(options::OPT_pthread))
       CmdArgs.push_back("-lpthread");
     CmdArgs.push_back("-lc");
     CmdArgs.push_back("-lCompilerRT-Generic");
     CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
     CmdArgs.push_back(
          Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
   }
 
   const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 /// DragonFly Tools
 
 // For now, DragonFly Assemble does just about the same as for
 // FreeBSD, but this may change soon.
 void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
                                        const InputInfo &Output,
                                        const InputInfoList &Inputs,
                                        const ArgList &Args,
                                        const char *LinkingOutput) const {
   claimNoWarnArgs(Args);
   ArgStringList CmdArgs;
 
   // When building 32-bit code on DragonFly/pc64, we have to explicitly
   // instruct as in the base system to assemble 32-bit code.
   if (getToolChain().getArch() == llvm::Triple::x86)
     CmdArgs.push_back("--32");
 
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   for (const auto &II : Inputs)
     CmdArgs.push_back(II.getFilename());
 
   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
                                    const InputInfo &Output,
                                    const InputInfoList &Inputs,
                                    const ArgList &Args,
                                    const char *LinkingOutput) const {
   const Driver &D = getToolChain().getDriver();
   ArgStringList CmdArgs;
   bool UseGCC47 = llvm::sys::fs::exists("/usr/lib/gcc47");
 
   if (!D.SysRoot.empty())
     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
 
   CmdArgs.push_back("--eh-frame-hdr");
   if (Args.hasArg(options::OPT_static)) {
     CmdArgs.push_back("-Bstatic");
   } else {
     if (Args.hasArg(options::OPT_rdynamic))
       CmdArgs.push_back("-export-dynamic");
     if (Args.hasArg(options::OPT_shared))
       CmdArgs.push_back("-Bshareable");
     else {
       CmdArgs.push_back("-dynamic-linker");
       CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
     }
     CmdArgs.push_back("--hash-style=both");
   }
 
   // When building 32-bit code on DragonFly/pc64, we have to explicitly
   // instruct ld in the base system to link 32-bit code.
   if (getToolChain().getArch() == llvm::Triple::x86) {
     CmdArgs.push_back("-m");
     CmdArgs.push_back("elf_i386");
   }
 
   if (Output.isFilename()) {
     CmdArgs.push_back("-o");
     CmdArgs.push_back(Output.getFilename());
   } else {
     assert(Output.isNothing() && "Invalid output.");
   }
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nostartfiles)) {
     if (!Args.hasArg(options::OPT_shared)) {
       if (Args.hasArg(options::OPT_pg))
         CmdArgs.push_back(Args.MakeArgString(
                                 getToolChain().GetFilePath("gcrt1.o")));
       else {
         if (Args.hasArg(options::OPT_pie))
           CmdArgs.push_back(Args.MakeArgString(
                                   getToolChain().GetFilePath("Scrt1.o")));
         else
           CmdArgs.push_back(Args.MakeArgString(
                                   getToolChain().GetFilePath("crt1.o")));
       }
     }
     CmdArgs.push_back(Args.MakeArgString(
                             getToolChain().GetFilePath("crti.o")));
     if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
       CmdArgs.push_back(Args.MakeArgString(
                               getToolChain().GetFilePath("crtbeginS.o")));
     else
       CmdArgs.push_back(Args.MakeArgString(
                               getToolChain().GetFilePath("crtbegin.o")));
   }
 
   Args.AddAllArgs(CmdArgs, options::OPT_L);
   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
   Args.AddAllArgs(CmdArgs, options::OPT_e);
 
   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nodefaultlibs)) {
     // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
     //         rpaths
     if (UseGCC47)
       CmdArgs.push_back("-L/usr/lib/gcc47");
     else
       CmdArgs.push_back("-L/usr/lib/gcc44");
 
     if (!Args.hasArg(options::OPT_static)) {
       if (UseGCC47) {
         CmdArgs.push_back("-rpath");
         CmdArgs.push_back("/usr/lib/gcc47");
       } else {
         CmdArgs.push_back("-rpath");
         CmdArgs.push_back("/usr/lib/gcc44");
       }
     }
 
     if (D.CCCIsCXX()) {
       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
       CmdArgs.push_back("-lm");
     }
 
     if (Args.hasArg(options::OPT_pthread))
       CmdArgs.push_back("-lpthread");
 
     if (!Args.hasArg(options::OPT_nolibc)) {
       CmdArgs.push_back("-lc");
     }
 
     if (UseGCC47) {
       if (Args.hasArg(options::OPT_static) ||
           Args.hasArg(options::OPT_static_libgcc)) {
         CmdArgs.push_back("-lgcc");
         CmdArgs.push_back("-lgcc_eh");
       } else {
         if (Args.hasArg(options::OPT_shared_libgcc)) {
           CmdArgs.push_back("-lgcc_pic");
           if (!Args.hasArg(options::OPT_shared))
             CmdArgs.push_back("-lgcc");
         } else {
           CmdArgs.push_back("-lgcc");
           CmdArgs.push_back("--as-needed");
           CmdArgs.push_back("-lgcc_pic");
           CmdArgs.push_back("--no-as-needed");
         }
       }
     } else {
       if (Args.hasArg(options::OPT_shared)) {
         CmdArgs.push_back("-lgcc_pic");
       } else {
         CmdArgs.push_back("-lgcc");
       }
     }
   }
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nostartfiles)) {
     if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
       CmdArgs.push_back(Args.MakeArgString(
                               getToolChain().GetFilePath("crtendS.o")));
     else
       CmdArgs.push_back(Args.MakeArgString(
                               getToolChain().GetFilePath("crtend.o")));
     CmdArgs.push_back(Args.MakeArgString(
                             getToolChain().GetFilePath("crtn.o")));
   }
 
   addProfileRT(getToolChain(), Args, CmdArgs);
 
   const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 // Try to find Exe from a Visual Studio distribution.  This first tries to find
 // an installed copy of Visual Studio and, failing that, looks in the PATH,
 // making sure that whatever executable that's found is not a same-named exe
 // from clang itself to prevent clang from falling back to itself.
 static std::string FindVisualStudioExecutable(const ToolChain &TC,
                                               const char *Exe,
                                               const char *ClangProgramPath) {
   const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
   std::string visualStudioBinDir;
   if (MSVC.getVisualStudioBinariesFolder(ClangProgramPath,
                                          visualStudioBinDir)) {
     SmallString<128> FilePath(visualStudioBinDir);
     llvm::sys::path::append(FilePath, Exe);
     if (llvm::sys::fs::can_execute(FilePath.c_str()))
       return FilePath.str();
   }
 
   return Exe;
 }
 
 void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
                                       const InputInfo &Output,
                                       const InputInfoList &Inputs,
                                       const ArgList &Args,
                                       const char *LinkingOutput) const {
   ArgStringList CmdArgs;
   const ToolChain &TC = getToolChain();
 
   assert((Output.isFilename() || Output.isNothing()) && "invalid output");
   if (Output.isFilename())
     CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
                                          Output.getFilename()));
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nostartfiles) && !C.getDriver().IsCLMode())
     CmdArgs.push_back("-defaultlib:libcmt");
 
   if (!llvm::sys::Process::GetEnv("LIB")) {
     // If the VC environment hasn't been configured (perhaps because the user
     // did not run vcvarsall), try to build a consistent link environment.  If
     // the environment variable is set however, assume the user knows what he's
     // doing.
     std::string VisualStudioDir;
     const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
     if (MSVC.getVisualStudioInstallDir(VisualStudioDir)) {
       SmallString<128> LibDir(VisualStudioDir);
       llvm::sys::path::append(LibDir, "VC", "lib");
       switch (MSVC.getArch()) {
       case llvm::Triple::x86:
         // x86 just puts the libraries directly in lib
         break;
       case llvm::Triple::x86_64:
         llvm::sys::path::append(LibDir, "amd64");
         break;
       case llvm::Triple::arm:
         llvm::sys::path::append(LibDir, "arm");
         break;
       default:
         break;
       }
       CmdArgs.push_back(
           Args.MakeArgString(std::string("-libpath:") + LibDir.c_str()));
     }
 
     std::string WindowsSdkLibPath;
     if (MSVC.getWindowsSDKLibraryPath(WindowsSdkLibPath))
       CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
                                            WindowsSdkLibPath.c_str()));
   }
 
   CmdArgs.push_back("-nologo");
 
   if (Args.hasArg(options::OPT_g_Group))
     CmdArgs.push_back("-debug");
 
   bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd);
   if (DLL) {
     CmdArgs.push_back(Args.MakeArgString("-dll"));
 
     SmallString<128> ImplibName(Output.getFilename());
     llvm::sys::path::replace_extension(ImplibName, "lib");
     CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
                                          ImplibName.str()));
   }
 
   if (TC.getSanitizerArgs().needsAsanRt()) {
     CmdArgs.push_back(Args.MakeArgString("-debug"));
     CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
     if (Args.hasArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd)) {
       static const char *CompilerRTComponents[] = {
         "asan_dynamic",
         "asan_dynamic_runtime_thunk",
       };
       for (const auto &Component : CompilerRTComponents)
         CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Component)));
       // Make sure the dynamic runtime thunk is not optimized out at link time
       // to ensure proper SEH handling.
       CmdArgs.push_back(Args.MakeArgString("-include:___asan_seh_interceptor"));
     } else if (DLL) {
       CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "asan_dll_thunk")));
     } else {
       static const char *CompilerRTComponents[] = {
         "asan",
         "asan_cxx",
       };
       for (const auto &Component : CompilerRTComponents)
         CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Component)));
     }
   }
 
   Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
 
   // Add filenames, libraries, and other linker inputs.
   for (const auto &Input : Inputs) {
     if (Input.isFilename()) {
       CmdArgs.push_back(Input.getFilename());
       continue;
     }
 
     const Arg &A = Input.getInputArg();
 
     // Render -l options differently for the MSVC linker.
     if (A.getOption().matches(options::OPT_l)) {
       StringRef Lib = A.getValue();
       const char *LinkLibArg;
       if (Lib.endswith(".lib"))
         LinkLibArg = Args.MakeArgString(Lib);
       else
         LinkLibArg = Args.MakeArgString(Lib + ".lib");
       CmdArgs.push_back(LinkLibArg);
       continue;
     }
 
     // Otherwise, this is some other kind of linker input option like -Wl, -z,
     // or -L. Render it, even if MSVC doesn't understand it.
     A.renderAsInput(Args, CmdArgs);
   }
 
   // We need to special case some linker paths.  In the case of lld, we need to
   // translate 'lld' into 'lld-link', and in the case of the regular msvc
   // linker, we need to use a special search algorithm.
   llvm::SmallString<128> linkPath;
   StringRef Linker = Args.getLastArgValue(options::OPT_fuse_ld_EQ, "link");
   if (Linker.equals_lower("lld"))
     Linker = "lld-link";
 
   if (Linker.equals_lower("link")) {
     // If we're using the MSVC linker, it's not sufficient to just use link
     // from the program PATH, because other environments like GnuWin32 install
     // their own link.exe which may come first.
     linkPath = FindVisualStudioExecutable(TC, "link.exe",
                                           C.getDriver().getClangProgramPath());
   } else {
     linkPath = Linker;
     llvm::sys::path::replace_extension(linkPath, "exe");
     linkPath = TC.GetProgramPath(linkPath.c_str());
   }
 
   const char *Exec = Args.MakeArgString(linkPath);
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
                                          const InputInfo &Output,
                                          const InputInfoList &Inputs,
                                          const ArgList &Args,
                                          const char *LinkingOutput) const {
   C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
 }
 
 std::unique_ptr<Command> visualstudio::Compile::GetCommand(
     Compilation &C, const JobAction &JA, const InputInfo &Output,
     const InputInfoList &Inputs, const ArgList &Args,
     const char *LinkingOutput) const {
   ArgStringList CmdArgs;
   CmdArgs.push_back("/nologo");
   CmdArgs.push_back("/c"); // Compile only.
   CmdArgs.push_back("/W0"); // No warnings.
 
   // The goal is to be able to invoke this tool correctly based on
   // any flag accepted by clang-cl.
 
   // These are spelled the same way in clang and cl.exe,.
   Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
   Args.AddAllArgs(CmdArgs, options::OPT_I);
 
   // Optimization level.
   if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
     if (A->getOption().getID() == options::OPT_O0) {
       CmdArgs.push_back("/Od");
     } else {
       StringRef OptLevel = A->getValue();
       if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
         A->render(Args, CmdArgs);
       else if (OptLevel == "3")
         CmdArgs.push_back("/Ox");
     }
   }
 
   // Flags for which clang-cl have an alias.
   // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
 
   if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
                    /*default=*/false))
     CmdArgs.push_back("/GR-");
   if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
                                options::OPT_fno_function_sections))
     CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
                           ? "/Gy"
                           : "/Gy-");
   if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
                                options::OPT_fno_data_sections))
     CmdArgs.push_back(
         A->getOption().getID() == options::OPT_fdata_sections ? "/Gw" : "/Gw-");
   if (Args.hasArg(options::OPT_fsyntax_only))
     CmdArgs.push_back("/Zs");
   if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only))
     CmdArgs.push_back("/Z7");
 
   std::vector<std::string> Includes = Args.getAllArgValues(options::OPT_include);
   for (const auto &Include : Includes)
     CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Include));
 
   // Flags that can simply be passed through.
   Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
   Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
   Args.AddAllArgs(CmdArgs, options::OPT__SLASH_EH);
 
   // The order of these flags is relevant, so pick the last one.
   if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
                                options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
     A->render(Args, CmdArgs);
 
 
   // Input filename.
   assert(Inputs.size() == 1);
   const InputInfo &II = Inputs[0];
   assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
   CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
   if (II.isFilename())
     CmdArgs.push_back(II.getFilename());
   else
     II.getInputArg().renderAsInput(Args, CmdArgs);
 
   // Output filename.
   assert(Output.getType() == types::TY_Object);
   const char *Fo = Args.MakeArgString(std::string("/Fo") +
                                       Output.getFilename());
   CmdArgs.push_back(Fo);
 
   const Driver &D = getToolChain().getDriver();
   std::string Exec = FindVisualStudioExecutable(getToolChain(), "cl.exe",
                                                 D.getClangProgramPath());
   return llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
                                     CmdArgs);
 }
 
 
 /// XCore Tools
 // We pass assemble and link construction to the xcc tool.
 
 void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
                                        const InputInfo &Output,
                                        const InputInfoList &Inputs,
                                        const ArgList &Args,
                                        const char *LinkingOutput) const {
   claimNoWarnArgs(Args);
   ArgStringList CmdArgs;
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   CmdArgs.push_back("-c");
 
   if (Args.hasArg(options::OPT_v))
     CmdArgs.push_back("-v");
 
   if (Arg *A = Args.getLastArg(options::OPT_g_Group))
     if (!A->getOption().matches(options::OPT_g0))
       CmdArgs.push_back("-g");
 
   if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
                    false))
     CmdArgs.push_back("-fverbose-asm");
 
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
                        options::OPT_Xassembler);
 
   for (const auto &II : Inputs)
     CmdArgs.push_back(II.getFilename());
 
   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
                                    const InputInfo &Output,
                                    const InputInfoList &Inputs,
                                    const ArgList &Args,
                                    const char *LinkingOutput) const {
   ArgStringList CmdArgs;
 
   if (Output.isFilename()) {
     CmdArgs.push_back("-o");
     CmdArgs.push_back(Output.getFilename());
   } else {
     assert(Output.isNothing() && "Invalid output.");
   }
 
   if (Args.hasArg(options::OPT_v))
     CmdArgs.push_back("-v");
 
   if (exceptionSettings(Args, getToolChain().getTriple()))
     CmdArgs.push_back("-fexceptions");
 
   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
 
   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 void CrossWindows::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
                                           const InputInfo &Output,
                                           const InputInfoList &Inputs,
                                           const ArgList &Args,
                                           const char *LinkingOutput) const {
   claimNoWarnArgs(Args);
   const auto &TC =
       static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
   ArgStringList CmdArgs;
   const char *Exec;
 
   switch (TC.getArch()) {
   default: llvm_unreachable("unsupported architecture");
   case llvm::Triple::arm:
   case llvm::Triple::thumb:
     break;
   case llvm::Triple::x86:
     CmdArgs.push_back("--32");
     break;
   case llvm::Triple::x86_64:
     CmdArgs.push_back("--64");
     break;
   }
 
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   for (const auto &Input : Inputs)
     CmdArgs.push_back(Input.getFilename());
 
   const std::string Assembler = TC.GetProgramPath("as");
   Exec = Args.MakeArgString(Assembler);
 
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
 
 void CrossWindows::Link::ConstructJob(Compilation &C, const JobAction &JA,
                                       const InputInfo &Output,
                                       const InputInfoList &Inputs,
                                       const ArgList &Args,
                                       const char *LinkingOutput) const {
   const auto &TC =
       static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
   const llvm::Triple &T = TC.getTriple();
   const Driver &D = TC.getDriver();
   SmallString<128> EntryPoint;
   ArgStringList CmdArgs;
   const char *Exec;
 
   // Silence warning for "clang -g foo.o -o foo"
   Args.ClaimAllArgs(options::OPT_g_Group);
   // and "clang -emit-llvm foo.o -o foo"
   Args.ClaimAllArgs(options::OPT_emit_llvm);
   // and for "clang -w foo.o -o foo"
   Args.ClaimAllArgs(options::OPT_w);
   // Other warning options are already handled somewhere else.
 
   if (!D.SysRoot.empty())
     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
 
   if (Args.hasArg(options::OPT_pie))
     CmdArgs.push_back("-pie");
   if (Args.hasArg(options::OPT_rdynamic))
     CmdArgs.push_back("-export-dynamic");
   if (Args.hasArg(options::OPT_s))
     CmdArgs.push_back("--strip-all");
 
   CmdArgs.push_back("-m");
   switch (TC.getArch()) {
   default: llvm_unreachable("unsupported architecture");
   case llvm::Triple::arm:
   case llvm::Triple::thumb:
     // FIXME: this is incorrect for WinCE
     CmdArgs.push_back("thumb2pe");
     break;
   case llvm::Triple::x86:
     CmdArgs.push_back("i386pe");
     EntryPoint.append("_");
     break;
   case llvm::Triple::x86_64:
     CmdArgs.push_back("i386pep");
     break;
   }
 
   if (Args.hasArg(options::OPT_shared)) {
     switch (T.getArch()) {
     default: llvm_unreachable("unsupported architecture");
     case llvm::Triple::arm:
     case llvm::Triple::thumb:
     case llvm::Triple::x86_64:
       EntryPoint.append("_DllMainCRTStartup");
       break;
     case llvm::Triple::x86:
       EntryPoint.append("_DllMainCRTStartup@12");
       break;
     }
 
     CmdArgs.push_back("-shared");
     CmdArgs.push_back("-Bdynamic");
 
     CmdArgs.push_back("--enable-auto-image-base");
 
     CmdArgs.push_back("--entry");
     CmdArgs.push_back(Args.MakeArgString(EntryPoint));
   } else {
     EntryPoint.append("mainCRTStartup");
 
     CmdArgs.push_back(Args.hasArg(options::OPT_static) ? "-Bstatic"
                                                        : "-Bdynamic");
 
     if (!Args.hasArg(options::OPT_nostdlib) &&
         !Args.hasArg(options::OPT_nostartfiles)) {
       CmdArgs.push_back("--entry");
       CmdArgs.push_back(Args.MakeArgString(EntryPoint));
     }
 
     // FIXME: handle subsystem
   }
 
   // NOTE: deal with multiple definitions on Windows (e.g. COMDAT)
   CmdArgs.push_back("--allow-multiple-definition");
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_rdynamic)) {
     SmallString<261> ImpLib(Output.getFilename());
     llvm::sys::path::replace_extension(ImpLib, ".lib");
 
     CmdArgs.push_back("--out-implib");
     CmdArgs.push_back(Args.MakeArgString(ImpLib));
   }
 
   if (!Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nostartfiles)) {
     const std::string CRTPath(D.SysRoot + "/usr/lib/");
     const char *CRTBegin;
 
     CRTBegin =
         Args.hasArg(options::OPT_shared) ? "crtbeginS.obj" : "crtbegin.obj";
     CmdArgs.push_back(Args.MakeArgString(CRTPath + CRTBegin));
   }
 
   Args.AddAllArgs(CmdArgs, options::OPT_L);
 
   const auto &Paths = TC.getFilePaths();
   for (const auto &Path : Paths)
     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
 
   AddLinkerInputs(TC, Inputs, Args, CmdArgs);
 
   if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
       !Args.hasArg(options::OPT_nodefaultlibs)) {
     bool StaticCXX = Args.hasArg(options::OPT_static_libstdcxx) &&
                      !Args.hasArg(options::OPT_static);
     if (StaticCXX)
       CmdArgs.push_back("-Bstatic");
     TC.AddCXXStdlibLibArgs(Args, CmdArgs);
     if (StaticCXX)
       CmdArgs.push_back("-Bdynamic");
   }
 
   if (!Args.hasArg(options::OPT_nostdlib)) {
     if (!Args.hasArg(options::OPT_nodefaultlibs)) {
       // TODO handle /MT[d] /MD[d]
       CmdArgs.push_back("-lmsvcrt");
       AddRunTimeLibs(TC, D, CmdArgs, Args);
     }
   }
 
   const std::string Linker = TC.GetProgramPath("ld");
   Exec = Args.MakeArgString(Linker);
 
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }
Index: projects/clang360-import/contrib/llvm/tools/clang
===================================================================
--- projects/clang360-import/contrib/llvm/tools/clang	(revision 277777)
+++ projects/clang360-import/contrib/llvm/tools/clang	(revision 277778)

Property changes on: projects/clang360-import/contrib/llvm/tools/clang
___________________________________________________________________
Modified: svn:mergeinfo
## -0,0 +0,1 ##
   Merged /head/contrib/llvm/tools/clang:r277719-277776
Index: projects/clang360-import/contrib/llvm
===================================================================
--- projects/clang360-import/contrib/llvm	(revision 277777)
+++ projects/clang360-import/contrib/llvm	(revision 277778)

Property changes on: projects/clang360-import/contrib/llvm
___________________________________________________________________
Modified: svn:mergeinfo
## -0,0 +0,1 ##
   Merged /head/contrib/llvm:r277719-277776
Index: projects/clang360-import/etc/Makefile
===================================================================
--- projects/clang360-import/etc/Makefile	(revision 277777)
+++ projects/clang360-import/etc/Makefile	(revision 277778)
@@ -1,409 +1,414 @@
 #	from: @(#)Makefile	5.11 (Berkeley) 5/21/91
 # $FreeBSD$
 
 .include <src.opts.mk>
 
 SUBDIR=	\
 	newsyslog.conf.d
 
 .if ${MK_SENDMAIL} != "no"
 SUBDIR+=sendmail
 .endif
 
 .if ${MK_TESTS} != "no"
 SUBDIR+=tests
 .endif
 
-BIN1=	auto_master \
-	crontab \
+BIN1=	crontab \
 	devd.conf \
 	devfs.conf \
 	ddb.conf \
 	dhclient.conf \
 	disktab \
 	fbtab \
 	ftpusers \
 	gettytab \
 	group \
 	hosts \
 	hosts.allow \
 	hosts.equiv \
 	inetd.conf \
 	libalias.conf \
 	libmap.conf \
 	login.access \
 	login.conf \
 	mac.conf \
 	motd \
 	netconfig \
 	network.subr \
 	networks \
 	newsyslog.conf \
 	nsswitch.conf \
 	phones \
 	profile \
 	protocols \
 	rc \
 	rc.bsdextended \
 	rc.firewall \
 	rc.initdiskless \
 	rc.sendmail \
 	rc.shutdown \
 	rc.subr \
 	remote \
 	rpc \
 	services \
 	shells \
 	sysctl.conf \
 	syslog.conf \
 	termcap.small
 
 .if ${MACHINE_ARCH} == "amd64" || ${MACHINE_ARCH} == "powerpc64"
 BIN1+=	libmap32.conf
 .endif
 
 .if exists(${.CURDIR}/etc.${MACHINE}/ttys)
 BIN1+=	etc.${MACHINE}/ttys
 .elif exists(${.CURDIR}/etc.${MACHINE_ARCH}/ttys)
 BIN1+=	etc.${MACHINE_ARCH}/ttys
 .elif exists(${.CURDIR}/etc.${MACHINE_CPUARCH}/ttys)
 BIN1+=	etc.${MACHINE_CPUARCH}/ttys
 .else
 .error etc.MACHINE/ttys missing
 .endif
 
 OPENBSMDIR=			${.CURDIR}/../contrib/openbsm
 BSM_ETC_OPEN_FILES=		${OPENBSMDIR}/etc/audit_class \
 				${OPENBSMDIR}/etc/audit_event
 BSM_ETC_RESTRICTED_FILES=	${OPENBSMDIR}/etc/audit_control \
 				${OPENBSMDIR}/etc/audit_user
 BSM_ETC_EXEC_FILES=		${OPENBSMDIR}/etc/audit_warn
 BSM_ETC_DIR=			${DESTDIR}/etc/security
 
 # NB: keep these sorted by MK_* knobs
 
 .if ${MK_AMD} != "no"
 BIN1+= amd.map
 .endif
 
 .if ${MK_APM} != "no"
 BIN1+= apmd.conf
 .endif
 
+.if ${MK_AUTOFS} != "no"
+BIN1+= auto_master
+.endif
+
 .if ${MK_BSNMP} != "no"
 BIN1+= snmpd.config
 .endif
 
 .if ${MK_FREEBSD_UPDATE} != "no"
 BIN1+= freebsd-update.conf
 .endif
 
 .if ${MK_LOCATE} != "no"
 BIN1+=	${.CURDIR}/../usr.bin/locate/locate/locate.rc
 .endif
 
 .if ${MK_LPR} != "no"
 BIN1+=	hosts.lpd printcap
 .endif
 
 .if ${MK_MAIL} != "no"
 BIN1+=	${.CURDIR}/../usr.bin/mail/misc/mail.rc
 .endif
 
 .if ${MK_NTP} != "no"
 BIN1+=	ntp.conf
 .endif
 
 .if ${MK_OPENSSH} != "no"
 SSH=	${.CURDIR}/../crypto/openssh/ssh_config \
 	${.CURDIR}/../crypto/openssh/sshd_config \
 	${.CURDIR}/../crypto/openssh/moduli
 .endif
 .if ${MK_OPENSSL} != "no"
 SSL=	${.CURDIR}/../crypto/openssl/apps/openssl.cnf
 .endif
 
 .if ${MK_NS_CACHING} != "no"
 BIN1+= nscd.conf
 .endif
 
 .if ${MK_PORTSNAP} != "no"
 BIN1+= portsnap.conf
 .endif
 
 .if ${MK_PF} != "no"
 BIN1+= pf.os
 .endif
 
 .if ${MK_TCSH} != "no"
 BIN1+= csh.cshrc csh.login csh.logout
 .endif
 
 .if ${MK_WIRELESS} != "no"
 BIN1+= regdomain.xml
 .endif
 
 # -rwxr-xr-x root:wheel, for the new cron root:wheel
 BIN2=	netstart pccard_ether rc.suspend rc.resume
 
 MTREE=	BSD.include.dist BSD.root.dist BSD.usr.dist BSD.var.dist
 .if ${MK_TESTS} != "no"
 MTREE+=	BSD.tests.dist
 .endif
 .if ${MK_SENDMAIL} != "no"
 MTREE+=	BSD.sendmail.dist
 .endif
 .if ${MK_DEBUG_FILES} != "no"
 MTREE+=	BSD.debug.dist
 .endif
 
 PPPCNF=	ppp.conf
 
 .if ${MK_SENDMAIL} == "no"
 ETCMAIL=mailer.conf aliases
 .else
 ETCMAIL=Makefile README mailer.conf access.sample virtusertable.sample \
 	mailertable.sample aliases
 .endif
 
 # Special top level files for FreeBSD
 FREEBSD=COPYRIGHT
 
 # Sanitize DESTDIR
 DESTDIR:=	${DESTDIR:C://*:/:g}
 
 afterinstall:
 .if ${MK_MAN} != "no"
 	${_+_}cd ${.CURDIR}/../share/man; ${MAKE} makedb
 .endif
 
 distribute:
 	# Avoid installing tests here; "make distribution" will do this and
 	# correctly place them in the right location.
 	${_+_}cd ${.CURDIR} ; ${MAKE} MK_TESTS=no install \
 	    DESTDIR=${DISTDIR}/${DISTRIBUTION}
 	${_+_}cd ${.CURDIR} ; ${MAKE} distribution DESTDIR=${DISTDIR}/${DISTRIBUTION}
 
 .include <bsd.endian.mk>
 .if ${TARGET_ENDIANNESS} == "1234"
 CAP_MKDB_ENDIAN?= -l
 PWD_MKDB_ENDIAN?= -L
 .elif ${TARGET_ENDIANNESS} == "4321"
 CAP_MKDB_ENDIAN?= -b
 PWD_MKDB_ENDIAN?= -B
 .else
 CAP_MKDB_ENDIAN?=
 PWD_MKDB_ENDIAN?=
 .endif
 
 .if defined(NO_ROOT)
 METALOG.add?=	cat -l >> ${METALOG}
 .endif
 
 distribution:
 .if !defined(DESTDIR)
 	@echo "set DESTDIR before running \"make ${.TARGET}\""
 	@false
 .endif
 	cd ${.CURDIR}; \
 	    ${INSTALL} -o ${BINOWN} -g ${BINGRP} -m 644 \
 		${BIN1} ${DESTDIR}/etc; \
 	    cap_mkdb ${CAP_MKDB_ENDIAN} ${DESTDIR}/etc/login.conf; \
 	    ${INSTALL} -o ${BINOWN} -g ${BINGRP} -m 755 \
 		${BIN2} ${DESTDIR}/etc; \
 	    ${INSTALL} -o ${BINOWN} -g ${BINGRP} -m 600 \
 		master.passwd nsmb.conf opieaccess ${DESTDIR}/etc;
 .if ${MK_AT} == "no"
 	sed -i "" -e 's;.*/usr/libexec/atrun;#&;' ${DESTDIR}/etc/crontab
 .endif
 .if ${MK_TCSH} == "no"
 	sed -i "" -e 's;/bin/csh;/bin/sh;' ${DESTDIR}/etc/master.passwd
 .endif
 	pwd_mkdb ${PWD_MKDB_ENDIAN} -i -p -d ${DESTDIR}/etc \
 	    ${DESTDIR}/etc/master.passwd
 .if defined(NO_ROOT)
 	( \
 		echo "./etc/login.conf.db type=file mode=0644 uname=root gname=wheel"; \
 		echo "./etc/passwd type=file mode=0644 uname=root gname=wheel"; \
 		echo "./etc/pwd.db type=file mode=0644 uname=root gname=wheel"; \
 		echo "./etc/spwd.db type=file mode=0600 uname=root gname=wheel"; \
 	) | ${METALOG.add}
 .endif
+.if ${MK_AUTOFS} != "no"
 	${_+_}cd ${.CURDIR}/autofs; ${MAKE} install
+.endif
 .if ${MK_BLUETOOTH} != "no"
 	${_+_}cd ${.CURDIR}/bluetooth; ${MAKE} install
 .endif
 .if ${MK_CASPER} != "no"
 	${_+_}cd ${.CURDIR}/casper; ${MAKE} install
 .endif
 	${_+_}cd ${.CURDIR}/defaults; ${MAKE} install
 	${_+_}cd ${.CURDIR}/devd; ${MAKE} install
 .if ${MK_DMAGENT} != "no"
 	${_+_}cd ${.CURDIR}/dma; ${MAKE} install
 .endif
 	${_+_}cd ${.CURDIR}/gss; ${MAKE} install
 	${_+_}cd ${.CURDIR}/periodic; ${MAKE} install
 	${_+_}cd ${.CURDIR}/pkg; ${MAKE} install
 	${_+_}cd ${.CURDIR}/rc.d; ${MAKE} install
 	${_+_}cd ${.CURDIR}/../share/termcap; ${MAKE} etc-termcap
 	${_+_}cd ${.CURDIR}/../usr.sbin/rmt; ${MAKE} etc-rmt
 	${_+_}cd ${.CURDIR}/pam.d; ${MAKE} install
 	cd ${.CURDIR}; ${INSTALL} -o ${BINOWN} -g ${BINGRP} -m 0444 \
 	    ${BSM_ETC_OPEN_FILES} ${BSM_ETC_DIR}
 	cd ${.CURDIR}; ${INSTALL} -o ${BINOWN} -g ${BINGRP} -m 0600 \
 	    ${BSM_ETC_RESTRICTED_FILES} ${BSM_ETC_DIR}
 	cd ${.CURDIR}; ${INSTALL} -o ${BINOWN} -g ${BINGRP} -m 0500 \
 	    ${BSM_ETC_EXEC_FILES} ${BSM_ETC_DIR}
 .if ${MK_UNBOUND} != "no"
 	if [ ! -e ${DESTDIR}/etc/unbound ]; then \
 		${INSTALL_SYMLINK} ../var/unbound ${DESTDIR}/etc/unbound; \
 	fi
 .endif
 .if ${MK_SENDMAIL} != "no"
 	${_+_}cd ${.CURDIR}/sendmail; ${MAKE} distribution
 .endif
 .if ${MK_OPENSSH} != "no"
 	cd ${.CURDIR}; ${INSTALL} -o ${BINOWN} -g ${BINGRP} -m 644 \
 	    ${SSH} ${DESTDIR}/etc/ssh
 .endif
 .if ${MK_OPENSSL} != "no"
 	cd ${.CURDIR}; ${INSTALL} -o ${BINOWN} -g ${BINGRP} -m 644 \
 	    ${SSL} ${DESTDIR}/etc/ssl
 .endif
 .if ${MK_KERBEROS} != "no"
 	cd ${.CURDIR}/root; \
 	    ${INSTALL} -o ${BINOWN} -g ${BINGRP} -m 644 \
 		dot.k5login ${DESTDIR}/root/.k5login;
 .endif
 	cd ${.CURDIR}/root; \
 	    ${INSTALL} -o ${BINOWN} -g ${BINGRP} -m 644 \
 		dot.profile ${DESTDIR}/root/.profile; \
 	    rm -f ${DESTDIR}/.profile; \
 	    ln ${DESTDIR}/root/.profile ${DESTDIR}/.profile
 .if ${MK_TCSH} != "no"
 	cd ${.CURDIR}/root; \
 	    ${INSTALL} -o ${BINOWN} -g ${BINGRP} -m 644 \
 		dot.cshrc ${DESTDIR}/root/.cshrc; \
 	    ${INSTALL} -o ${BINOWN} -g ${BINGRP} -m 644 \
 		dot.login ${DESTDIR}/root/.login; \
 	    rm -f ${DESTDIR}/.cshrc; \
 	    ln ${DESTDIR}/root/.cshrc ${DESTDIR}/.cshrc
 .endif
 	cd ${.CURDIR}/mtree; ${INSTALL} -o ${BINOWN} -g ${BINGRP} -m 444 \
 	    ${MTREE} ${DESTDIR}/etc/mtree
 .if ${MK_PPP} != "no"
 	cd ${.CURDIR}/ppp; ${INSTALL} -o ${BINOWN} -g ${BINGRP} -m 600 \
 	    ${PPPCNF} ${DESTDIR}/etc/ppp
 .endif
 .if ${MK_MAIL} != "no"
 	cd ${.CURDIR}/mail; ${INSTALL} -o ${BINOWN} -g ${BINGRP} -m 644 \
 	    ${ETCMAIL} ${DESTDIR}/etc/mail
 	if [ -d ${DESTDIR}/etc/mail -a -f ${DESTDIR}/etc/mail/aliases -a \
 	      ! -f ${DESTDIR}/etc/aliases ]; then \
 		ln -s mail/aliases ${DESTDIR}/etc/aliases; \
 	fi
 .endif
 	${INSTALL} -o ${BINOWN} -g operator -m 664 /dev/null \
 	    ${DESTDIR}/etc/dumpdates
 	${INSTALL} -o nobody -g ${BINGRP} -m 644 /dev/null \
 	    ${DESTDIR}/var/db/locate.database
 	${INSTALL} -o ${BINOWN} -g ${BINGRP} -m 644 ${.CURDIR}/minfree \
 	    ${DESTDIR}/var/crash
 	cd ${.CURDIR}/..; ${INSTALL} -o ${BINOWN} -g ${BINGRP} -m 444 \
 		${FREEBSD} ${DESTDIR}/
 .if ${MK_BOOT} != "no"
 .if exists(${.CURDIR}/../sys/${MACHINE}/conf/GENERIC.hints)
 	${INSTALL} -o ${BINOWN} -g ${BINGRP} -m 444 \
 	    ${.CURDIR}/../sys/${MACHINE}/conf/GENERIC.hints \
 	    ${DESTDIR}/boot/device.hints
 .endif
 .endif
 .if ${MK_NIS} == "no"
 	sed -i "" -e 's/.*_compat:/# &/' -e 's/compat$$/files/' \
 		${DESTDIR}/etc/nsswitch.conf
 .endif
 
 MTREE_CMD?=	mtree
 
 MTREES=		mtree/BSD.root.dist		/		\
 		mtree/BSD.var.dist		/var		\
 		mtree/BSD.usr.dist		/usr		\
 		mtree/BSD.include.dist		/usr/include
 .if ${MK_DEBUG_FILES} != "no"
 MTREES+=	mtree/BSD.debug.dist		/usr/lib
 .endif
 .if ${MK_GROFF} != "no"
 MTREES+=	mtree/BSD.groff.dist		/usr
 .endif
 .if ${MK_TESTS} != "no"
 MTREES+=	mtree/BSD.tests.dist		${TESTSBASE}
 .endif
 .if ${MK_SENDMAIL} != "no"
 MTREES+=	mtree/BSD.sendmail.dist		/
 .endif
 .for mtree in ${LOCAL_MTREE}
 MTREES+=	../${mtree}			/
 .endfor
 
 distrib-dirs: ${MTREES:N/*}
 	@set ${MTREES}; \
 	while test $$# -ge 2; do \
 		m=${.CURDIR}/$$1; \
 		shift; \
 		d=${DESTDIR}$$1; \
 		shift; \
 		test -d $$d || mkdir -p $$d; \
 		${ECHO} ${MTREE_CMD} -deU ${MTREE_FOLLOWS_SYMLINKS} \
 		    -f $$m -p $$d; \
 		${MTREE_CMD} -deU ${MTREE_FOLLOWS_SYMLINKS} -f $$m -p $$d; \
 	done; true
 .if defined(NO_ROOT)
 	@set ${MTREES}; \
 	while test $$# -ge 2; do \
 		m=${.CURDIR}/$$1; \
 		shift; \
 		d=$$1; \
 		test "$$d" == "/" && d=""; \
 		d=${DISTBASE}$$d; \
 		shift; \
 		test -d $$d || mkdir -p $$d; \
 		${ECHO} "${MTREE_CMD:N-W} -C -f $$m -K uname,gname | " \
 		    "sed s#^\.#.$$d# | ${METALOG.add}" ; \
 		${MTREE_CMD:N-W} -C -f $$m -K uname,gname | sed s#^\.#.$$d# | \
 		    ${METALOG.add} ; \
 	done; true
 .endif
 	${INSTALL_SYMLINK} usr/src/sys ${DESTDIR}/sys
 	cd ${DESTDIR}/usr/share/man; \
 	for mandir in man*; do \
 		${INSTALL_SYMLINK} ../$$mandir \
 		    ${DESTDIR}/usr/share/man/en.ISO8859-1/; \
 		${INSTALL_SYMLINK} ../$$mandir \
 		    ${DESTDIR}/usr/share/man/en.UTF-8/; \
 	done
 	cd ${DESTDIR}/usr/share/openssl/man; \
 	for mandir in man*; do \
 		${INSTALL_SYMLINK} ../$$mandir \
 		    ${DESTDIR}/usr/share/openssl/man/en.ISO8859-1/; \
 	done
 	set - `grep "^[a-zA-Z]" ${.CURDIR}/man.alias`; \
 	while [ $$# -gt 0 ] ; do \
 		${INSTALL_SYMLINK} "$$2" "${DESTDIR}/usr/share/man/$$1"; \
 		${INSTALL_SYMLINK} "$$2" \
 		    "${DESTDIR}/usr/share/openssl/man/$$1"; \
 		shift; shift; \
 	done
 	set - `grep "^[a-zA-Z]" ${.CURDIR}/nls.alias`; \
 	while [ $$# -gt 0 ] ; do \
 		${INSTALL_SYMLINK} "$$2" "${DESTDIR}/usr/share/nls/$$1"; \
 		shift; shift; \
 	done
 
 etc-examples:
 	cd ${.CURDIR}; ${INSTALL} -o ${BINOWN} -g ${BINGRP} -m 444 \
 	    ${BIN1} ${BIN2} nsmb.conf opieaccess \
 	    ${DESTDIR}/usr/share/examples/etc
 	${_+_}cd ${.CURDIR}/defaults; ${MAKE} install \
 	    DESTDIR=${DESTDIR}/usr/share/examples
 
 .include <bsd.prog.mk>
Index: projects/clang360-import/etc/defaults/Makefile
===================================================================
--- projects/clang360-import/etc/defaults/Makefile	(revision 277777)
+++ projects/clang360-import/etc/defaults/Makefile	(revision 277778)
@@ -1,7 +1,13 @@
 # $FreeBSD$
 
-FILES=	bluetooth.device.conf devfs.rules periodic.conf rc.conf
+.include <src.opts.mk>
+
+FILES=	devfs.rules periodic.conf rc.conf
 NO_OBJ=
 FILESDIR= /etc/defaults
+
+.if ${MK_BLUETOOTH} != "no"
+FILES+=	bluetooth.device.conf
+.endif
 
 .include <bsd.prog.mk>
Index: projects/clang360-import/etc/devd/Makefile
===================================================================
--- projects/clang360-import/etc/devd/Makefile	(revision 277777)
+++ projects/clang360-import/etc/devd/Makefile	(revision 277778)
@@ -1,28 +1,32 @@
 # $FreeBSD$
 
 .include <src.opts.mk>
 
+FILES=
+
 .if ${MACHINE} == "powerpc"
 FILES+=	apple.conf
 .endif
 
 .if ${MACHINE} == "amd64" || ${MACHINE} == "i386"
+.if ${MK_ACPI} != "no"
 FILES+=	asus.conf
+.endif
 .if ${MK_HYPERV} != "no"
 FILES+=	hyperv.conf
 .endif
 .endif
 
 .if ${MK_USB} != "no"
 FILES+=	uath.conf ulpt.conf usb.conf
 .endif
 
 .if ${MK_ZFS} != "no"
 FILES+=	zfs.conf
 .endif
 
 NO_OBJ=
 FILESDIR=	/etc/devd
 FILESMODE=	644
 
 .include <bsd.prog.mk>
Index: projects/clang360-import/etc/pam.d/Makefile
===================================================================
--- projects/clang360-import/etc/pam.d/Makefile	(revision 277777)
+++ projects/clang360-import/etc/pam.d/Makefile	(revision 277778)
@@ -1,23 +1,28 @@
 # $FreeBSD$
 
+.include <src.opts.mk>
+
 NO_OBJ=
 
 FILES=	README \
-	atrun \
 	cron \
 	ftpd \
 	imap \
 	login \
 	other \
 	passwd pop3 \
 	rsh \
 	sshd su system \
 	telnetd \
 	xdm
+
+.if ${MK_AT} != "no"
+FILES+=	atrun
+.endif
 
 FILESDIR=	/etc/pam.d
 FILESMODE=	644
 FILESMODE_README=	444
 LINKS=	${FILESDIR}/ftpd ${FILESDIR}/ftp
 
 .include <bsd.prog.mk>
Index: projects/clang360-import/etc/rc.d/Makefile
===================================================================
--- projects/clang360-import/etc/rc.d/Makefile	(revision 277777)
+++ projects/clang360-import/etc/rc.d/Makefile	(revision 277778)
@@ -1,228 +1,258 @@
 # $FreeBSD$
 
 .include <src.opts.mk>
 
 FILES=	DAEMON \
 	FILESYSTEMS \
 	LOGIN \
 	NETWORKING \
 	SERVERS \
 	abi \
 	accounting \
 	addswap \
 	adjkerntz \
-	amd \
-	apm \
-	apmd \
 	archdep \
 	atm1 \
 	atm2 \
 	atm3 \
 	auditd \
 	auditdistd \
-	automount \
-	automountd \
-	autounmountd \
 	bgfsck \
 	${_bluetooth} \
 	bootparams \
 	bridge \
 	${_bthidd} \
 	${_casperd} \
 	cleanvar \
 	cleartmp \
 	cron \
 	ctld \
 	ddb \
 	defaultroute \
 	devd \
 	devfs \
 	dhclient \
 	dmesg \
 	dumpon \
 	fsck \
 	ftpd \
 	gbde \
 	geli \
 	geli2 \
 	gptboot \
 	growfs \
 	gssd \
-	hastd \
 	${_hcsecd} \
 	hostapd \
 	hostid \
 	hostid_save \
 	hostname \
 	inetd \
 	ip6addrctl \
 	ipfilter \
 	ipfs \
 	ipfw \
 	ipmon \
 	ipnat \
-	ipropd_master \
-	ipropd_slave \
 	ipsec \
-	jail \
 	${_kadmind} \
 	${_kdc} \
 	${_kfd} \
 	kld \
 	kldxref \
 	${_kpasswdd} \
 	ldconfig \
 	local \
 	localpkg \
 	lockd \
-	lpd \
 	mixer \
 	motd \
 	mountcritlocal \
 	mountcritremote \
 	mountlate \
 	mdconfig \
 	mdconfig2 \
 	mountd \
 	moused \
 	mroute6d \
 	msgs \
 	natd \
 	netif \
 	netoptions \
 	netwait \
 	newsyslog \
 	nfsclient \
 	nfscbd \
 	nfsd \
 	nfsuserd \
 	nisdomain \
 	${_nscd} \
 	nsswitch \
 	ntpd \
 	ntpdate \
 	${_opensm} \
 	othermta \
 	pf \
 	pflog \
 	pfsync \
 	powerd \
-	power_profile \
 	ppp \
 	pppoed \
 	pwcheck \
 	quota \
 	random \
 	rarpd \
 	rctl \
 	resolv \
 	rfcomm_pppd_server \
 	root \
 	route6d \
 	routed \
 	routing \
 	rpcbind \
 	rtadvd \
 	rtsold \
 	savecore \
 	sdpd \
 	securelevel \
 	sendmail \
 	serial \
 	sppp \
 	${_sshd} \
 	statd \
 	static_arp \
 	static_ndp \
 	stf \
 	swap \
 	swaplate \
 	syscons \
 	sysctl \
 	syslogd \
 	timed \
 	tmp \
 	${_ubthidhci} \
 	ugidfw \
 	${_unbound} \
 	${_utx} \
 	var \
 	virecover \
 	watchdogd \
 	wpa_supplicant \
 	ypbind \
 	yppasswdd \
 	ypserv \
 	ypset \
 	ypupdated \
 	ypxfrd \
 	zfs \
 	zvol
 
+.if ${MK_ACCT} != "no"
+FILES+=		accounting
+.endif
+
+.if ${MK_ACPI} != "no"
+FILES+=		power_profile
+.endif
+
+.if ${MK_AMD} != "no"
+FILES+=		amd
+.endif
+
+.if ${MK_APM} != "no"
+FILES+=	apm
+FILES+=	apmd
+.endif
+
+.if ${MK_AUTOFS} != "no"
+FILES+=		automount
+FILES+=		automountd
+FILES+=		autounmountd
+.endif
+
 .if ${MK_BLUETOOTH} != "no"
 _bluetooth=	bluetooth
 _bthidd=	bthidd
 _hcsecd=	hcsecd
 _ubthidhci=	ubthidhci
 .endif
 
 .if ${MK_BSNMP} != "no"
 FILES+=		bsnmpd
 .endif
 
 .if ${MK_CASPER} != "no"
 _casperd=	casperd
 .endif
 
 .if ${MK_CCD} != "no"
 FILES+=		ccd
 .endif
 
+.if ${MK_HAST} != "no"
+FILES+=		hastd
+.endif
+
 .if ${MK_ISCSI} != "no"
 FILES+=		iscsictl
 FILES+=		iscsid
 .endif
 
+.if ${MK_JAIL} != "no"
+FILES+=	jail
+.endif
+
+.if ${MK_LPR} != "no"
+FILES+=		lpd
+.endif
+
 .if ${MK_NS_CACHING} != "no"
 _nscd=		nscd
 .endif
 
 .if ${MK_KERBEROS} != "no"
+FILES+=		ipropd_master
+FILES+=		ipropd_slave
 _kadmind=	kadmind
 _kdc=		kdc
 _kfd=		kfd
 _kpasswdd=	kpasswdd
 .endif
 
 .if ${MK_OFED} != "no"
 _opensm=	opensm
 .endif
 
 .if ${MK_OPENSSL} != "no"
 FILES+=		keyserv
 .endif
 
 .if ${MK_OPENSSH} != "no"
 _sshd=		sshd
 .endif
 
 .if ${MK_PF} != "no"
 FILES+=		ftp-proxy
 .endif
 
 .if ${MK_RCMDS} != "no"
 FILES+=		rwho
 .endif
 
 .if ${MK_UNBOUND} != "no"
 _unbound=	local_unbound
 .endif
 
 .if ${MK_UTMPX} != "no"
 _utx=		utx
+.endif
+
+.if ${MK_WIRELESS} != "no"
+FILES+=		hostapd
+FILES+=		wpa_supplicant
 .endif
 
 FILESDIR=	/etc/rc.d
 FILESMODE=	${BINMODE}
 
 .include <bsd.prog.mk>
Index: projects/clang360-import/etc
===================================================================
--- projects/clang360-import/etc	(revision 277777)
+++ projects/clang360-import/etc	(revision 277778)

Property changes on: projects/clang360-import/etc
___________________________________________________________________
Modified: svn:mergeinfo
## -0,0 +0,1 ##
   Merged /head/etc:r277719-277776
Index: projects/clang360-import/lib/Makefile
===================================================================
--- projects/clang360-import/lib/Makefile	(revision 277777)
+++ projects/clang360-import/lib/Makefile	(revision 277778)
@@ -1,323 +1,325 @@
 #	@(#)Makefile	8.1 (Berkeley) 6/4/93
 # $FreeBSD$
 
 .include <src.opts.mk>
 
 # The SUBDIR_ORDERED list is a small set of libraries which are used by many
 # of the other libraries.  These are built first with a .WAIT between them
 # and the main list to avoid needing a SUBDIR_DEPEND line on every library
 # naming just these few items.
 
 SUBDIR_ORDERED=	${_csu} \
 	.WAIT \
 	libc \
 	libc_nonshared \
 	libcompiler_rt \
 	${_libclang_rt} \
 	${_libcplusplus} \
 	${_libcxxrt} \
 	libelf \
 	msun
 
 # The main list; please keep these sorted alphabetically.
 
 SUBDIR=	${SUBDIR_ORDERED} \
 	.WAIT \
 	libalias \
 	libarchive \
 	${_libatm} \
 	libauditd \
 	libbegemot \
 	libblocksruntime \
 	${_libbluetooth} \
 	${_libbsnmp} \
 	libbsdstat \
 	libbsm \
 	libbz2 \
 	libcalendar \
 	libcam \
 	${_libcapsicum} \
 	${_libcasper} \
 	${_libcom_err} \
 	libcompat \
 	libcrypt \
 	libdevinfo \
 	libdevstat \
 	libdpv \
 	libdwarf \
 	libedit \
 	${_libelftc} \
 	${_libevent} \
 	libexecinfo \
 	libexpat \
 	libfetch \
 	libfigpar \
 	libgeom \
 	${_libgpio} \
 	${_libgssapi} \
 	${_librpcsec_gss} \
 	${_libiconv_modules} \
 	libipsec \
 	libjail \
 	libkiconv \
 	libkvm \
 	${_libldns} \
 	liblzma \
 	libmagic \
 	libmandoc \
 	libmemstat \
 	libmd \
 	${_libmilter} \
 	${_libmp} \
 	${_libnandfs} \
 	libnetbsd \
 	${_libnetgraph} \
 	${_libngatm} \
 	libnv \
 	libohash \
 	libopie \
 	libpam \
 	libpcap \
 	libpjdlog \
 	${_libpmc} \
 	${_libproc} \
 	libprocstat \
 	libradius \
 	librpcsvc \
 	librt \
 	${_librtld_db} \
 	libsbuf \
 	${_libsdp} \
 	${_libsm} \
 	${_libsmb} \
 	${_libsmdb} \
 	${_libsmutil} \
 	libsqlite3 \
 	libstand \
 	libstdbuf \
 	libstdthreads \
 	libtacplus \
 	${_libtelnet} \
 	${_libthr} \
 	libthread_db \
 	libucl \
 	libufs \
 	libugidfw \
 	libulog \
 	${_libunbound} \
 	${_libusbhid} \
 	${_libusb} \
 	libutil \
 	${_libvgl} \
 	${_libvmmapi} \
 	libwrap \
 	libxo \
 	liby \
 	${_libypclnt} \
 	libz \
 	ncurses \
 	${_atf} \
 	${_clang} \
 	${_cuse} \
 	${_tests}
 
 # Inter-library dependencies.  When the makefile for a library contains LDADD
 # libraries, those libraries should be listed as build order dependencies here.
 
 SUBDIR_DEPEND_libarchive= libz libbz2 libexpat liblzma libmd
 SUBDIR_DEPEND_libatm= libmd
 SUBDIR_DEPEND_libauditdm= libbsm
 SUBDIR_DEPEND_libbsnmp= ${_libnetgraph}
 SUBDIR_DEPEND_libc++= libcxxrt
 SUBDIR_DEPEND_libc= libcompiler_rt
 SUBDIR_DEPEND_libcam= libsbuf
 SUBDIR_DEPEND_libcapsicum= libnv
 SUBDIR_DEPEND_libcasper= libcapsicum libnv libpjdlog
 SUBDIR_DEPEND_libdevstat= libkvm
 SUBDIR_DEPEND_libdpv= libfigpar ncurses libutil
 SUBDIR_DEPEND_libedit= ncurses
 SUBDIR_DEPEND_libg++= msun
 SUBDIR_DEPEND_libgeom= libexpat libsbuf
 SUBDIR_DEPEND_liblibrpcsec_gss= libgssapi
 SUBDIR_DEPEND_libmagic= libz
 SUBDIR_DEPEND_libmemstat= libkvm
 SUBDIR_DEPEND_libopie= libmd
 SUBDIR_DEPEND_libpam= libcrypt libopie libradius librpcsvc libtacplus libutil ${_libypclnt} ${_libcom_err} 
 SUBDIR_DEPEND_libpjdlog= libutil
 SUBDIR_DEPEND_libprocstat= libkvm libutil
 SUBDIR_DEPEND_libradius= libmd
 SUBDIR_DEPEND_libreadline= ncurses
 SUBDIR_DEPEND_libsmb= libkiconv
 SUBDIR_DEPEND_libstdc++= msun
 SUBDIR_DEPEND_libtacplus= libmd
 SUBDIR_DEPEND_libulog= libmd
 SUBDIR_DEPEND_libunbound= ${_libldns}
 
 .if exists(${.CURDIR}/csu/${MACHINE_ARCH}-elf)
 _csu=csu/${MACHINE_ARCH}-elf
 .elif exists(${.CURDIR}/csu/${MACHINE_ARCH})
 _csu=csu/${MACHINE_ARCH}
 .elif exists(${.CURDIR}/csu/${MACHINE_CPUARCH}/Makefile)
 _csu=csu/${MACHINE_CPUARCH}
 .else
 _csu=csu
 .endif
 
 # NB: keep these sorted by MK_* knobs
 
 .if ${MK_ATM} != "no"
 _libngatm=	libngatm
 .endif
 
 .if ${MK_BLUETOOTH} != "no"
 _libbluetooth=	libbluetooth
 _libsdp=	libsdp
 .endif
 
 .if ${MK_BSNMP} != "no"
 _libbsnmp=	libbsnmp
 .endif
 
 .if ${MK_CASPER} != "no"
 _libcapsicum=	libcapsicum
 _libcasper=	libcasper
 .endif
 
 .if ${MK_CLANG} != "no" && !defined(COMPAT_32BIT)
 _clang=		clang
 .endif
 
 .if ${MK_CUSE} != "no"
 _cuse=		libcuse
 .endif
 
 .if ${MK_ELFTOOLCHAIN_TOOLS} != "no"
 _libelftc=	libelftc
 .endif
 
 .if ${MK_GPIO} != "no"
 _libgpio=	libgpio
 .endif
 
 .if ${MK_GSSAPI} != "no"
 _libgssapi=	libgssapi
 _librpcsec_gss=	librpcsec_gss
 .endif
 
 .if ${MK_ICONV} != "no"
 _libiconv_modules=	libiconv_modules
 .endif
 
 .if ${MK_KERBEROS_SUPPORT} != "no"
 _libcom_err= libcom_err
 .endif
 
 .if ${MK_LDNS} != "no"
 _libldns=	libldns
 .endif
 
 # The libraries under libclang_rt can only be built by clang, and only make
 # sense to build when clang is enabled at all.  Furthermore, they can only be
 # built for certain architectures.
 .if ${MK_CLANG} != "no" && ${COMPILER_TYPE} == "clang" && \
     (${MACHINE_CPUARCH} == "i386" || ${MACHINE_CPUARCH} == "amd64" || \
     (${MACHINE_CPUARCH} == "arm" && ${MACHINE_ARCH} != "armeb"))
 _libclang_rt=	libclang_rt
 .endif
 
 .if ${MK_LIBCPLUSPLUS} != "no"
 _libcxxrt=	libcxxrt
 _libcplusplus=	libc++
 .endif
 
 .if ${MK_LIBTHR} != "no"
 _libthr=	libthr
 .endif
 
 .if ${MK_NAND} != "no"
 _libnandfs=	libnandfs
 .endif
 
 .if ${MK_NETGRAPH} != "no"
 _libnetgraph=	libnetgraph
 .endif
 
 .if ${MK_NIS} != "no"
 _libypclnt=	libypclnt
 .endif
 
 .if ${MK_PF} != "no"
 _libevent=	libevent
 .endif
 
 .if ${MACHINE_CPUARCH} == "i386" || ${MACHINE_CPUARCH} == "amd64"
 _libsmb=	libsmb
 _libvgl=	libvgl
 _libproc=	libproc
 _librtld_db=	librtld_db
 .endif
 
 .if ${MACHINE_CPUARCH} == "amd64"
+.if ${MK_BHYVE} != "no"
 _libvmmapi=	libvmmapi
+.endif
 .endif
 
 .if ${MACHINE_CPUARCH} == "mips"
 _libproc=	libproc
 _librtld_db=	librtld_db
 .endif
 
 .if ${MACHINE_CPUARCH} == "powerpc"
 _libproc=	libproc
 _librtld_db=	librtld_db
 _libsmb=	libsmb
 .endif
 
 .if ${MACHINE_CPUARCH} == "sparc64"
 _libsmb=	libsmb
 .endif
 
 .if ${MK_OPENSSL} != "no"
 _libmp=		libmp
 .endif
 
 .if ${MK_PMC} != "no"
 _libpmc=	libpmc
 .endif
 
 .if ${MK_SENDMAIL} != "no"
 _libmilter=	libmilter
 _libsm=		libsm
 _libsmdb=	libsmdb
 _libsmutil=	libsmutil
 .endif
 
 .if ${MK_TELNET} != "no"
 _libtelnet=	libtelnet
 .endif
 
 .if ${MK_TESTS_SUPPORT} != "no"
 _atf=		atf
 .endif
 .if ${MK_TESTS} != "no"
 _tests=		tests
 .endif
 
 .if ${MK_UNBOUND} != "no"
 _libunbound=	libunbound
 .endif
 
 .if ${MK_USB} != "no"
 _libusbhid=	libusbhid
 _libusb=	libusb
 .endif
 
 .if !defined(LIBRARIES_ONLY)
 afterinstall:
 	${INSTALL_SYMLINK} ../include ${DESTDIR}/usr/lib/include
 .endif
 
 .if !make(install)
 SUBDIR_PARALLEL=
 .endif
 
 .include <bsd.subdir.mk>
Index: projects/clang360-import/sbin/Makefile
===================================================================
--- projects/clang360-import/sbin/Makefile	(revision 277777)
+++ projects/clang360-import/sbin/Makefile	(revision 277778)
@@ -1,137 +1,144 @@
 #	@(#)Makefile	8.5 (Berkeley) 3/31/94
 # $FreeBSD$
 
 .include <src.opts.mk>
 
 # XXX MISSING:		icheck ncheck
 
 SUBDIR=adjkerntz \
 	badsect \
 	camcontrol \
 	clri \
 	comcontrol \
 	conscontrol \
 	ddb \
 	devfs \
 	dhclient \
 	dmesg \
 	dump \
 	dumpfs \
 	dumpon \
 	etherswitchcfg \
 	ffsinfo \
 	fsck \
 	fsck_ffs \
 	fsck_msdosfs \
 	fsdb \
 	fsirand \
 	gbde \
 	geom \
 	ggate \
 	growfs \
 	gvinum \
-	hastctl \
-	hastd \
 	ifconfig \
 	init \
 	kldconfig \
 	kldload \
 	kldstat \
 	kldunload \
 	ldconfig \
 	md5 \
 	mdconfig \
 	mdmfs \
 	mknod \
 	mksnap_ffs \
 	mount \
 	mount_cd9660 \
 	mount_fusefs \
 	mount_msdosfs \
 	mount_nfs \
 	mount_nullfs \
 	mount_udf \
 	mount_unionfs \
 	newfs \
 	newfs_msdos \
 	nfsiod \
 	nos-tun \
 	ping \
 	rcorder \
 	reboot \
 	recoverdisk \
 	resolvconf \
 	restore \
 	route \
 	savecore \
 	setkey \
 	shutdown \
 	spppcontrol \
 	swapon \
 	sysctl \
 	tunefs \
 	umount
 
 .if ${MK_ATM} != "no"
 SUBDIR+=	atm
 .endif
 
 .if ${MK_CASPER} != "no"
 SUBDIR+=	casperd
 .endif
 
 .if ${MK_CCD} != "no"
 SUBDIR+=	ccdconfig
 .endif
 
 .if ${MK_CXX} != "no"
 SUBDIR+=	devd
 .endif
 
+.if ${MK_HAST} != "no"
+SUBDIR+=	hastctl
+SUBDIR+=	hastd
+.endif
+
 .if ${MK_IPFILTER} != "no"
 SUBDIR+=	ipf
 .endif
 
 .if ${MK_IPFW} != "no"
 SUBDIR+=	ipfw
 SUBDIR+=	natd
+.endif
+
+.if ${MK_ISCSI} != "no"
+SUBDIR+=	iscontrol
 .endif
 
 .if ${MK_NAND} != "no"
 SUBDIR+=	nandfs
 SUBDIR+=	newfs_nandfs
 .endif
 
 .if ${MK_PF} != "no"
 SUBDIR+=	pfctl
 SUBDIR+=	pflogd
 .endif
 
 .if ${MK_INET6} != "no"
 SUBDIR+=	ping6
 SUBDIR+=	rtsol
 .endif
 	
 .if ${MK_ISCSI} != "no"
 SUBDIR+=	iscontrol
 .endif
 
 .if ${MK_QUOTAS} != "no"
 SUBDIR+=	quotacheck
 .endif
 
 .if ${MK_ROUTED} != "no"
 SUBDIR+=	routed
 .endif
 
 .if ${MK_TESTS} != "no"
 SUBDIR+=	tests
 .endif
 
 .include <bsd.arch.inc.mk>
 
 SUBDIR:=	${SUBDIR:O}
 
 SUBDIR_PARALLEL=
 
 .include <bsd.subdir.mk>
Index: projects/clang360-import/sbin
===================================================================
--- projects/clang360-import/sbin	(revision 277777)
+++ projects/clang360-import/sbin	(revision 277778)

Property changes on: projects/clang360-import/sbin
___________________________________________________________________
Modified: svn:mergeinfo
## -0,0 +0,1 ##
   Merged /head/sbin:r277719-277776
Index: projects/clang360-import/share/examples/Makefile
===================================================================
--- projects/clang360-import/share/examples/Makefile	(revision 277777)
+++ projects/clang360-import/share/examples/Makefile	(revision 277778)
@@ -1,254 +1,262 @@
 # $FreeBSD$
 #
 # Doing a make install builds /usr/share/examples
 
 .include <src.opts.mk>
 
 LDIRS=	BSD_daemon \
 	FreeBSD_version \
 	IPv6 \
-	bhyve \
 	bootforth \
 	csh \
 	diskless \
 	drivers \
 	etc \
 	find_interface \
-	hast \
 	ibcs2 \
 	indent \
 	ipfw \
 	jails \
 	kld \
 	libusb20 \
 	libvgl \
 	mdoc \
 	netgraph \
 	perfmon \
 	ppi \
 	ppp \
 	printing \
 	ses \
 	scsi_target \
 	sunrpc
 
 XFILES=	BSD_daemon/FreeBSD.pfa \
 	BSD_daemon/README \
 	BSD_daemon/beastie.eps \
 	BSD_daemon/beastie.fig \
 	BSD_daemon/eps.patch \
 	BSD_daemon/poster.sh \
 	FreeBSD_version/FreeBSD_version.c \
 	FreeBSD_version/Makefile \
 	FreeBSD_version/README \
 	IPv6/USAGE \
-	bhyve/vmrun.sh \
 	bootforth/README \
 	bootforth/boot.4th \
 	bootforth/frames.4th \
 	bootforth/loader.rc \
 	bootforth/menu.4th \
 	bootforth/menuconf.4th \
 	bootforth/screen.4th \
 	csh/dot.cshrc \
 	diskless/ME \
 	diskless/README.BOOTP \
 	diskless/README.TEMPLATING \
 	diskless/clone_root \
 	drivers/README \
 	drivers/make_device_driver.sh \
 	drivers/make_pseudo_driver.sh \
 	etc/README.examples \
 	etc/bsd-style-copyright \
 	etc/make.conf \
 	find_interface/Makefile \
 	find_interface/README \
 	find_interface/find_interface.c \
-	hast/ucarp.sh \
-	hast/ucarp_down.sh \
-	hast/ucarp_up.sh \
-	hast/vip-down.sh \
-	hast/vip-up.sh \
 	ibcs2/README \
 	ibcs2/hello.uu \
 	indent/indent.pro \
 	ipfw/change_rules.sh \
 	jails/README \
 	kld/Makefile \
 	kld/cdev/Makefile \
 	kld/cdev/README \
 	kld/cdev/module/Makefile \
 	kld/cdev/module/cdev.c \
 	kld/cdev/module/cdev.h \
 	kld/cdev/module/cdevmod.c \
 	kld/cdev/test/Makefile \
 	kld/cdev/test/testcdev.c \
 	kld/dyn_sysctl/Makefile \
 	kld/dyn_sysctl/README \
 	kld/dyn_sysctl/dyn_sysctl.c \
 	kld/firmware/Makefile \
 	kld/firmware/README \
 	kld/firmware/fwconsumer/Makefile \
 	kld/firmware/fwconsumer/fw_consumer.c \
 	kld/firmware/fwimage/Makefile \
 	kld/firmware/fwimage/firmware.img.uu \
 	kld/khelp/Makefile \
 	kld/khelp/README \
 	kld/khelp/h_example.c \
 	kld/syscall/Makefile \
 	kld/syscall/module/Makefile \
 	kld/syscall/module/syscall.c \
 	kld/syscall/test/Makefile \
 	kld/syscall/test/call.c \
 	libusb20/Makefile \
 	libusb20/README \
 	libusb20/util.c \
 	libusb20/util.h \
 	libusb20/bulk.c \
 	libusb20/control.c \
 	libvgl/Makefile \
 	libvgl/demo.c \
 	mdoc/POSIX-copyright \
 	mdoc/deshallify.sh \
 	mdoc/example.1 \
 	mdoc/example.3 \
 	mdoc/example.4 \
 	mdoc/example.9 \
 	netgraph/ether.bridge \
 	netgraph/frame_relay \
 	netgraph/ngctl \
 	netgraph/raw \
 	netgraph/udp.tunnel \
 	netgraph/virtual.chain \
 	netgraph/virtual.lan \
 	perfmon/Makefile \
 	perfmon/README \
 	perfmon/perfmon.c \
 	ppi/Makefile \
 	ppi/ppilcd.c \
 	ppp/chap-auth \
 	ppp/login-auth \
 	ppp/ppp.conf.sample \
 	ppp/ppp.conf.span-isp \
 	ppp/ppp.conf.span-isp.working \
 	ppp/ppp.linkdown.sample \
 	ppp/ppp.linkdown.span-isp \
 	ppp/ppp.linkdown.span-isp.working \
 	ppp/ppp.linkup.sample \
 	ppp/ppp.linkup.span-isp \
 	ppp/ppp.linkup.span-isp.working \
 	ppp/ppp.secret.sample \
 	ppp/ppp.secret.span-isp \
 	ppp/ppp.secret.span-isp.working \
 	printing/README \
 	printing/diablo-if-net \
 	printing/hpdf \
 	printing/hpif \
 	printing/hpof \
 	printing/hprf \
 	printing/hpvf \
 	printing/if-simple \
 	printing/if-simpleX \
 	printing/ifhp \
 	printing/make-ps-header \
 	printing/netprint \
 	printing/psdf \
 	printing/psdfX \
 	printing/psif \
 	printing/pstf \
 	printing/pstfX \
 	ses/Makefile \
 	ses/Makefile.inc \
 	ses/getencstat/Makefile \
 	ses/getencstat/getencstat.0 \
 	ses/sesd/Makefile \
 	ses/sesd/sesd.0 \
 	ses/setencstat/Makefile \
 	ses/setencstat/setencstat.0 \
 	ses/setobjstat/Makefile \
 	ses/setobjstat/setobjstat.0 \
 	ses/srcs/chpmon.c \
 	ses/srcs/eltsub.c \
 	ses/srcs/eltsub.h \
 	ses/srcs/getencstat.c \
 	ses/srcs/getnobj.c \
 	ses/srcs/getobjmap.c \
 	ses/srcs/getobjstat.c \
 	ses/srcs/inienc.c \
 	ses/srcs/sesd.c \
 	ses/srcs/setencstat.c \
 	ses/srcs/setobjstat.c \
 	scsi_target/Makefile \
 	scsi_target/scsi_target.c \
 	scsi_target/scsi_target.h \
 	scsi_target/scsi_target.8 \
 	scsi_target/scsi_cmds.c \
 	sunrpc/Makefile \
 	sunrpc/dir/Makefile \
 	sunrpc/dir/dir.x \
 	sunrpc/dir/dir_proc.c \
 	sunrpc/dir/rls.c \
 	sunrpc/msg/Makefile \
 	sunrpc/msg/msg.x \
 	sunrpc/msg/msg_proc.c \
 	sunrpc/msg/printmsg.c \
 	sunrpc/msg/rprintmsg.c \
 	sunrpc/sort/Makefile \
 	sunrpc/sort/rsort.c \
 	sunrpc/sort/sort.x \
 	sunrpc/sort/sort_proc.c
 
 BINDIR= ${SHAREDIR}/examples
 
 NO_OBJ=
+
+.if ${MK_HAST} != "no"
+LDIRS+=		hast
+XFILES+=	hast/ucarp.sh \
+		hast/ucarp_down.sh \
+		hast/ucarp_up.sh \
+		hast/vip-down.sh \
+		hast/vip-up.sh
+.endif
+
+.if ${MACHINE_CPUARCH} == "amd64"
+.if ${MK_BHYVE} != "no"
+LDIRS+=		bhyve
+XFILES+=	bhyve/vmrun.sh
+.endif
+.endif
 
 # Define SHARED to indicate whether you want symbolic links to the system
 # source (``symlinks''), or a separate copy (``copies''); (latter useful
 # in environments where it's not possible to keep /sys publicly readable)
 SHARED?=	copies
 
 beforeinstall: ${SHARED} etc-examples
 .ORDER: ${SHARED} etc-examples
 
 copies:
 .for i in ${LDIRS}
 	if [ -L ${DESTDIR}${BINDIR}/$i ]; then \
 		rm -f ${DESTDIR}${BINDIR}/$i; \
 	fi
 .endfor
 	mtree -deU ${MTREE_FOLLOWS_SYMLINKS} \
 	    -f ${.CURDIR}/../../etc/mtree/BSD.usr.dist -p ${DESTDIR}/usr
 .for file in ${XFILES}
 	${INSTALL} -o ${SHAREOWN} -g ${SHAREGRP} -m ${SHAREMODE} \
 		${.CURDIR}/${file} ${DESTDIR}${BINDIR}/${file}
 .endfor
 
 symlinks:
 .for i in ${LDIRS}
 	rm -rf ${DESTDIR}${BINDIR}/$i
 	ln -s ${.CURDIR}/$i ${DESTDIR}${BINDIR}/$i
 .endfor
 
 etc-examples:
 .if ${SHARED} != "symlinks"
 	(cd ${.CURDIR}/../../etc; ${MAKE} etc-examples)
 .endif
 
 .if ${SHARED} != "symlinks"
 SUBDIR=	smbfs
 .if ${MK_IPFILTER} != "no"
 SUBDIR+=ipfilter
 .endif
 .if ${MK_PF} != "no"
 SUBDIR+=pf
 .endif
 .if ${MK_DMAGENT} != "no"
 SUBDIR+=dma
 .endif
 .endif
 
 .if ${MK_TESTS} != "no"
 SUBDIR+=tests
 .endif
 
 .include <bsd.subdir.mk>
Index: projects/clang360-import/share/man/man4/Makefile
===================================================================
--- projects/clang360-import/share/man/man4/Makefile	(revision 277777)
+++ projects/clang360-import/share/man/man4/Makefile	(revision 277778)
@@ -1,883 +1,886 @@
 #	@(#)Makefile	8.1 (Berkeley) 6/18/93
 # $FreeBSD$
 
 .include <src.opts.mk>
 
 MAN=	aac.4 \
 	aacraid.4 \
 	acpi.4 \
 	${_acpi_asus.4} \
 	${_acpi_asus_wmi.4} \
 	${_acpi_dock.4} \
 	${_acpi_fujitsu.4} \
 	${_acpi_hp.4} \
 	${_acpi_ibm.4} \
 	${_acpi_panasonic.4} \
 	${_acpi_rapidstart.4} \
 	${_acpi_sony.4} \
 	acpi_thermal.4 \
 	${_acpi_toshiba.4} \
 	acpi_video.4 \
 	${_acpi_wmi.4} \
 	ada.4 \
 	adv.4 \
 	adw.4 \
 	ae.4 \
 	${_aesni.4} \
 	age.4 \
 	agp.4 \
 	aha.4 \
 	ahb.4 \
 	ahc.4 \
 	ahci.4 \
 	ahd.4 \
 	${_aibs.4} \
 	aio.4 \
 	alc.4 \
 	ale.4 \
 	alpm.4 \
 	altera_atse.4 \
 	altera_avgen.4 \
 	altera_jtag_uart.4 \
 	altera_sdcard.4 \
 	altq.4 \
 	amdpm.4 \
 	${_amdsbwd.4} \
 	${_amdsmb.4} \
 	${_amdtemp.4} \
 	${_bxe.4} \
 	amr.4 \
 	an.4 \
 	${_aout.4} \
 	${_apic.4} \
 	arcmsr.4 \
 	${_asmc.4} \
 	ata.4 \
 	ath.4 \
 	ath_ahb.4 \
 	ath_hal.4 \
 	ath_pci.4 \
 	atkbd.4 \
 	atkbdc.4 \
 	atp.4 \
 	${_atf_test_case.4} \
 	${_atrtc.4} \
 	${_attimer.4} \
 	audit.4 \
 	auditpipe.4 \
 	aue.4 \
 	axe.4 \
 	axge.4 \
 	bce.4 \
 	bfe.4 \
 	bge.4 \
 	${_bhyve.4} \
 	bktr.4 \
 	blackhole.4 \
 	bpf.4 \
 	bridge.4 \
 	bt.4 \
 	bwi.4 \
 	bwn.4 \
 	capsicum.4 \
 	cardbus.4 \
 	carp.4 \
 	cas.4 \
 	cc_cdg.4 \
 	cc_chd.4 \
 	cc_cubic.4 \
 	cc_dctcp.4 \
 	cc_hd.4 \
 	cc_htcp.4 \
 	cc_newreno.4 \
 	cc_vegas.4 \
 	${_ccd.4} \
 	cd.4 \
 	cdce.4 \
 	ch.4 \
 	ciss.4 \
 	cm.4 \
 	cmx.4 \
 	${_coretemp.4} \
 	${_cpuctl.4} \
 	cpufreq.4 \
 	crypto.4 \
 	ctl.4 \
 	cue.4 \
 	cxgb.4 \
 	cxgbe.4 \
 	cy.4 \
 	da.4 \
 	dc.4 \
 	dcons.4 \
 	dcons_crom.4 \
 	ddb.4 \
 	de.4 \
 	devctl.4 \
 	digi.4 \
 	disc.4 \
 	divert.4 \
 	${_dpms.4} \
 	dpt.4 \
 	dummynet.4 \
 	ed.4 \
 	edsc.4 \
 	ehci.4 \
 	em.4 \
 	en.4 \
 	enc.4 \
 	epair.4 \
 	esp.4 \
 	est.4 \
 	et.4 \
 	etherswitch.4 \
 	eventtimers.4 \
 	exca.4 \
 	fatm.4 \
 	fd.4 \
 	fdc.4 \
 	fdt.4 \
 	fdtbus.4 \
 	ffclock.4 \
 	filemon.4 \
 	firewire.4 \
 	fpa.4 \
 	full.4 \
 	fwe.4 \
 	fwip.4 \
 	fwohci.4 \
 	fxp.4 \
 	gbde.4 \
 	gdb.4 \
 	gem.4 \
 	geom.4 \
 	geom_fox.4 \
 	geom_linux_lvm.4 \
 	geom_map.4 \
 	geom_uncompress.4 \
 	geom_uzip.4 \
 	gif.4 \
 	gpio.4 \
 	gpioiic.4 \
 	gpioled.4 \
 	gre.4 \
 	h_ertt.4 \
 	hatm.4 \
 	hifn.4 \
 	hme.4 \
 	hpet.4 \
 	${_hpt27xx.4} \
 	${_hptiop.4} \
 	${_hptmv.4} \
 	${_hptnr.4} \
 	${_hptrr.4} \
 	hv_ata_pci_disengage.4 \
 	hv_kvp.4 \
 	hv_netvsc.4 \
 	hv_storvsc.4 \
 	hv_utils.4 \
 	hv_vmbus.4 \
 	hwpmc.4 \
 	ichsmb.4 \
 	${_ichwd.4} \
 	icmp.4 \
 	icmp6.4 \
 	ida.4 \
 	ifmib.4 \
 	igb.4 \
 	igmp.4 \
 	iic.4 \
 	iicbb.4 \
 	iicbus.4 \
 	iicsmb.4 \
 	iir.4 \
 	inet.4 \
 	inet6.4 \
 	intpm.4 \
 	intro.4 \
 	${_io.4} \
 	ip.4 \
 	ip6.4 \
 	ipfirewall.4 \
 	ipheth.4 \
 	${_ipmi.4} \
 	ips.4 \
 	ipsec.4 \
 	ipw.4 \
 	ipwfw.4 \
 	isci.4 \
 	ismt.4 \
 	isp.4 \
 	ispfw.4 \
 	iwi.4 \
 	iwifw.4 \
 	iwn.4 \
 	iwnfw.4 \
 	ixgb.4 \
 	ixgbe.4 \
 	ixl.4 \
 	ixlv.4 \
 	jme.4 \
 	joy.4 \
 	kbdmux.4 \
 	keyboard.4 \
 	kld.4 \
 	ksyms.4 \
 	ktr.4 \
 	kue.4 \
 	lagg.4 \
 	le.4 \
 	led.4 \
 	lge.4 \
 	${_linux.4} \
 	lm75.4 \
 	lmc.4 \
 	lo.4 \
 	lp.4 \
 	lpbb.4 \
 	lpt.4 \
 	mac.4 \
 	mac_biba.4 \
 	mac_bsdextended.4 \
 	mac_ifoff.4 \
 	mac_lomac.4 \
 	mac_mls.4 \
 	mac_none.4 \
 	mac_partition.4 \
 	mac_portacl.4 \
 	mac_seeotheruids.4 \
 	mac_stub.4 \
 	mac_test.4 \
 	malo.4 \
 	mcd.4 \
 	md.4 \
 	me.4 \
 	mem.4 \
 	meteor.4 \
 	mfi.4 \
 	miibus.4 \
 	mk48txx.4 \
 	mld.4 \
 	mlx.4 \
 	mly.4 \
 	mmc.4 \
 	mmcsd.4 \
 	mn.4 \
 	mod_cc.4 \
 	mos.4 \
 	mouse.4 \
 	mpr.4 \
 	mps.4 \
 	mpt.4 \
 	mrsas.4 \
 	msk.4 \
 	mtio.4 \
 	multicast.4 \
 	mvs.4 \
 	mwl.4 \
 	mwlfw.4 \
 	mxge.4 \
 	my.4 \
 	nand.4 \
 	nandsim.4 \
 	natm.4 \
 	natmip.4 \
 	ncr.4 \
 	ncv.4 \
 	${_ndis.4} \
 	net80211.4 \
 	netfpga10g_nf10bmac.4 \
 	netgraph.4 \
 	netintro.4 \
 	netmap.4 \
 	${_nfe.4} \
 	${_nfsmb.4} \
 	ng_async.4 \
 	ng_atm.4 \
 	ngatmbase.4 \
 	ng_atmllc.4 \
 	ng_bluetooth.4 \
 	ng_bpf.4 \
 	ng_bridge.4 \
 	ng_bt3c.4 \
 	ng_btsocket.4 \
 	ng_car.4 \
 	ng_ccatm.4 \
 	ng_cisco.4 \
 	ng_deflate.4 \
 	ng_device.4 \
 	nge.4 \
 	ng_echo.4 \
 	ng_eiface.4 \
 	ng_etf.4 \
 	ng_ether.4 \
 	ng_ether_echo.4 \
 	ng_frame_relay.4 \
 	ng_gif.4 \
 	ng_gif_demux.4 \
 	ng_h4.4 \
 	ng_hci.4 \
 	ng_hole.4 \
 	ng_hub.4 \
 	ng_iface.4 \
 	ng_ipfw.4 \
 	ng_ip_input.4 \
 	ng_ksocket.4 \
 	ng_l2cap.4 \
 	ng_l2tp.4 \
 	ng_lmi.4 \
 	ng_mppc.4 \
 	ng_nat.4 \
 	ng_netflow.4 \
 	ng_one2many.4 \
 	ng_patch.4 \
 	ng_ppp.4 \
 	ng_pppoe.4 \
 	ng_pptpgre.4 \
 	ng_pred1.4 \
 	ng_rfc1490.4 \
 	ng_socket.4 \
 	ng_source.4 \
 	ng_split.4 \
 	ng_sppp.4 \
 	ng_sscfu.4 \
 	ng_sscop.4 \
 	ng_tag.4 \
 	ng_tcpmss.4 \
 	ng_tee.4 \
 	ng_tty.4 \
 	ng_ubt.4 \
 	ng_UI.4 \
 	ng_uni.4 \
 	ng_vjc.4 \
 	ng_vlan.4 \
 	nmdm.4 \
 	nsp.4 \
 	${_ntb.4} \
 	null.4 \
 	${_nvd.4} \
 	${_nvme.4} \
 	${_nvram.4} \
 	${_nvram2env.4} \
 	${_nxge.4} \
 	oce.4 \
 	ohci.4 \
 	orm.4 \
 	${_padlock.4} \
 	pass.4 \
 	patm.4 \
 	pccard.4 \
 	pccbb.4 \
 	pcf.4 \
 	pci.4 \
 	pcib.4 \
 	pcic.4 \
 	pcm.4 \
 	pcn.4 \
 	${_pf.4} \
 	${_pflog.4} \
 	${_pfsync.4} \
 	pim.4 \
 	polling.4 \
 	ppbus.4 \
 	ppc.4 \
 	ppi.4 \
 	procdesc.4 \
 	proto.4 \
 	psm.4 \
 	pst.4 \
 	pt.4 \
 	pts.4 \
 	pty.4 \
 	puc.4 \
 	${_qlxge.4} \
 	${_qlxgb.4} \
 	${_qlxgbe.4} \
 	ral.4 \
 	random.4 \
 	rc.4 \
 	re.4 \
 	rgephy.4 \
 	rights.4 \
 	rl.4 \
 	rndtest.4 \
 	route.4 \
 	rp.4 \
 	rsu.4 \
 	rsufw.4 \
 	rue.4 \
 	rum.4 \
 	run.4 \
 	runfw.4 \
 	sa.4 \
 	safe.4 \
 	sbp.4 \
 	sbp_targ.4 \
 	scc.4 \
 	scd.4 \
 	sched_4bsd.4 \
 	sched_ule.4 \
 	screen.4 \
 	scsi.4 \
 	sctp.4 \
 	sdhci.4 \
 	sem.4 \
 	send.4 \
 	ses.4 \
 	sf.4 \
 	${_sfxge.4} \
 	sge.4 \
 	si.4 \
 	siba.4 \
 	siftr.4 \
 	siis.4 \
 	simplebus.4 \
 	sio.4 \
 	sis.4 \
 	sk.4 \
 	smb.4 \
 	smbus.4 \
 	smp.4 \
 	smsc.4 \
 	sn.4 \
 	snd_ad1816.4 \
 	snd_als4000.4 \
 	snd_atiixp.4 \
 	snd_cmi.4 \
 	snd_cs4281.4 \
 	snd_csa.4 \
 	snd_ds1.4 \
 	snd_emu10k1.4 \
 	snd_emu10kx.4 \
 	snd_envy24.4 \
 	snd_envy24ht.4 \
 	snd_es137x.4 \
 	snd_ess.4 \
 	snd_fm801.4 \
 	snd_gusc.4 \
 	snd_hda.4 \
 	snd_hdspe.4 \
 	snd_ich.4 \
 	snd_maestro3.4 \
 	snd_maestro.4 \
 	snd_mss.4 \
 	snd_neomagic.4 \
 	snd_sbc.4 \
 	snd_solo.4 \
 	snd_spicds.4 \
 	snd_t4dwave.4 \
 	snd_uaudio.4 \
 	snd_via8233.4 \
 	snd_via82c686.4 \
 	snd_vibes.4 \
 	snp.4 \
 	spic.4 \
 	${_spkr.4} \
 	splash.4 \
 	sppp.4 \
 	ste.4 \
 	stf.4 \
 	stg.4 \
 	stge.4 \
 	sym.4 \
 	syncache.4 \
 	syncer.4 \
 	syscons.4 \
 	sysmouse.4 \
 	tap.4 \
 	targ.4 \
 	tcp.4 \
 	tdfx.4 \
 	terasic_mtl.4 \
 	termios.4 \
 	textdump.4 \
 	ti.4 \
 	timecounters.4 \
 	tl.4 \
 	${_tpm.4} \
 	trm.4 \
 	tty.4 \
 	tun.4 \
 	twa.4 \
 	twe.4 \
 	tws.4 \
 	tx.4 \
 	txp.4 \
 	u3g.4 \
 	uark.4 \
 	uart.4 \
 	uath.4 \
 	ubsa.4 \
 	ubsec.4 \
 	ubser.4 \
 	ubtbcmfw.4 \
 	uchcom.4 \
 	ucom.4 \
 	ucycom.4 \
 	udav.4 \
 	udbp.4 \
 	udp.4 \
 	udplite.4 \
 	uep.4 \
 	ufm.4 \
 	ufoma.4 \
 	uftdi.4 \
 	ugen.4 \
 	uhci.4 \
 	uhid.4 \
 	uhso.4 \
 	uipaq.4 \
 	ukbd.4 \
 	uled.4 \
 	ulpt.4 \
 	umass.4 \
 	umcs.4 \
 	umct.4 \
 	umodem.4 \
 	umoscom.4 \
 	ums.4 \
 	unix.4 \
 	upgt.4 \
 	uplcom.4 \
 	ural.4 \
 	urio.4 \
 	urndis.4 \
 	${_urtw.4} \
 	urtwn.4 \
 	urtwnfw.4 \
 	usb.4 \
 	usb_template.4 \
 	usb_quirk.4 \
 	uslcom.4 \
 	usfs.4 \
 	utopia.4 \
 	uvisor.4 \
 	uvscom.4 \
 	vale.4 \
 	vga.4 \
 	vge.4 \
 	viapm.4 \
 	${_viawd.4} \
 	${_virtio.4} \
 	${_virtio_balloon.4} \
 	${_virtio_blk.4} \
 	${_virtio_console.4} \
 	${_virtio_random.4} \
 	${_virtio_scsi.4} \
 	vkbd.4 \
 	vlan.4 \
 	vxlan.4 \
 	${_vmx.4} \
 	vpo.4 \
 	vr.4 \
 	vt.4 \
 	vte.4 \
 	${_vtnet.4} \
 	${_vxge.4} \
 	watchdog.4 \
 	wb.4 \
 	${_wbwd.4} \
 	wi.4 \
 	witness.4 \
 	wlan.4 \
 	wlan_acl.4 \
 	wlan_amrr.4 \
 	wlan_ccmp.4 \
 	wlan_tkip.4 \
 	wlan_wep.4 \
 	wlan_xauth.4 \
 	${_wpi.4} \
 	wsp.4 \
 	xe.4 \
 	${_xen.4} \
 	xhci.4 \
 	xl.4 \
 	${_xnb.4} \
 	xpt.4 \
 	zero.4 \
 	zyd.4
 
 MLINKS=	ae.4 if_ae.4
 MLINKS+=age.4 if_age.4
 MLINKS+=agp.4 agpgart.4
 MLINKS+=alc.4 if_alc.4
 MLINKS+=ale.4 if_ale.4
 MLINKS+=altera_atse.4 atse.4
 MLINKS+=altera_sdcard.4 altera_sdcardc.4
 MLINKS+=altq.4 ALTQ.4
 MLINKS+=ath.4 if_ath.4
 MLINKS+=ath_pci.4 if_ath_pci.4
 MLINKS+=an.4 if_an.4
 MLINKS+=aue.4 if_aue.4
 MLINKS+=axe.4 if_axe.4
 MLINKS+=bce.4 if_bce.4
 MLINKS+=bfe.4 if_bfe.4
 MLINKS+=bge.4 if_bge.4
 MLINKS+=bktr.4 brooktree.4
 MLINKS+=bridge.4 if_bridge.4
 MLINKS+=bwi.4 if_bwi.4
 MLINKS+=bwn.4 if_bwn.4
 MLINKS+=${_bxe.4} ${_if_bxe.4}
 MLINKS+=cas.4 if_cas.4
 MLINKS+=cdce.4 if_cdce.4
 MLINKS+=crypto.4 cryptodev.4
 MLINKS+=cue.4 if_cue.4
 MLINKS+=cxgb.4 if_cxgb.4
 MLINKS+=cxgbe.4 if_cxgbe.4
 MLINKS+=dc.4 if_dc.4
 MLINKS+=de.4 if_de.4
 MLINKS+=disc.4 if_disc.4
 MLINKS+=ed.4 if_ed.4
 MLINKS+=edsc.4 if_edsc.4
 MLINKS+=em.4 if_em.4
 MLINKS+=en.4 if_en.4
 MLINKS+=enc.4 if_enc.4
 MLINKS+=epair.4 if_epair.4
 MLINKS+=et.4 if_et.4
 MLINKS+=fatm.4 if_fatm.4
 MLINKS+=fd.4 stderr.4 \
 	fd.4 stdin.4 \
 	fd.4 stdout.4
 MLINKS+=fdt.4 FDT.4
 MLINKS+=firewire.4 ieee1394.4
 MLINKS+=fpa.4 fea.4
 MLINKS+=fwe.4 if_fwe.4
 MLINKS+=fwip.4 if_fwip.4
 MLINKS+=fxp.4 if_fxp.4
 MLINKS+=gem.4 if_gem.4
 MLINKS+=geom.4 GEOM.4
 MLINKS+=gif.4 if_gif.4
 MLINKS+=gpio.4 gpiobus.4
 MLINKS+=gre.4 if_gre.4
 MLINKS+=hatm.4 if_hatm.4
 MLINKS+=hme.4 if_hme.4
 MLINKS+=hpet.4 acpi_hpet.4
 MLINKS+=${_hptrr.4} ${_rr232x.4}
 MLINKS+=${_attimer.4} ${_i8254.4}
 MLINKS+=igb.4 if_igb.4
 MLINKS+=ip.4 rawip.4
 MLINKS+=ipfirewall.4 ipaccounting.4 \
 	ipfirewall.4 ipacct.4 \
 	ipfirewall.4 ipfw.4
 MLINKS+=ipheth.4 if_ipheth.4
 MLINKS+=ipw.4 if_ipw.4
 MLINKS+=iwi.4 if_iwi.4
 MLINKS+=iwn.4 if_iwn.4
 MLINKS+=ixgb.4 if_ixgb.4
 MLINKS+=ixgbe.4 ix.4
 MLINKS+=ixgbe.4 if_ix.4
 MLINKS+=ixgbe.4 if_ixgbe.4
 MLINKS+=ixl.4 if_ixl.4
 MLINKS+=ixlv.4 if_ixlv.4
 MLINKS+=jme.4 if_jme.4
 MLINKS+=kue.4 if_kue.4
 MLINKS+=lagg.4 trunk.4
 MLINKS+=lagg.4 if_lagg.4
 MLINKS+=le.4 if_le.4
 MLINKS+=lge.4 if_lge.4
 MLINKS+=lmc.4 if_lmc.4
 MLINKS+=lo.4 loop.4
 MLINKS+=lp.4 plip.4
 MLINKS+=malo.4 if_malo.4
 MLINKS+=md.4 vn.4
 MLINKS+=mem.4 kmem.4
 MLINKS+=mn.4 if_mn.4
 MLINKS+=mos.4 if_mos.4
 MLINKS+=msk.4 if_msk.4
 MLINKS+=mwl.4 if_mwl.4
 MLINKS+=mxge.4 if_mxge.4
 MLINKS+=my.4 if_my.4
 MLINKS+=${_ndis.4} ${_if_ndis.4}
 MLINKS+=netfpga10g_nf10bmac.4 if_nf10bmac.4
 MLINKS+=netintro.4 net.4 \
 	netintro.4 networking.4
 MLINKS+=${_nfe.4} ${_if_nfe.4}
 MLINKS+=nge.4 if_nge.4
 MLINKS+=${_ntb.4} ${_if_ntb.4} \
 	${_ntb.4} ${_ntb_hw.4}
 MLINKS+=${_nxge.4} ${_if_nxge.4}
 MLINKS+=patm.4 if_patm.4
 MLINKS+=pccbb.4 cbb.4
 MLINKS+=pcm.4 snd.4 \
 	pcm.4 sound.4
 MLINKS+=pcn.4 if_pcn.4
 MLINKS+=ral.4 if_ral.4
 MLINKS+=re.4 if_re.4
 MLINKS+=rl.4 if_rl.4
 MLINKS+=rue.4 if_rue.4
 MLINKS+=rum.4 if_rum.4
 MLINKS+=run.4 if_run.4
 MLINKS+=scsi.4 CAM.4 \
 	scsi.4 cam.4 \
 	scsi.4 scbus.4 \
 	scsi.4 SCSI.4
 MLINKS+=sf.4 if_sf.4
 MLINKS+=sge.4 if_sge.4
 MLINKS+=sis.4 if_sis.4
 MLINKS+=sk.4 if_sk.4
 MLINKS+=smp.4 SMP.4
 MLINKS+=smsc.4 if_smsc.4
 MLINKS+=sn.4 if_sn.4
 MLINKS+=snd_envy24.4 snd_ak452x.4
 MLINKS+=snd_sbc.4 snd_sb16.4 \
 	snd_sbc.4 snd_sb8.4
 MLINKS+=${_spkr.4} ${_speaker.4}
 MLINKS+=splash.4 screensaver.4
 MLINKS+=ste.4 if_ste.4
 MLINKS+=stf.4 if_stf.4
 MLINKS+=stge.4 if_stge.4
 MLINKS+=syncache.4 syncookies.4
 MLINKS+=syscons.4 sc.4
 MLINKS+=tap.4 if_tap.4
 MLINKS+=tdfx.4 tdfx_linux.4
 MLINKS+=ti.4 if_ti.4
 MLINKS+=tl.4 if_tl.4
 MLINKS+=tun.4 if_tun.4
 MLINKS+=tx.4 if_tx.4
 MLINKS+=txp.4 if_txp.4
 MLINKS+=u3g.4 u3gstub.4
 MLINKS+=uath.4 if_uath.4
 MLINKS+=udav.4 if_udav.4
 MLINKS+=upgt.4 if_upgt.4
 MLINKS+=ural.4 if_ural.4
 MLINKS+=urndis.4 if_urndis.4
 MLINKS+=${_urtw.4} ${_if_urtw.4}
 MLINKS+=vge.4 if_vge.4
 MLINKS+=vlan.4 if_vlan.4
 MLINKS+=vxlan.4 if_vxlan.4
 MLINKS+=${_vmx.4} ${_if_vmx.4}
 MLINKS+=vpo.4 imm.4
 MLINKS+=vr.4 if_vr.4
 MLINKS+=vte.4 if_vte.4
 MLINKS+=${_vtnet.4} ${_if_vtnet.4}
 MLINKS+=${_vxge.4} ${_if_vxge.4}
 MLINKS+=watchdog.4 SW_WATCHDOG.4
 MLINKS+=wb.4 if_wb.4
 MLINKS+=wi.4 if_wi.4
 MLINKS+=${_wpi.4} ${_if_wpi.4}
 MLINKS+=xe.4 if_xe.4
 MLINKS+=xl.4 if_xl.4
 MLINKS+=zyd.4 if_zyd.4
 
 .if ${MACHINE_CPUARCH} == "amd64" || ${MACHINE_CPUARCH} == "i386"
 _acpi_asus.4=	acpi_asus.4
 _acpi_asus_wmi.4=	acpi_asus_wmi.4
 _acpi_dock.4=	acpi_dock.4
 _acpi_fujitsu.4=acpi_fujitsu.4
 _acpi_hp.4=	acpi_hp.4
 _acpi_ibm.4=	acpi_ibm.4
 _acpi_panasonic.4=acpi_panasonic.4
 _acpi_rapidstart.4=acpi_rapidstart.4
 _acpi_sony.4=	acpi_sony.4
 _acpi_toshiba.4=acpi_toshiba.4
 _acpi_wmi.4=	acpi_wmi.4
 _aesni.4=	aesni.4
 _aout.4=	aout.4
 _apic.4=	apic.4
 _atrtc.4=	atrtc.4
 _attimer.4=	attimer.4
 _aibs.4=	aibs.4
 _amdsbwd.4=	amdsbwd.4
 _amdsmb.4=	amdsmb.4
 _amdtemp.4=	amdtemp.4
 _asmc.4=	asmc.4
 _bxe.4=		bxe.4
 _coretemp.4=	coretemp.4
 _cpuctl.4=	cpuctl.4
 _dpms.4=	dpms.4
 _hpt27xx.4=	hpt27xx.4
 _hptiop.4=	hptiop.4
 _hptmv.4=	hptmv.4
 _hptnr.4=	hptnr.4
 _hptrr.4=	hptrr.4
 _i8254.4=	i8254.4
 _ichwd.4=	ichwd.4
 _if_bxe.4=	if_bxe.4
 _if_ndis.4=	if_ndis.4
 _if_nfe.4=	if_nfe.4
 _if_nxge.4=	if_nxge.4
 _if_urtw.4=	if_urtw.4
 _if_vmx.4=	if_vmx.4
 _if_vtnet.4=	if_vtnet.4
 _if_vxge.4=	if_vxge.4
 _if_wpi.4=	if_wpi.4
 _ipmi.4=	ipmi.4
 _io.4=		io.4
 _linux.4=	linux.4
 _ndis.4=	ndis.4
 _nfe.4=		nfe.4
 _nfsmb.4=	nfsmb.4
 _nvd.4=		nvd.4
 _nvme.4=	nvme.4
 _nvram.4=	nvram.4
 _nxge.4=	nxge.4
 _virtio.4=	virtio.4
 _virtio_balloon.4=virtio_balloon.4
 _virtio_blk.4=	virtio_blk.4
 _virtio_console.4=virtio_console.4
 _virtio_random.4= virtio_random.4
 _virtio_scsi.4= virtio_scsi.4
 _vmx.4=		vmx.4
 _vtnet.4=	vtnet.4
 _vxge.4=	vxge.4
 _padlock.4=	padlock.4
 _rr232x.4=	rr232x.4
 _speaker.4=	speaker.4
 _spkr.4=	spkr.4
 _tpm.4=		tpm.4
 _urtw.4=	urtw.4
 _viawd.4=	viawd.4
 _wbwd.4=	wbwd.4
 _wpi.4=		wpi.4
 _xen.4=		xen.4
 _xnb.4=		xnb.4
 
 .endif
 
 .if ${MACHINE_CPUARCH} == "amd64"
-_bhyve.4=	bhyve.4
 _if_ntb.4=	if_ntb.4
 _ntb.4=		ntb.4
 _ntb_hw.4=	ntb_hw.4
 _qlxge.4=	qlxge.4
 _qlxgb.4=	qlxgb.4
 _qlxgbe.4=	qlxgbe.4
 _sfxge.4=	sfxge.4
 
 MLINKS+=qlxge.4 if_qlxge.4
 MLINKS+=qlxgb.4 if_qlxgb.4
 MLINKS+=qlxgbe.4 if_qlxgbe.4
 MLINKS+=sfxge.4 if_sfxge.4
+
+.if ${MK_BHYVE} != "no"
+_bhyve.4=	bhyve.4
+.endif
 .endif
 
 .if ${MACHINE_CPUARCH} == "mips"
 _nvram2env.4=	nvram2env.4
 .endif
 
 .if exists(${.CURDIR}/man4.${MACHINE_CPUARCH})
 SUBDIR=	man4.${MACHINE_CPUARCH}
 .endif
 
 .if ${MK_CCD} != "no"
 _ccd.4=		ccd.4
 .endif
 
 .if ${MK_ISCSI} != "no"
 MAN+=		iscsi.4
 MAN+=		iscsi_initiator.4
 
 .endif
 
 .if ${MK_TESTS} != "no"
 ATF=            ${.CURDIR}/../../../contrib/atf
 .PATH:          ${ATF}/doc
 _atf_test_case.4=	atf-test-case.4
 .endif
 
 .if ${MK_PF} != "no"
 _pf.4=		pf.4
 _pflog.4=	pflog.4
 _pfsync.4=	pfsync.4
 .endif
 
 .include <bsd.prog.mk>
Index: projects/clang360-import/share/man/man4
===================================================================
--- projects/clang360-import/share/man/man4	(revision 277777)
+++ projects/clang360-import/share/man/man4	(revision 277778)

Property changes on: projects/clang360-import/share/man/man4
___________________________________________________________________
Modified: svn:mergeinfo
## -0,0 +0,1 ##
   Merged /head/share/man/man4:r277719-277776
Index: projects/clang360-import/share/man/man5/Makefile
===================================================================
--- projects/clang360-import/share/man/man5/Makefile	(revision 277777)
+++ projects/clang360-import/share/man/man5/Makefile	(revision 277778)
@@ -1,104 +1,107 @@
 #	@(#)Makefile	8.1 (Berkeley) 6/5/93
 #	$FreeBSD$
 
 .include <src.opts.mk>
 
 #MISSING: dump.5 plot.5
 MAN=	acct.5 \
 	ar.5 \
 	a.out.5 \
-	autofs.5 \
 	bluetooth.device.conf.5 \
 	bluetooth.hosts.5 \
 	bluetooth.protocols.5 \
 	${_boot.config.5} \
 	core.5 \
 	devfs.5 \
 	devfs.conf.5 \
 	devfs.rules.5 \
 	device.hints.5 \
 	dir.5 \
 	disktab.5 \
 	elf.5 \
 	ethers.5 \
 	eui64.5 \
 	ext2fs.5 \
 	fbtab.5 \
 	fdescfs.5 \
 	forward.5 \
 	fs.5 \
 	fstab.5 \
 	group.5 \
 	hosts.5 \
 	hosts.equiv.5 \
 	hosts.lpd.5 \
 	intro.5 \
 	libmap.conf.5 \
 	link.5 \
 	linprocfs.5 \
 	linsysfs.5 \
 	mailer.conf.5 \
 	make.conf.5 \
 	moduli.5 \
 	motd.5 \
 	mqueuefs.5 \
 	msdosfs.5 \
 	networks.5 \
 	nsmb.conf.5 \
 	nsswitch.conf.5 \
 	nullfs.5 \
 	passwd.5 \
 	pbm.5 \
 	periodic.conf.5 \
 	phones.5 \
 	portindex.5 \
 	portsnap.conf.5 \
 	procfs.5 \
 	protocols.5 \
 	quota.user.5 \
 	rc.conf.5 \
 	rctl.conf.5 \
 	regdomain.5 \
 	reiserfs.5 \
 	remote.5 \
 	resolver.5 \
 	services.5 \
 	shells.5 \
 	src.conf.5 \
 	stab.5 \
 	style.Makefile.5 \
 	sysctl.conf.5 \
 	tmpfs.5
 
 MLINKS=	dir.5 dirent.5
 MLINKS+=fs.5 inode.5
 MLINKS+=hosts.equiv.5 rhosts.5
 MLINKS+=msdosfs.5 msdos.5
 MLINKS+=passwd.5 master.passwd.5
 MLINKS+=portindex.5 INDEX.5
 MLINKS+=quota.user.5 quota.group.5
 MLINKS+=rc.conf.5 rc.conf.local.5
 MLINKS+=resolver.5 resolv.conf.5
+
+.if ${MK_AUTOFS} != "no"
+MAN+=	autofs.5
+.endif
 
 .if ${MK_FREEBSD_UPDATE} != "no"
 MAN+=	freebsd-update.conf.5
 .endif
 
 .if ${MK_HESIOD} != "no"
 MAN+=	hesiod.conf.5 
 .endif
 
 .if ${MK_NAND} != "no"
 MAN+=	nandfs.5
 .endif
 
 .if ${MK_PF} != "no"
 MAN+=	pf.conf.5 \
 	pf.os.5
 .endif
 
 .if ${MACHINE_CPUARCH} == "amd64" || ${MACHINE_CPUARCH} == "i386"
 _boot.config.5=	boot.config.5
 .endif
 
 .include <bsd.prog.mk>
Index: projects/clang360-import/share/man/man5/src.conf.5
===================================================================
--- projects/clang360-import/share/man/man5/src.conf.5	(revision 277777)
+++ projects/clang360-import/share/man/man5/src.conf.5	(revision 277778)
@@ -1,1213 +1,1230 @@
 .\" DO NOT EDIT-- this file is automatically generated.
 .\" from FreeBSD: head/tools/build/options/makeman 255964 2013-10-01 07:22:04Z des
 .\" $FreeBSD$
-.Dd January 24, 2015
+.Dd January 25, 2015
 .Dt SRC.CONF 5
 .Os
 .Sh NAME
 .Nm src.conf
 .Nd "source build options"
 .Sh DESCRIPTION
 The
 .Nm
 file contains settings that will apply to every build involving the
 .Fx
 source tree; see
 .Xr build 7 .
 .Pp
 The
 .Nm
 file uses the standard makefile syntax.
 However,
 .Nm
 should not specify any dependencies to
 .Xr make 1 .
 Instead,
 .Nm
 is to set
 .Xr make 1
 variables that control the aspects of how the system builds.
 .Pp
 The default location of
 .Nm
 is
 .Pa /etc/src.conf ,
 though an alternative location can be specified in the
 .Xr make 1
 variable
 .Va SRCCONF .
 Overriding the location of
 .Nm
 may be necessary if the system-wide settings are not suitable
 for a particular build.
 For instance, setting
 .Va SRCCONF
 to
 .Pa /dev/null
 effectively resets all build controls to their defaults.
 .Pp
 The only purpose of
 .Nm
 is to control the compilation of the
 .Fx
 source code, which is usually located in
 .Pa /usr/src .
 As a rule, the system administrator creates
 .Nm
 when the values of certain control variables need to be changed
 from their defaults.
 .Pp
 In addition, control variables can be specified
 for a particular build via the
 .Fl D
 option of
 .Xr make 1
 or in its environment; see
 .Xr environ 7 .
 .Pp
 The values of variables are ignored regardless of their setting;
 even if they would be set to
 .Dq Li FALSE
 or
 .Dq Li NO .
 Just the existence of an option will cause
 it to be honoured by
 .Xr make 1 .
 .Pp
 The following list provides a name and short description for variables
 that can be used for source builds.
 .Bl -tag -width indent
 .It Va WITHOUT_ACCT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_ACCT 223201 2011-06-17 20:47:44Z ed
 Set to not build process accounting tools such as
 .Xr accton 8
 and
 .Xr sa 8 .
 .It Va WITHOUT_ACPI
 .\" from FreeBSD: head/tools/build/options/WITHOUT_ACPI 156932 2006-03-21 07:50:50Z ru
 Set to not build
 .Xr acpiconf 8 ,
 .Xr acpidump 8
 and related programs.
 .It Va WITHOUT_AMD
 .\" from FreeBSD: head/tools/build/options/WITHOUT_AMD 183242 2008-09-21 22:02:26Z sam
 Set to not build
 .Xr amd 8 ,
 and related programs.
 .It Va WITHOUT_APM
 .\" from FreeBSD: head/tools/build/options/WITHOUT_APM 183242 2008-09-21 22:02:26Z sam
 Set to not build
 .Xr apm 8 ,
 .Xr apmd 8
 and related programs.
 .It Va WITHOUT_ASSERT_DEBUG
 .\" from FreeBSD: head/tools/build/options/WITHOUT_ASSERT_DEBUG 162215 2006-09-11 13:55:27Z ru
 Set to compile programs and libraries without the
 .Xr assert 3
 checks.
 .It Va WITHOUT_AT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_AT 183242 2008-09-21 22:02:26Z sam
 Set to not build
 .Xr at 1
 and related utilities.
 .It Va WITHOUT_ATM
 .\" from FreeBSD: head/tools/build/options/WITHOUT_ATM 156932 2006-03-21 07:50:50Z ru
 Set to not build
 programs and libraries related to ATM networking.
 .It Va WITHOUT_AUDIT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_AUDIT 156932 2006-03-21 07:50:50Z ru
 Set to not build audit support into system programs.
 .It Va WITHOUT_AUTHPF
 .\" from FreeBSD: head/tools/build/options/WITHOUT_AUTHPF 156932 2006-03-21 07:50:50Z ru
 Set to not build
 .Xr authpf 8 .
+.It Va WITHOUT_AUTOFS
+.\" from FreeBSD: head/tools/build/options/WITHOUT_AUTOFS 277728 2015-01-26 07:15:49Z ngie
+Set to not build
+.Xr autofs 4
+related programs, libraries, and kernel modules.
+.It Va WITHOUT_BHYVE
+.\" from FreeBSD: head/tools/build/options/WITHOUT_BHYVE 277727 2015-01-26 06:44:48Z ngie
+Set to not build or install
+.Xr bhyve 8 ,
+associated utilities, and examples.
+.Pp
+This option only affects amd64/amd64.
 .It Va WITHOUT_BINUTILS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_BINUTILS 266158 2014-05-15 16:51:45Z brooks
 Set to not build or install binutils (as, c++-filt, gconv,
 ld, nm, objcopy, objdump, readelf, size and strip) as part
 of the normal system build.
 The resulting system cannot build programs from source.
 .It Va WITHOUT_BINUTILS_BOOTSTRAP
 .\" from FreeBSD: head/tools/build/options/WITHOUT_BINUTILS_BOOTSTRAP 264660 2014-04-18 17:03:58Z imp
 Set to not build binutils (as, c++-filt, gconv,
 ld, nm, objcopy, objdump, readelf, size and strip)
 as part of the bootstrap process.
 .Bf -symbolic
 The option does not work for build targets unless some alternative
 toolchain is provided.
 .Ef
 .It Va WITHOUT_BLUETOOTH
 .\" from FreeBSD: head/tools/build/options/WITHOUT_BLUETOOTH 156932 2006-03-21 07:50:50Z ru
 Set to not build Bluetooth related kernel modules, programs and libraries.
 .It Va WITHOUT_BOOT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_BOOT 156932 2006-03-21 07:50:50Z ru
 Set to not build the boot blocks and loader.
 .It Va WITHOUT_BSDINSTALL
 .\" from FreeBSD: head/tools/build/options/WITHOUT_BSDINSTALL 277677 2015-01-25 04:43:13Z ngie
 Set to not build
 .Xr bsdinstall 8 ,
 .Xr sade 8 ,
 and related programs.
 .It Va WITHOUT_BSD_CPIO
 .\" from FreeBSD: head/tools/build/options/WITHOUT_BSD_CPIO 179813 2008-06-16 05:48:15Z dougb
 Set to not build the BSD licensed version of cpio based on
 .Xr libarchive 3 .
 .It Va WITH_BSD_GREP
 .\" from FreeBSD: head/tools/build/options/WITH_BSD_GREP 222273 2011-05-25 01:04:12Z obrien
 Install BSD-licensed grep as '[ef]grep' instead of GNU grep.
 .It Va WITHOUT_BSNMP
 .\" from FreeBSD: head/tools/build/options/WITHOUT_BSNMP 183306 2008-09-23 16:15:42Z sam
 Set to not build or install
 .Xr bsnmpd 1
 and related libraries and data files.
 .It Va WITHOUT_BZIP2
 .\" from FreeBSD: head/tools/build/options/WITHOUT_BZIP2 174550 2007-12-12 16:43:17Z ru
 Set to not build contributed bzip2 software as a part of the base system.
 .Bf -symbolic
 The option has no effect yet.
 .Ef
 When set, it also enforces the following options:
 .Pp
 .Bl -item -compact
 .It
 .Va WITHOUT_BZIP2_SUPPORT
 .El
 .It Va WITHOUT_BZIP2_SUPPORT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_BZIP2_SUPPORT 166255 2007-01-26 10:19:08Z delphij
 Set to build some programs without optional bzip2 support.
 .It Va WITHOUT_CALENDAR
 .\" from FreeBSD: head/tools/build/options/WITHOUT_CALENDAR 156932 2006-03-21 07:50:50Z ru
 Set to not build
 .Xr calendar 1 .
 .It Va WITHOUT_CAPSICUM
 .\" from FreeBSD: head/tools/build/options/WITHOUT_CAPSICUM 229319 2012-01-02 21:57:58Z rwatson
 Set to not build Capsicum support into system programs.
 .It Va WITHOUT_CASPER
 .\" from FreeBSD: head/tools/build/options/WITHOUT_CASPER 258838 2013-12-02 08:21:28Z pjd
 Set to not build Casper program and related libraries.
 .It Va WITHOUT_CCD
 .\" from FreeBSD: head/tools/build/options/WITHOUT_CCD 277678 2015-01-25 04:52:48Z ngie
 Set to not build
 .Xr geom_ccd 4
 and related utilities.
 .It Va WITHOUT_CDDL
 .\" from FreeBSD: head/tools/build/options/WITHOUT_CDDL 163861 2006-11-01 09:02:11Z jb
 Set to not build code licensed under Sun's CDDL.
 When set, it also enforces the following options:
 .Pp
 .Bl -item -compact
 .It
 .Va WITHOUT_CTF
 .It
 .Va WITHOUT_ZFS
 .El
 .It Va WITHOUT_CLANG
 .\" from FreeBSD: head/tools/build/options/WITHOUT_CLANG 264660 2014-04-18 17:03:58Z imp
 Set to not build the Clang C/C++ compiler during the regular phase of the build.
 .Pp
 It is a default setting on
 arm/armeb, mips/mipsel, mips/mips, mips/mips64el, mips/mips64, mips/mipsn32 and sparc64/sparc64.
 When set, it also enforces the following options:
 .Pp
 .Bl -item -compact
 .It
 .Va WITHOUT_CLANG_EXTRAS
 .It
 .Va WITHOUT_CLANG_FULL
 .El
 .It Va WITH_CLANG
 .\" from FreeBSD: head/tools/build/options/WITH_CLANG 264660 2014-04-18 17:03:58Z imp
 Set to build the Clang C/C++ compiler during the normal phase of the build.
 .Pp
 It is a default setting on
 amd64/amd64, arm/arm, arm/armv6, arm/armv6hf, i386/i386, pc98/i386, powerpc/powerpc and powerpc/powerpc64.
 .It Va WITHOUT_CLANG_BOOTSTRAP
 .\" from FreeBSD: head/tools/build/options/WITHOUT_CLANG_BOOTSTRAP 273177 2014-10-16 18:28:11Z skreuzer
 Set to not build the Clang C/C++ compiler during the bootstrap phase of the build.
 You must enable either gcc or clang bootstrap to be able to build the system,
 unless an alternative compiler is provided via
 XCC.
 .Pp
 It is a default setting on
 arm/armeb, mips/mipsel, mips/mips, mips/mips64el, mips/mips64, mips/mipsn32, powerpc/powerpc, powerpc/powerpc64 and sparc64/sparc64.
 .It Va WITH_CLANG_BOOTSTRAP
 .\" from FreeBSD: head/tools/build/options/WITH_CLANG_BOOTSTRAP 264660 2014-04-18 17:03:58Z imp
 Set to build the Clang C/C++ compiler during the bootstrap phase of the build.
 .Pp
 It is a default setting on
 amd64/amd64, arm/arm, arm/armv6, arm/armv6hf, i386/i386 and pc98/i386.
 .It Va WITH_CLANG_EXTRAS
 .\" from FreeBSD: head/tools/build/options/WITH_CLANG_EXTRAS 231057 2012-02-05 23:56:22Z dim
 Set to build additional clang and llvm tools, such as bugpoint.
 .It Va WITHOUT_CLANG_FULL
 .\" from FreeBSD: head/tools/build/options/WITHOUT_CLANG_FULL 246259 2013-02-02 22:28:29Z dim
 Set to avoid building the ARCMigrate, Rewriter and StaticAnalyzer components of
 the Clang C/C++ compiler.
 .Pp
 It is a default setting on
 arm/arm, arm/armeb, arm/armv6, arm/armv6hf, mips/mipsel, mips/mips, mips/mips64el, mips/mips64, mips/mipsn32 and sparc64/sparc64.
 .It Va WITH_CLANG_FULL
 .\" from FreeBSD: head/tools/build/options/WITH_CLANG_FULL 246259 2013-02-02 22:28:29Z dim
 Set to build the ARCMigrate, Rewriter and StaticAnalyzer components of the
 Clang C/C++ compiler.
 .Pp
 It is a default setting on
 amd64/amd64, i386/i386, pc98/i386, powerpc/powerpc and powerpc/powerpc64.
 .It Va WITHOUT_CLANG_IS_CC
 .\" from FreeBSD: head/tools/build/options/WITHOUT_CLANG_IS_CC 242629 2012-11-05 21:53:23Z brooks
 Set to install the GCC compiler as
 .Pa /usr/bin/cc ,
 .Pa /usr/bin/c++
 and
 .Pa /usr/bin/cpp .
 .Pp
 It is a default setting on
 arm/armeb, mips/mipsel, mips/mips, mips/mips64el, mips/mips64, mips/mipsn32, powerpc/powerpc, powerpc/powerpc64 and sparc64/sparc64.
 .It Va WITH_CLANG_IS_CC
 .\" from FreeBSD: head/tools/build/options/WITH_CLANG_IS_CC 235342 2012-05-12 16:12:36Z gjb
 Set to install the Clang C/C++ compiler as
 .Pa /usr/bin/cc ,
 .Pa /usr/bin/c++
 and
 .Pa /usr/bin/cpp .
 .Pp
 It is a default setting on
 amd64/amd64, arm/arm, arm/armv6, arm/armv6hf, i386/i386 and pc98/i386.
 .It Va WITHOUT_CPP
 .\" from FreeBSD: head/tools/build/options/WITHOUT_CPP 156932 2006-03-21 07:50:50Z ru
 Set to not build
 .Xr cpp 1 .
 .It Va WITHOUT_CROSS_COMPILER
 .\" from FreeBSD: head/tools/build/options/WITHOUT_CROSS_COMPILER 275138 2014-11-26 20:43:09Z gjb
 Set to not build any cross compiler in the cross-tools stage of buildworld.
 If you are compiling a different version of
 .Fx
 than what is installed on the system, you will need to provide an alternate
 compiler with XCC to ensure success.
 If you are compiling with an identical version of
 .Fx
 to the host, this option may be safely used.
 This option may also be safe when the host version of
 .Fx
 is close to the sources being built, but all bets are off if there have
 been any changes to the toolchain between the versions.
 When set, it also enforces the following options:
 .Pp
 .Bl -item -compact
 .It
 .Va WITHOUT_BINUTILS_BOOTSTRAP
 .It
 .Va WITHOUT_CLANG_BOOTSTRAP
 .It
 .Va WITHOUT_GCC_BOOTSTRAP
 .El
 .It Va WITHOUT_CRYPT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_CRYPT 156932 2006-03-21 07:50:50Z ru
 Set to not build any crypto code.
 When set, it also enforces the following options:
 .Pp
 .Bl -item -compact
 .It
 .Va WITHOUT_KERBEROS
 .It
 .Va WITHOUT_KERBEROS_SUPPORT
 .It
 .Va WITHOUT_OPENSSH
 .It
 .Va WITHOUT_OPENSSL
 .El
 .Pp
 When set, the following options are also in effect:
 .Pp
 .Bl -inset -compact
 .It Va WITHOUT_GSSAPI
 (unless
 .Va WITH_GSSAPI
 is set explicitly)
 .El
 .It Va WITH_CTF
 .\" from FreeBSD: head/tools/build/options/WITH_CTF 228159 2011-11-30 18:22:44Z fjoe
 Set to compile with CTF (Compact C Type Format) data.
 CTF data encapsulates a reduced form of debugging information
 similar to DWARF and the venerable stabs and is required for DTrace.
 .It Va WITHOUT_CTM
 .\" from FreeBSD: head/tools/build/options/WITHOUT_CTM 183242 2008-09-21 22:02:26Z sam
 Set to not build
 .Xr ctm 1
 and related utilities.
 .It Va WITHOUT_CUSE
 .\" from FreeBSD: head/tools/build/options/WITHOUT_CUSE 270171 2014-08-19 15:40:26Z hselasky
 Set to not build CUSE-related programs and libraries.
 .It Va WITHOUT_CXX
 .\" from FreeBSD: head/tools/build/options/WITHOUT_CXX 220402 2011-04-06 20:19:07Z uqs
 Set to not build
 .Xr g++ 1
 and related libraries.
 It will also prevent building of
 .Xr gperf 1
 and
 .Xr devd 8 .
 When set, it also enforces the following options:
 .Pp
 .Bl -item -compact
 .It
 .Va WITHOUT_CLANG
 .It
 .Va WITHOUT_CLANG_EXTRAS
 .It
 .Va WITHOUT_CLANG_FULL
 .It
 .Va WITHOUT_GNUCXX
 .It
 .Va WITHOUT_GROFF
 .El
 .It Va WITH_DEBUG_FILES
 .\" from FreeBSD: head/tools/build/options/WITH_DEBUG_FILES 251512 2013-06-07 21:40:02Z emaste
 Set to strip debug info into a separate file for each executable binary
 and shared library.
 The debug files will be placed in a subdirectory of
 .Pa /usr/lib/debug
 and are located automatically by
 .Xr gdb 1 .
 .It Va WITHOUT_DICT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_DICT 156932 2006-03-21 07:50:50Z ru
 Set to not build the Webster dictionary files.
 .It Va WITHOUT_DMAGENT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_DMAGENT 262335 2014-02-22 13:05:23Z bapt
 Set to not build dma Mail Transport Agent
 .It Va WITHOUT_DOCCOMPRESS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_DOCCOMPRESS 266752 2014-05-27 15:52:27Z gjb
 Set to not to install compressed system documentation.
 Only the uncompressed version will be installed.
 .It Va WITHOUT_DYNAMICROOT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_DYNAMICROOT 156932 2006-03-21 07:50:50Z ru
 Set this if you do not want to link
 .Pa /bin
 and
 .Pa /sbin
 dynamically.
 .It Va WITHOUT_ED_CRYPTO
 .\" from FreeBSD: head/tools/build/options/WITHOUT_ED_CRYPTO 235660 2012-05-19 20:05:27Z marcel
 Set to build
 .Xr ed 1
 without support for encryption/decryption.
 .It Va WITHOUT_EE
 .\" from FreeBSD: head/tools/build/options/WITHOUT_EE 277663 2015-01-25 00:03:44Z ngie
 Set to not build and install
 .Xr edit 1 ,
 .Xr ee 1 ,
 and related programs.
 .It Va WITH_EISA
 .\" from FreeBSD: head/tools/build/options/WITH_EISA 264654 2014-04-18 16:53:06Z imp
 Set to build EISA kernel modules.
 .It Va WITHOUT_ELFTOOLCHAIN_TOOLS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_ELFTOOLCHAIN_TOOLS 276796 2015-01-07 22:02:37Z emaste
 Set to use
 .Xr addr2line 1 ,
 .Xr nm 1 ,
 .Xr size 1 ,
 .Xr strings 1 ,
 and
 .Xr strip 1
 from GNU binutils instead of the ELF Tool Chain project.
 .It Va WITHOUT_EXAMPLES
 .\" from FreeBSD: head/tools/build/options/WITHOUT_EXAMPLES 156938 2006-03-21 09:06:24Z ru
 Set to avoid installing examples to
 .Pa /usr/share/examples/ .
 .It Va WITHOUT_FDT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_FDT 221539 2011-05-06 19:10:27Z ru
 Set to not build Flattened Device Tree support as part of the base system.
 This includes the device tree compiler (dtc) and libfdt support library.
 .It Va WITHOUT_FLOPPY
 .\" from FreeBSD: head/tools/build/options/WITHOUT_FLOPPY 221540 2011-05-06 19:13:03Z ru
 Set to not build or install programs
 for operating floppy disk driver.
 .It Va WITH_FMAKE
 .\" from FreeBSD: head/tools/build/options/WITH_FMAKE 275138 2014-11-26 20:43:09Z gjb
 Causes the old FreeBSD
 .Xr make 1
 program to be built and installed as fmake.
 .It Va WITHOUT_FMTREE
 .\" from FreeBSD: head/tools/build/options/WITHOUT_FMTREE 261299 2014-01-30 21:37:43Z brooks
 Set to not build and install
 .Pa /usr/sbin/fmtree .
 .It Va WITHOUT_FORMAT_EXTENSIONS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_FORMAT_EXTENSIONS 250658 2013-05-15 13:04:10Z brooks
 Set to not enable
 .Fl fformat-extensions
 when compiling the kernel.
 Also disables all format checking.
 .It Va WITHOUT_FORTH
 .\" from FreeBSD: head/tools/build/options/WITHOUT_FORTH 156932 2006-03-21 07:50:50Z ru
 Set to build bootloaders without Forth support.
 .It Va WITHOUT_FP_LIBC
 .\" from FreeBSD: head/tools/build/options/WITHOUT_FP_LIBC 156932 2006-03-21 07:50:50Z ru
 Set to build
 .Nm libc
 without floating-point support.
 .It Va WITHOUT_FREEBSD_UPDATE
 .\" from FreeBSD: head/tools/build/options/WITHOUT_FREEBSD_UPDATE 183242 2008-09-21 22:02:26Z sam
 Set to not build
 .Xr freebsd-update 8 .
 .It Va WITHOUT_GAMES
 .\" from FreeBSD: head/tools/build/options/WITHOUT_GAMES 156932 2006-03-21 07:50:50Z ru
 Set to not build games.
 .It Va WITHOUT_GCC
 .\" from FreeBSD: head/tools/build/options/WITHOUT_GCC 264660 2014-04-18 17:03:58Z imp
 Set to not build and install gcc and g++ as part of the normal build process.
 .Pp
 It is a default setting on
 amd64/amd64, arm/arm, arm/armv6, arm/armv6hf, i386/i386 and pc98/i386.
 .It Va WITH_GCC
 .\" from FreeBSD: head/tools/build/options/WITH_GCC 255326 2013-09-06 20:49:48Z zeising
 Set to build and install gcc and g++.
 .Pp
 It is a default setting on
 arm/armeb, mips/mipsel, mips/mips, mips/mips64el, mips/mips64, mips/mipsn32, powerpc/powerpc, powerpc/powerpc64 and sparc64/sparc64.
 .It Va WITHOUT_GCC_BOOTSTRAP
 .\" from FreeBSD: head/tools/build/options/WITHOUT_GCC_BOOTSTRAP 273177 2014-10-16 18:28:11Z skreuzer
 Set to not build gcc and g++ as part of the bootstrap process.
 You must enable either gcc or clang bootstrap to be able to build the system,
 unless an alternative compiler is provided via
 XCC.
 .Pp
 It is a default setting on
 amd64/amd64, arm/arm, arm/armv6, arm/armv6hf, i386/i386 and pc98/i386.
 .It Va WITH_GCC_BOOTSTRAP
 .\" from FreeBSD: head/tools/build/options/WITH_GCC_BOOTSTRAP 264660 2014-04-18 17:03:58Z imp
 Set to build gcc and g++ as part of the bootstrap process.
 .Pp
 It is a default setting on
 arm/armeb, mips/mipsel, mips/mips, mips/mips64el, mips/mips64, mips/mipsn32, powerpc/powerpc, powerpc/powerpc64 and sparc64/sparc64.
 .It Va WITHOUT_GCOV
 .\" from FreeBSD: head/tools/build/options/WITHOUT_GCOV 156932 2006-03-21 07:50:50Z ru
 Set to not build the
 .Xr gcov 1
 tool.
 .It Va WITHOUT_GDB
 .\" from FreeBSD: head/tools/build/options/WITHOUT_GDB 156932 2006-03-21 07:50:50Z ru
 Set to not build
 .Xr gdb 1 .
 .It Va WITHOUT_GNU
 .\" from FreeBSD: head/tools/build/options/WITHOUT_GNU 174550 2007-12-12 16:43:17Z ru
 Set to not build contributed GNU software as a part of the base system.
 This option can be useful if the system built must not contain any code
 covered by the GNU Public License due to legal reasons.
 .Bf -symbolic
 The option has no effect yet.
 .Ef
 When set, it also enforces the following options:
 .Pp
 .Bl -item -compact
 .It
 .Va WITHOUT_GNU_SUPPORT
 .El
 .It Va WITHOUT_GNUCXX
 .\" from FreeBSD: head/tools/build/options/WITHOUT_GNUCXX 255321 2013-09-06 20:08:03Z theraven
 Do not build the GNU C++ stack (g++, libstdc++).
 This is the default on platforms where clang is the system compiler.
 .Pp
 It is a default setting on
 amd64/amd64, arm/arm, arm/armv6, arm/armv6hf, i386/i386 and pc98/i386.
 .It Va WITH_GNUCXX
 .\" from FreeBSD: head/tools/build/options/WITH_GNUCXX 255321 2013-09-06 20:08:03Z theraven
 Build the GNU C++ stack (g++, libstdc++).
 This is the default on platforms where gcc is the system compiler.
 .Pp
 It is a default setting on
 arm/armeb, mips/mipsel, mips/mips, mips/mips64el, mips/mips64, mips/mipsn32, powerpc/powerpc, powerpc/powerpc64 and sparc64/sparc64.
 .It Va WITHOUT_GNU_GREP_COMPAT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_GNU_GREP_COMPAT 273421 2014-10-21 20:44:33Z emaste
 Set this option to omit the gnu extensions to grep from being included in
 BSD grep.
 .It Va WITHOUT_GNU_SUPPORT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_GNU_SUPPORT 156932 2006-03-21 07:50:50Z ru
 Set to build some programs without optional GNU support.
 .It Va WITHOUT_GPIO
 .\" from FreeBSD: head/tools/build/options/WITHOUT_GPIO 228081 2011-11-28 17:54:34Z dim
 Set to not build
 .Xr gpioctl 8
 as part of the base system.
 .It Va WITHOUT_GPL_DTC
 .\" from FreeBSD: head/tools/build/options/WITHOUT_GPL_DTC 264515 2014-04-15 20:41:55Z imp
 Set to build the BSD licensed version of the device tree compiler, instead of the
 GPL'd one from elinux.org.
 .It Va WITHOUT_GROFF
 .\" from FreeBSD: head/tools/build/options/WITHOUT_GROFF 218941 2011-02-22 08:13:49Z uqs
 Set to not build
 .Xr groff 1
 and
 .Xr vgrind 1 .
 You should consider installing the textproc/groff port to not break
 .Xr man 1 .
 .It Va WITHOUT_GSSAPI
 .\" from FreeBSD: head/tools/build/options/WITHOUT_GSSAPI 174548 2007-12-12 16:39:32Z ru
 Set to not build libgssapi.
+.It Va WITHOUT_HAST
+.\" from FreeBSD: head/tools/build/options/WITHOUT_HAST 277725 2015-01-26 06:27:07Z ngie
+Set to not build
+.Xr hastd 8
+and related utilities.
 .It Va WITH_HESIOD
 .\" from FreeBSD: head/tools/build/options/WITH_HESIOD 156932 2006-03-21 07:50:50Z ru
 Set to build Hesiod support.
 .It Va WITHOUT_HTML
 .\" from FreeBSD: head/tools/build/options/WITHOUT_HTML 156932 2006-03-21 07:50:50Z ru
 Set to not build HTML docs.
 .It Va WITHOUT_HYPERV
 .\" from FreeBSD: head/tools/build/options/WITHOUT_HYPERV 271493 2014-09-13 02:15:31Z delphij
 Set to not build or install HyperV utilities.
 .It Va WITHOUT_ICONV
 .\" from FreeBSD: head/tools/build/options/WITHOUT_ICONV 254919 2013-08-26 17:15:56Z antoine
 Set to not build iconv as part of libc.
 .It Va WITHOUT_INCLUDES
 .\" from FreeBSD: head/tools/build/options/WITHOUT_INCLUDES 275138 2014-11-26 20:43:09Z gjb
 Set to not install header files.
 This option used to be spelled
 .Va NO_INCS .
 .Bf -symbolic
 The option does not work for build targets.
 .Ef
 .It Va WITHOUT_INET
 .\" from FreeBSD: head/tools/build/options/WITHOUT_INET 221266 2011-04-30 17:58:28Z bz
 Set to not build programs and libraries related to IPv4 networking.
 When set, it also enforces the following options:
 .Pp
 .Bl -item -compact
 .It
 .Va WITHOUT_INET_SUPPORT
 .El
 .It Va WITHOUT_INET6
 .\" from FreeBSD: head/tools/build/options/WITHOUT_INET6 156932 2006-03-21 07:50:50Z ru
 Set to not build
 programs and libraries related to IPv6 networking.
 When set, it also enforces the following options:
 .Pp
 .Bl -item -compact
 .It
 .Va WITHOUT_INET6_SUPPORT
 .El
 .It Va WITHOUT_INET6_SUPPORT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_INET6_SUPPORT 156932 2006-03-21 07:50:50Z ru
 Set to build libraries, programs, and kernel modules without IPv6 support.
 .It Va WITHOUT_INET_SUPPORT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_INET_SUPPORT 221266 2011-04-30 17:58:28Z bz
 Set to build libraries, programs, and kernel modules without IPv4 support.
 .It Va WITHOUT_INSTALLLIB
 .\" from FreeBSD: head/tools/build/options/WITHOUT_INSTALLLIB 174497 2007-12-09 21:56:21Z dougb
 Set this if you do not want to install optional libraries.
 For example when creating a
 .Xr nanobsd 8
 image.
 .It Va WITH_INSTALL_AS_USER
 .\" from FreeBSD: head/tools/build/options/WITH_INSTALL_AS_USER 238021 2012-07-02 20:24:01Z marcel
 Set to make install targets succeed for non-root users by installing
 files with owner and group attributes set to that of the user running
 the
 .Xr make 1
 command.
 The user still has to set the
 .Va DESTDIR
 variable to point to a directory where the user has write permissions.
 .It Va WITHOUT_IPFILTER
 .\" from FreeBSD: head/tools/build/options/WITHOUT_IPFILTER 156932 2006-03-21 07:50:50Z ru
 Set to not build IP Filter package.
 .It Va WITHOUT_IPFW
 .\" from FreeBSD: head/tools/build/options/WITHOUT_IPFW 183242 2008-09-21 22:02:26Z sam
 Set to not build IPFW tools.
 .It Va WITHOUT_ISCSI
 .\" from FreeBSD: head/tools/build/options/WITHOUT_ISCSI 277675 2015-01-25 04:20:11Z ngie
 Set to not build
 .Xr iscid 8
 and related utilities.
 .It Va WITHOUT_JAIL
 .\" from FreeBSD: head/tools/build/options/WITHOUT_JAIL 249966 2013-04-27 04:09:09Z eadler
 Set to not build tools for the support of jails; e.g.,
 .Xr jail 8 .
 .It Va WITHOUT_KDUMP
 .\" from FreeBSD: head/tools/build/options/WITHOUT_KDUMP 240690 2012-09-19 11:38:37Z zeising
 Set to not build
 .Xr kdump 1
 and
 .Xr truss 1 .
 .It Va WITHOUT_KERBEROS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_KERBEROS 174549 2007-12-12 16:42:03Z ru
 Set this if you do not want to build Kerberos 5 (KTH Heimdal).
 When set, it also enforces the following options:
 .Pp
 .Bl -item -compact
 .It
 .Va WITHOUT_KERBEROS_SUPPORT
 .El
 .Pp
 When set, the following options are also in effect:
 .Pp
 .Bl -inset -compact
 .It Va WITHOUT_GSSAPI
 (unless
 .Va WITH_GSSAPI
 is set explicitly)
 .El
 .It Va WITHOUT_KERBEROS_SUPPORT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_KERBEROS_SUPPORT 251794 2013-06-15 20:29:07Z eadler
 Set to build some programs without Kerberos support, like
 .Xr ssh 1 ,
 .Xr telnet 1 ,
 .Xr sshd 8 ,
 and
 .Xr telnetd 8 .
 .It Va WITHOUT_KERNEL_SYMBOLS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_KERNEL_SYMBOLS 222189 2011-05-22 18:23:17Z imp
 Set to not install kernel symbol files.
 .Bf -symbolic
 This option is recommended for those people who have small root partitions.
 .Ef
 .It Va WITHOUT_KVM
 .\" from FreeBSD: head/tools/build/options/WITHOUT_KVM 174550 2007-12-12 16:43:17Z ru
 Set to not build the
 .Nm libkvm
 library as a part of the base system.
 .Bf -symbolic
 The option has no effect yet.
 .Ef
 When set, it also enforces the following options:
 .Pp
 .Bl -item -compact
 .It
 .Va WITHOUT_KVM_SUPPORT
 .El
 .It Va WITHOUT_KVM_SUPPORT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_KVM_SUPPORT 170644 2007-06-13 02:08:04Z sepotvin
 Set to build some programs without optional
 .Nm libkvm
 support.
 .It Va WITHOUT_LDNS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_LDNS 255591 2013-09-15 13:11:13Z des
 Setting this variable will prevent the LDNS library from being built.
 When set, it also enforces the following options:
 .Pp
 .Bl -item -compact
 .It
 .Va WITHOUT_LDNS_UTILS
 .It
 .Va WITHOUT_UNBOUND
 .El
 .It Va WITHOUT_LDNS_UTILS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_LDNS_UTILS 255850 2013-09-24 14:33:31Z des
 Setting this variable will prevent building the LDNS utilities
 .Xr drill 1
 and
 .Xr host 1 .
 .It Va WITHOUT_LEGACY_CONSOLE
 .\" from FreeBSD: head/tools/build/options/WITHOUT_LEGACY_CONSOLE 249966 2013-04-27 04:09:09Z eadler
 Set to not build programs that support a legacy PC console; e.g.,
 .Xr kbdcontrol 8
 and
 .Xr vidcontrol 8 .
 .It Va WITHOUT_LIB32
 .\" from FreeBSD: head/tools/build/options/WITHOUT_LIB32 274664 2014-11-18 17:06:48Z imp
 On 64-bit platforms, set to not build 32-bit library set and a
 .Nm ld-elf32.so.1
 runtime linker.
 .It Va WITHOUT_LIBCPLUSPLUS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_LIBCPLUSPLUS 246262 2013-02-02 22:42:46Z dim
 Set to avoid building libcxxrt and libc++.
 .It Va WITHOUT_LIBPTHREAD
 .\" from FreeBSD: head/tools/build/options/WITHOUT_LIBPTHREAD 188848 2009-02-20 11:09:55Z mtm
 Set to not build the
 .Nm libpthread
 providing library,
 .Nm libthr .
 When set, it also enforces the following options:
 .Pp
 .Bl -item -compact
 .It
 .Va WITHOUT_LIBTHR
 .El
 .It Va WITHOUT_LIBTHR
 .\" from FreeBSD: head/tools/build/options/WITHOUT_LIBTHR 156932 2006-03-21 07:50:50Z ru
 Set to not build the
 .Nm libthr
 (1:1 threading)
 library.
 .It Va WITH_LLDB
 .\" from FreeBSD: head/tools/build/options/WITH_LLDB 255722 2013-09-20 01:52:02Z emaste
 Set to build the LLDB debugger.
 .It Va WITHOUT_LOCALES
 .\" from FreeBSD: head/tools/build/options/WITHOUT_LOCALES 156932 2006-03-21 07:50:50Z ru
 Set to not build localization files; see
 .Xr locale 1 .
 .It Va WITHOUT_LOCATE
 .\" from FreeBSD: head/tools/build/options/WITHOUT_LOCATE 183242 2008-09-21 22:02:26Z sam
 Set to not build
 .Xr locate 1
 and related programs.
 .It Va WITHOUT_LPR
 .\" from FreeBSD: head/tools/build/options/WITHOUT_LPR 156932 2006-03-21 07:50:50Z ru
 Set to not build
 .Xr lpr 1
 and related programs.
 .It Va WITHOUT_LS_COLORS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_LS_COLORS 235660 2012-05-19 20:05:27Z marcel
 Set to build
 .Xr ls 1
 without support for colors to distinguish file types.
 .It Va WITHOUT_LZMA_SUPPORT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_LZMA_SUPPORT 245171 2013-01-08 18:37:12Z obrien
 Set to build some programs without optional lzma compression support.
 .It Va WITHOUT_MAIL
 .\" from FreeBSD: head/tools/build/options/WITHOUT_MAIL 183242 2008-09-21 22:02:26Z sam
 Set to not build any mail support (MUA or MTA).
 When set, it also enforces the following options:
 .Pp
 .Bl -item -compact
 .It
 .Va WITHOUT_DMAGENT
 .It
 .Va WITHOUT_MAILWRAPPER
 .It
 .Va WITHOUT_SENDMAIL
 .El
 .It Va WITHOUT_MAILWRAPPER
 .\" from FreeBSD: head/tools/build/options/WITHOUT_MAILWRAPPER 156932 2006-03-21 07:50:50Z ru
 Set to not build the
 .Xr mailwrapper 8
 MTA selector.
 .It Va WITHOUT_MAKE
 .\" from FreeBSD: head/tools/build/options/WITHOUT_MAKE 183242 2008-09-21 22:02:26Z sam
 Set to not install
 .Xr make 1
 and related support files.
 .It Va WITHOUT_MAN
 .\" from FreeBSD: head/tools/build/options/WITHOUT_MAN 156932 2006-03-21 07:50:50Z ru
 Set to not build manual pages.
 When set, the following options are also in effect:
 .Pp
 .Bl -inset -compact
 .It Va WITHOUT_MAN_UTILS
 (unless
 .Va WITH_MAN_UTILS
 is set explicitly)
 .El
 .It Va WITHOUT_MANCOMPRESS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_MANCOMPRESS 266752 2014-05-27 15:52:27Z gjb
 Set to not to install compressed man pages.
 Only the uncompressed versions will be installed.
 .It Va WITHOUT_MAN_UTILS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_MAN_UTILS 208322 2010-05-20 00:07:21Z jkim
 Set to not build utilities for manual pages,
 .Xr apropos 1 ,
 .Xr catman 1 ,
 .Xr makewhatis 1 ,
 .Xr man 1 ,
 .Xr whatis 1 ,
 .Xr manctl 8 ,
 and related support files.
 .It Va WITH_NAND
 .\" from FreeBSD: head/tools/build/options/WITH_NAND 235537 2012-05-17 10:11:18Z gber
 Set to build the NAND Flash components.
 .It Va WITHOUT_NDIS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_NDIS 183242 2008-09-21 22:02:26Z sam
 Set to not build programs and libraries
 related to NDIS emulation support.
 .It Va WITHOUT_NETCAT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_NETCAT 156932 2006-03-21 07:50:50Z ru
 Set to not build
 .Xr nc 1
 utility.
 .It Va WITHOUT_NETGRAPH
 .\" from FreeBSD: head/tools/build/options/WITHOUT_NETGRAPH 183242 2008-09-21 22:02:26Z sam
 Set to not build applications to support
 .Xr netgraph 4 .
 When set, it also enforces the following options:
 .Pp
 .Bl -item -compact
 .It
 .Va WITHOUT_ATM
 .It
 .Va WITHOUT_BLUETOOTH
 .It
 .Va WITHOUT_NETGRAPH_SUPPORT
 .El
 .It Va WITHOUT_NETGRAPH_SUPPORT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_NETGRAPH_SUPPORT 183305 2008-09-23 16:11:15Z sam
 Set to build libraries, programs, and kernel modules without netgraph support.
 .It Va WITHOUT_NIS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_NIS 156932 2006-03-21 07:50:50Z ru
 Set to not build
 .Xr NIS 8
 support and related programs.
 If set, you might need to adopt your
 .Xr nsswitch.conf 5
 and remove
 .Sq nis
 entries.
 .It Va WITHOUT_NLS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_NLS 156932 2006-03-21 07:50:50Z ru
 Set to not build NLS catalogs.
 .It Va WITHOUT_NLS_CATALOGS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_NLS_CATALOGS 156932 2006-03-21 07:50:50Z ru
 Set to not build NLS catalog support for
 .Xr csh 1 .
 .It Va WITHOUT_NS_CACHING
 .\" from FreeBSD: head/tools/build/options/WITHOUT_NS_CACHING 172803 2007-10-19 14:01:25Z ru
 Set to disable name caching in the
 .Pa nsswitch
 subsystem.
 The generic caching daemon,
 .Xr nscd 8 ,
 will not be built either if this option is set.
 .It Va WITHOUT_NTP
 .\" from FreeBSD: head/tools/build/options/WITHOUT_NTP 183242 2008-09-21 22:02:26Z sam
 Set to not build
 .Xr ntpd 8
 and related programs.
 .It Va WITH_OFED
 .\" from FreeBSD: head/tools/build/options/WITH_OFED 228081 2011-11-28 17:54:34Z dim
 Set to build the
 .Dq "OpenFabrics Enterprise Distribution"
 Infiniband software stack.
 .It Va WITH_OPENLDAP
 .\" from FreeBSD: head/tools/build/options/WITH_OPENLDAP 264902 2014-04-24 23:17:31Z imp
 Enable building openldap support for kerberos.
 .It Va WITHOUT_OPENSSH
 .\" from FreeBSD: head/tools/build/options/WITHOUT_OPENSSH 156932 2006-03-21 07:50:50Z ru
 Set to not build OpenSSH.
 .It Va WITH_OPENSSH_NONE_CIPHER
 .\" from FreeBSD: head/tools/build/options/WITH_OPENSSH_NONE_CIPHER 245527 2013-01-17 01:51:04Z bz
 Set to include the "None" cipher support in OpenSSH and its libraries.
 Additional adjustments may need to be done to system configuration
 files, such as
 .Xr sshd_config 5 ,
 to enable this cipher.
 Please see
 .Pa /usr/src/crypto/openssh/README.hpn
 for full details.
 .It Va WITHOUT_OPENSSL
 .\" from FreeBSD: head/tools/build/options/WITHOUT_OPENSSL 156932 2006-03-21 07:50:50Z ru
 Set to not build OpenSSL.
 When set, it also enforces the following options:
 .Pp
 .Bl -item -compact
 .It
 .Va WITHOUT_KERBEROS
 .It
 .Va WITHOUT_KERBEROS_SUPPORT
 .It
 .Va WITHOUT_OPENSSH
 .El
 .Pp
 When set, the following options are also in effect:
 .Pp
 .Bl -inset -compact
 .It Va WITHOUT_GSSAPI
 (unless
 .Va WITH_GSSAPI
 is set explicitly)
 .El
 .It Va WITHOUT_PAM
 .\" from FreeBSD: head/tools/build/options/WITHOUT_PAM 174550 2007-12-12 16:43:17Z ru
 Set to not build PAM library and modules.
 .Bf -symbolic
 This option is deprecated and does nothing.
 .Ef
 When set, it also enforces the following options:
 .Pp
 .Bl -item -compact
 .It
 .Va WITHOUT_PAM_SUPPORT
 .El
 .It Va WITHOUT_PAM_SUPPORT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_PAM_SUPPORT 156932 2006-03-21 07:50:50Z ru
 Set to build some programs without PAM support, particularly
 .Xr ftpd 8
 and
 .Xr ppp 8 .
 .It Va WITHOUT_PC_SYSINSTALL
 .\" from FreeBSD: head/tools/build/options/WITHOUT_PC_SYSINSTALL 245606 2013-01-18 15:57:09Z eadler
 Set to not build
 .Xr pc-sysinstall 8
 and related programs.
 .It Va WITHOUT_PF
 .\" from FreeBSD: head/tools/build/options/WITHOUT_PF 156932 2006-03-21 07:50:50Z ru
 Set to not build PF firewall package.
 When set, it also enforces the following options:
 .Pp
 .Bl -item -compact
 .It
 .Va WITHOUT_AUTHPF
 .El
 .It Va WITHOUT_PKGBOOTSTRAP
 .\" from FreeBSD: head/tools/build/options/WITHOUT_PKGBOOTSTRAP 258924 2013-12-04 15:58:42Z bdrewery
 Set to not build
 .Xr pkg 7
 bootstrap tool.
 .It Va WITHOUT_PMC
 .\" from FreeBSD: head/tools/build/options/WITHOUT_PMC 183242 2008-09-21 22:02:26Z sam
 Set to not build
 .Xr pmccontrol 8
 and related programs.
 .It Va WITHOUT_PORTSNAP
 .\" from FreeBSD: head/tools/build/options/WITHOUT_PORTSNAP 183242 2008-09-21 22:02:26Z sam
 Set to not build or install
 .Xr portsnap 8
 and related files.
 .It Va WITHOUT_PPP
 .\" from FreeBSD: head/tools/build/options/WITHOUT_PPP 183242 2008-09-21 22:02:26Z sam
 Set to not build
 .Xr ppp 8
 and related programs.
 .It Va WITHOUT_PROFILE
 .\" from FreeBSD: head/tools/build/options/WITHOUT_PROFILE 228196 2011-12-02 09:09:54Z fjoe
 Set to avoid compiling profiled libraries.
 .It Va WITHOUT_QUOTAS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_QUOTAS 183242 2008-09-21 22:02:26Z sam
 Set to not build
 .Xr quota 8
 and related programs.
 .It Va WITHOUT_RCMDS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_RCMDS 156932 2006-03-21 07:50:50Z ru
 Disable building of the
 .Bx
 r-commands.
 This includes
 .Xr rlogin 1 ,
 .Xr rsh 1 ,
 etc.
 .It Va WITHOUT_RCS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_RCS 275138 2014-11-26 20:43:09Z gjb
 Set to not build
 .Xr rcs 1 ,
 .Xr etcupdate 8 ,
 and related utilities.
 .It Va WITHOUT_RESCUE
 .\" from FreeBSD: head/tools/build/options/WITHOUT_RESCUE 156932 2006-03-21 07:50:50Z ru
 Set to not build
 .Xr rescue 8 .
 .It Va WITHOUT_ROUTED
 .\" from FreeBSD: head/tools/build/options/WITHOUT_ROUTED 183242 2008-09-21 22:02:26Z sam
 Set to not build
 .Xr routed 8
 utility.
 .It Va WITHOUT_SENDMAIL
 .\" from FreeBSD: head/tools/build/options/WITHOUT_SENDMAIL 156932 2006-03-21 07:50:50Z ru
 Set to not build
 .Xr sendmail 8
 and related programs.
 .It Va WITHOUT_SETUID_LOGIN
 .\" from FreeBSD: head/tools/build/options/WITHOUT_SETUID_LOGIN 156932 2006-03-21 07:50:50Z ru
 Set this to disable the installation of
 .Xr login 1
 as a set-user-ID root program.
 .It Va WITHOUT_SHAREDOCS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_SHAREDOCS 156932 2006-03-21 07:50:50Z ru
 Set to not build the
 .Bx 4.4
 legacy docs.
 .It Va WITH_SHARED_TOOLCHAIN
 .\" from FreeBSD: head/tools/build/options/WITH_SHARED_TOOLCHAIN 235342 2012-05-12 16:12:36Z gjb
 Set to build the toolchain binaries shared.
 The set includes
 .Xr cc 1 ,
 .Xr make 1
 and necessary utilities like assembler, linker and library archive manager.
 .It Va WITH_SORT_THREADS
 .\" from FreeBSD: head/tools/build/options/WITH_SORT_THREADS 264158 2014-04-05 18:00:45Z imp
 Set to enable threads in
 .Xr sort 1 .
 .It Va WITHOUT_SOURCELESS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_SOURCELESS 230972 2012-02-04 00:54:43Z rmh
 Set to not build kernel modules that include sourceless code (either microcode or native code for host CPU).
 When set, it also enforces the following options:
 .Pp
 .Bl -item -compact
 .It
 .Va WITHOUT_SOURCELESS_HOST
 .It
 .Va WITHOUT_SOURCELESS_UCODE
 .El
 .It Va WITHOUT_SOURCELESS_HOST
 .\" from FreeBSD: head/tools/build/options/WITHOUT_SOURCELESS_HOST 230972 2012-02-04 00:54:43Z rmh
 Set to not build kernel modules that include sourceless native code for host CPU.
 .It Va WITHOUT_SOURCELESS_UCODE
 .\" from FreeBSD: head/tools/build/options/WITHOUT_SOURCELESS_UCODE 230972 2012-02-04 00:54:43Z rmh
 Set to not build kernel modules that include sourceless microcode.
 .It Va WITHOUT_SSP
 .\" from FreeBSD: head/tools/build/options/WITHOUT_SSP 180012 2008-06-25 21:33:28Z ru
 Set to not build world with propolice stack smashing protection.
 .It Va WITH_SVN
 .\" from FreeBSD: head/tools/build/options/WITH_SVN 252561 2013-07-03 12:36:47Z zeising
 Set to install
 .Xr svnlite 1
 as
 .Xr svn 1 .
 .It Va WITHOUT_SVNLITE
 .\" from FreeBSD: head/tools/build/options/WITHOUT_SVNLITE 252561 2013-07-03 12:36:47Z zeising
 Set to not build
 .Xr svnlite 1
 and related programs.
 .It Va WITHOUT_SYMVER
 .\" from FreeBSD: head/tools/build/options/WITHOUT_SYMVER 169649 2007-05-17 05:03:24Z deischen
 Set to disable symbol versioning when building shared libraries.
 .It Va WITHOUT_SYSCALL_COMPAT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_SYSCALL_COMPAT 265826 2014-05-10 16:37:28Z imp
 Do not include some compatible syscall wrappers in libc.
 .It Va WITHOUT_SYSCONS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_SYSCONS 156932 2006-03-21 07:50:50Z ru
 Set to not build
 .Xr syscons 4
 support files such as keyboard maps, fonts, and screen output maps.
 .It Va WITHOUT_SYSINSTALL
 .\" from FreeBSD: head/tools/build/options/WITHOUT_SYSINSTALL 183242 2008-09-21 22:02:26Z sam
 Set to not build
 .Xr sysinstall 8
 and related programs.
 .It Va WITHOUT_TALK
 .\" from FreeBSD: head/tools/build/options/WITHOUT_TALK 277676 2015-01-25 04:37:44Z ngie
 Set to not build or install
 .Xr talk 1
 and
 .Xr talkd 8 .
 .It Va WITHOUT_TCSH
 .\" from FreeBSD: head/tools/build/options/WITHOUT_TCSH 156932 2006-03-21 07:50:50Z ru
 Set to not build and install
 .Pa /bin/csh
 (which is
 .Xr tcsh 1 ) .
 .It Va WITHOUT_TELNET
 .\" from FreeBSD: head/tools/build/options/WITHOUT_TELNET 183242 2008-09-21 22:02:26Z sam
 Set to not build
 .Xr telnet 8
 and related programs.
 .It Va WITHOUT_TESTS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_TESTS 268778 2014-07-16 21:40:11Z jmmv
 Set to not build nor install the
 .Fx
 Test Suite in
 .Pa /usr/tests/ .
 See
 .Xr tests 7
 for more details.
 This also disables the build of all test-related dependencies, including ATF.
 When set, it also enforces the following options:
 .Pp
 .Bl -item -compact
 .It
 .Va WITHOUT_TESTS_SUPPORT
 .El
 .It Va WITHOUT_TESTS_SUPPORT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_TESTS_SUPPORT 274665 2014-11-18 17:06:50Z imp
 Set to disables the build of all test-related dependencies, including ATF.
 .It Va WITHOUT_TEXTPROC
 .\" from FreeBSD: head/tools/build/options/WITHOUT_TEXTPROC 183242 2008-09-21 22:02:26Z sam
 Set to not build
 programs used for text processing.
 When set, it also enforces the following options:
 .Pp
 .Bl -item -compact
 .It
 .Va WITHOUT_GROFF
 .El
 .It Va WITHOUT_TOOLCHAIN
 .\" from FreeBSD: head/tools/build/options/WITHOUT_TOOLCHAIN 273172 2014-10-16 15:55:13Z brooks
 Set to not install header or
 programs used for program development,
 compilers, debuggers etc.
 .Bf -symbolic
 The option does not work for build targets.
 .Ef
 When set, it also enforces the following options:
 .Pp
 .Bl -item -compact
 .It
 .Va WITHOUT_BINUTILS
 .It
 .Va WITHOUT_CLANG
 .It
 .Va WITHOUT_CLANG_EXTRAS
 .It
 .Va WITHOUT_CLANG_FULL
 .It
 .Va WITHOUT_GCC
 .It
 .Va WITHOUT_GDB
 .It
 .Va WITHOUT_INCLUDES
 .El
 .It Va WITHOUT_UNBOUND
 .\" from FreeBSD: head/tools/build/options/WITHOUT_UNBOUND 255597 2013-09-15 14:51:23Z des
 Set to not build
 .Xr unbound 8
 and related programs.
 .It Va WITHOUT_USB
 .\" from FreeBSD: head/tools/build/options/WITHOUT_USB 156932 2006-03-21 07:50:50Z ru
 Set to not build USB-related programs and libraries.
 .It Va WITHOUT_USB_GADGET_EXAMPLES
 .\" from FreeBSD: head/tools/build/options/WITHOUT_USB_GADGET_EXAMPLES 274665 2014-11-18 17:06:50Z imp
 Set to build USB gadget kernel modules.
 .It Va WITHOUT_UTMPX
 .\" from FreeBSD: head/tools/build/options/WITHOUT_UTMPX 231530 2012-02-11 20:28:42Z ed
 Set to not build user accounting tools such as
 .Xr last 1 ,
 .Xr users 1 ,
 .Xr who 1 ,
 .Xr ac 8 ,
 .Xr lastlogin 8
 and
 .Xr utx 8 .
 .It Va WITHOUT_VI
 .\" from FreeBSD: head/tools/build/options/WITHOUT_VI 264903 2014-04-24 23:17:40Z imp
 Set to not build and install vi, view, ex and related programs.
 .It Va WITHOUT_VT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_VT 268022 2014-06-30 00:20:12Z emaste
 Set to not build
 .Xr vt 4
 support files (fonts and keymaps).
 .It Va WITHOUT_WARNS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_WARNS 276559 2015-01-02 18:57:58Z bapt
 Set this to not add warning flags to the compiler invocations.
 Useful as a temporary workaround when code enters the tree
 which triggers warnings in environments that differ from the
 original developer.
 .It Va WITHOUT_WIRELESS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_WIRELESS 183242 2008-09-21 22:02:26Z sam
 Set to not build programs used for 802.11 wireless networks; especially
 .Xr wpa_supplicant 8
 and
 .Xr hostapd 8 .
 When set, it also enforces the following options:
 .Pp
 .Bl -item -compact
 .It
 .Va WITHOUT_WIRELESS_SUPPORT
 .El
 .It Va WITHOUT_WIRELESS_SUPPORT
 .\" from FreeBSD: head/tools/build/options/WITHOUT_WIRELESS_SUPPORT 183305 2008-09-23 16:11:15Z sam
 Set to build libraries, programs, and kernel modules without
 802.11 wireless support.
 .It Va WITHOUT_WPA_SUPPLICANT_EAPOL
 .\" from FreeBSD: head/tools/build/options/WITHOUT_WPA_SUPPLICANT_EAPOL 156932 2006-03-21 07:50:50Z ru
 Build
 .Xr wpa_supplicant 8
 without support for the IEEE 802.1X protocol and without
 support for EAP-PEAP, EAP-TLS, EAP-LEAP, and EAP-TTLS
 protocols (usable only via 802.1X).
 .It Va WITHOUT_ZFS
 .\" from FreeBSD: head/tools/build/options/WITHOUT_ZFS 168409 2007-04-06 02:13:30Z pjd
 Set to not build ZFS file system.
 .It Va WITHOUT_ZONEINFO
 .\" from FreeBSD: head/tools/build/options/WITHOUT_ZONEINFO 235342 2012-05-12 16:12:36Z gjb
 Set to not build the timezone database.
 .El
 .Sh FILES
 .Bl -tag -compact -width Pa
 .It Pa /etc/src.conf
 .It Pa /usr/share/mk/bsd.own.mk
 .El
 .Sh SEE ALSO
 .Xr make 1 ,
 .Xr make.conf 5 ,
 .Xr build 7 ,
 .Xr ports 7
 .Sh HISTORY
 The
 .Nm
 file appeared in
 .Fx 7.0 .
 .Sh AUTHORS
 This manual page was autogenerated.
Index: projects/clang360-import/share/mk/src.opts.mk
===================================================================
--- projects/clang360-import/share/mk/src.opts.mk	(revision 277777)
+++ projects/clang360-import/share/mk/src.opts.mk	(revision 277778)
@@ -1,378 +1,381 @@
 # $FreeBSD$
 #
 # Option file for FreeBSD /usr/src builds.
 #
 # Users define WITH_FOO and WITHOUT_FOO on the command line or in /etc/src.conf
 # and /etc/make.conf files. These translate in the build system to MK_FOO={yes,no}
 # with sensible (usually) defaults.
 #
 # Makefiles must include bsd.opts.mk after defining specific MK_FOO options that
 # are applicable for that Makefile (typically there are none, but sometimes there
 # are exceptions). Recursive makes usually add MK_FOO=no for options that they wish
 # to omit from that make.
 #
 # Makefiles must include bsd.mkopt.mk before they test the value of any MK_FOO
 # variable.
 #
 # Makefiles may also assume that this file is included by src.opts.mk should it
 # need variables defined there prior to the end of the Makefile where
 # bsd.{subdir,lib.bin}.mk is traditionally included.
 #
 # The old-style YES_FOO and NO_FOO are being phased out. No new instances of them
 # should be added. Old instances should be removed since they were just to
 # bridge the gap between FreeBSD 4 and FreeBSD 5.
 #
 # Makefiles should never test WITH_FOO or WITHOUT_FOO directly (although an
 # exception is made for _WITHOUT_SRCONF which turns off this mechanism
 # completely inside bsd.*.mk files).
 #
 
 .if !target(__<src.opts.mk>__)
 __<src.opts.mk>__:
 
 .include <bsd.own.mk>
 
 #
 # Define MK_* variables (which are either "yes" or "no") for users
 # to set via WITH_*/WITHOUT_* in /etc/src.conf and override in the
 # make(1) environment.
 # These should be tested with `== "no"' or `!= "no"' in makefiles.
 # The NO_* variables should only be set by makefiles for variables
 # that haven't been converted over.
 #
 
 # These options are used by src the builds
 
 __DEFAULT_YES_OPTIONS = \
     ACCT \
     ACPI \
     AMD \
     APM \
     AT \
     ATM \
     AUDIT \
     AUTHPF \
+    AUTOFS \
+    BHYVE \
     BINUTILS \
     BINUTILS_BOOTSTRAP \
     BLUETOOTH \
     BOOT \
     BSD_CPIO \
     BSDINSTALL \
     BSNMP \
     BZIP2 \
     CALENDAR \
     CAPSICUM \
     CASPER \
     CCD \
     CDDL \
     CPP \
     CROSS_COMPILER \
     CRYPT \
     CTM \
     CUSE \
     CXX \
     DICT \
     DMAGENT \
     DYNAMICROOT \
     ED_CRYPTO \
     EE \
     ELFTOOLCHAIN_TOOLS \
     EXAMPLES \
     FDT \
     FLOPPY \
     FMTREE \
     FORTH \
     FP_LIBC \
     FREEBSD_UPDATE \
     GAMES \
     GCOV \
     GDB \
     GNU \
     GNU_GREP_COMPAT \
     GPIO \
     GPL_DTC \
     GROFF \
+    HAST \
     HTML \
     HYPERV \
     ICONV \
     INET \
     INET6 \
     IPFILTER \
     IPFW \
     ISCSI \
     JAIL \
     KDUMP \
     KVM \
     LDNS \
     LDNS_UTILS \
     LEGACY_CONSOLE \
     LIB32 \
     LIBPTHREAD \
     LIBTHR \
     LOCALES \
     LOCATE \
     LPR \
     LS_COLORS \
     LZMA_SUPPORT \
     MAIL \
     MAILWRAPPER \
     MAKE \
     NDIS \
     NETCAT \
     NETGRAPH \
     NLS_CATALOGS \
     NS_CACHING \
     NTP \
     OPENSSL \
     PAM \
     PC_SYSINSTALL \
     PF \
     PKGBOOTSTRAP \
     PMC \
     PORTSNAP \
     PPP \
     QUOTAS \
     RCMDS \
     RCS \
     RESCUE \
     ROUTED \
     SENDMAIL \
     SETUID_LOGIN \
     SHAREDOCS \
     SOURCELESS \
     SOURCELESS_HOST \
     SOURCELESS_UCODE \
     SVNLITE \
     SYSCALL_COMPAT \
     SYSCONS \
     SYSINSTALL \
     TALK \
     TCSH \
     TELNET \
     TESTS \
     TEXTPROC \
     UNBOUND \
     USB \
     UTMPX \
     VI \
     VT \
     WIRELESS \
     WPA_SUPPLICANT_EAPOL \
     ZFS \
     ZONEINFO
 
 __DEFAULT_NO_OPTIONS = \
     BSD_GREP \
     CLANG_EXTRAS \
     EISA \
     FMAKE \
     HESIOD \
     LLDB \
     NAND \
     OFED \
     OPENLDAP \
     OPENSSH_NONE_CIPHER \
     SHARED_TOOLCHAIN \
     SORT_THREADS \
     SVN
 
 #
 # Default behaviour of some options depends on the architecture.  Unfortunately
 # this means that we have to test TARGET_ARCH (the buildworld case) as well
 # as MACHINE_ARCH (the non-buildworld case).  Normally TARGET_ARCH is not
 # used at all in bsd.*.mk, but we have to make an exception here if we want
 # to allow defaults for some things like clang to vary by target architecture.
 # Additional, per-target behavior should be rarely added only after much
 # gnashing of teeth and grinding of gears.
 #
 .if defined(TARGET_ARCH)
 __T=${TARGET_ARCH}
 .else
 __T=${MACHINE_ARCH}
 .endif
 .if defined(TARGET)
 __TT=${TARGET}
 .else
 __TT=${MACHINE}
 .endif
 
 .include <bsd.compiler.mk>
 .if !${COMPILER_FEATURES:Mc++11}
 # If the compiler is not C++11 capable, disable clang and use gcc instead.
 __DEFAULT_YES_OPTIONS+=GCC GCC_BOOTSTRAP GNUCXX
 __DEFAULT_NO_OPTIONS+=CLANG CLANG_BOOTSTRAP CLANG_FULL CLANG_IS_CC
 .elif ${__T} == "amd64" || ${__T} == "i386"
 # On x86, clang is enabled, and will be installed as the default cc.
 __DEFAULT_YES_OPTIONS+=CLANG CLANG_BOOTSTRAP CLANG_FULL CLANG_IS_CC
 __DEFAULT_NO_OPTIONS+=GCC GCC_BOOTSTRAP GNUCXX
 .elif ${__TT} == "arm" && ${__T:Marm*eb*} == ""
 # On little-endian arm, clang is enabled, and it is installed as the default
 # cc, but since gcc is unable to build the full clang, disable it by default.
 __DEFAULT_YES_OPTIONS+=CLANG CLANG_BOOTSTRAP CLANG_IS_CC
 __DEFAULT_NO_OPTIONS+=CLANG_FULL GCC GCC_BOOTSTRAP GNUCXX
 .elif ${__T:Mpowerpc*}
 # On powerpc, clang is enabled, but gcc is installed as the default cc.
 __DEFAULT_YES_OPTIONS+=CLANG CLANG_FULL GCC GCC_BOOTSTRAP GNUCXX
 __DEFAULT_NO_OPTIONS+=CLANG_BOOTSTRAP CLANG_IS_CC
 .else
 # Everything else disables clang, and uses gcc instead.
 __DEFAULT_YES_OPTIONS+=GCC GCC_BOOTSTRAP GNUCXX
 __DEFAULT_NO_OPTIONS+=CLANG CLANG_BOOTSTRAP CLANG_FULL CLANG_IS_CC
 .endif
 
 .include <bsd.mkopt.mk>
 
 #
 # MK_* options that default to "yes" if the compiler is a C++11 compiler.
 #
 .for var in \
     LIBCPLUSPLUS
 .if !defined(MK_${var})
 .if ${COMPILER_FEATURES:Mc++11}
 .if defined(WITHOUT_${var})
 MK_${var}:=	no
 .else
 MK_${var}:=	yes
 .endif
 .else
 .if defined(WITH_${var})
 MK_${var}:=	yes
 .else
 MK_${var}:=	no
 .endif
 .endif
 .endif
 .endfor
 
 #
 # Force some options off if their dependencies are off.
 # Order is somewhat important.
 #
 .if ${MK_LIBPTHREAD} == "no"
 MK_LIBTHR:=	no
 .endif
 
 .if ${MK_LDNS} == "no"
 MK_LDNS_UTILS:=	no
 MK_UNBOUND:= no
 .endif
 
 .if ${MK_SOURCELESS} == "no"
 MK_SOURCELESS_HOST:=	no
 MK_SOURCELESS_UCODE:= no
 .endif
 
 .if ${MK_CDDL} == "no"
 MK_ZFS:=	no
 MK_CTF:=	no
 .endif
 
 .if ${MK_CRYPT} == "no"
 MK_OPENSSL:=	no
 MK_OPENSSH:=	no
 MK_KERBEROS:=	no
 .endif
 
 .if ${MK_CXX} == "no"
 MK_CLANG:=	no
 MK_GROFF:=	no
 MK_GNUCXX:=	no
 .endif
 
 .if ${MK_MAIL} == "no"
 MK_MAILWRAPPER:= no
 MK_SENDMAIL:=	no
 MK_DMAGENT:=	no
 .endif
 
 .if ${MK_NETGRAPH} == "no"
 MK_ATM:=	no
 MK_BLUETOOTH:=	no
 .endif
 
 .if ${MK_OPENSSL} == "no"
 MK_OPENSSH:=	no
 MK_KERBEROS:=	no
 .endif
 
 .if ${MK_PF} == "no"
 MK_AUTHPF:=	no
 .endif
 
 .if ${MK_TEXTPROC} == "no"
 MK_GROFF:=	no
 .endif
 
 .if ${MK_CROSS_COMPILER} == "no"
 MK_BINUTILS_BOOTSTRAP:= no
 MK_CLANG_BOOTSTRAP:= no
 MK_GCC_BOOTSTRAP:= no
 .endif
 
 .if ${MK_TOOLCHAIN} == "no"
 MK_BINUTILS:=	no
 MK_CLANG:=	no
 MK_GCC:=	no
 MK_GDB:=	no
 MK_INCLUDES:=	no
 .endif
 
 .if ${MK_CLANG} == "no"
 MK_CLANG_EXTRAS:= no
 MK_CLANG_FULL:= no
 .endif
 
 #
 # Set defaults for the MK_*_SUPPORT variables.
 #
 
 #
 # MK_*_SUPPORT options which default to "yes" unless their corresponding
 # MK_* variable is set to "no".
 #
 .for var in \
     BZIP2 \
     GNU \
     INET \
     INET6 \
     KERBEROS \
     KVM \
     NETGRAPH \
     PAM \
     TESTS \
     WIRELESS
 .if defined(WITHOUT_${var}_SUPPORT) || ${MK_${var}} == "no"
 MK_${var}_SUPPORT:= no
 .else
 MK_${var}_SUPPORT:= yes
 .endif
 .endfor
 
 #
 # MK_* options whose default value depends on another option.
 #
 .for vv in \
     GSSAPI/KERBEROS \
     MAN_UTILS/MAN
 .if defined(WITH_${vv:H})
 MK_${vv:H}:=	yes
 .elif defined(WITHOUT_${vv:H})
 MK_${vv:H}:=	no
 .else
 MK_${vv:H}:=	${MK_${vv:T}}
 .endif
 .endfor
 
 .if !${COMPILER_FEATURES:Mc++11}
 MK_LLDB:=	no
 .endif
 
 # gcc 4.8 and newer supports libc++, so suppress gnuc++ in that case.
 # while in theory we could build it with that, we don't want to do
 # that since it creates too much confusion for too little gain.
 .if ${COMPILER_TYPE} == "gcc" && ${COMPILER_VERSION} >= 40800
 MK_GNUCXX:=no
 MK_GCC:=no
 .endif
 
 .endif #  !target(__<src.opts.mk>__)
Index: projects/clang360-import/share
===================================================================
--- projects/clang360-import/share	(revision 277777)
+++ projects/clang360-import/share	(revision 277778)

Property changes on: projects/clang360-import/share
___________________________________________________________________
Modified: svn:mergeinfo
## -0,0 +0,1 ##
   Merged /head/share:r277719-277776
Index: projects/clang360-import/sys/amd64/amd64/machdep.c
===================================================================
--- projects/clang360-import/sys/amd64/amd64/machdep.c	(revision 277777)
+++ projects/clang360-import/sys/amd64/amd64/machdep.c	(revision 277778)
@@ -1,2824 +1,2836 @@
 /*-
  * Copyright (c) 2003 Peter Wemm.
  * Copyright (c) 1992 Terrence R. Lambert.
  * Copyright (c) 1982, 1987, 1990 The Regents of the University of California.
  * All rights reserved.
  *
  * This code is derived from software contributed to Berkeley by
  * William Jolitz.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *	This product includes software developed by the University of
  *	California, Berkeley and its contributors.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
  *	from: @(#)machdep.c	7.4 (Berkeley) 6/3/91
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include "opt_atpic.h"
 #include "opt_compat.h"
 #include "opt_cpu.h"
 #include "opt_ddb.h"
 #include "opt_inet.h"
 #include "opt_isa.h"
 #include "opt_kstack_pages.h"
 #include "opt_maxmem.h"
 #include "opt_mp_watchdog.h"
 #include "opt_perfmon.h"
 #include "opt_platform.h"
 #include "opt_sched.h"
 
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/systm.h>
 #include <sys/bio.h>
 #include <sys/buf.h>
 #include <sys/bus.h>
 #include <sys/callout.h>
 #include <sys/cons.h>
 #include <sys/cpu.h>
 #include <sys/efi.h>
 #include <sys/eventhandler.h>
 #include <sys/exec.h>
 #include <sys/imgact.h>
 #include <sys/kdb.h>
 #include <sys/kernel.h>
 #include <sys/ktr.h>
 #include <sys/linker.h>
 #include <sys/lock.h>
 #include <sys/malloc.h>
 #include <sys/memrange.h>
 #include <sys/msgbuf.h>
 #include <sys/mutex.h>
 #include <sys/pcpu.h>
 #include <sys/ptrace.h>
 #include <sys/reboot.h>
 #include <sys/rwlock.h>
 #include <sys/sched.h>
 #include <sys/signalvar.h>
 #ifdef SMP
 #include <sys/smp.h>
 #endif
 #include <sys/syscallsubr.h>
 #include <sys/sysctl.h>
 #include <sys/sysent.h>
 #include <sys/sysproto.h>
 #include <sys/ucontext.h>
 #include <sys/vmmeter.h>
 
 #include <vm/vm.h>
 #include <vm/vm_extern.h>
 #include <vm/vm_kern.h>
 #include <vm/vm_page.h>
 #include <vm/vm_map.h>
 #include <vm/vm_object.h>
 #include <vm/vm_pager.h>
 #include <vm/vm_param.h>
 
 #ifdef DDB
 #ifndef KDB
 #error KDB must be enabled in order for DDB to work!
 #endif
 #include <ddb/ddb.h>
 #include <ddb/db_sym.h>
 #endif
 
 #include <net/netisr.h>
 
 #include <machine/clock.h>
 #include <machine/cpu.h>
 #include <machine/cputypes.h>
 #include <machine/intr_machdep.h>
 #include <x86/mca.h>
 #include <machine/md_var.h>
 #include <machine/metadata.h>
 #include <machine/mp_watchdog.h>
 #include <machine/pc/bios.h>
 #include <machine/pcb.h>
 #include <machine/proc.h>
 #include <machine/reg.h>
 #include <machine/sigframe.h>
 #include <machine/specialreg.h>
 #ifdef PERFMON
 #include <machine/perfmon.h>
 #endif
 #include <machine/tss.h>
 #ifdef SMP
 #include <machine/smp.h>
 #endif
 #ifdef FDT
 #include <x86/fdt.h>
 #endif
 
 #ifdef DEV_ATPIC
 #include <x86/isa/icu.h>
 #else
 #include <x86/apicvar.h>
 #endif
 
 #include <isa/isareg.h>
 #include <isa/rtc.h>
 #include <x86/init.h>
 
 /* Sanity check for __curthread() */
 CTASSERT(offsetof(struct pcpu, pc_curthread) == 0);
 
 extern u_int64_t hammer_time(u_int64_t, u_int64_t);
 
 #define	CS_SECURE(cs)		(ISPL(cs) == SEL_UPL)
 #define	EFL_SECURE(ef, oef)	((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
 
 static void cpu_startup(void *);
 static void get_fpcontext(struct thread *td, mcontext_t *mcp,
     char *xfpusave, size_t xfpusave_len);
 static int  set_fpcontext(struct thread *td, const mcontext_t *mcp,
     char *xfpustate, size_t xfpustate_len);
 SYSINIT(cpu, SI_SUB_CPU, SI_ORDER_FIRST, cpu_startup, NULL);
 
 /* Preload data parse function */
 static caddr_t native_parse_preload_data(u_int64_t);
 
 /* Native function to fetch and parse the e820 map */
 static void native_parse_memmap(caddr_t, vm_paddr_t *, int *);
 
 /* Default init_ops implementation. */
 struct init_ops init_ops = {
 	.parse_preload_data =	native_parse_preload_data,
 	.early_clock_source_init =	i8254_init,
 	.early_delay =			i8254_delay,
 	.parse_memmap =			native_parse_memmap,
 #ifdef SMP
 	.mp_bootaddress =		mp_bootaddress,
 	.start_all_aps =		native_start_all_aps,
 #endif
 	.msi_init =			msi_init,
 };
 
 /*
  * The file "conf/ldscript.amd64" defines the symbol "kernphys".  Its value is
  * the physical address at which the kernel is loaded.
  */
 extern char kernphys[];
 
 struct msgbuf *msgbufp;
 
 /* Intel ICH registers */
 #define ICH_PMBASE	0x400
 #define ICH_SMI_EN	ICH_PMBASE + 0x30
 
 int	_udatasel, _ucodesel, _ucode32sel, _ufssel, _ugssel;
 
 int cold = 1;
 
 long Maxmem = 0;
 long realmem = 0;
 
 /*
  * The number of PHYSMAP entries must be one less than the number of
  * PHYSSEG entries because the PHYSMAP entry that spans the largest
  * physical address that is accessible by ISA DMA is split into two
  * PHYSSEG entries.
  */
 #define	PHYSMAP_SIZE	(2 * (VM_PHYSSEG_MAX - 1))
 
 vm_paddr_t phys_avail[PHYSMAP_SIZE + 2];
 vm_paddr_t dump_avail[PHYSMAP_SIZE + 2];
 
 /* must be 2 less so 0 0 can signal end of chunks */
 #define PHYS_AVAIL_ARRAY_END ((sizeof(phys_avail) / sizeof(phys_avail[0])) - 2)
 #define DUMP_AVAIL_ARRAY_END ((sizeof(dump_avail) / sizeof(dump_avail[0])) - 2)
 
 struct kva_md_info kmi;
 
 static struct trapframe proc0_tf;
 struct region_descriptor r_gdt, r_idt;
 
 struct pcpu __pcpu[MAXCPU];
 
 struct mtx icu_lock;
 
 struct mem_range_softc mem_range_softc;
 
 struct mtx dt_lock;	/* lock for GDT and LDT */
 
 void (*vmm_resume_p)(void);
 
 static void
 cpu_startup(dummy)
 	void *dummy;
 {
 	uintmax_t memsize;
 	char *sysenv;
 
 	/*
 	 * On MacBooks, we need to disallow the legacy USB circuit to
 	 * generate an SMI# because this can cause several problems,
 	 * namely: incorrect CPU frequency detection and failure to
 	 * start the APs.
 	 * We do this by disabling a bit in the SMI_EN (SMI Control and
 	 * Enable register) of the Intel ICH LPC Interface Bridge. 
 	 */
 	sysenv = kern_getenv("smbios.system.product");
 	if (sysenv != NULL) {
 		if (strncmp(sysenv, "MacBook1,1", 10) == 0 ||
 		    strncmp(sysenv, "MacBook3,1", 10) == 0 ||
 		    strncmp(sysenv, "MacBook4,1", 10) == 0 ||
 		    strncmp(sysenv, "MacBookPro1,1", 13) == 0 ||
 		    strncmp(sysenv, "MacBookPro1,2", 13) == 0 ||
 		    strncmp(sysenv, "MacBookPro3,1", 13) == 0 ||
 		    strncmp(sysenv, "MacBookPro4,1", 13) == 0 ||
 		    strncmp(sysenv, "Macmini1,1", 10) == 0) {
 			if (bootverbose)
 				printf("Disabling LEGACY_USB_EN bit on "
 				    "Intel ICH.\n");
 			outl(ICH_SMI_EN, inl(ICH_SMI_EN) & ~0x8);
 		}
 		freeenv(sysenv);
 	}
 
 	/*
 	 * Good {morning,afternoon,evening,night}.
 	 */
 	startrtclock();
 	printcpuinfo();
 	panicifcpuunsupported();
 #ifdef PERFMON
 	perfmon_init();
 #endif
 
 	/*
 	 * Display physical memory if SMBIOS reports reasonable amount.
 	 */
 	memsize = 0;
 	sysenv = kern_getenv("smbios.memory.enabled");
 	if (sysenv != NULL) {
 		memsize = (uintmax_t)strtoul(sysenv, (char **)NULL, 10) << 10;
 		freeenv(sysenv);
 	}
 	if (memsize < ptoa((uintmax_t)vm_cnt.v_free_count))
 		memsize = ptoa((uintmax_t)Maxmem);
 	printf("real memory  = %ju (%ju MB)\n", memsize, memsize >> 20);
 	realmem = atop(memsize);
 
 	/*
 	 * Display any holes after the first chunk of extended memory.
 	 */
 	if (bootverbose) {
 		int indx;
 
 		printf("Physical memory chunk(s):\n");
 		for (indx = 0; phys_avail[indx + 1] != 0; indx += 2) {
 			vm_paddr_t size;
 
 			size = phys_avail[indx + 1] - phys_avail[indx];
 			printf(
 			    "0x%016jx - 0x%016jx, %ju bytes (%ju pages)\n",
 			    (uintmax_t)phys_avail[indx],
 			    (uintmax_t)phys_avail[indx + 1] - 1,
 			    (uintmax_t)size, (uintmax_t)size / PAGE_SIZE);
 		}
 	}
 
 	vm_ksubmap_init(&kmi);
 
 	printf("avail memory = %ju (%ju MB)\n",
 	    ptoa((uintmax_t)vm_cnt.v_free_count),
 	    ptoa((uintmax_t)vm_cnt.v_free_count) / 1048576);
 
 	/*
 	 * Set up buffers, so they can be used to read disk labels.
 	 */
 	bufinit();
 	vm_pager_bufferinit();
 
 	cpu_setregs();
 }
 
 /*
  * Send an interrupt to process.
  *
  * Stack is set up to allow sigcode stored
  * at top to call routine, followed by call
  * to sigreturn routine below.  After sigreturn
  * resets the signal mask, the stack, and the
  * frame pointer, it returns to the user
  * specified pc, psl.
  */
 void
 sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask)
 {
 	struct sigframe sf, *sfp;
 	struct pcb *pcb;
 	struct proc *p;
 	struct thread *td;
 	struct sigacts *psp;
 	char *sp;
 	struct trapframe *regs;
 	char *xfpusave;
 	size_t xfpusave_len;
 	int sig;
 	int oonstack;
 
 	td = curthread;
 	pcb = td->td_pcb;
 	p = td->td_proc;
 	PROC_LOCK_ASSERT(p, MA_OWNED);
 	sig = ksi->ksi_signo;
 	psp = p->p_sigacts;
 	mtx_assert(&psp->ps_mtx, MA_OWNED);
 	regs = td->td_frame;
 	oonstack = sigonstack(regs->tf_rsp);
 
 	if (cpu_max_ext_state_size > sizeof(struct savefpu) && use_xsave) {
 		xfpusave_len = cpu_max_ext_state_size - sizeof(struct savefpu);
 		xfpusave = __builtin_alloca(xfpusave_len);
 	} else {
 		xfpusave_len = 0;
 		xfpusave = NULL;
 	}
 
 	/* Save user context. */
 	bzero(&sf, sizeof(sf));
 	sf.sf_uc.uc_sigmask = *mask;
 	sf.sf_uc.uc_stack = td->td_sigstk;
 	sf.sf_uc.uc_stack.ss_flags = (td->td_pflags & TDP_ALTSTACK)
 	    ? ((oonstack) ? SS_ONSTACK : 0) : SS_DISABLE;
 	sf.sf_uc.uc_mcontext.mc_onstack = (oonstack) ? 1 : 0;
 	bcopy(regs, &sf.sf_uc.uc_mcontext.mc_rdi, sizeof(*regs));
 	sf.sf_uc.uc_mcontext.mc_len = sizeof(sf.sf_uc.uc_mcontext); /* magic */
 	get_fpcontext(td, &sf.sf_uc.uc_mcontext, xfpusave, xfpusave_len);
 	fpstate_drop(td);
 	sf.sf_uc.uc_mcontext.mc_fsbase = pcb->pcb_fsbase;
 	sf.sf_uc.uc_mcontext.mc_gsbase = pcb->pcb_gsbase;
 	bzero(sf.sf_uc.uc_mcontext.mc_spare,
 	    sizeof(sf.sf_uc.uc_mcontext.mc_spare));
 	bzero(sf.sf_uc.__spare__, sizeof(sf.sf_uc.__spare__));
 
 	/* Allocate space for the signal handler context. */
 	if ((td->td_pflags & TDP_ALTSTACK) != 0 && !oonstack &&
 	    SIGISMEMBER(psp->ps_sigonstack, sig)) {
 		sp = td->td_sigstk.ss_sp + td->td_sigstk.ss_size;
 #if defined(COMPAT_43)
 		td->td_sigstk.ss_flags |= SS_ONSTACK;
 #endif
 	} else
 		sp = (char *)regs->tf_rsp - 128;
 	if (xfpusave != NULL) {
 		sp -= xfpusave_len;
 		sp = (char *)((unsigned long)sp & ~0x3Ful);
 		sf.sf_uc.uc_mcontext.mc_xfpustate = (register_t)sp;
 	}
 	sp -= sizeof(struct sigframe);
 	/* Align to 16 bytes. */
 	sfp = (struct sigframe *)((unsigned long)sp & ~0xFul);
 
 	/* Translate the signal if appropriate. */
 	if (p->p_sysent->sv_sigtbl && sig <= p->p_sysent->sv_sigsize)
 		sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
 
 	/* Build the argument list for the signal handler. */
 	regs->tf_rdi = sig;			/* arg 1 in %rdi */
 	regs->tf_rdx = (register_t)&sfp->sf_uc;	/* arg 3 in %rdx */
 	bzero(&sf.sf_si, sizeof(sf.sf_si));
 	if (SIGISMEMBER(psp->ps_siginfo, sig)) {
 		/* Signal handler installed with SA_SIGINFO. */
 		regs->tf_rsi = (register_t)&sfp->sf_si;	/* arg 2 in %rsi */
 		sf.sf_ahu.sf_action = (__siginfohandler_t *)catcher;
 
 		/* Fill in POSIX parts */
 		sf.sf_si = ksi->ksi_info;
 		sf.sf_si.si_signo = sig; /* maybe a translated signal */
 		regs->tf_rcx = (register_t)ksi->ksi_addr; /* arg 4 in %rcx */
 	} else {
 		/* Old FreeBSD-style arguments. */
 		regs->tf_rsi = ksi->ksi_code;	/* arg 2 in %rsi */
 		regs->tf_rcx = (register_t)ksi->ksi_addr; /* arg 4 in %rcx */
 		sf.sf_ahu.sf_handler = catcher;
 	}
 	mtx_unlock(&psp->ps_mtx);
 	PROC_UNLOCK(p);
 
 	/*
 	 * Copy the sigframe out to the user's stack.
 	 */
 	if (copyout(&sf, sfp, sizeof(*sfp)) != 0 ||
 	    (xfpusave != NULL && copyout(xfpusave,
 	    (void *)sf.sf_uc.uc_mcontext.mc_xfpustate, xfpusave_len)
 	    != 0)) {
 #ifdef DEBUG
 		printf("process %ld has trashed its stack\n", (long)p->p_pid);
 #endif
 		PROC_LOCK(p);
 		sigexit(td, SIGILL);
 	}
 
 	regs->tf_rsp = (long)sfp;
 	regs->tf_rip = p->p_sysent->sv_sigcode_base;
 	regs->tf_rflags &= ~(PSL_T | PSL_D);
 	regs->tf_cs = _ucodesel;
 	regs->tf_ds = _udatasel;
 	regs->tf_es = _udatasel;
 	regs->tf_fs = _ufssel;
 	regs->tf_gs = _ugssel;
 	regs->tf_flags = TF_HASSEGS;
 	set_pcb_flags(pcb, PCB_FULL_IRET);
 	PROC_LOCK(p);
 	mtx_lock(&psp->ps_mtx);
 }
 
 /*
  * System call to cleanup state after a signal
  * has been taken.  Reset signal mask and
  * stack state from context left by sendsig (above).
  * Return to previous pc and psl as specified by
  * context left by sendsig. Check carefully to
  * make sure that the user has not modified the
  * state to gain improper privileges.
  *
  * MPSAFE
  */
 int
 sys_sigreturn(td, uap)
 	struct thread *td;
 	struct sigreturn_args /* {
 		const struct __ucontext *sigcntxp;
 	} */ *uap;
 {
 	ucontext_t uc;
 	struct pcb *pcb;
 	struct proc *p;
 	struct trapframe *regs;
 	ucontext_t *ucp;
 	char *xfpustate;
 	size_t xfpustate_len;
 	long rflags;
 	int cs, error, ret;
 	ksiginfo_t ksi;
 
 	pcb = td->td_pcb;
 	p = td->td_proc;
 
 	error = copyin(uap->sigcntxp, &uc, sizeof(uc));
 	if (error != 0) {
 		uprintf("pid %d (%s): sigreturn copyin failed\n",
 		    p->p_pid, td->td_name);
 		return (error);
 	}
 	ucp = &uc;
 	if ((ucp->uc_mcontext.mc_flags & ~_MC_FLAG_MASK) != 0) {
 		uprintf("pid %d (%s): sigreturn mc_flags %x\n", p->p_pid,
 		    td->td_name, ucp->uc_mcontext.mc_flags);
 		return (EINVAL);
 	}
 	regs = td->td_frame;
 	rflags = ucp->uc_mcontext.mc_rflags;
 	/*
 	 * Don't allow users to change privileged or reserved flags.
 	 */
 	if (!EFL_SECURE(rflags, regs->tf_rflags)) {
 		uprintf("pid %d (%s): sigreturn rflags = 0x%lx\n", p->p_pid,
 		    td->td_name, rflags);
 		return (EINVAL);
 	}
 
 	/*
 	 * Don't allow users to load a valid privileged %cs.  Let the
 	 * hardware check for invalid selectors, excess privilege in
 	 * other selectors, invalid %eip's and invalid %esp's.
 	 */
 	cs = ucp->uc_mcontext.mc_cs;
 	if (!CS_SECURE(cs)) {
 		uprintf("pid %d (%s): sigreturn cs = 0x%x\n", p->p_pid,
 		    td->td_name, cs);
 		ksiginfo_init_trap(&ksi);
 		ksi.ksi_signo = SIGBUS;
 		ksi.ksi_code = BUS_OBJERR;
 		ksi.ksi_trapno = T_PROTFLT;
 		ksi.ksi_addr = (void *)regs->tf_rip;
 		trapsignal(td, &ksi);
 		return (EINVAL);
 	}
 
 	if ((uc.uc_mcontext.mc_flags & _MC_HASFPXSTATE) != 0) {
 		xfpustate_len = uc.uc_mcontext.mc_xfpustate_len;
 		if (xfpustate_len > cpu_max_ext_state_size -
 		    sizeof(struct savefpu)) {
 			uprintf("pid %d (%s): sigreturn xfpusave_len = 0x%zx\n",
 			    p->p_pid, td->td_name, xfpustate_len);
 			return (EINVAL);
 		}
 		xfpustate = __builtin_alloca(xfpustate_len);
 		error = copyin((const void *)uc.uc_mcontext.mc_xfpustate,
 		    xfpustate, xfpustate_len);
 		if (error != 0) {
 			uprintf(
 	"pid %d (%s): sigreturn copying xfpustate failed\n",
 			    p->p_pid, td->td_name);
 			return (error);
 		}
 	} else {
 		xfpustate = NULL;
 		xfpustate_len = 0;
 	}
 	ret = set_fpcontext(td, &ucp->uc_mcontext, xfpustate, xfpustate_len);
 	if (ret != 0) {
 		uprintf("pid %d (%s): sigreturn set_fpcontext err %d\n",
 		    p->p_pid, td->td_name, ret);
 		return (ret);
 	}
 	bcopy(&ucp->uc_mcontext.mc_rdi, regs, sizeof(*regs));
 	pcb->pcb_fsbase = ucp->uc_mcontext.mc_fsbase;
 	pcb->pcb_gsbase = ucp->uc_mcontext.mc_gsbase;
 
 #if defined(COMPAT_43)
 	if (ucp->uc_mcontext.mc_onstack & 1)
 		td->td_sigstk.ss_flags |= SS_ONSTACK;
 	else
 		td->td_sigstk.ss_flags &= ~SS_ONSTACK;
 #endif
 
 	kern_sigprocmask(td, SIG_SETMASK, &ucp->uc_sigmask, NULL, 0);
 	set_pcb_flags(pcb, PCB_FULL_IRET);
 	return (EJUSTRETURN);
 }
 
 #ifdef COMPAT_FREEBSD4
 int
 freebsd4_sigreturn(struct thread *td, struct freebsd4_sigreturn_args *uap)
 {
  
 	return sys_sigreturn(td, (struct sigreturn_args *)uap);
 }
 #endif
 
 
 /*
  * Machine dependent boot() routine
  *
  * I haven't seen anything to put here yet
  * Possibly some stuff might be grafted back here from boot()
  */
 void
 cpu_boot(int howto)
 {
 }
 
 /*
  * Flush the D-cache for non-DMA I/O so that the I-cache can
  * be made coherent later.
  */
 void
 cpu_flush_dcache(void *ptr, size_t len)
 {
 	/* Not applicable */
 }
 
 /* Get current clock frequency for the given cpu id. */
 int
 cpu_est_clockrate(int cpu_id, uint64_t *rate)
 {
 	uint64_t tsc1, tsc2;
 	uint64_t acnt, mcnt, perf;
 	register_t reg;
 
 	if (pcpu_find(cpu_id) == NULL || rate == NULL)
 		return (EINVAL);
 
 	/*
 	 * If TSC is P-state invariant and APERF/MPERF MSRs do not exist,
 	 * DELAY(9) based logic fails.
 	 */
 	if (tsc_is_invariant && !tsc_perf_stat)
 		return (EOPNOTSUPP);
 
 #ifdef SMP
 	if (smp_cpus > 1) {
 		/* Schedule ourselves on the indicated cpu. */
 		thread_lock(curthread);
 		sched_bind(curthread, cpu_id);
 		thread_unlock(curthread);
 	}
 #endif
 
 	/* Calibrate by measuring a short delay. */
 	reg = intr_disable();
 	if (tsc_is_invariant) {
 		wrmsr(MSR_MPERF, 0);
 		wrmsr(MSR_APERF, 0);
 		tsc1 = rdtsc();
 		DELAY(1000);
 		mcnt = rdmsr(MSR_MPERF);
 		acnt = rdmsr(MSR_APERF);
 		tsc2 = rdtsc();
 		intr_restore(reg);
 		perf = 1000 * acnt / mcnt;
 		*rate = (tsc2 - tsc1) * perf;
 	} else {
 		tsc1 = rdtsc();
 		DELAY(1000);
 		tsc2 = rdtsc();
 		intr_restore(reg);
 		*rate = (tsc2 - tsc1) * 1000;
 	}
 
 #ifdef SMP
 	if (smp_cpus > 1) {
 		thread_lock(curthread);
 		sched_unbind(curthread);
 		thread_unlock(curthread);
 	}
 #endif
 
 	return (0);
 }
 
 /*
  * Shutdown the CPU as much as possible
  */
 void
 cpu_halt(void)
 {
 	for (;;)
 		halt();
 }
 
 void (*cpu_idle_hook)(sbintime_t) = NULL;	/* ACPI idle hook. */
 static int	cpu_ident_amdc1e = 0;	/* AMD C1E supported. */
 static int	idle_mwait = 1;		/* Use MONITOR/MWAIT for short idle. */
 SYSCTL_INT(_machdep, OID_AUTO, idle_mwait, CTLFLAG_RWTUN, &idle_mwait,
     0, "Use MONITOR/MWAIT for short idle");
 
 #define	STATE_RUNNING	0x0
 #define	STATE_MWAIT	0x1
 #define	STATE_SLEEPING	0x2
 
 static void
 cpu_idle_acpi(sbintime_t sbt)
 {
 	int *state;
 
 	state = (int *)PCPU_PTR(monitorbuf);
 	*state = STATE_SLEEPING;
 
 	/* See comments in cpu_idle_hlt(). */
 	disable_intr();
 	if (sched_runnable())
 		enable_intr();
 	else if (cpu_idle_hook)
 		cpu_idle_hook(sbt);
 	else
 		__asm __volatile("sti; hlt");
 	*state = STATE_RUNNING;
 }
 
 static void
 cpu_idle_hlt(sbintime_t sbt)
 {
 	int *state;
 
 	state = (int *)PCPU_PTR(monitorbuf);
 	*state = STATE_SLEEPING;
 
 	/*
 	 * Since we may be in a critical section from cpu_idle(), if
 	 * an interrupt fires during that critical section we may have
 	 * a pending preemption.  If the CPU halts, then that thread
 	 * may not execute until a later interrupt awakens the CPU.
 	 * To handle this race, check for a runnable thread after
 	 * disabling interrupts and immediately return if one is
 	 * found.  Also, we must absolutely guarentee that hlt is
 	 * the next instruction after sti.  This ensures that any
 	 * interrupt that fires after the call to disable_intr() will
 	 * immediately awaken the CPU from hlt.  Finally, please note
 	 * that on x86 this works fine because of interrupts enabled only
 	 * after the instruction following sti takes place, while IF is set
 	 * to 1 immediately, allowing hlt instruction to acknowledge the
 	 * interrupt.
 	 */
 	disable_intr();
 	if (sched_runnable())
 		enable_intr();
 	else
 		__asm __volatile("sti; hlt");
 	*state = STATE_RUNNING;
 }
 
 /*
  * MWAIT cpu power states.  Lower 4 bits are sub-states.
  */
 #define	MWAIT_C0	0xf0
 #define	MWAIT_C1	0x00
 #define	MWAIT_C2	0x10
 #define	MWAIT_C3	0x20
 #define	MWAIT_C4	0x30
 
 static void
 cpu_idle_mwait(sbintime_t sbt)
 {
 	int *state;
 
 	state = (int *)PCPU_PTR(monitorbuf);
 	*state = STATE_MWAIT;
 
 	/* See comments in cpu_idle_hlt(). */
 	disable_intr();
 	if (sched_runnable()) {
 		enable_intr();
 		*state = STATE_RUNNING;
 		return;
 	}
 	cpu_monitor(state, 0, 0);
 	if (*state == STATE_MWAIT)
 		__asm __volatile("sti; mwait" : : "a" (MWAIT_C1), "c" (0));
 	else
 		enable_intr();
 	*state = STATE_RUNNING;
 }
 
 static void
 cpu_idle_spin(sbintime_t sbt)
 {
 	int *state;
 	int i;
 
 	state = (int *)PCPU_PTR(monitorbuf);
 	*state = STATE_RUNNING;
 
 	/*
 	 * The sched_runnable() call is racy but as long as there is
 	 * a loop missing it one time will have just a little impact if any
 	 * (and it is much better than missing the check at all).
 	 */
 	for (i = 0; i < 1000; i++) {
 		if (sched_runnable())
 			return;
 		cpu_spinwait();
 	}
 }
 
 /*
  * C1E renders the local APIC timer dead, so we disable it by
  * reading the Interrupt Pending Message register and clearing
  * both C1eOnCmpHalt (bit 28) and SmiOnCmpHalt (bit 27).
  * 
  * Reference:
  *   "BIOS and Kernel Developer's Guide for AMD NPT Family 0Fh Processors"
  *   #32559 revision 3.00+
  */
 #define	MSR_AMDK8_IPM		0xc0010055
 #define	AMDK8_SMIONCMPHALT	(1ULL << 27)
 #define	AMDK8_C1EONCMPHALT	(1ULL << 28)
 #define	AMDK8_CMPHALT		(AMDK8_SMIONCMPHALT | AMDK8_C1EONCMPHALT)
 
 static void
 cpu_probe_amdc1e(void)
 {
 
 	/*
 	 * Detect the presence of C1E capability mostly on latest
 	 * dual-cores (or future) k8 family.
 	 */
 	if (cpu_vendor_id == CPU_VENDOR_AMD &&
 	    (cpu_id & 0x00000f00) == 0x00000f00 &&
 	    (cpu_id & 0x0fff0000) >=  0x00040000) {
 		cpu_ident_amdc1e = 1;
 	}
 }
 
 void (*cpu_idle_fn)(sbintime_t) = cpu_idle_acpi;
 
 void
 cpu_idle(int busy)
 {
 	uint64_t msr;
 	sbintime_t sbt = -1;
 
 	CTR2(KTR_SPARE2, "cpu_idle(%d) at %d",
 	    busy, curcpu);
 #ifdef MP_WATCHDOG
 	ap_watchdog(PCPU_GET(cpuid));
 #endif
 	/* If we are busy - try to use fast methods. */
 	if (busy) {
 		if ((cpu_feature2 & CPUID2_MON) && idle_mwait) {
 			cpu_idle_mwait(busy);
 			goto out;
 		}
 	}
 
 	/* If we have time - switch timers into idle mode. */
 	if (!busy) {
 		critical_enter();
 		sbt = cpu_idleclock();
 	}
 
 	/* Apply AMD APIC timer C1E workaround. */
 	if (cpu_ident_amdc1e && cpu_disable_c3_sleep) {
 		msr = rdmsr(MSR_AMDK8_IPM);
 		if (msr & AMDK8_CMPHALT)
 			wrmsr(MSR_AMDK8_IPM, msr & ~AMDK8_CMPHALT);
 	}
 
 	/* Call main idle method. */
 	cpu_idle_fn(sbt);
 
 	/* Switch timers back into active mode. */
 	if (!busy) {
 		cpu_activeclock();
 		critical_exit();
 	}
 out:
 	CTR2(KTR_SPARE2, "cpu_idle(%d) at %d done",
 	    busy, curcpu);
 }
 
 int
 cpu_idle_wakeup(int cpu)
 {
 	struct pcpu *pcpu;
 	int *state;
 
 	pcpu = pcpu_find(cpu);
 	state = (int *)pcpu->pc_monitorbuf;
 	/*
 	 * This doesn't need to be atomic since missing the race will
 	 * simply result in unnecessary IPIs.
 	 */
 	if (*state == STATE_SLEEPING)
 		return (0);
 	if (*state == STATE_MWAIT)
 		*state = STATE_RUNNING;
 	return (1);
 }
 
 /*
  * Ordered by speed/power consumption.
  */
 struct {
 	void	*id_fn;
 	char	*id_name;
 } idle_tbl[] = {
 	{ cpu_idle_spin, "spin" },
 	{ cpu_idle_mwait, "mwait" },
 	{ cpu_idle_hlt, "hlt" },
 	{ cpu_idle_acpi, "acpi" },
 	{ NULL, NULL }
 };
 
 static int
 idle_sysctl_available(SYSCTL_HANDLER_ARGS)
 {
 	char *avail, *p;
 	int error;
 	int i;
 
 	avail = malloc(256, M_TEMP, M_WAITOK);
 	p = avail;
 	for (i = 0; idle_tbl[i].id_name != NULL; i++) {
 		if (strstr(idle_tbl[i].id_name, "mwait") &&
 		    (cpu_feature2 & CPUID2_MON) == 0)
 			continue;
 		if (strcmp(idle_tbl[i].id_name, "acpi") == 0 &&
 		    cpu_idle_hook == NULL)
 			continue;
 		p += sprintf(p, "%s%s", p != avail ? ", " : "",
 		    idle_tbl[i].id_name);
 	}
 	error = sysctl_handle_string(oidp, avail, 0, req);
 	free(avail, M_TEMP);
 	return (error);
 }
 
 SYSCTL_PROC(_machdep, OID_AUTO, idle_available, CTLTYPE_STRING | CTLFLAG_RD,
     0, 0, idle_sysctl_available, "A", "list of available idle functions");
 
 static int
 idle_sysctl(SYSCTL_HANDLER_ARGS)
 {
 	char buf[16];
 	int error;
 	char *p;
 	int i;
 
 	p = "unknown";
 	for (i = 0; idle_tbl[i].id_name != NULL; i++) {
 		if (idle_tbl[i].id_fn == cpu_idle_fn) {
 			p = idle_tbl[i].id_name;
 			break;
 		}
 	}
 	strncpy(buf, p, sizeof(buf));
 	error = sysctl_handle_string(oidp, buf, sizeof(buf), req);
 	if (error != 0 || req->newptr == NULL)
 		return (error);
 	for (i = 0; idle_tbl[i].id_name != NULL; i++) {
 		if (strstr(idle_tbl[i].id_name, "mwait") &&
 		    (cpu_feature2 & CPUID2_MON) == 0)
 			continue;
 		if (strcmp(idle_tbl[i].id_name, "acpi") == 0 &&
 		    cpu_idle_hook == NULL)
 			continue;
 		if (strcmp(idle_tbl[i].id_name, buf))
 			continue;
 		cpu_idle_fn = idle_tbl[i].id_fn;
 		return (0);
 	}
 	return (EINVAL);
 }
 
 SYSCTL_PROC(_machdep, OID_AUTO, idle, CTLTYPE_STRING | CTLFLAG_RW, 0, 0,
     idle_sysctl, "A", "currently selected idle function");
 
 /*
  * Reset registers to default values on exec.
  */
 void
 exec_setregs(struct thread *td, struct image_params *imgp, u_long stack)
 {
 	struct trapframe *regs = td->td_frame;
 	struct pcb *pcb = td->td_pcb;
 
 	mtx_lock(&dt_lock);
 	if (td->td_proc->p_md.md_ldt != NULL)
 		user_ldt_free(td);
 	else
 		mtx_unlock(&dt_lock);
 	
 	pcb->pcb_fsbase = 0;
 	pcb->pcb_gsbase = 0;
 	clear_pcb_flags(pcb, PCB_32BIT);
 	pcb->pcb_initial_fpucw = __INITIAL_FPUCW__;
 	set_pcb_flags(pcb, PCB_FULL_IRET);
 
 	bzero((char *)regs, sizeof(struct trapframe));
 	regs->tf_rip = imgp->entry_addr;
 	regs->tf_rsp = ((stack - 8) & ~0xFul) + 8;
 	regs->tf_rdi = stack;		/* argv */
 	regs->tf_rflags = PSL_USER | (regs->tf_rflags & PSL_T);
 	regs->tf_ss = _udatasel;
 	regs->tf_cs = _ucodesel;
 	regs->tf_ds = _udatasel;
 	regs->tf_es = _udatasel;
 	regs->tf_fs = _ufssel;
 	regs->tf_gs = _ugssel;
 	regs->tf_flags = TF_HASSEGS;
 	td->td_retval[1] = 0;
 
 	/*
 	 * Reset the hardware debug registers if they were in use.
 	 * They won't have any meaning for the newly exec'd process.
 	 */
 	if (pcb->pcb_flags & PCB_DBREGS) {
 		pcb->pcb_dr0 = 0;
 		pcb->pcb_dr1 = 0;
 		pcb->pcb_dr2 = 0;
 		pcb->pcb_dr3 = 0;
 		pcb->pcb_dr6 = 0;
 		pcb->pcb_dr7 = 0;
 		if (pcb == curpcb) {
 			/*
 			 * Clear the debug registers on the running
 			 * CPU, otherwise they will end up affecting
 			 * the next process we switch to.
 			 */
 			reset_dbregs();
 		}
 		clear_pcb_flags(pcb, PCB_DBREGS);
 	}
 
 	/*
 	 * Drop the FP state if we hold it, so that the process gets a
 	 * clean FP state if it uses the FPU again.
 	 */
 	fpstate_drop(td);
 }
 
 void
 cpu_setregs(void)
 {
 	register_t cr0;
 
 	cr0 = rcr0();
 	/*
 	 * CR0_MP, CR0_NE and CR0_TS are also set by npx_probe() for the
 	 * BSP.  See the comments there about why we set them.
 	 */
 	cr0 |= CR0_MP | CR0_NE | CR0_TS | CR0_WP | CR0_AM;
 	load_cr0(cr0);
 }
 
 /*
  * Initialize amd64 and configure to run kernel
  */
 
 /*
  * Initialize segments & interrupt table
  */
 
 struct user_segment_descriptor gdt[NGDT * MAXCPU];/* global descriptor tables */
 static struct gate_descriptor idt0[NIDT];
 struct gate_descriptor *idt = &idt0[0];	/* interrupt descriptor table */
 
 static char dblfault_stack[PAGE_SIZE] __aligned(16);
 
 static char nmi0_stack[PAGE_SIZE] __aligned(16);
 CTASSERT(sizeof(struct nmi_pcpu) == 16);
 
 struct amd64tss common_tss[MAXCPU];
 
 /*
  * Software prototypes -- in more palatable form.
  *
  * Keep GUFS32, GUGS32, GUCODE32 and GUDATA at the same
  * slots as corresponding segments for i386 kernel.
  */
 struct soft_segment_descriptor gdt_segs[] = {
 /* GNULL_SEL	0 Null Descriptor */
 {	.ssd_base = 0x0,
 	.ssd_limit = 0x0,
 	.ssd_type = 0,
 	.ssd_dpl = 0,
 	.ssd_p = 0,
 	.ssd_long = 0,
 	.ssd_def32 = 0,
 	.ssd_gran = 0		},
 /* GNULL2_SEL	1 Null Descriptor */
 {	.ssd_base = 0x0,
 	.ssd_limit = 0x0,
 	.ssd_type = 0,
 	.ssd_dpl = 0,
 	.ssd_p = 0,
 	.ssd_long = 0,
 	.ssd_def32 = 0,
 	.ssd_gran = 0		},
 /* GUFS32_SEL	2 32 bit %gs Descriptor for user */
 {	.ssd_base = 0x0,
 	.ssd_limit = 0xfffff,
 	.ssd_type = SDT_MEMRWA,
 	.ssd_dpl = SEL_UPL,
 	.ssd_p = 1,
 	.ssd_long = 0,
 	.ssd_def32 = 1,
 	.ssd_gran = 1		},
 /* GUGS32_SEL	3 32 bit %fs Descriptor for user */
 {	.ssd_base = 0x0,
 	.ssd_limit = 0xfffff,
 	.ssd_type = SDT_MEMRWA,
 	.ssd_dpl = SEL_UPL,
 	.ssd_p = 1,
 	.ssd_long = 0,
 	.ssd_def32 = 1,
 	.ssd_gran = 1		},
 /* GCODE_SEL	4 Code Descriptor for kernel */
 {	.ssd_base = 0x0,
 	.ssd_limit = 0xfffff,
 	.ssd_type = SDT_MEMERA,
 	.ssd_dpl = SEL_KPL,
 	.ssd_p = 1,
 	.ssd_long = 1,
 	.ssd_def32 = 0,
 	.ssd_gran = 1		},
 /* GDATA_SEL	5 Data Descriptor for kernel */
 {	.ssd_base = 0x0,
 	.ssd_limit = 0xfffff,
 	.ssd_type = SDT_MEMRWA,
 	.ssd_dpl = SEL_KPL,
 	.ssd_p = 1,
 	.ssd_long = 1,
 	.ssd_def32 = 0,
 	.ssd_gran = 1		},
 /* GUCODE32_SEL	6 32 bit Code Descriptor for user */
 {	.ssd_base = 0x0,
 	.ssd_limit = 0xfffff,
 	.ssd_type = SDT_MEMERA,
 	.ssd_dpl = SEL_UPL,
 	.ssd_p = 1,
 	.ssd_long = 0,
 	.ssd_def32 = 1,
 	.ssd_gran = 1		},
 /* GUDATA_SEL	7 32/64 bit Data Descriptor for user */
 {	.ssd_base = 0x0,
 	.ssd_limit = 0xfffff,
 	.ssd_type = SDT_MEMRWA,
 	.ssd_dpl = SEL_UPL,
 	.ssd_p = 1,
 	.ssd_long = 0,
 	.ssd_def32 = 1,
 	.ssd_gran = 1		},
 /* GUCODE_SEL	8 64 bit Code Descriptor for user */
 {	.ssd_base = 0x0,
 	.ssd_limit = 0xfffff,
 	.ssd_type = SDT_MEMERA,
 	.ssd_dpl = SEL_UPL,
 	.ssd_p = 1,
 	.ssd_long = 1,
 	.ssd_def32 = 0,
 	.ssd_gran = 1		},
 /* GPROC0_SEL	9 Proc 0 Tss Descriptor */
 {	.ssd_base = 0x0,
 	.ssd_limit = sizeof(struct amd64tss) + IOPERM_BITMAP_SIZE - 1,
 	.ssd_type = SDT_SYSTSS,
 	.ssd_dpl = SEL_KPL,
 	.ssd_p = 1,
 	.ssd_long = 0,
 	.ssd_def32 = 0,
 	.ssd_gran = 0		},
 /* Actually, the TSS is a system descriptor which is double size */
 {	.ssd_base = 0x0,
 	.ssd_limit = 0x0,
 	.ssd_type = 0,
 	.ssd_dpl = 0,
 	.ssd_p = 0,
 	.ssd_long = 0,
 	.ssd_def32 = 0,
 	.ssd_gran = 0		},
 /* GUSERLDT_SEL	11 LDT Descriptor */
 {	.ssd_base = 0x0,
 	.ssd_limit = 0x0,
 	.ssd_type = 0,
 	.ssd_dpl = 0,
 	.ssd_p = 0,
 	.ssd_long = 0,
 	.ssd_def32 = 0,
 	.ssd_gran = 0		},
 /* GUSERLDT_SEL	12 LDT Descriptor, double size */
 {	.ssd_base = 0x0,
 	.ssd_limit = 0x0,
 	.ssd_type = 0,
 	.ssd_dpl = 0,
 	.ssd_p = 0,
 	.ssd_long = 0,
 	.ssd_def32 = 0,
 	.ssd_gran = 0		},
 };
 
 void
 setidt(idx, func, typ, dpl, ist)
 	int idx;
 	inthand_t *func;
 	int typ;
 	int dpl;
 	int ist;
 {
 	struct gate_descriptor *ip;
 
 	ip = idt + idx;
 	ip->gd_looffset = (uintptr_t)func;
 	ip->gd_selector = GSEL(GCODE_SEL, SEL_KPL);
 	ip->gd_ist = ist;
 	ip->gd_xx = 0;
 	ip->gd_type = typ;
 	ip->gd_dpl = dpl;
 	ip->gd_p = 1;
 	ip->gd_hioffset = ((uintptr_t)func)>>16 ;
 }
 
 extern inthand_t
 	IDTVEC(div), IDTVEC(dbg), IDTVEC(nmi), IDTVEC(bpt), IDTVEC(ofl),
 	IDTVEC(bnd), IDTVEC(ill), IDTVEC(dna), IDTVEC(fpusegm),
 	IDTVEC(tss), IDTVEC(missing), IDTVEC(stk), IDTVEC(prot),
 	IDTVEC(page), IDTVEC(mchk), IDTVEC(rsvd), IDTVEC(fpu), IDTVEC(align),
 	IDTVEC(xmm), IDTVEC(dblfault),
 #ifdef KDTRACE_HOOKS
 	IDTVEC(dtrace_ret),
 #endif
 #ifdef XENHVM
 	IDTVEC(xen_intr_upcall),
 #endif
 	IDTVEC(fast_syscall), IDTVEC(fast_syscall32);
 
 #ifdef DDB
 /*
  * Display the index and function name of any IDT entries that don't use
  * the default 'rsvd' entry point.
  */
 DB_SHOW_COMMAND(idt, db_show_idt)
 {
 	struct gate_descriptor *ip;
 	int idx;
 	uintptr_t func;
 
 	ip = idt;
 	for (idx = 0; idx < NIDT && !db_pager_quit; idx++) {
 		func = ((long)ip->gd_hioffset << 16 | ip->gd_looffset);
 		if (func != (uintptr_t)&IDTVEC(rsvd)) {
 			db_printf("%3d\t", idx);
 			db_printsym(func, DB_STGY_PROC);
 			db_printf("\n");
 		}
 		ip++;
 	}
 }
 
 /* Show privileged registers. */
 DB_SHOW_COMMAND(sysregs, db_show_sysregs)
 {
 	struct {
 		uint16_t limit;
 		uint64_t base;
 	} __packed idtr, gdtr;
 	uint16_t ldt, tr;
 
 	__asm __volatile("sidt %0" : "=m" (idtr));
 	db_printf("idtr\t0x%016lx/%04x\n",
 	    (u_long)idtr.base, (u_int)idtr.limit);
 	__asm __volatile("sgdt %0" : "=m" (gdtr));
 	db_printf("gdtr\t0x%016lx/%04x\n",
 	    (u_long)gdtr.base, (u_int)gdtr.limit);
 	__asm __volatile("sldt %0" : "=r" (ldt));
 	db_printf("ldtr\t0x%04x\n", ldt);
 	__asm __volatile("str %0" : "=r" (tr));
 	db_printf("tr\t0x%04x\n", tr);
 	db_printf("cr0\t0x%016lx\n", rcr0());
 	db_printf("cr2\t0x%016lx\n", rcr2());
 	db_printf("cr3\t0x%016lx\n", rcr3());
 	db_printf("cr4\t0x%016lx\n", rcr4());
 	db_printf("EFER\t%016lx\n", rdmsr(MSR_EFER));
 	db_printf("FEATURES_CTL\t%016lx\n", rdmsr(MSR_IA32_FEATURE_CONTROL));
 	db_printf("DEBUG_CTL\t%016lx\n", rdmsr(MSR_DEBUGCTLMSR));
 	db_printf("PAT\t%016lx\n", rdmsr(MSR_PAT));
 	db_printf("GSBASE\t%016lx\n", rdmsr(MSR_GSBASE));
 }
 #endif
 
 void
 sdtossd(sd, ssd)
 	struct user_segment_descriptor *sd;
 	struct soft_segment_descriptor *ssd;
 {
 
 	ssd->ssd_base  = (sd->sd_hibase << 24) | sd->sd_lobase;
 	ssd->ssd_limit = (sd->sd_hilimit << 16) | sd->sd_lolimit;
 	ssd->ssd_type  = sd->sd_type;
 	ssd->ssd_dpl   = sd->sd_dpl;
 	ssd->ssd_p     = sd->sd_p;
 	ssd->ssd_long  = sd->sd_long;
 	ssd->ssd_def32 = sd->sd_def32;
 	ssd->ssd_gran  = sd->sd_gran;
 }
 
 void
 ssdtosd(ssd, sd)
 	struct soft_segment_descriptor *ssd;
 	struct user_segment_descriptor *sd;
 {
 
 	sd->sd_lobase = (ssd->ssd_base) & 0xffffff;
 	sd->sd_hibase = (ssd->ssd_base >> 24) & 0xff;
 	sd->sd_lolimit = (ssd->ssd_limit) & 0xffff;
 	sd->sd_hilimit = (ssd->ssd_limit >> 16) & 0xf;
 	sd->sd_type  = ssd->ssd_type;
 	sd->sd_dpl   = ssd->ssd_dpl;
 	sd->sd_p     = ssd->ssd_p;
 	sd->sd_long  = ssd->ssd_long;
 	sd->sd_def32 = ssd->ssd_def32;
 	sd->sd_gran  = ssd->ssd_gran;
 }
 
 void
 ssdtosyssd(ssd, sd)
 	struct soft_segment_descriptor *ssd;
 	struct system_segment_descriptor *sd;
 {
 
 	sd->sd_lobase = (ssd->ssd_base) & 0xffffff;
 	sd->sd_hibase = (ssd->ssd_base >> 24) & 0xfffffffffful;
 	sd->sd_lolimit = (ssd->ssd_limit) & 0xffff;
 	sd->sd_hilimit = (ssd->ssd_limit >> 16) & 0xf;
 	sd->sd_type  = ssd->ssd_type;
 	sd->sd_dpl   = ssd->ssd_dpl;
 	sd->sd_p     = ssd->ssd_p;
 	sd->sd_gran  = ssd->ssd_gran;
 }
 
 #if !defined(DEV_ATPIC) && defined(DEV_ISA)
 #include <isa/isavar.h>
 #include <isa/isareg.h>
 /*
  * Return a bitmap of the current interrupt requests.  This is 8259-specific
  * and is only suitable for use at probe time.
  * This is only here to pacify sio.  It is NOT FATAL if this doesn't work.
  * It shouldn't be here.  There should probably be an APIC centric
  * implementation in the apic driver code, if at all.
  */
 intrmask_t
 isa_irq_pending(void)
 {
 	u_char irr1;
 	u_char irr2;
 
 	irr1 = inb(IO_ICU1);
 	irr2 = inb(IO_ICU2);
 	return ((irr2 << 8) | irr1);
 }
 #endif
 
 u_int basemem;
 
 static int
 add_physmap_entry(uint64_t base, uint64_t length, vm_paddr_t *physmap,
     int *physmap_idxp)
 {
 	int i, insert_idx, physmap_idx;
 
 	physmap_idx = *physmap_idxp;
 
 	if (length == 0)
 		return (1);
 
 	/*
 	 * Find insertion point while checking for overlap.  Start off by
 	 * assuming the new entry will be added to the end.
+	 *
+	 * NB: physmap_idx points to the next free slot.
 	 */
-	insert_idx = physmap_idx + 2;
+	insert_idx = physmap_idx;
 	for (i = 0; i <= physmap_idx; i += 2) {
 		if (base < physmap[i + 1]) {
 			if (base + length <= physmap[i]) {
 				insert_idx = i;
 				break;
 			}
 			if (boothowto & RB_VERBOSE)
 				printf(
 		    "Overlapping memory regions, ignoring second region\n");
 			return (1);
 		}
 	}
 
 	/* See if we can prepend to the next entry. */
 	if (insert_idx <= physmap_idx && base + length == physmap[insert_idx]) {
 		physmap[insert_idx] = base;
 		return (1);
 	}
 
 	/* See if we can append to the previous entry. */
 	if (insert_idx > 0 && base == physmap[insert_idx - 1]) {
 		physmap[insert_idx - 1] += length;
 		return (1);
 	}
 
 	physmap_idx += 2;
 	*physmap_idxp = physmap_idx;
 	if (physmap_idx == PHYSMAP_SIZE) {
 		printf(
 		"Too many segments in the physical address map, giving up\n");
 		return (0);
 	}
 
 	/*
 	 * Move the last 'N' entries down to make room for the new
 	 * entry if needed.
 	 */
-	for (i = physmap_idx; i > insert_idx; i -= 2) {
+	for (i = (physmap_idx - 2); i > insert_idx; i -= 2) {
 		physmap[i] = physmap[i - 2];
 		physmap[i + 1] = physmap[i - 1];
 	}
 
 	/* Insert the new entry. */
 	physmap[insert_idx] = base;
 	physmap[insert_idx + 1] = base + length;
 	return (1);
 }
 
 void
 bios_add_smap_entries(struct bios_smap *smapbase, u_int32_t smapsize,
                       vm_paddr_t *physmap, int *physmap_idx)
 {
 	struct bios_smap *smap, *smapend;
 
 	smapend = (struct bios_smap *)((uintptr_t)smapbase + smapsize);
 
 	for (smap = smapbase; smap < smapend; smap++) {
 		if (boothowto & RB_VERBOSE)
 			printf("SMAP type=%02x base=%016lx len=%016lx\n",
 			    smap->type, smap->base, smap->length);
 
 		if (smap->type != SMAP_TYPE_MEMORY)
 			continue;
 
 		if (!add_physmap_entry(smap->base, smap->length, physmap,
 		    physmap_idx))
 			break;
 	}
 }
 
 #define efi_next_descriptor(ptr, size) \
 	((struct efi_md *)(((uint8_t *) ptr) + size))
 
 static void
 add_efi_map_entries(struct efi_map_header *efihdr, vm_paddr_t *physmap,
     int *physmap_idx)
 {
 	struct efi_md *map, *p;
 	const char *type;
 	size_t efisz;
 	int ndesc, i;
 
 	static const char *types[] = {
 		"Reserved",
 		"LoaderCode",
 		"LoaderData",
 		"BootServicesCode",
 		"BootServicesData",
 		"RuntimeServicesCode",
 		"RuntimeServicesData",
 		"ConventionalMemory",
 		"UnusableMemory",
 		"ACPIReclaimMemory",
 		"ACPIMemoryNVS",
 		"MemoryMappedIO",
 		"MemoryMappedIOPortSpace",
 		"PalCode"
 	};
 
 	/*
 	 * Memory map data provided by UEFI via the GetMemoryMap
 	 * Boot Services API.
 	 */
 	efisz = (sizeof(struct efi_map_header) + 0xf) & ~0xf;
 	map = (struct efi_md *)((uint8_t *)efihdr + efisz); 
 
 	if (efihdr->descriptor_size == 0)
 		return;
 	ndesc = efihdr->memory_size / efihdr->descriptor_size;
 
 	if (boothowto & RB_VERBOSE)
 		printf("%23s %12s %12s %8s %4s\n",
 		    "Type", "Physical", "Virtual", "#Pages", "Attr");
 
 	for (i = 0, p = map; i < ndesc; i++,
 	    p = efi_next_descriptor(p, efihdr->descriptor_size)) {
 		if (boothowto & RB_VERBOSE) {
 			if (p->md_type <= EFI_MD_TYPE_PALCODE)
 				type = types[p->md_type];
 			else
 				type = "<INVALID>";
 			printf("%23s %012lx %12p %08lx ", type, p->md_phys,
 			    p->md_virt, p->md_pages);
 			if (p->md_attr & EFI_MD_ATTR_UC)
 				printf("UC ");
 			if (p->md_attr & EFI_MD_ATTR_WC)
 				printf("WC ");
 			if (p->md_attr & EFI_MD_ATTR_WT)
 				printf("WT ");
 			if (p->md_attr & EFI_MD_ATTR_WB)
 				printf("WB ");
 			if (p->md_attr & EFI_MD_ATTR_UCE)
 				printf("UCE ");
 			if (p->md_attr & EFI_MD_ATTR_WP)
 				printf("WP ");
 			if (p->md_attr & EFI_MD_ATTR_RP)
 				printf("RP ");
 			if (p->md_attr & EFI_MD_ATTR_XP)
 				printf("XP ");
 			if (p->md_attr & EFI_MD_ATTR_RT)
 				printf("RUNTIME");
 			printf("\n");
 		}
 
 		switch (p->md_type) {
 		case EFI_MD_TYPE_CODE:
 		case EFI_MD_TYPE_DATA:
 		case EFI_MD_TYPE_BS_CODE:
 		case EFI_MD_TYPE_BS_DATA:
 		case EFI_MD_TYPE_FREE:
 			/*
 			 * We're allowed to use any entry with these types.
 			 */
 			break;
 		default:
 			continue;
 		}
 
 		if (!add_physmap_entry(p->md_phys, (p->md_pages * PAGE_SIZE),
 		    physmap, physmap_idx))
 			break;
 	}
 }
 
 static char bootmethod[16] = "";
 SYSCTL_STRING(_machdep, OID_AUTO, bootmethod, CTLFLAG_RD, bootmethod, 0,
     "System firmware boot method");
 
 static void
 native_parse_memmap(caddr_t kmdp, vm_paddr_t *physmap, int *physmap_idx)
 {
 	struct bios_smap *smap;
 	struct efi_map_header *efihdr;
 	u_int32_t size;
 
 	/*
 	 * Memory map from INT 15:E820.
 	 *
 	 * subr_module.c says:
 	 * "Consumer may safely assume that size value precedes data."
 	 * ie: an int32_t immediately precedes smap.
 	 */
 
 	efihdr = (struct efi_map_header *)preload_search_info(kmdp,
 	    MODINFO_METADATA | MODINFOMD_EFI_MAP);
 	smap = (struct bios_smap *)preload_search_info(kmdp,
 	    MODINFO_METADATA | MODINFOMD_SMAP);
 	if (efihdr == NULL && smap == NULL)
 		panic("No BIOS smap or EFI map info from loader!");
 
 	if (efihdr != NULL) {
 		add_efi_map_entries(efihdr, physmap, physmap_idx);
 		strlcpy(bootmethod, "UEFI", sizeof(bootmethod));
 	} else {
 		size = *((u_int32_t *)smap - 1);
 		bios_add_smap_entries(smap, size, physmap, physmap_idx);
 		strlcpy(bootmethod, "BIOS", sizeof(bootmethod));
 	}
 }
 
 #define	PAGES_PER_GB	(1024 * 1024 * 1024 / PAGE_SIZE)
 
 /*
  * Populate the (physmap) array with base/bound pairs describing the
  * available physical memory in the system, then test this memory and
  * build the phys_avail array describing the actually-available memory.
  *
  * Total memory size may be set by the kernel environment variable
  * hw.physmem or the compile-time define MAXMEM.
  *
  * XXX first should be vm_paddr_t.
  */
 static void
 getmemsize(caddr_t kmdp, u_int64_t first)
 {
 	int i, physmap_idx, pa_indx, da_indx;
 	vm_paddr_t pa, physmap[PHYSMAP_SIZE];
 	u_long physmem_start, physmem_tunable, memtest;
 	pt_entry_t *pte;
 	quad_t dcons_addr, dcons_size;
 	int page_counter;
 
 	bzero(physmap, sizeof(physmap));
-	basemem = 0;
 	physmap_idx = 0;
 
 	init_ops.parse_memmap(kmdp, physmap, &physmap_idx);
+	physmap_idx -= 2;
 
 	/*
 	 * Find the 'base memory' segment for SMP
 	 */
 	basemem = 0;
 	for (i = 0; i <= physmap_idx; i += 2) {
-		if (physmap[i] == 0x00000000) {
+		if (physmap[i] <= 0xA0000) {
 			basemem = physmap[i + 1] / 1024;
 			break;
 		}
 	}
-	if (basemem == 0)
-		panic("BIOS smap did not include a basemem segment!");
+	if (basemem == 0 || basemem > 640) {
+		if (bootverbose)
+			printf(
+		"Memory map doesn't contain a basemem segment, faking it");
+		basemem = 640;
+	}
 
 	/*
 	 * Make hole for "AP -> long mode" bootstrap code.  The
 	 * mp_bootaddress vector is only available when the kernel
 	 * is configured to support APs and APs for the system start
 	 * in 32bit mode (e.g. SMP bare metal).
 	 */
-	if (init_ops.mp_bootaddress)
+	if (init_ops.mp_bootaddress) {
+		if (physmap[1] >= 0x100000000)
+			panic(
+	"Basemem segment is not suitable for AP bootstrap code!");
 		physmap[1] = init_ops.mp_bootaddress(physmap[1] / 1024);
+	}
 
 	/*
 	 * Maxmem isn't the "maximum memory", it's one larger than the
 	 * highest page of the physical address space.  It should be
 	 * called something like "Maxphyspage".  We may adjust this
 	 * based on ``hw.physmem'' and the results of the memory test.
 	 */
 	Maxmem = atop(physmap[physmap_idx + 1]);
 
 #ifdef MAXMEM
 	Maxmem = MAXMEM / 4;
 #endif
 
 	if (TUNABLE_ULONG_FETCH("hw.physmem", &physmem_tunable))
 		Maxmem = atop(physmem_tunable);
 
 	/*
 	 * The boot memory test is disabled by default, as it takes a
 	 * significant amount of time on large-memory systems, and is
 	 * unfriendly to virtual machines as it unnecessarily touches all
 	 * pages.
 	 *
 	 * A general name is used as the code may be extended to support
 	 * additional tests beyond the current "page present" test.
 	 */
 	memtest = 0;
 	TUNABLE_ULONG_FETCH("hw.memtest.tests", &memtest);
 
 	/*
 	 * Don't allow MAXMEM or hw.physmem to extend the amount of memory
 	 * in the system.
 	 */
 	if (Maxmem > atop(physmap[physmap_idx + 1]))
 		Maxmem = atop(physmap[physmap_idx + 1]);
 
 	if (atop(physmap[physmap_idx + 1]) != Maxmem &&
 	    (boothowto & RB_VERBOSE))
 		printf("Physical memory use set to %ldK\n", Maxmem * 4);
 
 	/* call pmap initialization to make new kernel address space */
 	pmap_bootstrap(&first);
 
 	/*
 	 * Size up each available chunk of physical memory.
 	 *
 	 * XXX Some BIOSes corrupt low 64KB between suspend and resume.
 	 * By default, mask off the first 16 pages unless we appear to be
 	 * running in a VM.
 	 */
 	physmem_start = (vm_guest > VM_GUEST_NO ? 1 : 16) << PAGE_SHIFT;
 	TUNABLE_ULONG_FETCH("hw.physmem.start", &physmem_start);
-	if (physmem_start < PAGE_SIZE)
-		physmap[0] = PAGE_SIZE;
-	else if (physmem_start >= physmap[1])
-		physmap[0] = round_page(physmap[1] - PAGE_SIZE);
-	else
-		physmap[0] = round_page(physmem_start);
+	if (physmap[0] < physmem_start) {
+		if (physmem_start < PAGE_SIZE)
+			physmap[0] = PAGE_SIZE;
+		else if (physmem_start >= physmap[1])
+			physmap[0] = round_page(physmap[1] - PAGE_SIZE);
+		else
+			physmap[0] = round_page(physmem_start);
+	}
 	pa_indx = 0;
 	da_indx = 1;
 	phys_avail[pa_indx++] = physmap[0];
 	phys_avail[pa_indx] = physmap[0];
 	dump_avail[da_indx] = physmap[0];
 	pte = CMAP1;
 
 	/*
 	 * Get dcons buffer address
 	 */
 	if (getenv_quad("dcons.addr", &dcons_addr) == 0 ||
 	    getenv_quad("dcons.size", &dcons_size) == 0)
 		dcons_addr = 0;
 
 	/*
 	 * physmap is in bytes, so when converting to page boundaries,
 	 * round up the start address and round down the end address.
 	 */
 	page_counter = 0;
 	if (memtest != 0)
 		printf("Testing system memory");
 	for (i = 0; i <= physmap_idx; i += 2) {
 		vm_paddr_t end;
 
 		end = ptoa((vm_paddr_t)Maxmem);
 		if (physmap[i + 1] < end)
 			end = trunc_page(physmap[i + 1]);
 		for (pa = round_page(physmap[i]); pa < end; pa += PAGE_SIZE) {
 			int tmp, page_bad, full;
 			int *ptr = (int *)CADDR1;
 
 			full = FALSE;
 			/*
 			 * block out kernel memory as not available.
 			 */
 			if (pa >= (vm_paddr_t)kernphys && pa < first)
 				goto do_dump_avail;
 
 			/*
 			 * block out dcons buffer
 			 */
 			if (dcons_addr > 0
 			    && pa >= trunc_page(dcons_addr)
 			    && pa < dcons_addr + dcons_size)
 				goto do_dump_avail;
 
 			page_bad = FALSE;
 			if (memtest == 0)
 				goto skip_memtest;
 
 			/*
 			 * Print a "." every GB to show we're making
 			 * progress.
 			 */
 			page_counter++;
 			if ((page_counter % PAGES_PER_GB) == 0)
 				printf(".");
 
 			/*
 			 * map page into kernel: valid, read/write,non-cacheable
 			 */
 			*pte = pa | PG_V | PG_RW | PG_NC_PWT | PG_NC_PCD;
 			invltlb();
 
 			tmp = *(int *)ptr;
 			/*
 			 * Test for alternating 1's and 0's
 			 */
 			*(volatile int *)ptr = 0xaaaaaaaa;
 			if (*(volatile int *)ptr != 0xaaaaaaaa)
 				page_bad = TRUE;
 			/*
 			 * Test for alternating 0's and 1's
 			 */
 			*(volatile int *)ptr = 0x55555555;
 			if (*(volatile int *)ptr != 0x55555555)
 				page_bad = TRUE;
 			/*
 			 * Test for all 1's
 			 */
 			*(volatile int *)ptr = 0xffffffff;
 			if (*(volatile int *)ptr != 0xffffffff)
 				page_bad = TRUE;
 			/*
 			 * Test for all 0's
 			 */
 			*(volatile int *)ptr = 0x0;
 			if (*(volatile int *)ptr != 0x0)
 				page_bad = TRUE;
 			/*
 			 * Restore original value.
 			 */
 			*(int *)ptr = tmp;
 
 skip_memtest:
 			/*
 			 * Adjust array of valid/good pages.
 			 */
 			if (page_bad == TRUE)
 				continue;
 			/*
 			 * If this good page is a continuation of the
 			 * previous set of good pages, then just increase
 			 * the end pointer. Otherwise start a new chunk.
 			 * Note that "end" points one higher than end,
 			 * making the range >= start and < end.
 			 * If we're also doing a speculative memory
 			 * test and we at or past the end, bump up Maxmem
 			 * so that we keep going. The first bad page
 			 * will terminate the loop.
 			 */
 			if (phys_avail[pa_indx] == pa) {
 				phys_avail[pa_indx] += PAGE_SIZE;
 			} else {
 				pa_indx++;
 				if (pa_indx == PHYS_AVAIL_ARRAY_END) {
 					printf(
 		"Too many holes in the physical address space, giving up\n");
 					pa_indx--;
 					full = TRUE;
 					goto do_dump_avail;
 				}
 				phys_avail[pa_indx++] = pa;	/* start */
 				phys_avail[pa_indx] = pa + PAGE_SIZE; /* end */
 			}
 			physmem++;
 do_dump_avail:
 			if (dump_avail[da_indx] == pa) {
 				dump_avail[da_indx] += PAGE_SIZE;
 			} else {
 				da_indx++;
 				if (da_indx == DUMP_AVAIL_ARRAY_END) {
 					da_indx--;
 					goto do_next;
 				}
 				dump_avail[da_indx++] = pa; /* start */
 				dump_avail[da_indx] = pa + PAGE_SIZE; /* end */
 			}
 do_next:
 			if (full)
 				break;
 		}
 	}
 	*pte = 0;
 	invltlb();
 	if (memtest != 0)
 		printf("\n");
 
 	/*
 	 * XXX
 	 * The last chunk must contain at least one page plus the message
 	 * buffer to avoid complicating other code (message buffer address
 	 * calculation, etc.).
 	 */
 	while (phys_avail[pa_indx - 1] + PAGE_SIZE +
 	    round_page(msgbufsize) >= phys_avail[pa_indx]) {
 		physmem -= atop(phys_avail[pa_indx] - phys_avail[pa_indx - 1]);
 		phys_avail[pa_indx--] = 0;
 		phys_avail[pa_indx--] = 0;
 	}
 
 	Maxmem = atop(phys_avail[pa_indx]);
 
 	/* Trim off space for the message buffer. */
 	phys_avail[pa_indx] -= round_page(msgbufsize);
 
 	/* Map the message buffer. */
 	msgbufp = (struct msgbuf *)PHYS_TO_DMAP(phys_avail[pa_indx]);
 }
 
 static caddr_t
 native_parse_preload_data(u_int64_t modulep)
 {
 	caddr_t kmdp;
 #ifdef DDB
 	vm_offset_t ksym_start;
 	vm_offset_t ksym_end;
 #endif
 
 	preload_metadata = (caddr_t)(uintptr_t)(modulep + KERNBASE);
 	preload_bootstrap_relocate(KERNBASE);
 	kmdp = preload_search_by_type("elf kernel");
 	if (kmdp == NULL)
 		kmdp = preload_search_by_type("elf64 kernel");
 	boothowto = MD_FETCH(kmdp, MODINFOMD_HOWTO, int);
 	kern_envp = MD_FETCH(kmdp, MODINFOMD_ENVP, char *) + KERNBASE;
 #ifdef DDB
 	ksym_start = MD_FETCH(kmdp, MODINFOMD_SSYM, uintptr_t);
 	ksym_end = MD_FETCH(kmdp, MODINFOMD_ESYM, uintptr_t);
 	db_fetch_ksymtab(ksym_start, ksym_end);
 #endif
 
 	return (kmdp);
 }
 
 u_int64_t
 hammer_time(u_int64_t modulep, u_int64_t physfree)
 {
 	caddr_t kmdp;
 	int gsel_tss, x;
 	struct pcpu *pc;
 	struct nmi_pcpu *np;
 	struct xstate_hdr *xhdr;
 	u_int64_t msr;
 	char *env;
 	size_t kstack0_sz;
 
 	thread0.td_kstack = physfree + KERNBASE;
 	thread0.td_kstack_pages = KSTACK_PAGES;
 	kstack0_sz = thread0.td_kstack_pages * PAGE_SIZE;
 	bzero((void *)thread0.td_kstack, kstack0_sz);
 	physfree += kstack0_sz;
 
 	/*
  	 * This may be done better later if it gets more high level
  	 * components in it. If so just link td->td_proc here.
 	 */
 	proc_linkup0(&proc0, &thread0);
 
 	kmdp = init_ops.parse_preload_data(modulep);
 
 	/* Init basic tunables, hz etc */
 	init_param1();
 
 	/*
 	 * make gdt memory segments
 	 */
 	for (x = 0; x < NGDT; x++) {
 		if (x != GPROC0_SEL && x != (GPROC0_SEL + 1) &&
 		    x != GUSERLDT_SEL && x != (GUSERLDT_SEL) + 1)
 			ssdtosd(&gdt_segs[x], &gdt[x]);
 	}
 	gdt_segs[GPROC0_SEL].ssd_base = (uintptr_t)&common_tss[0];
 	ssdtosyssd(&gdt_segs[GPROC0_SEL],
 	    (struct system_segment_descriptor *)&gdt[GPROC0_SEL]);
 
 	r_gdt.rd_limit = NGDT * sizeof(gdt[0]) - 1;
 	r_gdt.rd_base =  (long) gdt;
 	lgdt(&r_gdt);
 	pc = &__pcpu[0];
 
 	wrmsr(MSR_FSBASE, 0);		/* User value */
 	wrmsr(MSR_GSBASE, (u_int64_t)pc);
 	wrmsr(MSR_KGSBASE, 0);		/* User value while in the kernel */
 
 	pcpu_init(pc, 0, sizeof(struct pcpu));
 	dpcpu_init((void *)(physfree + KERNBASE), 0);
 	physfree += DPCPU_SIZE;
 	PCPU_SET(prvspace, pc);
 	PCPU_SET(curthread, &thread0);
 	PCPU_SET(tssp, &common_tss[0]);
 	PCPU_SET(commontssp, &common_tss[0]);
 	PCPU_SET(tss, (struct system_segment_descriptor *)&gdt[GPROC0_SEL]);
 	PCPU_SET(ldt, (struct system_segment_descriptor *)&gdt[GUSERLDT_SEL]);
 	PCPU_SET(fs32p, &gdt[GUFS32_SEL]);
 	PCPU_SET(gs32p, &gdt[GUGS32_SEL]);
 
 	/*
 	 * Initialize mutexes.
 	 *
 	 * icu_lock: in order to allow an interrupt to occur in a critical
 	 * 	     section, to set pcpu->ipending (etc...) properly, we
 	 *	     must be able to get the icu lock, so it can't be
 	 *	     under witness.
 	 */
 	mutex_init();
 	mtx_init(&icu_lock, "icu", NULL, MTX_SPIN | MTX_NOWITNESS);
 	mtx_init(&dt_lock, "descriptor tables", NULL, MTX_DEF);
 
 	/* exceptions */
 	for (x = 0; x < NIDT; x++)
 		setidt(x, &IDTVEC(rsvd), SDT_SYSIGT, SEL_KPL, 0);
 	setidt(IDT_DE, &IDTVEC(div),  SDT_SYSIGT, SEL_KPL, 0);
 	setidt(IDT_DB, &IDTVEC(dbg),  SDT_SYSIGT, SEL_KPL, 0);
 	setidt(IDT_NMI, &IDTVEC(nmi),  SDT_SYSIGT, SEL_KPL, 2);
  	setidt(IDT_BP, &IDTVEC(bpt),  SDT_SYSIGT, SEL_UPL, 0);
 	setidt(IDT_OF, &IDTVEC(ofl),  SDT_SYSIGT, SEL_KPL, 0);
 	setidt(IDT_BR, &IDTVEC(bnd),  SDT_SYSIGT, SEL_KPL, 0);
 	setidt(IDT_UD, &IDTVEC(ill),  SDT_SYSIGT, SEL_KPL, 0);
 	setidt(IDT_NM, &IDTVEC(dna),  SDT_SYSIGT, SEL_KPL, 0);
 	setidt(IDT_DF, &IDTVEC(dblfault), SDT_SYSIGT, SEL_KPL, 1);
 	setidt(IDT_FPUGP, &IDTVEC(fpusegm),  SDT_SYSIGT, SEL_KPL, 0);
 	setidt(IDT_TS, &IDTVEC(tss),  SDT_SYSIGT, SEL_KPL, 0);
 	setidt(IDT_NP, &IDTVEC(missing),  SDT_SYSIGT, SEL_KPL, 0);
 	setidt(IDT_SS, &IDTVEC(stk),  SDT_SYSIGT, SEL_KPL, 0);
 	setidt(IDT_GP, &IDTVEC(prot),  SDT_SYSIGT, SEL_KPL, 0);
 	setidt(IDT_PF, &IDTVEC(page),  SDT_SYSIGT, SEL_KPL, 0);
 	setidt(IDT_MF, &IDTVEC(fpu),  SDT_SYSIGT, SEL_KPL, 0);
 	setidt(IDT_AC, &IDTVEC(align), SDT_SYSIGT, SEL_KPL, 0);
 	setidt(IDT_MC, &IDTVEC(mchk),  SDT_SYSIGT, SEL_KPL, 0);
 	setidt(IDT_XF, &IDTVEC(xmm), SDT_SYSIGT, SEL_KPL, 0);
 #ifdef KDTRACE_HOOKS
 	setidt(IDT_DTRACE_RET, &IDTVEC(dtrace_ret), SDT_SYSIGT, SEL_UPL, 0);
 #endif
 #ifdef XENHVM
 	setidt(IDT_EVTCHN, &IDTVEC(xen_intr_upcall), SDT_SYSIGT, SEL_UPL, 0);
 #endif
 
 	r_idt.rd_limit = sizeof(idt0) - 1;
 	r_idt.rd_base = (long) idt;
 	lidt(&r_idt);
 
 	/*
 	 * Initialize the clock before the console so that console
 	 * initialization can use DELAY().
 	 */
 	clock_init();
 
 	/*
 	 * Use vt(4) by default for UEFI boot (during the sc(4)/vt(4)
 	 * transition).
 	 */
 	if (kmdp != NULL && preload_search_info(kmdp,
 	    MODINFO_METADATA | MODINFOMD_EFI_MAP) != NULL)
 		vty_set_preferred(VTY_VT);
 
 	/*
 	 * Initialize the console before we print anything out.
 	 */
 	cninit();
 
 #ifdef DEV_ISA
 #ifdef DEV_ATPIC
 	elcr_probe();
 	atpic_startup();
 #else
 	/* Reset and mask the atpics and leave them shut down. */
 	atpic_reset();
 
 	/*
 	 * Point the ICU spurious interrupt vectors at the APIC spurious
 	 * interrupt handler.
 	 */
 	setidt(IDT_IO_INTS + 7, IDTVEC(spuriousint), SDT_SYSIGT, SEL_KPL, 0);
 	setidt(IDT_IO_INTS + 15, IDTVEC(spuriousint), SDT_SYSIGT, SEL_KPL, 0);
 #endif
 #else
 #error "have you forgotten the isa device?";
 #endif
 
 	kdb_init();
 
 #ifdef KDB
 	if (boothowto & RB_KDB)
 		kdb_enter(KDB_WHY_BOOTFLAGS,
 		    "Boot flags requested debugger");
 #endif
 
 	identify_cpu();		/* Final stage of CPU initialization */
 	initializecpu();	/* Initialize CPU registers */
 	initializecpucache();
 
 	/* doublefault stack space, runs on ist1 */
 	common_tss[0].tss_ist1 = (long)&dblfault_stack[sizeof(dblfault_stack)];
 
 	/*
 	 * NMI stack, runs on ist2.  The pcpu pointer is stored just
 	 * above the start of the ist2 stack.
 	 */
 	np = ((struct nmi_pcpu *) &nmi0_stack[sizeof(nmi0_stack)]) - 1;
 	np->np_pcpu = (register_t) pc;
 	common_tss[0].tss_ist2 = (long) np;
 
 	/* Set the IO permission bitmap (empty due to tss seg limit) */
 	common_tss[0].tss_iobase = sizeof(struct amd64tss) + IOPERM_BITMAP_SIZE;
 
 	gsel_tss = GSEL(GPROC0_SEL, SEL_KPL);
 	ltr(gsel_tss);
 
 	/* Set up the fast syscall stuff */
 	msr = rdmsr(MSR_EFER) | EFER_SCE;
 	wrmsr(MSR_EFER, msr);
 	wrmsr(MSR_LSTAR, (u_int64_t)IDTVEC(fast_syscall));
 	wrmsr(MSR_CSTAR, (u_int64_t)IDTVEC(fast_syscall32));
 	msr = ((u_int64_t)GSEL(GCODE_SEL, SEL_KPL) << 32) |
 	      ((u_int64_t)GSEL(GUCODE32_SEL, SEL_UPL) << 48);
 	wrmsr(MSR_STAR, msr);
 	wrmsr(MSR_SF_MASK, PSL_NT|PSL_T|PSL_I|PSL_C|PSL_D);
 
 	getmemsize(kmdp, physfree);
 	init_param2(physmem);
 
 	/* now running on new page tables, configured,and u/iom is accessible */
 
 	msgbufinit(msgbufp, msgbufsize);
 	fpuinit();
 
 	/*
 	 * Set up thread0 pcb after fpuinit calculated pcb + fpu save
 	 * area size.  Zero out the extended state header in fpu save
 	 * area.
 	 */
 	thread0.td_pcb = get_pcb_td(&thread0);
 	bzero(get_pcb_user_save_td(&thread0), cpu_max_ext_state_size);
 	if (use_xsave) {
 		xhdr = (struct xstate_hdr *)(get_pcb_user_save_td(&thread0) +
 		    1);
 		xhdr->xstate_bv = xsave_mask;
 	}
 	/* make an initial tss so cpu can get interrupt stack on syscall! */
 	common_tss[0].tss_rsp0 = (vm_offset_t)thread0.td_pcb;
 	/* Ensure the stack is aligned to 16 bytes */
 	common_tss[0].tss_rsp0 &= ~0xFul;
 	PCPU_SET(rsp0, common_tss[0].tss_rsp0);
 	PCPU_SET(curpcb, thread0.td_pcb);
 
 	/* transfer to user mode */
 
 	_ucodesel = GSEL(GUCODE_SEL, SEL_UPL);
 	_udatasel = GSEL(GUDATA_SEL, SEL_UPL);
 	_ucode32sel = GSEL(GUCODE32_SEL, SEL_UPL);
 	_ufssel = GSEL(GUFS32_SEL, SEL_UPL);
 	_ugssel = GSEL(GUGS32_SEL, SEL_UPL);
 
 	load_ds(_udatasel);
 	load_es(_udatasel);
 	load_fs(_ufssel);
 
 	/* setup proc 0's pcb */
 	thread0.td_pcb->pcb_flags = 0;
 	thread0.td_pcb->pcb_cr3 = KPML4phys; /* PCID 0 is reserved for kernel */
 	thread0.td_frame = &proc0_tf;
 
         env = kern_getenv("kernelname");
 	if (env != NULL)
 		strlcpy(kernelname, env, sizeof(kernelname));
 
 	cpu_probe_amdc1e();
 
 #ifdef FDT
 	x86_init_fdt();
 #endif
 
 	/* Location of kernel stack for locore */
 	return ((u_int64_t)thread0.td_pcb);
 }
 
 void
 cpu_pcpu_init(struct pcpu *pcpu, int cpuid, size_t size)
 {
 
 	pcpu->pc_acpi_id = 0xffffffff;
 }
 
 static int
 smap_sysctl_handler(SYSCTL_HANDLER_ARGS)
 {
 	struct bios_smap *smapbase;
 	struct bios_smap_xattr smap;
 	caddr_t kmdp;
 	uint32_t *smapattr;
 	int count, error, i;
 
 	/* Retrieve the system memory map from the loader. */
 	kmdp = preload_search_by_type("elf kernel");
 	if (kmdp == NULL)
 		kmdp = preload_search_by_type("elf64 kernel");
 	smapbase = (struct bios_smap *)preload_search_info(kmdp,
 	    MODINFO_METADATA | MODINFOMD_SMAP);
 	if (smapbase == NULL)
 		return (0);
 	smapattr = (uint32_t *)preload_search_info(kmdp,
 	    MODINFO_METADATA | MODINFOMD_SMAP_XATTR);
 	count = *((uint32_t *)smapbase - 1) / sizeof(*smapbase);
 	error = 0;
 	for (i = 0; i < count; i++) {
 		smap.base = smapbase[i].base;
 		smap.length = smapbase[i].length;
 		smap.type = smapbase[i].type;
 		if (smapattr != NULL)
 			smap.xattr = smapattr[i];
 		else
 			smap.xattr = 0;
 		error = SYSCTL_OUT(req, &smap, sizeof(smap));
 	}
 	return (error);
 }
 SYSCTL_PROC(_machdep, OID_AUTO, smap, CTLTYPE_OPAQUE|CTLFLAG_RD, NULL, 0,
     smap_sysctl_handler, "S,bios_smap_xattr", "Raw BIOS SMAP data");
 
 static int
 efi_map_sysctl_handler(SYSCTL_HANDLER_ARGS)
 {
 	struct efi_map_header *efihdr;
 	caddr_t kmdp;
 	uint32_t efisize;
 
 	kmdp = preload_search_by_type("elf kernel");
 	if (kmdp == NULL)
 		kmdp = preload_search_by_type("elf64 kernel");
 	efihdr = (struct efi_map_header *)preload_search_info(kmdp,
 	    MODINFO_METADATA | MODINFOMD_EFI_MAP);
 	if (efihdr == NULL)
 		return (0);
 	efisize = *((uint32_t *)efihdr - 1);
 	return (SYSCTL_OUT(req, efihdr, efisize));
 }
 SYSCTL_PROC(_machdep, OID_AUTO, efi_map, CTLTYPE_OPAQUE|CTLFLAG_RD, NULL, 0,
     efi_map_sysctl_handler, "S,efi_map_header", "Raw EFI Memory Map");
 
 void
 spinlock_enter(void)
 {
 	struct thread *td;
 	register_t flags;
 
 	td = curthread;
 	if (td->td_md.md_spinlock_count == 0) {
 		flags = intr_disable();
 		td->td_md.md_spinlock_count = 1;
 		td->td_md.md_saved_flags = flags;
 	} else
 		td->td_md.md_spinlock_count++;
 	critical_enter();
 }
 
 void
 spinlock_exit(void)
 {
 	struct thread *td;
 	register_t flags;
 
 	td = curthread;
 	critical_exit();
 	flags = td->td_md.md_saved_flags;
 	td->td_md.md_spinlock_count--;
 	if (td->td_md.md_spinlock_count == 0)
 		intr_restore(flags);
 }
 
 /*
  * Construct a PCB from a trapframe. This is called from kdb_trap() where
  * we want to start a backtrace from the function that caused us to enter
  * the debugger. We have the context in the trapframe, but base the trace
  * on the PCB. The PCB doesn't have to be perfect, as long as it contains
  * enough for a backtrace.
  */
 void
 makectx(struct trapframe *tf, struct pcb *pcb)
 {
 
 	pcb->pcb_r12 = tf->tf_r12;
 	pcb->pcb_r13 = tf->tf_r13;
 	pcb->pcb_r14 = tf->tf_r14;
 	pcb->pcb_r15 = tf->tf_r15;
 	pcb->pcb_rbp = tf->tf_rbp;
 	pcb->pcb_rbx = tf->tf_rbx;
 	pcb->pcb_rip = tf->tf_rip;
 	pcb->pcb_rsp = tf->tf_rsp;
 }
 
 int
 ptrace_set_pc(struct thread *td, unsigned long addr)
 {
 
 	td->td_frame->tf_rip = addr;
 	set_pcb_flags(td->td_pcb, PCB_FULL_IRET);
 	return (0);
 }
 
 int
 ptrace_single_step(struct thread *td)
 {
 	td->td_frame->tf_rflags |= PSL_T;
 	return (0);
 }
 
 int
 ptrace_clear_single_step(struct thread *td)
 {
 	td->td_frame->tf_rflags &= ~PSL_T;
 	return (0);
 }
 
 int
 fill_regs(struct thread *td, struct reg *regs)
 {
 	struct trapframe *tp;
 
 	tp = td->td_frame;
 	return (fill_frame_regs(tp, regs));
 }
 
 int
 fill_frame_regs(struct trapframe *tp, struct reg *regs)
 {
 	regs->r_r15 = tp->tf_r15;
 	regs->r_r14 = tp->tf_r14;
 	regs->r_r13 = tp->tf_r13;
 	regs->r_r12 = tp->tf_r12;
 	regs->r_r11 = tp->tf_r11;
 	regs->r_r10 = tp->tf_r10;
 	regs->r_r9  = tp->tf_r9;
 	regs->r_r8  = tp->tf_r8;
 	regs->r_rdi = tp->tf_rdi;
 	regs->r_rsi = tp->tf_rsi;
 	regs->r_rbp = tp->tf_rbp;
 	regs->r_rbx = tp->tf_rbx;
 	regs->r_rdx = tp->tf_rdx;
 	regs->r_rcx = tp->tf_rcx;
 	regs->r_rax = tp->tf_rax;
 	regs->r_rip = tp->tf_rip;
 	regs->r_cs = tp->tf_cs;
 	regs->r_rflags = tp->tf_rflags;
 	regs->r_rsp = tp->tf_rsp;
 	regs->r_ss = tp->tf_ss;
 	if (tp->tf_flags & TF_HASSEGS) {
 		regs->r_ds = tp->tf_ds;
 		regs->r_es = tp->tf_es;
 		regs->r_fs = tp->tf_fs;
 		regs->r_gs = tp->tf_gs;
 	} else {
 		regs->r_ds = 0;
 		regs->r_es = 0;
 		regs->r_fs = 0;
 		regs->r_gs = 0;
 	}
 	return (0);
 }
 
 int
 set_regs(struct thread *td, struct reg *regs)
 {
 	struct trapframe *tp;
 	register_t rflags;
 
 	tp = td->td_frame;
 	rflags = regs->r_rflags & 0xffffffff;
 	if (!EFL_SECURE(rflags, tp->tf_rflags) || !CS_SECURE(regs->r_cs))
 		return (EINVAL);
 	tp->tf_r15 = regs->r_r15;
 	tp->tf_r14 = regs->r_r14;
 	tp->tf_r13 = regs->r_r13;
 	tp->tf_r12 = regs->r_r12;
 	tp->tf_r11 = regs->r_r11;
 	tp->tf_r10 = regs->r_r10;
 	tp->tf_r9  = regs->r_r9;
 	tp->tf_r8  = regs->r_r8;
 	tp->tf_rdi = regs->r_rdi;
 	tp->tf_rsi = regs->r_rsi;
 	tp->tf_rbp = regs->r_rbp;
 	tp->tf_rbx = regs->r_rbx;
 	tp->tf_rdx = regs->r_rdx;
 	tp->tf_rcx = regs->r_rcx;
 	tp->tf_rax = regs->r_rax;
 	tp->tf_rip = regs->r_rip;
 	tp->tf_cs = regs->r_cs;
 	tp->tf_rflags = rflags;
 	tp->tf_rsp = regs->r_rsp;
 	tp->tf_ss = regs->r_ss;
 	if (0) {	/* XXXKIB */
 		tp->tf_ds = regs->r_ds;
 		tp->tf_es = regs->r_es;
 		tp->tf_fs = regs->r_fs;
 		tp->tf_gs = regs->r_gs;
 		tp->tf_flags = TF_HASSEGS;
 	}
 	set_pcb_flags(td->td_pcb, PCB_FULL_IRET);
 	return (0);
 }
 
 /* XXX check all this stuff! */
 /* externalize from sv_xmm */
 static void
 fill_fpregs_xmm(struct savefpu *sv_xmm, struct fpreg *fpregs)
 {
 	struct envxmm *penv_fpreg = (struct envxmm *)&fpregs->fpr_env;
 	struct envxmm *penv_xmm = &sv_xmm->sv_env;
 	int i;
 
 	/* pcb -> fpregs */
 	bzero(fpregs, sizeof(*fpregs));
 
 	/* FPU control/status */
 	penv_fpreg->en_cw = penv_xmm->en_cw;
 	penv_fpreg->en_sw = penv_xmm->en_sw;
 	penv_fpreg->en_tw = penv_xmm->en_tw;
 	penv_fpreg->en_opcode = penv_xmm->en_opcode;
 	penv_fpreg->en_rip = penv_xmm->en_rip;
 	penv_fpreg->en_rdp = penv_xmm->en_rdp;
 	penv_fpreg->en_mxcsr = penv_xmm->en_mxcsr;
 	penv_fpreg->en_mxcsr_mask = penv_xmm->en_mxcsr_mask;
 
 	/* FPU registers */
 	for (i = 0; i < 8; ++i)
 		bcopy(sv_xmm->sv_fp[i].fp_acc.fp_bytes, fpregs->fpr_acc[i], 10);
 
 	/* SSE registers */
 	for (i = 0; i < 16; ++i)
 		bcopy(sv_xmm->sv_xmm[i].xmm_bytes, fpregs->fpr_xacc[i], 16);
 }
 
 /* internalize from fpregs into sv_xmm */
 static void
 set_fpregs_xmm(struct fpreg *fpregs, struct savefpu *sv_xmm)
 {
 	struct envxmm *penv_xmm = &sv_xmm->sv_env;
 	struct envxmm *penv_fpreg = (struct envxmm *)&fpregs->fpr_env;
 	int i;
 
 	/* fpregs -> pcb */
 	/* FPU control/status */
 	penv_xmm->en_cw = penv_fpreg->en_cw;
 	penv_xmm->en_sw = penv_fpreg->en_sw;
 	penv_xmm->en_tw = penv_fpreg->en_tw;
 	penv_xmm->en_opcode = penv_fpreg->en_opcode;
 	penv_xmm->en_rip = penv_fpreg->en_rip;
 	penv_xmm->en_rdp = penv_fpreg->en_rdp;
 	penv_xmm->en_mxcsr = penv_fpreg->en_mxcsr;
 	penv_xmm->en_mxcsr_mask = penv_fpreg->en_mxcsr_mask & cpu_mxcsr_mask;
 
 	/* FPU registers */
 	for (i = 0; i < 8; ++i)
 		bcopy(fpregs->fpr_acc[i], sv_xmm->sv_fp[i].fp_acc.fp_bytes, 10);
 
 	/* SSE registers */
 	for (i = 0; i < 16; ++i)
 		bcopy(fpregs->fpr_xacc[i], sv_xmm->sv_xmm[i].xmm_bytes, 16);
 }
 
 /* externalize from td->pcb */
 int
 fill_fpregs(struct thread *td, struct fpreg *fpregs)
 {
 
 	KASSERT(td == curthread || TD_IS_SUSPENDED(td) ||
 	    P_SHOULDSTOP(td->td_proc),
 	    ("not suspended thread %p", td));
 	fpugetregs(td);
 	fill_fpregs_xmm(get_pcb_user_save_td(td), fpregs);
 	return (0);
 }
 
 /* internalize to td->pcb */
 int
 set_fpregs(struct thread *td, struct fpreg *fpregs)
 {
 
 	set_fpregs_xmm(fpregs, get_pcb_user_save_td(td));
 	fpuuserinited(td);
 	return (0);
 }
 
 /*
  * Get machine context.
  */
 int
 get_mcontext(struct thread *td, mcontext_t *mcp, int flags)
 {
 	struct pcb *pcb;
 	struct trapframe *tp;
 
 	pcb = td->td_pcb;
 	tp = td->td_frame;
 	PROC_LOCK(curthread->td_proc);
 	mcp->mc_onstack = sigonstack(tp->tf_rsp);
 	PROC_UNLOCK(curthread->td_proc);
 	mcp->mc_r15 = tp->tf_r15;
 	mcp->mc_r14 = tp->tf_r14;
 	mcp->mc_r13 = tp->tf_r13;
 	mcp->mc_r12 = tp->tf_r12;
 	mcp->mc_r11 = tp->tf_r11;
 	mcp->mc_r10 = tp->tf_r10;
 	mcp->mc_r9  = tp->tf_r9;
 	mcp->mc_r8  = tp->tf_r8;
 	mcp->mc_rdi = tp->tf_rdi;
 	mcp->mc_rsi = tp->tf_rsi;
 	mcp->mc_rbp = tp->tf_rbp;
 	mcp->mc_rbx = tp->tf_rbx;
 	mcp->mc_rcx = tp->tf_rcx;
 	mcp->mc_rflags = tp->tf_rflags;
 	if (flags & GET_MC_CLEAR_RET) {
 		mcp->mc_rax = 0;
 		mcp->mc_rdx = 0;
 		mcp->mc_rflags &= ~PSL_C;
 	} else {
 		mcp->mc_rax = tp->tf_rax;
 		mcp->mc_rdx = tp->tf_rdx;
 	}
 	mcp->mc_rip = tp->tf_rip;
 	mcp->mc_cs = tp->tf_cs;
 	mcp->mc_rsp = tp->tf_rsp;
 	mcp->mc_ss = tp->tf_ss;
 	mcp->mc_ds = tp->tf_ds;
 	mcp->mc_es = tp->tf_es;
 	mcp->mc_fs = tp->tf_fs;
 	mcp->mc_gs = tp->tf_gs;
 	mcp->mc_flags = tp->tf_flags;
 	mcp->mc_len = sizeof(*mcp);
 	get_fpcontext(td, mcp, NULL, 0);
 	mcp->mc_fsbase = pcb->pcb_fsbase;
 	mcp->mc_gsbase = pcb->pcb_gsbase;
 	mcp->mc_xfpustate = 0;
 	mcp->mc_xfpustate_len = 0;
 	bzero(mcp->mc_spare, sizeof(mcp->mc_spare));
 	return (0);
 }
 
 /*
  * Set machine context.
  *
  * However, we don't set any but the user modifiable flags, and we won't
  * touch the cs selector.
  */
 int
 set_mcontext(struct thread *td, const mcontext_t *mcp)
 {
 	struct pcb *pcb;
 	struct trapframe *tp;
 	char *xfpustate;
 	long rflags;
 	int ret;
 
 	pcb = td->td_pcb;
 	tp = td->td_frame;
 	if (mcp->mc_len != sizeof(*mcp) ||
 	    (mcp->mc_flags & ~_MC_FLAG_MASK) != 0)
 		return (EINVAL);
 	rflags = (mcp->mc_rflags & PSL_USERCHANGE) |
 	    (tp->tf_rflags & ~PSL_USERCHANGE);
 	if (mcp->mc_flags & _MC_HASFPXSTATE) {
 		if (mcp->mc_xfpustate_len > cpu_max_ext_state_size -
 		    sizeof(struct savefpu))
 			return (EINVAL);
 		xfpustate = __builtin_alloca(mcp->mc_xfpustate_len);
 		ret = copyin((void *)mcp->mc_xfpustate, xfpustate,
 		    mcp->mc_xfpustate_len);
 		if (ret != 0)
 			return (ret);
 	} else
 		xfpustate = NULL;
 	ret = set_fpcontext(td, mcp, xfpustate, mcp->mc_xfpustate_len);
 	if (ret != 0)
 		return (ret);
 	tp->tf_r15 = mcp->mc_r15;
 	tp->tf_r14 = mcp->mc_r14;
 	tp->tf_r13 = mcp->mc_r13;
 	tp->tf_r12 = mcp->mc_r12;
 	tp->tf_r11 = mcp->mc_r11;
 	tp->tf_r10 = mcp->mc_r10;
 	tp->tf_r9  = mcp->mc_r9;
 	tp->tf_r8  = mcp->mc_r8;
 	tp->tf_rdi = mcp->mc_rdi;
 	tp->tf_rsi = mcp->mc_rsi;
 	tp->tf_rbp = mcp->mc_rbp;
 	tp->tf_rbx = mcp->mc_rbx;
 	tp->tf_rdx = mcp->mc_rdx;
 	tp->tf_rcx = mcp->mc_rcx;
 	tp->tf_rax = mcp->mc_rax;
 	tp->tf_rip = mcp->mc_rip;
 	tp->tf_rflags = rflags;
 	tp->tf_rsp = mcp->mc_rsp;
 	tp->tf_ss = mcp->mc_ss;
 	tp->tf_flags = mcp->mc_flags;
 	if (tp->tf_flags & TF_HASSEGS) {
 		tp->tf_ds = mcp->mc_ds;
 		tp->tf_es = mcp->mc_es;
 		tp->tf_fs = mcp->mc_fs;
 		tp->tf_gs = mcp->mc_gs;
 	}
 	if (mcp->mc_flags & _MC_HASBASES) {
 		pcb->pcb_fsbase = mcp->mc_fsbase;
 		pcb->pcb_gsbase = mcp->mc_gsbase;
 	}
 	set_pcb_flags(pcb, PCB_FULL_IRET);
 	return (0);
 }
 
 static void
 get_fpcontext(struct thread *td, mcontext_t *mcp, char *xfpusave,
     size_t xfpusave_len)
 {
 	size_t max_len, len;
 
 	mcp->mc_ownedfp = fpugetregs(td);
 	bcopy(get_pcb_user_save_td(td), &mcp->mc_fpstate[0],
 	    sizeof(mcp->mc_fpstate));
 	mcp->mc_fpformat = fpuformat();
 	if (!use_xsave || xfpusave_len == 0)
 		return;
 	max_len = cpu_max_ext_state_size - sizeof(struct savefpu);
 	len = xfpusave_len;
 	if (len > max_len) {
 		len = max_len;
 		bzero(xfpusave + max_len, len - max_len);
 	}
 	mcp->mc_flags |= _MC_HASFPXSTATE;
 	mcp->mc_xfpustate_len = len;
 	bcopy(get_pcb_user_save_td(td) + 1, xfpusave, len);
 }
 
 static int
 set_fpcontext(struct thread *td, const mcontext_t *mcp, char *xfpustate,
     size_t xfpustate_len)
 {
 	struct savefpu *fpstate;
 	int error;
 
 	if (mcp->mc_fpformat == _MC_FPFMT_NODEV)
 		return (0);
 	else if (mcp->mc_fpformat != _MC_FPFMT_XMM)
 		return (EINVAL);
 	else if (mcp->mc_ownedfp == _MC_FPOWNED_NONE) {
 		/* We don't care what state is left in the FPU or PCB. */
 		fpstate_drop(td);
 		error = 0;
 	} else if (mcp->mc_ownedfp == _MC_FPOWNED_FPU ||
 	    mcp->mc_ownedfp == _MC_FPOWNED_PCB) {
 		fpstate = (struct savefpu *)&mcp->mc_fpstate;
 		fpstate->sv_env.en_mxcsr &= cpu_mxcsr_mask;
 		error = fpusetregs(td, fpstate, xfpustate, xfpustate_len);
 	} else
 		return (EINVAL);
 	return (error);
 }
 
 void
 fpstate_drop(struct thread *td)
 {
 
 	KASSERT(PCB_USER_FPU(td->td_pcb), ("fpstate_drop: kernel-owned fpu"));
 	critical_enter();
 	if (PCPU_GET(fpcurthread) == td)
 		fpudrop();
 	/*
 	 * XXX force a full drop of the fpu.  The above only drops it if we
 	 * owned it.
 	 *
 	 * XXX I don't much like fpugetuserregs()'s semantics of doing a full
 	 * drop.  Dropping only to the pcb matches fnsave's behaviour.
 	 * We only need to drop to !PCB_INITDONE in sendsig().  But
 	 * sendsig() is the only caller of fpugetuserregs()... perhaps we just
 	 * have too many layers.
 	 */
 	clear_pcb_flags(curthread->td_pcb,
 	    PCB_FPUINITDONE | PCB_USERFPUINITDONE);
 	critical_exit();
 }
 
 int
 fill_dbregs(struct thread *td, struct dbreg *dbregs)
 {
 	struct pcb *pcb;
 
 	if (td == NULL) {
 		dbregs->dr[0] = rdr0();
 		dbregs->dr[1] = rdr1();
 		dbregs->dr[2] = rdr2();
 		dbregs->dr[3] = rdr3();
 		dbregs->dr[6] = rdr6();
 		dbregs->dr[7] = rdr7();
 	} else {
 		pcb = td->td_pcb;
 		dbregs->dr[0] = pcb->pcb_dr0;
 		dbregs->dr[1] = pcb->pcb_dr1;
 		dbregs->dr[2] = pcb->pcb_dr2;
 		dbregs->dr[3] = pcb->pcb_dr3;
 		dbregs->dr[6] = pcb->pcb_dr6;
 		dbregs->dr[7] = pcb->pcb_dr7;
 	}
 	dbregs->dr[4] = 0;
 	dbregs->dr[5] = 0;
 	dbregs->dr[8] = 0;
 	dbregs->dr[9] = 0;
 	dbregs->dr[10] = 0;
 	dbregs->dr[11] = 0;
 	dbregs->dr[12] = 0;
 	dbregs->dr[13] = 0;
 	dbregs->dr[14] = 0;
 	dbregs->dr[15] = 0;
 	return (0);
 }
 
 int
 set_dbregs(struct thread *td, struct dbreg *dbregs)
 {
 	struct pcb *pcb;
 	int i;
 
 	if (td == NULL) {
 		load_dr0(dbregs->dr[0]);
 		load_dr1(dbregs->dr[1]);
 		load_dr2(dbregs->dr[2]);
 		load_dr3(dbregs->dr[3]);
 		load_dr6(dbregs->dr[6]);
 		load_dr7(dbregs->dr[7]);
 	} else {
 		/*
 		 * Don't let an illegal value for dr7 get set.  Specifically,
 		 * check for undefined settings.  Setting these bit patterns
 		 * result in undefined behaviour and can lead to an unexpected
 		 * TRCTRAP or a general protection fault right here.
 		 * Upper bits of dr6 and dr7 must not be set
 		 */
 		for (i = 0; i < 4; i++) {
 			if (DBREG_DR7_ACCESS(dbregs->dr[7], i) == 0x02)
 				return (EINVAL);
 			if (td->td_frame->tf_cs == _ucode32sel &&
 			    DBREG_DR7_LEN(dbregs->dr[7], i) == DBREG_DR7_LEN_8)
 				return (EINVAL);
 		}
 		if ((dbregs->dr[6] & 0xffffffff00000000ul) != 0 ||
 		    (dbregs->dr[7] & 0xffffffff00000000ul) != 0)
 			return (EINVAL);
 
 		pcb = td->td_pcb;
 
 		/*
 		 * Don't let a process set a breakpoint that is not within the
 		 * process's address space.  If a process could do this, it
 		 * could halt the system by setting a breakpoint in the kernel
 		 * (if ddb was enabled).  Thus, we need to check to make sure
 		 * that no breakpoints are being enabled for addresses outside
 		 * process's address space.
 		 *
 		 * XXX - what about when the watched area of the user's
 		 * address space is written into from within the kernel
 		 * ... wouldn't that still cause a breakpoint to be generated
 		 * from within kernel mode?
 		 */
 
 		if (DBREG_DR7_ENABLED(dbregs->dr[7], 0)) {
 			/* dr0 is enabled */
 			if (dbregs->dr[0] >= VM_MAXUSER_ADDRESS)
 				return (EINVAL);
 		}
 		if (DBREG_DR7_ENABLED(dbregs->dr[7], 1)) {
 			/* dr1 is enabled */
 			if (dbregs->dr[1] >= VM_MAXUSER_ADDRESS)
 				return (EINVAL);
 		}
 		if (DBREG_DR7_ENABLED(dbregs->dr[7], 2)) {
 			/* dr2 is enabled */
 			if (dbregs->dr[2] >= VM_MAXUSER_ADDRESS)
 				return (EINVAL);
 		}
 		if (DBREG_DR7_ENABLED(dbregs->dr[7], 3)) {
 			/* dr3 is enabled */
 			if (dbregs->dr[3] >= VM_MAXUSER_ADDRESS)
 				return (EINVAL);
 		}
 
 		pcb->pcb_dr0 = dbregs->dr[0];
 		pcb->pcb_dr1 = dbregs->dr[1];
 		pcb->pcb_dr2 = dbregs->dr[2];
 		pcb->pcb_dr3 = dbregs->dr[3];
 		pcb->pcb_dr6 = dbregs->dr[6];
 		pcb->pcb_dr7 = dbregs->dr[7];
 
 		set_pcb_flags(pcb, PCB_DBREGS);
 	}
 
 	return (0);
 }
 
 void
 reset_dbregs(void)
 {
 
 	load_dr7(0);	/* Turn off the control bits first */
 	load_dr0(0);
 	load_dr1(0);
 	load_dr2(0);
 	load_dr3(0);
 	load_dr6(0);
 }
 
 /*
  * Return > 0 if a hardware breakpoint has been hit, and the
  * breakpoint was in user space.  Return 0, otherwise.
  */
 int
 user_dbreg_trap(void)
 {
         u_int64_t dr7, dr6; /* debug registers dr6 and dr7 */
         u_int64_t bp;       /* breakpoint bits extracted from dr6 */
         int nbp;            /* number of breakpoints that triggered */
         caddr_t addr[4];    /* breakpoint addresses */
         int i;
         
         dr7 = rdr7();
         if ((dr7 & 0x000000ff) == 0) {
                 /*
                  * all GE and LE bits in the dr7 register are zero,
                  * thus the trap couldn't have been caused by the
                  * hardware debug registers
                  */
                 return 0;
         }
 
         nbp = 0;
         dr6 = rdr6();
         bp = dr6 & 0x0000000f;
 
         if (!bp) {
                 /*
                  * None of the breakpoint bits are set meaning this
                  * trap was not caused by any of the debug registers
                  */
                 return 0;
         }
 
         /*
          * at least one of the breakpoints were hit, check to see
          * which ones and if any of them are user space addresses
          */
 
         if (bp & 0x01) {
                 addr[nbp++] = (caddr_t)rdr0();
         }
         if (bp & 0x02) {
                 addr[nbp++] = (caddr_t)rdr1();
         }
         if (bp & 0x04) {
                 addr[nbp++] = (caddr_t)rdr2();
         }
         if (bp & 0x08) {
                 addr[nbp++] = (caddr_t)rdr3();
         }
 
         for (i = 0; i < nbp; i++) {
                 if (addr[i] < (caddr_t)VM_MAXUSER_ADDRESS) {
                         /*
                          * addr[i] is in user space
                          */
                         return nbp;
                 }
         }
 
         /*
          * None of the breakpoints are in user space.
          */
         return 0;
 }
 
 #ifdef KDB
 
 /*
  * Provide inb() and outb() as functions.  They are normally only available as
  * inline functions, thus cannot be called from the debugger.
  */
 
 /* silence compiler warnings */
 u_char inb_(u_short);
 void outb_(u_short, u_char);
 
 u_char
 inb_(u_short port)
 {
 	return inb(port);
 }
 
 void
 outb_(u_short port, u_char data)
 {
 	outb(port, data);
 }
 
 #endif /* KDB */
Index: projects/clang360-import/sys/arm/arm/mem.c
===================================================================
--- projects/clang360-import/sys/arm/arm/mem.c	(revision 277777)
+++ projects/clang360-import/sys/arm/arm/mem.c	(revision 277778)
@@ -1,161 +1,167 @@
 /*-
  * Copyright (c) 1988 University of Utah.
  * Copyright (c) 1982, 1986, 1990 The Regents of the University of California.
  * All rights reserved.
  *
  * This code is derived from software contributed to Berkeley by
  * the Systems Programming Group of the University of Utah Computer
  * Science Department, and code derived from software contributed to
  * Berkeley by William Jolitz.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
  *	from: Utah $Hdr: mem.c 1.13 89/10/08$
  *	from: @(#)mem.c	7.2 (Berkeley) 5/9/91
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 /*
  * Memory special file
  */
 
 #include <sys/param.h>
 #include <sys/conf.h>
 #include <sys/fcntl.h>
 #include <sys/ioccom.h>
 #include <sys/kernel.h>
 #include <sys/lock.h>
 #include <sys/malloc.h>
 #include <sys/memrange.h>
 #include <sys/module.h>
 #include <sys/mutex.h>
 #include <sys/proc.h>
 #include <sys/signalvar.h>
+#include <sys/sx.h>
 #include <sys/systm.h>
 #include <sys/uio.h>
 
 #include <vm/vm.h>
 #include <vm/pmap.h>
 #include <vm/vm_extern.h>
 
 #include <machine/memdev.h>
 #include <machine/vmparam.h>
 
 /*
  * Used in /dev/mem drivers and elsewhere
  */
 MALLOC_DEFINE(M_MEMDESC, "memdesc", "memory range descriptors");
 
 struct mem_range_softc mem_range_softc;
 
+static struct sx tmppt_lock;
+SX_SYSINIT(tmppt, &tmppt_lock, "mem4map");
+
 /* ARGSUSED */
 int
 memrw(struct cdev *dev, struct uio *uio, int flags)
 {
 	int o;
 	u_int c = 0, v;
 	struct iovec *iov;
 	int error = 0;
 	vm_offset_t addr, eaddr;
 
 	while (uio->uio_resid > 0 && error == 0) {
 		iov = uio->uio_iov;
 		if (iov->iov_len == 0) {
 			uio->uio_iov++;
 			uio->uio_iovcnt--;
 			if (uio->uio_iovcnt < 0)
 				panic("memrw");
 			continue;
 		}
 		if (dev2unit(dev) == CDEV_MINOR_MEM) {
 			int i;
 			int address_valid = 0;
 
 			v = uio->uio_offset;
 			v &= ~PAGE_MASK;
 			for (i = 0; dump_avail[i] || dump_avail[i + 1];
 			i += 2) {
 				if (v >= dump_avail[i] &&
 				    v < dump_avail[i + 1]) {
 					address_valid = 1;
 					break;
 				}
 			}
 			if (!address_valid)
 				return (EINVAL);
+			sx_xlock(&tmppt_lock);
 			pmap_kenter((vm_offset_t)_tmppt, v);
 			o = (int)uio->uio_offset & PAGE_MASK;
 			c = (u_int)(PAGE_SIZE - ((int)iov->iov_base & PAGE_MASK));
 			c = min(c, (u_int)(PAGE_SIZE - o));
 			c = min(c, (u_int)iov->iov_len);
 			error = uiomove((caddr_t)&_tmppt[o], (int)c, uio);
 			pmap_qremove((vm_offset_t)_tmppt, 1);
+			sx_xunlock(&tmppt_lock);
 			continue;
 		}
 		else if (dev2unit(dev) == CDEV_MINOR_KMEM) {
 			c = iov->iov_len;
 
 			/*
 			 * Make sure that all of the pages are currently
 			 * resident so that we don't create any zero-fill
 			 * pages.
 			 */
 			addr = trunc_page(uio->uio_offset);
 			eaddr = round_page(uio->uio_offset + c);
 
 			for (; addr < eaddr; addr += PAGE_SIZE)
 				if (pmap_extract(kernel_pmap, addr) == 0)
 					return (EFAULT);
 			if (!kernacc((caddr_t)(int)uio->uio_offset, c,
 			    uio->uio_rw == UIO_READ ?
 			    VM_PROT_READ : VM_PROT_WRITE))
 					return (EFAULT);
 			error = uiomove((caddr_t)(int)uio->uio_offset, (int)c, uio);
 			continue;
 		}
 		/* else panic! */
 	}
 	return (error);
 }
 
 /*
  * allow user processes to MMAP some memory sections
  * instead of going through read/write
  */
 /* ARGSUSED */
 
 int
 memmmap(struct cdev *dev, vm_ooffset_t offset, vm_paddr_t *paddr,
     int prot __unused, vm_memattr_t *memattr __unused)
 {
 	if (dev2unit(dev) == CDEV_MINOR_MEM)
 		*paddr = offset;
 	else if (dev2unit(dev) == CDEV_MINOR_KMEM)
         	*paddr = vtophys(offset);
 	/* else panic! */
 	return (0);
 }
Index: projects/clang360-import/sys/arm/arm/pmu.c
===================================================================
--- projects/clang360-import/sys/arm/arm/pmu.c	(nonexistent)
+++ projects/clang360-import/sys/arm/arm/pmu.c	(revision 277778)
@@ -0,0 +1,157 @@
+/*-
+ * Copyright (c) 2015 Ruslan Bukin <br@bsdpad.com>
+ * All rights reserved.
+ *
+ * This software was developed by SRI International and the University of
+ * Cambridge Computer Laboratory under DARPA/AFRL contract (FA8750-10-C-0237)
+ * ("CTSRD"), as part of the DARPA CRASH research programme.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Performance Monitoring Unit
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include "opt_hwpmc_hooks.h"
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/bus.h>
+#include <sys/kernel.h>
+#include <sys/module.h>
+#include <sys/malloc.h>
+#include <sys/rman.h>
+#include <sys/timeet.h>
+#include <sys/timetc.h>
+#include <sys/pmc.h>
+#include <sys/pmckern.h>
+
+#include <dev/fdt/fdt_common.h>
+#include <dev/ofw/openfirm.h>
+#include <dev/ofw/ofw_bus.h>
+#include <dev/ofw/ofw_bus_subr.h>
+
+#include <machine/bus.h>
+#include <machine/fdt.h>
+#include <machine/cpu.h>
+#include <machine/intr.h>
+
+struct pmu_softc {
+	struct resource		*res[1];
+	device_t		dev;
+	void			*ih;
+};
+
+static struct ofw_compat_data compat_data[] = {
+	{"arm,cortex-a17-pmu",	1},
+	{"arm,cortex-a15-pmu",	1},
+	{"arm,cortex-a12-pmu",	1},
+	{"arm,cortex-a9-pmu",	1},
+	{"arm,cortex-a8-pmu",	1},
+	{"arm,cortex-a7-pmu",	1},
+	{"arm,cortex-a5-pmu",	1},
+	{"arm,arm11mpcore-pmu",	1},
+	{"arm,arm1176-pmu",	1},
+	{"arm,arm1136-pmu",	1},
+	{"qcom,krait-pmu",	1},
+	{NULL,			0}
+};
+
+static struct resource_spec pmu_spec[] = {
+	{ SYS_RES_IRQ,		0,	RF_ACTIVE },
+	{ -1, 0 }
+};
+
+static int
+pmu_intr(void *arg)
+{
+	struct trapframe *tf;
+
+	tf = arg;
+
+#ifdef HWPMC_HOOKS
+	if (pmc_intr)
+		(*pmc_intr)(PCPU_GET(cpuid), tf);
+#endif
+
+	return (FILTER_HANDLED);
+}
+
+static int
+pmu_probe(device_t dev)
+{
+
+	if (!ofw_bus_status_okay(dev))
+		return (ENXIO);
+
+	if (ofw_bus_search_compatible(dev, compat_data)->ocd_data != 0) {
+		device_set_desc(dev, "Performance Monitoring Unit");
+		return (BUS_PROBE_DEFAULT);
+	}
+
+	return (ENXIO);
+}
+
+static int
+pmu_attach(device_t dev)
+{
+	struct pmu_softc *sc;
+	int err;
+
+	sc = device_get_softc(dev);
+	sc->dev = dev;
+
+	if (bus_alloc_resources(dev, pmu_spec, sc->res)) {
+		device_printf(dev, "could not allocate resources\n");
+		return (ENXIO);
+	}
+
+	/* Setup interrupt handler */
+	err = bus_setup_intr(dev, sc->res[0], INTR_MPSAFE | INTR_TYPE_MISC,
+	    pmu_intr, NULL, NULL, &sc->ih);
+	if (err) {
+		device_printf(dev, "Unable to setup interrupt handler.\n");
+		return (ENXIO);
+	}
+
+	return (0);
+}
+
+static device_method_t pmu_methods[] = {
+	DEVMETHOD(device_probe,		pmu_probe),
+	DEVMETHOD(device_attach,	pmu_attach),
+	{ 0, 0 }
+};
+
+static driver_t pmu_driver = {
+	"pmu",
+	pmu_methods,
+	sizeof(struct pmu_softc),
+};
+
+static devclass_t pmu_devclass;
+
+DRIVER_MODULE(pmu, simplebus, pmu_driver, pmu_devclass, 0, 0);

Property changes on: projects/clang360-import/sys/arm/arm/pmu.c
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+FreeBSD=%H
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Index: projects/clang360-import/sys/arm/ti/ti_i2c.c
===================================================================
--- projects/clang360-import/sys/arm/ti/ti_i2c.c	(revision 277777)
+++ projects/clang360-import/sys/arm/ti/ti_i2c.c	(revision 277778)
@@ -1,945 +1,979 @@
 /*-
  * Copyright (c) 2011 Ben Gray <ben.r.gray@gmail.com>.
  * Copyright (c) 2014 Luiz Otavio O Souza <loos@freebsd.org>.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 /**
  * Driver for the I2C module on the TI SoC.
  *
  * This driver is heavily based on the TWI driver for the AT91 (at91_twi.c).
  *
  * CAUTION: The I2Ci registers are limited to 16 bit and 8 bit data accesses,
  * 32 bit data access is not allowed and can corrupt register content.
  *
  * This driver currently doesn't use DMA for the transfer, although I hope to
  * incorporate that sometime in the future.  The idea being that for transaction
  * larger than a certain size the DMA engine is used, for anything less the
  * normal interrupt/fifo driven option is used.
  *
  *
  * WARNING: This driver uses mtx_sleep and interrupts to perform transactions,
  * which means you can't do a transaction during startup before the interrupts
  * have been enabled.  Hint - the freebsd function config_intrhook_establish().
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/bus.h>
 #include <sys/conf.h>
 #include <sys/kernel.h>
 #include <sys/lock.h>
 #include <sys/mbuf.h>
 #include <sys/malloc.h>
 #include <sys/module.h>
 #include <sys/mutex.h>
 #include <sys/rman.h>
 #include <sys/sysctl.h>
 #include <machine/bus.h>
 
 #include <dev/ofw/openfirm.h>
 #include <dev/ofw/ofw_bus.h>
 #include <dev/ofw/ofw_bus_subr.h>
 
 #include <arm/ti/ti_cpuid.h>
 #include <arm/ti/ti_prcm.h>
 #include <arm/ti/ti_i2c.h>
 
 #include <dev/iicbus/iiconf.h>
 #include <dev/iicbus/iicbus.h>
 
 #include "iicbus_if.h"
 
 /**
  *	I2C device driver context, a pointer to this is stored in the device
  *	driver structure.
  */
 struct ti_i2c_softc
 {
 	device_t		sc_dev;
 	uint32_t		device_id;
 	struct resource*	sc_irq_res;
 	struct resource*	sc_mem_res;
 	device_t		sc_iicbus;
 
 	void*			sc_irq_h;
 
 	struct mtx		sc_mtx;
 
 	struct iic_msg*		sc_buffer;
 	int			sc_bus_inuse;
 	int			sc_buffer_pos;
 	int			sc_error;
 	int			sc_fifo_trsh;
+	int			sc_timeout;
 
 	uint16_t		sc_con_reg;
 	uint16_t		sc_rev;
 };
 
 struct ti_i2c_clock_config
 {
 	u_int   frequency;	/* Bus frequency in Hz */
 	uint8_t psc;		/* Fast/Standard mode prescale divider */
 	uint8_t scll;		/* Fast/Standard mode SCL low time */
 	uint8_t sclh;		/* Fast/Standard mode SCL high time */
 	uint8_t hsscll;		/* High Speed mode SCL low time */
 	uint8_t hssclh;		/* High Speed mode SCL high time */
 };
 
 #if defined(SOC_OMAP4)
 /*
  * OMAP4 i2c bus clock is 96MHz / ((psc + 1) * (scll + 7 + sclh + 5)).
  * The prescaler values for 100KHz and 400KHz modes come from the table in the
  * OMAP4 TRM.  The table doesn't list 1MHz; these values should give that speed.
  */
 static struct ti_i2c_clock_config ti_omap4_i2c_clock_configs[] = {
 	{  100000, 23,  13,  15,  0,  0},
 	{  400000,  9,   5,   7,  0,  0},
 	{ 1000000,  3,   5,   7,  0,  0},
 /*	{ 3200000,  1, 113, 115,  7, 10}, - HS mode */
 	{       0 /* Table terminator */ }
 };
 #endif
 
 #if defined(SOC_TI_AM335X)
 /*
  * AM335x i2c bus clock is 48MHZ / ((psc + 1) * (scll + 7 + sclh + 5))
  * In all cases we prescale the clock to 24MHz as recommended in the manual.
  */
 static struct ti_i2c_clock_config ti_am335x_i2c_clock_configs[] = {
 	{  100000, 1, 111, 117, 0, 0},
 	{  400000, 1,  23,  25, 0, 0},
 	{ 1000000, 1,   5,   7, 0, 0},
 	{       0 /* Table terminator */ }
 };
 #endif
 
 /**
  *	Locking macros used throughout the driver
  */
 #define	TI_I2C_LOCK(_sc)		mtx_lock(&(_sc)->sc_mtx)
 #define	TI_I2C_UNLOCK(_sc)		mtx_unlock(&(_sc)->sc_mtx)
 #define	TI_I2C_LOCK_INIT(_sc)						\
 	mtx_init(&_sc->sc_mtx, device_get_nameunit(_sc->sc_dev),	\
 	    "ti_i2c", MTX_DEF)
 #define	TI_I2C_LOCK_DESTROY(_sc)	mtx_destroy(&_sc->sc_mtx)
 #define	TI_I2C_ASSERT_LOCKED(_sc)	mtx_assert(&_sc->sc_mtx, MA_OWNED)
 #define	TI_I2C_ASSERT_UNLOCKED(_sc)	mtx_assert(&_sc->sc_mtx, MA_NOTOWNED)
 
 #ifdef DEBUG
 #define	ti_i2c_dbg(_sc, fmt, args...)					\
 	device_printf((_sc)->sc_dev, fmt, ##args)
 #else
 #define	ti_i2c_dbg(_sc, fmt, args...)
 #endif
 
 /**
  *	ti_i2c_read_2 - reads a 16-bit value from one of the I2C registers
  *	@sc: I2C device context
  *	@off: the byte offset within the register bank to read from.
  *
  *
  *	LOCKING:
  *	No locking required
  *
  *	RETURNS:
  *	16-bit value read from the register.
  */
 static inline uint16_t
 ti_i2c_read_2(struct ti_i2c_softc *sc, bus_size_t off)
 {
 
 	return (bus_read_2(sc->sc_mem_res, off));
 }
 
 /**
  *	ti_i2c_write_2 - writes a 16-bit value to one of the I2C registers
  *	@sc: I2C device context
  *	@off: the byte offset within the register bank to read from.
  *	@val: the value to write into the register
  *
  *	LOCKING:
  *	No locking required
  *
  *	RETURNS:
  *	16-bit value read from the register.
  */
 static inline void
 ti_i2c_write_2(struct ti_i2c_softc *sc, bus_size_t off, uint16_t val)
 {
 
 	bus_write_2(sc->sc_mem_res, off, val);
 }
 
 static int
 ti_i2c_transfer_intr(struct ti_i2c_softc* sc, uint16_t status)
 {
 	int amount, done, i;
 
 	done = 0;
 	amount = 0;
 	/* Check for the error conditions. */
 	if (status & I2C_STAT_NACK) {
 		/* No ACK from slave. */
 		ti_i2c_dbg(sc, "NACK\n");
 		ti_i2c_write_2(sc, I2C_REG_STATUS, I2C_STAT_NACK);
 		sc->sc_error = ENXIO;
 	} else if (status & I2C_STAT_AL) {
 		/* Arbitration lost. */
 		ti_i2c_dbg(sc, "Arbitration lost\n");
 		ti_i2c_write_2(sc, I2C_REG_STATUS, I2C_STAT_AL);
 		sc->sc_error = ENXIO;
 	}
 
 	/* Check if we have finished. */
 	if (status & I2C_STAT_ARDY) {
 		/* Register access ready - transaction complete basically. */
 		ti_i2c_dbg(sc, "ARDY transaction complete\n");
 		if (sc->sc_error != 0 && sc->sc_buffer->flags & IIC_M_NOSTOP) {
 			ti_i2c_write_2(sc, I2C_REG_CON,
 			    sc->sc_con_reg | I2C_CON_STP);
 		}
 		ti_i2c_write_2(sc, I2C_REG_STATUS,
 		    I2C_STAT_ARDY | I2C_STAT_RDR | I2C_STAT_RRDY |
 		    I2C_STAT_XDR | I2C_STAT_XRDY);
 		return (1);
 	}
 
 	if (sc->sc_buffer->flags & IIC_M_RD) {
 		/* Read some data. */
 		if (status & I2C_STAT_RDR) {
 			/*
 			 * Receive draining interrupt - last data received.
 			 * The set FIFO threshold wont be reached to trigger
 			 * RRDY.
 			 */
 			ti_i2c_dbg(sc, "Receive draining interrupt\n");
 
 			/*
 			 * Drain the FIFO.  Read the pending data in the FIFO.
 			 */
 			amount = sc->sc_buffer->len - sc->sc_buffer_pos;
 		} else if (status & I2C_STAT_RRDY) {
 			/*
 			 * Receive data ready interrupt - FIFO has reached the
 			 * set threshold.
 			 */
 			ti_i2c_dbg(sc, "Receive data ready interrupt\n");
 
 			amount = min(sc->sc_fifo_trsh,
 			    sc->sc_buffer->len - sc->sc_buffer_pos);
 		}
 
 		/* Read the bytes from the fifo. */
 		for (i = 0; i < amount; i++)
 			sc->sc_buffer->buf[sc->sc_buffer_pos++] = 
 			    (uint8_t)(ti_i2c_read_2(sc, I2C_REG_DATA) & 0xff);
 
 		if (status & I2C_STAT_RDR)
 			ti_i2c_write_2(sc, I2C_REG_STATUS, I2C_STAT_RDR);
 		if (status & I2C_STAT_RRDY)
 			ti_i2c_write_2(sc, I2C_REG_STATUS, I2C_STAT_RRDY);
 
 	} else {
 		/* Write some data. */
 		if (status & I2C_STAT_XDR) {
 			/*
 			 * Transmit draining interrupt - FIFO level is below
 			 * the set threshold and the amount of data still to
 			 * be transferred wont reach the set FIFO threshold.
 			 */
 			ti_i2c_dbg(sc, "Transmit draining interrupt\n");
 
 			/*
 			 * Drain the TX data.  Write the pending data in the
 			 * FIFO.
 			 */
 			amount = sc->sc_buffer->len - sc->sc_buffer_pos;
 		} else if (status & I2C_STAT_XRDY) {
 			/*
 			 * Transmit data ready interrupt - the FIFO level
 			 * is below the set threshold.
 			 */
 			ti_i2c_dbg(sc, "Transmit data ready interrupt\n");
 
 			amount = min(sc->sc_fifo_trsh,
 			    sc->sc_buffer->len - sc->sc_buffer_pos);
 		}
 
 		/* Write the bytes from the fifo. */
 		for (i = 0; i < amount; i++)
 			ti_i2c_write_2(sc, I2C_REG_DATA,
 			    sc->sc_buffer->buf[sc->sc_buffer_pos++]);
 
 		if (status & I2C_STAT_XDR)
 			ti_i2c_write_2(sc, I2C_REG_STATUS, I2C_STAT_XDR);
 		if (status & I2C_STAT_XRDY)
 			ti_i2c_write_2(sc, I2C_REG_STATUS, I2C_STAT_XRDY);
 	}
 
 	return (done);
 }
 
 /**
  *	ti_i2c_intr - interrupt handler for the I2C module
  *	@dev: i2c device handle
  *
  *
  *
  *	LOCKING:
  *	Called from timer context
  *
  *	RETURNS:
  *	EH_HANDLED or EH_NOT_HANDLED
  */
 static void
 ti_i2c_intr(void *arg)
 {
 	int done;
 	struct ti_i2c_softc *sc;
 	uint16_t events, status;
 
  	sc = (struct ti_i2c_softc *)arg;
 
 	TI_I2C_LOCK(sc);
 
 	status = ti_i2c_read_2(sc, I2C_REG_STATUS);
 	if (status == 0) {
 		TI_I2C_UNLOCK(sc);
 		return;
 	}
 
 	/* Save enabled interrupts. */
 	events = ti_i2c_read_2(sc, I2C_REG_IRQENABLE_SET);
 
 	/* We only care about enabled interrupts. */
 	status &= events;
 
 	done = 0;
 
 	if (sc->sc_buffer != NULL)
 		done = ti_i2c_transfer_intr(sc, status);
 	else {
 		ti_i2c_dbg(sc, "Transfer interrupt without buffer\n");
 		sc->sc_error = EINVAL;
 		done = 1;
 	}
 
 	if (done)
 		/* Wakeup the process that started the transaction. */
 		wakeup(sc);
 
 	TI_I2C_UNLOCK(sc);
 }
 
 /**
  *	ti_i2c_transfer - called to perform the transfer
  *	@dev: i2c device handle
  *	@msgs: the messages to send/receive
  *	@nmsgs: the number of messages in the msgs array
  *
  *
  *	LOCKING:
  *	Internally locked
  *
  *	RETURNS:
  *	0 on function succeeded
  *	EINVAL if invalid message is passed as an arg
  */
 static int
 ti_i2c_transfer(device_t dev, struct iic_msg *msgs, uint32_t nmsgs)
 {
 	int err, i, repstart, timeout;
 	struct ti_i2c_softc *sc;
 	uint16_t reg;
 
  	sc = device_get_softc(dev);
 	TI_I2C_LOCK(sc);
 
 	/* If the controller is busy wait until it is available. */
 	while (sc->sc_bus_inuse == 1)
 		mtx_sleep(sc, &sc->sc_mtx, 0, "i2cbuswait", 0);
 
 	/* Now we have control over the I2C controller. */
 	sc->sc_bus_inuse = 1;
 
 	err = 0;
 	repstart = 0;
 	for (i = 0; i < nmsgs; i++) {
 
 		sc->sc_buffer = &msgs[i];
 		sc->sc_buffer_pos = 0;
 		sc->sc_error = 0;
 
 		/* Zero byte transfers aren't allowed. */
 		if (sc->sc_buffer == NULL || sc->sc_buffer->buf == NULL ||
 		    sc->sc_buffer->len == 0) {
 			err = EINVAL;
 			break;
 		}
 
 		/* Check if the i2c bus is free. */
 		if (repstart == 0) {
 			/*
 			 * On repeated start we send the START condition while
 			 * the bus _is_ busy.
 			 */
 			timeout = 0;
 			while (ti_i2c_read_2(sc, I2C_REG_STATUS_RAW) & I2C_STAT_BB) {
 				if (timeout++ > 100) {
 					err = EBUSY;
 					goto out;
 				}
 				DELAY(1000);
 			}
 			timeout = 0;
 		} else
 			repstart = 0;
 
 		if (sc->sc_buffer->flags & IIC_M_NOSTOP)
 			repstart = 1;
 
 		/* Set the slave address. */
 		ti_i2c_write_2(sc, I2C_REG_SA, msgs[i].slave >> 1);
 
 		/* Write the data length. */
 		ti_i2c_write_2(sc, I2C_REG_CNT, sc->sc_buffer->len);
 
 		/* Clear the RX and the TX FIFO. */
 		reg = ti_i2c_read_2(sc, I2C_REG_BUF);
 		reg |= I2C_BUF_RXFIFO_CLR | I2C_BUF_TXFIFO_CLR;
 		ti_i2c_write_2(sc, I2C_REG_BUF, reg);
 
 		reg = sc->sc_con_reg | I2C_CON_STT;
 		if (repstart == 0)
 			reg |= I2C_CON_STP;
 		if ((sc->sc_buffer->flags & IIC_M_RD) == 0)
 			reg |= I2C_CON_TRX;
 		ti_i2c_write_2(sc, I2C_REG_CON, reg);
 
 		/* Wait for an event. */
-		err = mtx_sleep(sc, &sc->sc_mtx, 0, "i2ciowait", hz);
+		err = mtx_sleep(sc, &sc->sc_mtx, 0, "i2ciowait", sc->sc_timeout);
 		if (err == 0)
 			err = sc->sc_error;
 
 		if (err)
 			break;
 	}
 
 out:
 	if (timeout == 0) {
 		while (ti_i2c_read_2(sc, I2C_REG_STATUS_RAW) & I2C_STAT_BB) {
 			if (timeout++ > 100)
 				break;
 			DELAY(1000);
 		}
 	}
 	/* Put the controller in master mode again. */
 	if ((ti_i2c_read_2(sc, I2C_REG_CON) & I2C_CON_MST) == 0)
 		ti_i2c_write_2(sc, I2C_REG_CON, sc->sc_con_reg);
 
 	sc->sc_buffer = NULL;
 	sc->sc_bus_inuse = 0;
 
 	/* Wake up the processes that are waiting for the bus. */
 	wakeup(sc);
 
 	TI_I2C_UNLOCK(sc);
 
 	return (err);
 }
 
 static int
 ti_i2c_reset(struct ti_i2c_softc *sc, u_char speed)
 {
 	int timeout;
 	struct ti_i2c_clock_config *clkcfg;
 	u_int busfreq;
 	uint16_t fifo_trsh, reg, scll, sclh;
 
 	switch (ti_chip()) {
 #ifdef SOC_OMAP4
 	case CHIP_OMAP_4:
 		clkcfg = ti_omap4_i2c_clock_configs;
 		break;
 #endif
 #ifdef SOC_TI_AM335X
 	case CHIP_AM335X:
 		clkcfg = ti_am335x_i2c_clock_configs;
 		break;
 #endif
 	default:
 		panic("Unknown Ti SoC, unable to reset the i2c");
 	}
 
 	/*
 	 * If we haven't attached the bus yet, just init at the default slow
 	 * speed.  This lets us get the hardware initialized enough to attach
 	 * the bus which is where the real speed configuration is handled. After
 	 * the bus is attached, get the configured speed from it.  Search the
 	 * configuration table for the best speed we can do that doesn't exceed
 	 * the requested speed.
 	 */
 	if (sc->sc_iicbus == NULL)
 		busfreq = 100000;
 	else
 		busfreq = IICBUS_GET_FREQUENCY(sc->sc_iicbus, speed);
 	for (;;) {
 		if (clkcfg[1].frequency == 0 || clkcfg[1].frequency > busfreq)
 			break;
 		clkcfg++;
 	}
 
 	/*
 	 * 23.1.4.3 - HS I2C Software Reset
 	 *    From OMAP4 TRM at page 4068.
 	 *
 	 * 1. Ensure that the module is disabled.
 	 */
 	sc->sc_con_reg = 0;
 	ti_i2c_write_2(sc, I2C_REG_CON, sc->sc_con_reg);
 
 	/* 2. Issue a softreset to the controller. */
 	bus_write_2(sc->sc_mem_res, I2C_REG_SYSC, I2C_REG_SYSC_SRST);
 
 	/*
 	 * 3. Enable the module.
 	 *    The I2Ci.I2C_SYSS[0] RDONE bit is asserted only after the module
 	 *    is enabled by setting the I2Ci.I2C_CON[15] I2C_EN bit to 1.
 	 */
 	ti_i2c_write_2(sc, I2C_REG_CON, I2C_CON_I2C_EN);
 
  	/* 4. Wait for the software reset to complete. */
 	timeout = 0;
 	while ((ti_i2c_read_2(sc, I2C_REG_SYSS) & I2C_SYSS_RDONE) == 0) {
 		if (timeout++ > 100)
 			return (EBUSY);
 		DELAY(100);
 	}
 
 	/*
 	 * Disable the I2C controller once again, now that the reset has
 	 * finished.
 	 */
 	ti_i2c_write_2(sc, I2C_REG_CON, sc->sc_con_reg);
 
 	/*
 	 * The following sequence is taken from the OMAP4 TRM at page 4077.
 	 *
 	 * 1. Enable the functional and interface clocks (see Section
 	 *    23.1.5.1.1.1.1).  Done at ti_i2c_activate().
 	 *
 	 * 2. Program the prescaler to obtain an approximately 12MHz internal
 	 *    sampling clock (I2Ci_INTERNAL_CLK) by programming the
 	 *    corresponding value in the I2Ci.I2C_PSC[3:0] PSC field.
 	 *    This value depends on the frequency of the functional clock
 	 *    (I2Ci_FCLK).  Because this frequency is 96MHz, the
 	 *    I2Ci.I2C_PSC[7:0] PSC field value is 0x7.
 	 */
 	ti_i2c_write_2(sc, I2C_REG_PSC, clkcfg->psc);
 
 	/*
 	 * 3. Program the I2Ci.I2C_SCLL[7:0] SCLL and I2Ci.I2C_SCLH[7:0] SCLH
 	 *    bit fields to obtain a bit rate of 100 Kbps, 400 Kbps or 1Mbps.
 	 *    These values depend on the internal sampling clock frequency
 	 *    (see Table 23-8).
 	 */
 	scll = clkcfg->scll & I2C_SCLL_MASK;
 	sclh = clkcfg->sclh & I2C_SCLH_MASK;
 
 	/*
 	 * 4. (Optional) Program the I2Ci.I2C_SCLL[15:8] HSSCLL and
 	 *    I2Ci.I2C_SCLH[15:8] HSSCLH fields to obtain a bit rate of
 	 *    400K bps or 3.4M bps (for the second phase of HS mode).  These
 	 *    values depend on the internal sampling clock frequency (see
 	 *    Table 23-8).
 	 *
 	 * 5. (Optional) If a bit rate of 3.4M bps is used and the bus line
 	 *    capacitance exceeds 45 pF, (see Section 18.4.8, PAD Functional
 	 *    Multiplexing and Configuration).
 	 */
 	switch (ti_chip()) {
 #ifdef SOC_OMAP4
 	case CHIP_OMAP_4:
 		if ((clkcfg->hsscll + clkcfg->hssclh) > 0) {
 			scll |= clkcfg->hsscll << I2C_HSSCLL_SHIFT;
 			sclh |= clkcfg->hssclh << I2C_HSSCLH_SHIFT;
 			sc->sc_con_reg |= I2C_CON_OPMODE_HS;
 		}
 		break;
 #endif
 	}
 
 	/* Write the selected bit rate. */
 	ti_i2c_write_2(sc, I2C_REG_SCLL, scll);
 	ti_i2c_write_2(sc, I2C_REG_SCLH, sclh);
 
 	/*
 	 * 6. Configure the Own Address of the I2C controller by storing it in
 	 *    the I2Ci.I2C_OA0 register.  Up to four Own Addresses can be
 	 *    programmed in the I2Ci.I2C_OAi registers (where i = 0, 1, 2, 3)
 	 *    for each I2C controller.
 	 *
 	 * Note: For a 10-bit address, set the corresponding expand Own Address
 	 * bit in the I2Ci.I2C_CON register.
 	 *
 	 * Driver currently always in single master mode so ignore this step.
 	 */
 
 	/*
 	 * 7. Set the TX threshold (in transmitter mode) and the RX threshold
 	 *    (in receiver mode) by setting the I2Ci.I2C_BUF[5:0]XTRSH field to
 	 *    (TX threshold - 1) and the I2Ci.I2C_BUF[13:8]RTRSH field to (RX
 	 *    threshold - 1), where the TX and RX thresholds are greater than
 	 *    or equal to 1.
 	 *
 	 * The threshold is set to 5 for now.
 	 */
 	fifo_trsh = (sc->sc_fifo_trsh - 1) & I2C_BUF_TRSH_MASK;
 	reg = fifo_trsh | (fifo_trsh << I2C_BUF_RXTRSH_SHIFT);
 	ti_i2c_write_2(sc, I2C_REG_BUF, reg);
 
 	/*
 	 * 8. Take the I2C controller out of reset by setting the
 	 *    I2Ci.I2C_CON[15] I2C_EN bit to 1.
 	 *
 	 * 23.1.5.1.1.1.2 - Initialize the I2C Controller
 	 *
 	 * To initialize the I2C controller, perform the following steps:
 	 *
 	 * 1. Configure the I2Ci.I2C_CON register:
 	 *     . For master or slave mode, set the I2Ci.I2C_CON[10] MST bit
 	 *       (0: slave, 1: master).
 	 *     . For transmitter or receiver mode, set the I2Ci.I2C_CON[9] TRX
 	 *       bit (0: receiver, 1: transmitter).
 	 */
 
 	/* Enable the I2C controller in master mode. */
 	sc->sc_con_reg |= I2C_CON_I2C_EN | I2C_CON_MST;
 	ti_i2c_write_2(sc, I2C_REG_CON, sc->sc_con_reg);
 
 	/*
 	 * 2. If using an interrupt to transmit/receive data, set the
 	 *    corresponding bit in the I2Ci.I2C_IE register (the I2Ci.I2C_IE[4]
 	 *    XRDY_IE bit for the transmit interrupt, the I2Ci.I2C_IE[3] RRDY
 	 *    bit for the receive interrupt).
 	 */
 
 	/* Set the interrupts we want to be notified. */
 	reg = I2C_IE_XDR |	/* Transmit draining interrupt. */
 	    I2C_IE_XRDY |	/* Transmit Data Ready interrupt. */
 	    I2C_IE_RDR |	/* Receive draining interrupt. */
 	    I2C_IE_RRDY |	/* Receive Data Ready interrupt. */
 	    I2C_IE_ARDY |	/* Register Access Ready interrupt. */
 	    I2C_IE_NACK |	/* No Acknowledgment interrupt. */
 	    I2C_IE_AL;		/* Arbitration lost interrupt. */
 
 	/* Enable the interrupts. */
 	ti_i2c_write_2(sc, I2C_REG_IRQENABLE_SET, reg);
 
 	/*
 	 * 3. If using DMA to receive/transmit data, set to 1 the corresponding
 	 *    bit in the I2Ci.I2C_BUF register (the I2Ci.I2C_BUF[15] RDMA_EN
 	 *    bit for the receive DMA channel, the I2Ci.I2C_BUF[7] XDMA_EN bit
 	 *    for the transmit DMA channel).
 	 *
 	 * Not using DMA for now, so ignore this.
 	 */
 
 	return (0);
 }
 
 static int
 ti_i2c_iicbus_reset(device_t dev, u_char speed, u_char addr, u_char *oldaddr)
 {
 	struct ti_i2c_softc *sc;
 	int err;
 
 	sc = device_get_softc(dev);
 	TI_I2C_LOCK(sc);
 	err = ti_i2c_reset(sc, speed);
 	TI_I2C_UNLOCK(sc);
 	if (err)
 		return (err);
 
 	return (IIC_ENOADDR);
 }
 
 static int
 ti_i2c_activate(device_t dev)
 {
 	clk_ident_t clk;
 	int err;
 	struct ti_i2c_softc *sc;
 
 	sc = (struct ti_i2c_softc*)device_get_softc(dev);
 
 	/*
 	 * 1. Enable the functional and interface clocks (see Section
 	 * 23.1.5.1.1.1.1).
 	 */
 	clk = I2C0_CLK + sc->device_id;
 	err = ti_prcm_clk_enable(clk);
 	if (err)
 		return (err);
 
 	return (ti_i2c_reset(sc, IIC_UNKNOWN));
 }
 
 /**
  *	ti_i2c_deactivate - deactivates the controller and releases resources
  *	@dev: i2c device handle
  *
  *
  *
  *	LOCKING:
  *	Assumed called in an atomic context.
  *
  *	RETURNS:
  *	nothing
  */
 static void
 ti_i2c_deactivate(device_t dev)
 {
 	struct ti_i2c_softc *sc = device_get_softc(dev);
 	clk_ident_t clk;
 
 	/* Disable the controller - cancel all transactions. */
 	ti_i2c_write_2(sc, I2C_REG_IRQENABLE_CLR, 0xffff);
 	ti_i2c_write_2(sc, I2C_REG_STATUS, 0xffff);
 	ti_i2c_write_2(sc, I2C_REG_CON, 0);
 
 	/* Release the interrupt handler. */
 	if (sc->sc_irq_h != NULL) {
 		bus_teardown_intr(dev, sc->sc_irq_res, sc->sc_irq_h);
 		sc->sc_irq_h = NULL;
 	}
 
 	bus_generic_detach(sc->sc_dev);
 
 	/* Unmap the I2C controller registers. */
 	if (sc->sc_mem_res != NULL) {
 		bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->sc_mem_res);
 		sc->sc_mem_res = NULL;
 	}
 
 	/* Release the IRQ resource. */
 	if (sc->sc_irq_res != NULL) {
 		bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sc_irq_res);
 		sc->sc_irq_res = NULL;
 	}
 
 	/* Finally disable the functional and interface clocks. */
 	clk = I2C0_CLK + sc->device_id;
 	ti_prcm_clk_disable(clk);
 }
 
 static int
 ti_i2c_sysctl_clk(SYSCTL_HANDLER_ARGS)
 {
-	device_t dev;
 	int clk, psc, sclh, scll;
 	struct ti_i2c_softc *sc;
 
-	dev = (device_t)arg1;
-	sc = device_get_softc(dev);
+	sc = arg1;
 
 	TI_I2C_LOCK(sc);
 	/* Get the system prescaler value. */
 	psc = (int)ti_i2c_read_2(sc, I2C_REG_PSC) + 1;
 
 	/* Get the bitrate. */
 	scll = (int)ti_i2c_read_2(sc, I2C_REG_SCLL) & I2C_SCLL_MASK;
 	sclh = (int)ti_i2c_read_2(sc, I2C_REG_SCLH) & I2C_SCLH_MASK;
 
 	clk = I2C_CLK / psc / (scll + 7 + sclh + 5);
 	TI_I2C_UNLOCK(sc);
 
 	return (sysctl_handle_int(oidp, &clk, 0, req));
 }
 
 static int
+ti_i2c_sysctl_timeout(SYSCTL_HANDLER_ARGS)
+{
+	struct ti_i2c_softc *sc;
+	unsigned int val;
+	int err;
+
+	sc = arg1;
+
+	/* 
+	 * MTX_DEF lock can't be held while doing uimove in
+	 * sysctl_handle_int
+	 */
+	TI_I2C_LOCK(sc);
+	val = sc->sc_timeout;
+	TI_I2C_UNLOCK(sc);
+
+	err = sysctl_handle_int(oidp, &val, 0, req);
+	/* Write request? */
+	if ((err == 0) && (req->newptr != NULL)) {
+		TI_I2C_LOCK(sc);
+		sc->sc_timeout = val;
+		TI_I2C_UNLOCK(sc);
+	}
+
+	return (err);
+}
+
+static int
 ti_i2c_probe(device_t dev)
 {
 
 	if (!ofw_bus_status_okay(dev))
 		return (ENXIO);
 	if (!ofw_bus_is_compatible(dev, "ti,i2c"))
 		return (ENXIO);
 	device_set_desc(dev, "TI I2C Controller");
 
 	return (0);
 }
 
 static int
 ti_i2c_attach(device_t dev)
 {
 	int err, rid;
 	phandle_t node;
 	struct ti_i2c_softc *sc;
 	struct sysctl_ctx_list *ctx;
 	struct sysctl_oid_list *tree;
 	uint16_t fifosz;
 
  	sc = device_get_softc(dev);
 	sc->sc_dev = dev;
 
 	/* Get the i2c device id from FDT. */
 	node = ofw_bus_get_node(dev);
 	if ((OF_getencprop(node, "i2c-device-id", &sc->device_id,
 	    sizeof(sc->device_id))) <= 0) {
 		device_printf(dev, "missing i2c-device-id attribute in FDT\n");
 		return (ENXIO);
 	}
 
 	/* Get the memory resource for the register mapping. */
 	rid = 0;
 	sc->sc_mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
 	    RF_ACTIVE);
 	if (sc->sc_mem_res == NULL) {
 		device_printf(dev, "Cannot map registers.\n");
 		return (ENXIO);
 	}
 
 	/* Allocate our IRQ resource. */
 	rid = 0;
 	sc->sc_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
 	    RF_ACTIVE | RF_SHAREABLE);
 	if (sc->sc_irq_res == NULL) {
 		bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->sc_mem_res);
 		device_printf(dev, "Cannot allocate interrupt.\n");
 		return (ENXIO);
 	}
 
 	TI_I2C_LOCK_INIT(sc);
 
 	/* First of all, we _must_ activate the H/W. */
 	err = ti_i2c_activate(dev);
 	if (err) {
 		device_printf(dev, "ti_i2c_activate failed\n");
 		goto out;
 	}
 
 	/* Read the version number of the I2C module */
 	sc->sc_rev = ti_i2c_read_2(sc, I2C_REG_REVNB_HI) & 0xff;
 
 	/* Get the fifo size. */
 	fifosz = ti_i2c_read_2(sc, I2C_REG_BUFSTAT);
 	fifosz >>= I2C_BUFSTAT_FIFODEPTH_SHIFT;
 	fifosz &= I2C_BUFSTAT_FIFODEPTH_MASK;
 
 	device_printf(dev, "I2C revision %d.%d FIFO size: %d bytes\n",
 	    sc->sc_rev >> 4, sc->sc_rev & 0xf, 8 << fifosz);
 
 	/* Set the FIFO threshold to 5 for now. */
 	sc->sc_fifo_trsh = 5;
 
+	/* Set I2C bus timeout */
+	sc->sc_timeout = 5*hz;
+
 	ctx = device_get_sysctl_ctx(dev);
 	tree = SYSCTL_CHILDREN(device_get_sysctl_tree(dev));
 	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "i2c_clock",
-	    CTLFLAG_RD | CTLTYPE_UINT | CTLFLAG_MPSAFE, dev, 0,
+	    CTLFLAG_RD | CTLTYPE_UINT | CTLFLAG_MPSAFE, sc, 0,
 	    ti_i2c_sysctl_clk, "IU", "I2C bus clock");
+
+	SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "i2c_timeout",
+	    CTLFLAG_RW | CTLTYPE_UINT | CTLFLAG_MPSAFE, sc, 0,
+	    ti_i2c_sysctl_timeout, "IU", "I2C bus timeout (in ticks)");
 
 	/* Activate the interrupt. */
 	err = bus_setup_intr(dev, sc->sc_irq_res, INTR_TYPE_MISC | INTR_MPSAFE,
 	    NULL, ti_i2c_intr, sc, &sc->sc_irq_h);
 	if (err)
 		goto out;
 
 	/* Attach the iicbus. */
 	if ((sc->sc_iicbus = device_add_child(dev, "iicbus", -1)) == NULL) {
 		device_printf(dev, "could not allocate iicbus instance\n");
 		err = ENXIO;
 		goto out;
 	}
 
 	/* Probe and attach the iicbus */
 	bus_generic_attach(dev);
 
 out:
 	if (err) {
 		ti_i2c_deactivate(dev);
 		TI_I2C_LOCK_DESTROY(sc);
 	}
 
 	return (err);
 }
 
 static int
 ti_i2c_detach(device_t dev)
 {
 	struct ti_i2c_softc *sc;
 	int rv;
 
  	sc = device_get_softc(dev);
 	ti_i2c_deactivate(dev);
 	TI_I2C_LOCK_DESTROY(sc);
 	if (sc->sc_iicbus &&
 	    (rv = device_delete_child(dev, sc->sc_iicbus)) != 0)
 		return (rv);
 
 	return (0);
 }
 
 static phandle_t
 ti_i2c_get_node(device_t bus, device_t dev)
 {
 
 	/* Share controller node with iibus device. */
 	return (ofw_bus_get_node(bus));
 }
 
 static device_method_t ti_i2c_methods[] = {
 	/* Device interface */
 	DEVMETHOD(device_probe,		ti_i2c_probe),
 	DEVMETHOD(device_attach,	ti_i2c_attach),
 	DEVMETHOD(device_detach,	ti_i2c_detach),
 
 	/* OFW methods */
 	DEVMETHOD(ofw_bus_get_node,	ti_i2c_get_node),
 
 	/* iicbus interface */
 	DEVMETHOD(iicbus_callback,	iicbus_null_callback),
 	DEVMETHOD(iicbus_reset,		ti_i2c_iicbus_reset),
 	DEVMETHOD(iicbus_transfer,	ti_i2c_transfer),
 
 	DEVMETHOD_END
 };
 
 static driver_t ti_i2c_driver = {
 	"iichb",
 	ti_i2c_methods,
 	sizeof(struct ti_i2c_softc),
 };
 
 static devclass_t ti_i2c_devclass;
 
 DRIVER_MODULE(ti_iic, simplebus, ti_i2c_driver, ti_i2c_devclass, 0, 0);
 DRIVER_MODULE(iicbus, ti_iic, iicbus_driver, iicbus_devclass, 0, 0);
 
 MODULE_DEPEND(ti_iic, ti_prcm, 1, 1, 1);
 MODULE_DEPEND(ti_iic, iicbus, 1, 1, 1);
Index: projects/clang360-import/sys/boot/fdt/dts/arm/am335x.dtsi
===================================================================
--- projects/clang360-import/sys/boot/fdt/dts/arm/am335x.dtsi	(revision 277777)
+++ projects/clang360-import/sys/boot/fdt/dts/arm/am335x.dtsi	(revision 277778)
@@ -1,344 +1,349 @@
 /*-
  * Copyright (c) 2012 Damjan Marion <dmarion@Freebsd.org>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * 
  * $FreeBSD$
  */
 
 / {
 	#address-cells = <1>;
 	#size-cells = <1>;
 
 	interrupt-parent = <&AINTC>;
 
 	SOC: am335x {
 		#address-cells = <1>;
 		#size-cells = <1>;
 		compatible = "simple-bus";
 		ranges;
 		bus-frequency = <0>;
 
 		AINTC: interrupt-controller@48200000 {
 			compatible = "ti,aintc";
 			interrupt-controller;
 			#address-cells = <0>;
 			#interrupt-cells = <1>;
 			reg =	< 0x48200000 0x1000 >;
 		};
 
+		pmu {
+			compatible = "arm,cortex-a8-pmu";
+			interrupts = <3>;
+		};
+
 		scm@44e10000 {
 			compatible = "ti,scm";
 			reg =	< 0x44e10000 0x2000 >;
 		};
 
 		prcm@44E00000 {
 			compatible = "am335x,prcm";
 			#address-cells = <1>;
 			#size-cells = <1>;
 			reg = < 0x44E00000 0x1300 >;
 		};
 
 		dmtimers@44E05000 {
 			compatible = "ti,am335x-dmtimer";
 			#address-cells = <1>;
 			#size-cells = <1>;
 			reg =	< 0x44E05000 0x1000
 				  0x44E31000 0x1000
 				  0x48040000 0x1000
 				  0x48042000 0x1000
 				  0x48044000 0x1000
 				  0x48046000 0x1000
 				  0x48048000 0x1000
 				  0x4804A000 0x1000 >;
 			interrupts = < 66 67 68 69 92 93 94 95 >;
 			interrupt-parent = <&AINTC>;
 		};
 
 		rtc: rtc@44E3E000 {
 			compatible = "ti,da830-rtc";
 			reg = <0x44E3E000 0x1000>;
 			interrupts = < 75 76 >;
 			interrupt-parent = <&AINTC>;
 		};
 
 		adc0: adc@44E0D000 {
 			compatible = "ti,adc";
 			reg = <0x44E0D000 0x2000>;
 			interrupts = < 16 >;
 			interrupt-parent = <&AINTC>;
  		};
 
 		wdt1@44E35000 {
 			compatible = "ti,omap3-wdt";
 			reg = <0x44E35000 0x1000>;
 			interrupts = <91>;
 			interrupt-parent = <&AINTC>;
 		};
  		
 		GPIO: gpio {
 			#gpio-cells = <3>;
 			compatible = "ti,gpio";
 			gpio-controller;
 			reg =<	0x44E07000 0x1000
 				0x4804C000 0x1000
 				0x481AC000 0x1000
 				0x481AE000 0x1000 >;
 			interrupts = < 96 97 98 99 32 33 62 63 >;
 			interrupt-parent = <&AINTC>;
 			interrupt-controller;
 			#interrupt-cells = <1>;
 		};
 
 		uart0: serial@44E09000 {
 			compatible = "ti,ns16550";
 			reg = <0x44E09000 0x1000>;
 			reg-shift = <2>;
 			interrupts = < 72 >;
 			interrupt-parent = <&AINTC>;
  			clock-frequency = < 48000000 >;
 			uart-device-id = < 0 >;
  		};
  		
  		uart1: serial@48022000 {
  			compatible = "ti,ns16550";
  			reg = <0x48022000 0x1000>;
  			reg-shift = <2>;
  			interrupts = < 73 >;
  			interrupt-parent = <&AINTC>;
  			clock-frequency = < 48000000 >; 
 			uart-device-id = < 1 >;
 			status = "disabled";
  		};
  		
  		uart2: serial@48024000 {
  			compatible = "ti,ns16550";
  			reg = <0x48024000 0x1000>;
  			reg-shift = <2>;
  			interrupts = < 74 >;
  			interrupt-parent = <&AINTC>;
  			clock-frequency = < 48000000 >; 
 			uart-device-id = < 2 >;
 			status = "disabled";
  		};
  		
  		uart3: serial@481a6000 {
  			compatible = "ti,ns16550";
  			reg = <0x481A6000 0x1000>;
  			reg-shift = <2>;
  			interrupts = < 44 >;
  			interrupt-parent = <&AINTC>;
  			clock-frequency = < 48000000 >; 
 			uart-device-id = < 3 >;
 			status = "disabled";
  		};
  
  		uart4: serial@481a8000 {
  			compatible = "ti,ns16550";
  			reg = <0x481A8000 0x1000>;
  			reg-shift = <2>;
  			interrupts = < 45 >;
  			interrupt-parent = <&AINTC>;
  			clock-frequency = < 48000000 >; 
 			uart-device-id = < 4 >;
 			status = "disabled";
  		};
  
  		uart5: serial@481aa000 {
  			compatible = "ti,ns16550";
  			reg = <0x481AA000 0x1000>;
  			reg-shift = <2>;
  			interrupts = < 46 >;
  			interrupt-parent = <&AINTC>;
  			clock-frequency = < 48000000 >; 
 			uart-device-id = < 5 >;
 			status = "disabled";
   		};
 
 		edma3@49000000 {
 			compatible = "ti,edma3";
 			reg =<	0x49000000 0x100000	/* Channel Controller Regs */
 				0x49800000 0x100000	/* Transfer Controller 0 Regs */
 				0x49900000 0x100000	/* Transfer Controller 1 Regs */
 				0x49a00000 0x100000 >;	/* Transfer Controller 2 Regs */
 			interrupts = <12 13 14>;
 			interrupt-parent = <&AINTC>;
 		};
 
 		mmchs0@48060000 {
 			compatible = "ti,omap3-hsmmc", "ti,mmchs";
 			reg =<0x48060000 0x1000 >;
 			interrupts = <64>;
 			interrupt-parent = <&AINTC>;
 			mmchs-device-id = <0>;
 			mmchs-wp-gpio-pin = <0xffffffff>;
 			ti,dual-volt;
 		};
 
 		mmchs1@481D8000 {
 			compatible = "ti,omap3-hsmmc", "ti,mmchs";
 			reg =<0x481D8000 0x1000 >;
 			interrupts = <28>;
 			interrupt-parent = <&AINTC>;
 			mmchs-device-id = <1>;
 			mmchs-wp-gpio-pin = <0xffffffff>;
 			status = "disabled";
 		};
 
 		enet0: ethernet@4A100000 {
 			#address-cells = <1>;
 			#size-cells = <1>;
 			compatible = "ti,cpsw";
 			reg = <0x4A100000 0x4000>;
 			interrupts = <40 41 42 43>;
 			interrupt-parent = <&AINTC>;
 			phy-handle = <&phy0>;
 			mdio@0 {
 				#address-cells = <1>;
 				#size-cells = <0>;
 				compatible = "ti,cpsw-mdio";
 				phy0: ethernet-phy@0 {
 					reg = <0x0>;
 				};
 			};
 		};
 
 		i2c0: i2c@44e0b000 {
 			#address-cells = <1>;
 			#size-cells = <0>;
 			compatible = "ti,i2c";
 			reg =<	0x44e0b000 0x1000 >;
 			interrupts = <70>;
 			interrupt-parent = <&AINTC>;
 			i2c-device-id = <0>;
 		};
 
 		i2c1: i2c@4802a000 {
 			#address-cells = <1>;
 			#size-cells = <0>;
 			compatible = "ti,i2c";
 			reg =<  0x4802a000 0x1000 >;
 			interrupts = <71>;
 			interrupt-parent = <&AINTC>;
 			i2c-device-id = <1>;
 		};
 
 		i2c2: i2c@4819c000 {
 			#address-cells = <1>;
 			#size-cells = <0>;
 			compatible = "ti,i2c";
 			reg =<  0x4819c000 0x1000 >;
 			interrupts = <30>;
 			interrupt-parent = <&AINTC>;
 			i2c-device-id = <2>;
 		};
 
 		pwm@48300000 {
 			compatible = "ti,am335x-pwm";
 			#address-cells = <1>;
 			#size-cells = <1>;
 			reg = < 0x48300000 0x100	/* PWMSS0 */
 				0x48300100 0x80		/* eCAP0 */
 				0x48300180 0x80		/* eQEP0 */
 				0x48300200 0x60		/* ePWM0 */
 			>;
 			interrupts = <86 58>; /* ePWM0INT, ePWM0_TZINT */
 			interrupt-parent = <&AINTC>;
 			pwm-device-id = <0>;
 		};
 
 		pwm@48302000 {
 			compatible = "ti,am335x-pwm";
 			#address-cells = <1>;
 			#size-cells = <1>;
 			reg = < 0x48302000 0x100	/* PWMSS1 */
 				0x48302100 0x80		/* eCAP1 */
 				0x48302180 0x80		/* eQEP1 */
 				0x48302200 0x60		/* ePWM1 */
 			>;
 			interrupts = <87 59>; /* ePWM1INT, ePWM1_TZINT */
 			interrupt-parent = <&AINTC>;
 			pwm-device-id = <1>;
 		};
 
 		pwm@48304000 {
 			compatible = "ti,am335x-pwm";
 			#address-cells = <1>;
 			#size-cells = <1>;
 			reg = < 0x48304000 0x100	/* PWMSS2 */
 				0x48304100 0x80		/* eCAP2 */
 				0x48304180 0x80		/* eQEP2 */
 				0x48304200 0x60		/* ePWM2 */
 			>;
 			interrupts = <88 60>; /* ePWM2INT, ePWM2_TZINT */
 			interrupt-parent = <&AINTC>;
 			pwm-device-id = <2>;
 		};
 
 		lcd: lcd@4830e000 {
 			#address-cells = <1>;
 			#size-cells = <0>;
 			compatible = "ti,am335x-lcd";
 			reg =<	0x4830e000 0x1000 >;
 			interrupts = <36>;
 			interrupt-parent = <&AINTC>;
 		};
 
  		usb@47400000 {
  			#address-cells = <1>;
  			#size-cells = <0>;
  			compatible = "ti,musb-am33xx";
  			reg =<	0x47400000 0x1000	/* USBSS */
  				0x47401000 0x300	/* USB0 */
  				0x47401300 0x100 	/* USB0_PHY */
  				0x47401400 0x400 	/* USB0_CORE */
  				0x47401800 0x300 	/* USB1 */
  				0x47401B00 0x100 	/* USB1_PHY */
  				0x47401C00 0x400 	/* USB1_CORE */
  			>;
  			interrupts = <17 18 19>;
  			interrupt-parent = <&AINTC>;
  			/* 1 - Host Mode, 0 - Device Mode */
  			modemask = <2>;
  		};
 
 		mbox0@480C8000 {
 			compatible = "am335x,system-mbox";
 			reg = < 0x480C8000 0x1000 >;
 			interrupts = <77>;
 			interrupt-parent = <&AINTC>;
 		};
 
 		spinlock0@480CA000 {
 			compatible = "am335x,spinlock";
 			reg = < 0x480CA000 0x1000 >;
 		};
 
 		pruss@4A300000 {
 			compatible = "ti,pruss-v2";
 			reg = <0x4A300000 0x80000>;
  			interrupt-parent = <&AINTC>;
 			interrupts = <20 21 22 23 24 25 26 27>;
 		};
 	};
 };
Index: projects/clang360-import/sys/boot
===================================================================
--- projects/clang360-import/sys/boot	(revision 277777)
+++ projects/clang360-import/sys/boot	(revision 277778)

Property changes on: projects/clang360-import/sys/boot
___________________________________________________________________
Modified: svn:mergeinfo
## -0,0 +0,1 ##
   Merged /head/sys/boot:r277719-277776
Index: projects/clang360-import/sys/cam/scsi/scsi_da.c
===================================================================
--- projects/clang360-import/sys/cam/scsi/scsi_da.c	(revision 277777)
+++ projects/clang360-import/sys/cam/scsi/scsi_da.c	(revision 277778)
@@ -1,3994 +1,3994 @@
 /*-
  * Implementation of SCSI Direct Access Peripheral driver for CAM.
  *
  * Copyright (c) 1997 Justin T. Gibbs.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions, and the following disclaimer,
  *    without modification, immediately at the beginning of the file.
  * 2. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include <sys/param.h>
 
 #ifdef _KERNEL
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/bio.h>
 #include <sys/sysctl.h>
 #include <sys/taskqueue.h>
 #include <sys/lock.h>
 #include <sys/mutex.h>
 #include <sys/conf.h>
 #include <sys/devicestat.h>
 #include <sys/eventhandler.h>
 #include <sys/malloc.h>
 #include <sys/cons.h>
 #include <sys/endian.h>
 #include <sys/proc.h>
 #include <geom/geom.h>
 #include <geom/geom_disk.h>
 #endif /* _KERNEL */
 
 #ifndef _KERNEL
 #include <stdio.h>
 #include <string.h>
 #endif /* _KERNEL */
 
 #include <cam/cam.h>
 #include <cam/cam_ccb.h>
 #include <cam/cam_periph.h>
 #include <cam/cam_xpt_periph.h>
 #include <cam/cam_sim.h>
 
 #include <cam/scsi/scsi_message.h>
 
 #ifndef _KERNEL 
 #include <cam/scsi/scsi_da.h>
 #endif /* !_KERNEL */
 
 #ifdef _KERNEL
 typedef enum {
 	DA_STATE_PROBE_RC,
 	DA_STATE_PROBE_RC16,
 	DA_STATE_PROBE_LBP,
 	DA_STATE_PROBE_BLK_LIMITS,
 	DA_STATE_PROBE_BDC,
 	DA_STATE_PROBE_ATA,
 	DA_STATE_NORMAL
 } da_state;
 
 typedef enum {
 	DA_FLAG_PACK_INVALID	= 0x001,
 	DA_FLAG_NEW_PACK	= 0x002,
 	DA_FLAG_PACK_LOCKED	= 0x004,
 	DA_FLAG_PACK_REMOVABLE	= 0x008,
 	DA_FLAG_NEED_OTAG	= 0x020,
 	DA_FLAG_WAS_OTAG	= 0x040,
 	DA_FLAG_RETRY_UA	= 0x080,
 	DA_FLAG_OPEN		= 0x100,
 	DA_FLAG_SCTX_INIT	= 0x200,
 	DA_FLAG_CAN_RC16	= 0x400,
 	DA_FLAG_PROBED		= 0x800,
 	DA_FLAG_DIRTY		= 0x1000,
 	DA_FLAG_ANNOUNCED	= 0x2000
 } da_flags;
 
 typedef enum {
 	DA_Q_NONE		= 0x00,
 	DA_Q_NO_SYNC_CACHE	= 0x01,
 	DA_Q_NO_6_BYTE		= 0x02,
 	DA_Q_NO_PREVENT		= 0x04,
 	DA_Q_4K			= 0x08,
 	DA_Q_NO_RC16		= 0x10,
 	DA_Q_NO_UNMAP		= 0x20
 } da_quirks;
 
 #define DA_Q_BIT_STRING		\
 	"\020"			\
 	"\001NO_SYNC_CACHE"	\
 	"\002NO_6_BYTE"		\
 	"\003NO_PREVENT"	\
 	"\0044K"		\
 	"\005NO_RC16"
 
 typedef enum {
 	DA_CCB_PROBE_RC		= 0x01,
 	DA_CCB_PROBE_RC16	= 0x02,
 	DA_CCB_PROBE_LBP	= 0x03,
 	DA_CCB_PROBE_BLK_LIMITS	= 0x04,
 	DA_CCB_PROBE_BDC	= 0x05,
 	DA_CCB_PROBE_ATA	= 0x06,
 	DA_CCB_BUFFER_IO	= 0x07,
 	DA_CCB_DUMP		= 0x0A,
 	DA_CCB_DELETE		= 0x0B,
  	DA_CCB_TUR		= 0x0C,
 	DA_CCB_TYPE_MASK	= 0x0F,
 	DA_CCB_RETRY_UA		= 0x10
 } da_ccb_state;
 
 /*
  * Order here is important for method choice
  *
  * We prefer ATA_TRIM as tests run against a Sandforce 2281 SSD attached to
  * LSI 2008 (mps) controller (FW: v12, Drv: v14) resulted 20% quicker deletes
  * using ATA_TRIM than the corresponding UNMAP results for a real world mysql
  * import taking 5mins.
  *
  */
 typedef enum {
 	DA_DELETE_NONE,
 	DA_DELETE_DISABLE,
 	DA_DELETE_ATA_TRIM,
 	DA_DELETE_UNMAP,
 	DA_DELETE_WS16,
 	DA_DELETE_WS10,
 	DA_DELETE_ZERO,
 	DA_DELETE_MIN = DA_DELETE_ATA_TRIM,
 	DA_DELETE_MAX = DA_DELETE_ZERO
 } da_delete_methods;
 
 typedef void da_delete_func_t (struct cam_periph *periph, union ccb *ccb,
 			      struct bio *bp);
 static da_delete_func_t da_delete_trim;
 static da_delete_func_t da_delete_unmap;
 static da_delete_func_t da_delete_ws;
 
 static const void * da_delete_functions[] = {
 	NULL,
 	NULL,
 	da_delete_trim,
 	da_delete_unmap,
 	da_delete_ws,
 	da_delete_ws,
 	da_delete_ws
 };
 
 static const char *da_delete_method_names[] =
     { "NONE", "DISABLE", "ATA_TRIM", "UNMAP", "WS16", "WS10", "ZERO" };
 static const char *da_delete_method_desc[] =
     { "NONE", "DISABLED", "ATA TRIM", "UNMAP", "WRITE SAME(16) with UNMAP",
       "WRITE SAME(10) with UNMAP", "ZERO" };
 
 /* Offsets into our private area for storing information */
 #define ccb_state	ppriv_field0
 #define ccb_bp		ppriv_ptr1
 
 struct disk_params {
 	u_int8_t  heads;
 	u_int32_t cylinders;
 	u_int8_t  secs_per_track;
 	u_int32_t secsize;	/* Number of bytes/sector */
 	u_int64_t sectors;	/* total number sectors */
 	u_int     stripesize;
 	u_int     stripeoffset;
 };
 
 #define UNMAP_RANGE_MAX		0xffffffff
 #define UNMAP_HEAD_SIZE		8
 #define UNMAP_RANGE_SIZE	16
 #define UNMAP_MAX_RANGES	2048 /* Protocol Max is 4095 */
 #define UNMAP_BUF_SIZE		((UNMAP_MAX_RANGES * UNMAP_RANGE_SIZE) + \
 				UNMAP_HEAD_SIZE)
 
 #define WS10_MAX_BLKS		0xffff
 #define WS16_MAX_BLKS		0xffffffff
 #define ATA_TRIM_MAX_RANGES	((UNMAP_BUF_SIZE / \
 	(ATA_DSM_RANGE_SIZE * ATA_DSM_BLK_SIZE)) * ATA_DSM_BLK_SIZE)
 
 struct da_softc {
 	struct	 bio_queue_head bio_queue;
 	struct	 bio_queue_head delete_queue;
 	struct	 bio_queue_head delete_run_queue;
 	LIST_HEAD(, ccb_hdr) pending_ccbs;
 	int	 tur;			/* TEST UNIT READY should be sent */
 	int	 refcount;		/* Active xpt_action() calls */
 	da_state state;
 	da_flags flags;	
 	da_quirks quirks;
 	int	 sort_io_queue;
 	int	 minimum_cmd_size;
 	int	 error_inject;
 	int	 trim_max_ranges;
 	int	 delete_running;
 	int	 delete_available;	/* Delete methods possibly available */
 	u_int	 maxio;
 	uint32_t		unmap_max_ranges;
 	uint32_t		unmap_max_lba; /* Max LBAs in UNMAP req */
 	uint64_t		ws_max_blks;
 	da_delete_methods	delete_method;
 	da_delete_func_t	*delete_func;
 	struct	 disk_params params;
 	struct	 disk *disk;
 	union	 ccb saved_ccb;
 	struct task		sysctl_task;
 	struct sysctl_ctx_list	sysctl_ctx;
 	struct sysctl_oid	*sysctl_tree;
 	struct callout		sendordered_c;
 	uint64_t wwpn;
 	uint8_t	 unmap_buf[UNMAP_BUF_SIZE];
 	struct scsi_read_capacity_data_long rcaplong;
 	struct callout		mediapoll_c;
 };
 
 #define dadeleteflag(softc, delete_method, enable)			\
 	if (enable) {							\
 		softc->delete_available |= (1 << delete_method);	\
 	} else {							\
 		softc->delete_available &= ~(1 << delete_method);	\
 	}
 
 struct da_quirk_entry {
 	struct scsi_inquiry_pattern inq_pat;
 	da_quirks quirks;
 };
 
 static const char quantum[] = "QUANTUM";
 static const char microp[] = "MICROP";
 
 static struct da_quirk_entry da_quirk_table[] =
 {
 	/* SPI, FC devices */
 	{
 		/*
 		 * Fujitsu M2513A MO drives.
 		 * Tested devices: M2513A2 firmware versions 1200 & 1300.
 		 * (dip switch selects whether T_DIRECT or T_OPTICAL device)
 		 * Reported by: W.Scholten <whs@xs4all.nl>
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "FUJITSU", "M2513A", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/* See above. */
 		{T_OPTICAL, SIP_MEDIA_REMOVABLE, "FUJITSU", "M2513A", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * This particular Fujitsu drive doesn't like the
 		 * synchronize cache command.
 		 * Reported by: Tom Jackson <toj@gorilla.net>
 		 */
 		{T_DIRECT, SIP_MEDIA_FIXED, "FUJITSU", "M2954*", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * This drive doesn't like the synchronize cache command
 		 * either.  Reported by: Matthew Jacob <mjacob@feral.com>
 		 * in NetBSD PR kern/6027, August 24, 1998.
 		 */
 		{T_DIRECT, SIP_MEDIA_FIXED, microp, "2217*", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * This drive doesn't like the synchronize cache command
 		 * either.  Reported by: Hellmuth Michaelis (hm@kts.org)
 		 * (PR 8882).
 		 */
 		{T_DIRECT, SIP_MEDIA_FIXED, microp, "2112*", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * Doesn't like the synchronize cache command.
 		 * Reported by: Blaz Zupan <blaz@gold.amis.net>
 		 */
 		{T_DIRECT, SIP_MEDIA_FIXED, "NEC", "D3847*", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * Doesn't like the synchronize cache command.
 		 * Reported by: Blaz Zupan <blaz@gold.amis.net>
 		 */
 		{T_DIRECT, SIP_MEDIA_FIXED, quantum, "MAVERICK 540S", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * Doesn't like the synchronize cache command.
 		 */
 		{T_DIRECT, SIP_MEDIA_FIXED, quantum, "LPS525S", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * Doesn't like the synchronize cache command.
 		 * Reported by: walter@pelissero.de
 		 */
 		{T_DIRECT, SIP_MEDIA_FIXED, quantum, "LPS540S", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * Doesn't work correctly with 6 byte reads/writes.
 		 * Returns illegal request, and points to byte 9 of the
 		 * 6-byte CDB.
 		 * Reported by:  Adam McDougall <bsdx@spawnet.com>
 		 */
 		{T_DIRECT, SIP_MEDIA_FIXED, quantum, "VIKING 4*", "*"},
 		/*quirks*/ DA_Q_NO_6_BYTE
 	},
 	{
 		/* See above. */
 		{T_DIRECT, SIP_MEDIA_FIXED, quantum, "VIKING 2*", "*"},
 		/*quirks*/ DA_Q_NO_6_BYTE
 	},
 	{
 		/*
 		 * Doesn't like the synchronize cache command.
 		 * Reported by: walter@pelissero.de
 		 */
 		{T_DIRECT, SIP_MEDIA_FIXED, "CONNER", "CP3500*", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * The CISS RAID controllers do not support SYNC_CACHE
 		 */
 		{T_DIRECT, SIP_MEDIA_FIXED, "COMPAQ", "RAID*", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * The STEC SSDs sometimes hang on UNMAP.
 		 */
 		{T_DIRECT, SIP_MEDIA_FIXED, "STEC", "*", "*"},
 		/*quirks*/ DA_Q_NO_UNMAP
 	},
 	/* USB mass storage devices supported by umass(4) */
 	{
 		/*
 		 * EXATELECOM (Sigmatel) i-Bead 100/105 USB Flash MP3 Player
 		 * PR: kern/51675
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "EXATEL", "i-BEAD10*", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * Power Quotient Int. (PQI) USB flash key
 		 * PR: kern/53067
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "Generic*", "USB Flash Disk*",
 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
  	{
  		/*
  		 * Creative Nomad MUVO mp3 player (USB)
  		 * PR: kern/53094
  		 */
  		{T_DIRECT, SIP_MEDIA_REMOVABLE, "CREATIVE", "NOMAD_MUVO", "*"},
  		/*quirks*/ DA_Q_NO_SYNC_CACHE|DA_Q_NO_PREVENT
  	},
 	{
 		/*
 		 * Jungsoft NEXDISK USB flash key
 		 * PR: kern/54737
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "JUNGSOFT", "NEXDISK*", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * FreeDik USB Mini Data Drive
 		 * PR: kern/54786
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "FreeDik*", "Mini Data Drive",
 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * Sigmatel USB Flash MP3 Player
 		 * PR: kern/57046
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "SigmaTel", "MSCN", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE|DA_Q_NO_PREVENT
 	},
 	{
 		/*
 		 * Neuros USB Digital Audio Computer
 		 * PR: kern/63645
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "NEUROS", "dig. audio comp.",
 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * SEAGRAND NP-900 MP3 Player
 		 * PR: kern/64563
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "SEAGRAND", "NP-900*", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE|DA_Q_NO_PREVENT
 	},
 	{
 		/*
 		 * iRiver iFP MP3 player (with UMS Firmware)
 		 * PR: kern/54881, i386/63941, kern/66124
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "iRiver", "iFP*", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE
  	},
 	{
 		/*
 		 * Frontier Labs NEX IA+ Digital Audio Player, rev 1.10/0.01
 		 * PR: kern/70158
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "FL" , "Nex*", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * ZICPlay USB MP3 Player with FM
 		 * PR: kern/75057
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "ACTIONS*" , "USB DISK*", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * TEAC USB floppy mechanisms
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "TEAC" , "FD-05*", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * Kingston DataTraveler II+ USB Pen-Drive.
 		 * Reported by: Pawel Jakub Dawidek <pjd@FreeBSD.org>
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "Kingston" , "DataTraveler II+",
 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * USB DISK Pro PMAP
 		 * Reported by: jhs
 		 * PR: usb/96381
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, " ", "USB DISK Pro", "PMAP"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * Motorola E398 Mobile Phone (TransFlash memory card).
 		 * Reported by: Wojciech A. Koszek <dunstan@FreeBSD.czest.pl>
 		 * PR: usb/89889
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "Motorola" , "Motorola Phone",
 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * Qware BeatZkey! Pro
 		 * PR: usb/79164
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "GENERIC", "USB DISK DEVICE",
 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * Time DPA20B 1GB MP3 Player
 		 * PR: usb/81846
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "USB2.0*", "(FS) FLASH DISK*",
 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * Samsung USB key 128Mb
 		 * PR: usb/90081
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "USB-DISK", "FreeDik-FlashUsb",
 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * Kingston DataTraveler 2.0 USB Flash memory.
 		 * PR: usb/89196
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "Kingston", "DataTraveler 2.0",
 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * Creative MUVO Slim mp3 player (USB)
 		 * PR: usb/86131
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "CREATIVE", "MuVo Slim",
 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE|DA_Q_NO_PREVENT
 		},
 	{
 		/*
 		 * United MP5512 Portable MP3 Player (2-in-1 USB DISK/MP3)
 		 * PR: usb/80487
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "Generic*", "MUSIC DISK",
 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * SanDisk Micro Cruzer 128MB
 		 * PR: usb/75970
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "SanDisk" , "Micro Cruzer",
 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * TOSHIBA TransMemory USB sticks
 		 * PR: kern/94660
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "TOSHIBA", "TransMemory",
 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * PNY USB 3.0 Flash Drives
 		*/
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "PNY", "USB 3.0 FD*",
 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE | DA_Q_NO_RC16
 	},
 	{
 		/*
 		 * PNY USB Flash keys
 		 * PR: usb/75578, usb/72344, usb/65436 
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "*" , "USB DISK*",
 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * Genesys 6-in-1 Card Reader
 		 * PR: usb/94647
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "Generic*", "STORAGE DEVICE*",
 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * Rekam Digital CAMERA
 		 * PR: usb/98713
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "CAMERA*", "4MP-9J6*",
 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * iRiver H10 MP3 player
 		 * PR: usb/102547
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "iriver", "H10*",
 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * iRiver U10 MP3 player
 		 * PR: usb/92306
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "iriver", "U10*",
 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * X-Micro Flash Disk
 		 * PR: usb/96901
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "X-Micro", "Flash Disk",
 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * EasyMP3 EM732X USB 2.0 Flash MP3 Player
 		 * PR: usb/96546
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "EM732X", "MP3 Player*",
 		"1.00"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * Denver MP3 player
 		 * PR: usb/107101
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "DENVER", "MP3 PLAYER",
 		 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * Philips USB Key Audio KEY013
 		 * PR: usb/68412
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "PHILIPS", "Key*", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE | DA_Q_NO_PREVENT
 	},
 	{
 		/*
 		 * JNC MP3 Player
 		 * PR: usb/94439
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "JNC*" , "MP3 Player*",
 		 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * SAMSUNG MP0402H
 		 * PR: usb/108427
 		 */
 		{T_DIRECT, SIP_MEDIA_FIXED, "SAMSUNG", "MP0402H", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * I/O Magic USB flash - Giga Bank
 		 * PR: usb/108810
 		 */
 		{T_DIRECT, SIP_MEDIA_FIXED, "GS-Magic", "stor*", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * JoyFly 128mb USB Flash Drive
 		 * PR: 96133
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "USB 2.0", "Flash Disk*",
 		 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * ChipsBnk usb stick
 		 * PR: 103702
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "ChipsBnk", "USB*",
 		 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * Storcase (Kingston) InfoStation IFS FC2/SATA-R 201A
 		 * PR: 129858
 		 */
 		{T_DIRECT, SIP_MEDIA_FIXED, "IFS", "FC2/SATA-R*",
 		 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * Samsung YP-U3 mp3-player
 		 * PR: 125398
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "Samsung", "YP-U3",
 		 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "Netac", "OnlyDisk*",
 		 "2000"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * Sony Cyber-Shot DSC cameras
 		 * PR: usb/137035
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "Sony", "Sony DSC", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE | DA_Q_NO_PREVENT
 	},
 	{
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "Kingston", "DataTraveler G3",
 		 "1.00"}, /*quirks*/ DA_Q_NO_PREVENT
 	},
 	{
 		/* At least several Transcent USB sticks lie on RC16. */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "JetFlash", "Transcend*",
 		 "*"}, /*quirks*/ DA_Q_NO_RC16
 	},
 	/* ATA/SATA devices over SAS/USB/... */
 	{
 		/* Hitachi Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "Hitachi", "H??????????E3*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Samsung Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "SAMSUNG HD155UI*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Samsung Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "SAMSUNG", "HD155UI*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Samsung Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "SAMSUNG HD204UI*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Samsung Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "SAMSUNG", "HD204UI*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Seagate Barracuda Green Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST????DL*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Seagate Barracuda Green Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ST????DL", "*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Seagate Barracuda Green Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST???DM*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Seagate Barracuda Green Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ST???DM*", "*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Seagate Barracuda Green Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST????DM*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Seagate Barracuda Green Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ST????DM", "*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Seagate Momentus Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST9500423AS*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Seagate Momentus Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ST950042", "3AS*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Seagate Momentus Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST9500424AS*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Seagate Momentus Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ST950042", "4AS*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Seagate Momentus Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST9640423AS*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Seagate Momentus Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ST964042", "3AS*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Seagate Momentus Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST9640424AS*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Seagate Momentus Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ST964042", "4AS*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Seagate Momentus Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST9750420AS*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Seagate Momentus Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ST975042", "0AS*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Seagate Momentus Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST9750422AS*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Seagate Momentus Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ST975042", "2AS*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Seagate Momentus Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST9750423AS*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Seagate Momentus Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ST975042", "3AS*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Seagate Momentus Thin Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST???LT*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* Seagate Momentus Thin Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ST???LT*", "*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* WDC Caviar Green Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD????RS*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* WDC Caviar Green Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "??RS*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* WDC Caviar Green Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD????RX*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* WDC Caviar Green Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "??RX*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* WDC Caviar Green Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD??????RS*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* WDC Caviar Green Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "????RS*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* WDC Caviar Green Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD??????RX*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* WDC Caviar Green Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "????RX*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* WDC Scorpio Black Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD???PKT*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* WDC Scorpio Black Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "?PKT*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* WDC Scorpio Black Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD?????PKT*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* WDC Scorpio Black Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "???PKT*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* WDC Scorpio Blue Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD???PVT*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* WDC Scorpio Blue Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "?PVT*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* WDC Scorpio Blue Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD?????PVT*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/* WDC Scorpio Blue Advanced Format (4k) drives */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "???PVT*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * Olympus FE-210 camera
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "OLYMPUS", "FE210*",
 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * LG UP3S MP3 player
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "LG", "UP3S",
 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * Laser MP3-2GA13 MP3 player
 		 */
 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "USB 2.0", "(HS) Flash Disk",
 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	{
 		/*
 		 * LaCie external 250GB Hard drive des by Porsche
 		 * Submitted by: Ben Stuyts <ben@altesco.nl>
 		 * PR: 121474
 		 */
 		{T_DIRECT, SIP_MEDIA_FIXED, "SAMSUNG", "HM250JI", "*"},
 		/*quirks*/ DA_Q_NO_SYNC_CACHE
 	},
 	/* SATA SSDs */
 	{
 		/*
 		 * Corsair Force 2 SSDs
 		 * 4k optimised & trim only works in 4k requests + 4k aligned
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "Corsair CSSD-F*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * Corsair Force 3 SSDs
 		 * 4k optimised & trim only works in 4k requests + 4k aligned
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "Corsair Force 3*", "*" },
 		/*quirks*/DA_Q_4K
 	},
         {
 		/*
 		 * Corsair Neutron GTX SSDs
 		 * 4k optimised & trim only works in 4k requests + 4k aligned
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "Corsair Neutron GTX*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * Corsair Force GT & GS SSDs
 		 * 4k optimised & trim only works in 4k requests + 4k aligned
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "Corsair Force G*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * Crucial M4 SSDs
 		 * 4k optimised & trim only works in 4k requests + 4k aligned
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "M4-CT???M4SSD2*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * Crucial RealSSD C300 SSDs
 		 * 4k optimised
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "C300-CTFDDAC???MAG*",
 		"*" }, /*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * Intel 320 Series SSDs
 		 * 4k optimised & trim only works in 4k requests + 4k aligned
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "INTEL SSDSA2CW*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * Intel 330 Series SSDs
 		 * 4k optimised & trim only works in 4k requests + 4k aligned
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "INTEL SSDSC2CT*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * Intel 510 Series SSDs
 		 * 4k optimised & trim only works in 4k requests + 4k aligned
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "INTEL SSDSC2MH*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * Intel 520 Series SSDs
 		 * 4k optimised & trim only works in 4k requests + 4k aligned
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "INTEL SSDSC2BW*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * Intel X25-M Series SSDs
 		 * 4k optimised & trim only works in 4k requests + 4k aligned
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "INTEL SSDSA2M*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * Kingston E100 Series SSDs
 		 * 4k optimised & trim only works in 4k requests + 4k aligned
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "KINGSTON SE100S3*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * Kingston HyperX 3k SSDs
 		 * 4k optimised & trim only works in 4k requests + 4k aligned
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "KINGSTON SH103S3*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * Marvell SSDs (entry taken from OpenSolaris)
 		 * 4k optimised & trim only works in 4k requests + 4k aligned
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "MARVELL SD88SA02*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * OCZ Agility 2 SSDs
 		 * 4k optimised & trim only works in 4k requests + 4k aligned
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "OCZ-AGILITY2*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * OCZ Agility 3 SSDs
 		 * 4k optimised & trim only works in 4k requests + 4k aligned
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "OCZ-AGILITY3*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * OCZ Deneva R Series SSDs
 		 * 4k optimised & trim only works in 4k requests + 4k aligned
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "DENRSTE251M45*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * OCZ Vertex 2 SSDs (inc pro series)
 		 * 4k optimised & trim only works in 4k requests + 4k aligned
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "OCZ?VERTEX2*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * OCZ Vertex 3 SSDs
 		 * 4k optimised & trim only works in 4k requests + 4k aligned
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "OCZ-VERTEX3*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * OCZ Vertex 4 SSDs
 		 * 4k optimised & trim only works in 4k requests + 4k aligned
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "OCZ-VERTEX4*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * Samsung 830 Series SSDs
 		 * 4k optimised & trim only works in 4k requests + 4k aligned
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "SAMSUNG SSD 830 Series*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * Samsung 840 SSDs
 		 * 4k optimised & trim only works in 4k requests + 4k aligned
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "Samsung SSD 840*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * Samsung 843T Series SSDs
 		 * 4k optimised
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "SAMSUNG MZ7WD*", "*" },
 		/*quirks*/DA_Q_4K
 	},
  	{
  		/*
 		 * Samsung 850 SSDs
 		 * 4k optimised & trim only works in 4k requests + 4k aligned
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "Samsung SSD 850*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * Samsung PM853T Series SSDs
 		 * 4k optimised
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "SAMSUNG MZ7GE*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * SuperTalent TeraDrive CT SSDs
 		 * 4k optimised & trim only works in 4k requests + 4k aligned
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "FTM??CT25H*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 	{
 		/*
 		 * XceedIOPS SATA SSDs
 		 * 4k optimised
 		 */
 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "SG9XCS2D*", "*" },
 		/*quirks*/DA_Q_4K
 	},
 };
 
 static	disk_strategy_t	dastrategy;
 static	dumper_t	dadump;
 static	periph_init_t	dainit;
 static	void		daasync(void *callback_arg, u_int32_t code,
 				struct cam_path *path, void *arg);
 static	void		dasysctlinit(void *context, int pending);
 static	int		dacmdsizesysctl(SYSCTL_HANDLER_ARGS);
 static	int		dadeletemethodsysctl(SYSCTL_HANDLER_ARGS);
 static	int		dadeletemaxsysctl(SYSCTL_HANDLER_ARGS);
 static	void		dadeletemethodset(struct da_softc *softc,
 					  da_delete_methods delete_method);
 static	off_t		dadeletemaxsize(struct da_softc *softc,
 					da_delete_methods delete_method);
 static	void		dadeletemethodchoose(struct da_softc *softc,
 					     da_delete_methods default_method);
 static	void		daprobedone(struct cam_periph *periph, union ccb *ccb);
 
 static	periph_ctor_t	daregister;
 static	periph_dtor_t	dacleanup;
 static	periph_start_t	dastart;
 static	periph_oninv_t	daoninvalidate;
 static	void		dadone(struct cam_periph *periph,
 			       union ccb *done_ccb);
 static  int		daerror(union ccb *ccb, u_int32_t cam_flags,
 				u_int32_t sense_flags);
 static void		daprevent(struct cam_periph *periph, int action);
 static void		dareprobe(struct cam_periph *periph);
 static void		dasetgeom(struct cam_periph *periph, uint32_t block_len,
 				  uint64_t maxsector,
 				  struct scsi_read_capacity_data_long *rcaplong,
 				  size_t rcap_size);
 static timeout_t	dasendorderedtag;
 static void		dashutdown(void *arg, int howto);
 static timeout_t	damediapoll;
 
 #ifndef	DA_DEFAULT_POLL_PERIOD
 #define	DA_DEFAULT_POLL_PERIOD	3
 #endif
 
 #ifndef DA_DEFAULT_TIMEOUT
 #define DA_DEFAULT_TIMEOUT 60	/* Timeout in seconds */
 #endif
 
 #ifndef	DA_DEFAULT_RETRY
 #define	DA_DEFAULT_RETRY	4
 #endif
 
 #ifndef	DA_DEFAULT_SEND_ORDERED
 #define	DA_DEFAULT_SEND_ORDERED	1
 #endif
 
 #define DA_SIO (softc->sort_io_queue >= 0 ? \
     softc->sort_io_queue : cam_sort_io_queues)
 
 static int da_poll_period = DA_DEFAULT_POLL_PERIOD;
 static int da_retry_count = DA_DEFAULT_RETRY;
 static int da_default_timeout = DA_DEFAULT_TIMEOUT;
 static int da_send_ordered = DA_DEFAULT_SEND_ORDERED;
 
 static SYSCTL_NODE(_kern_cam, OID_AUTO, da, CTLFLAG_RD, 0,
             "CAM Direct Access Disk driver");
 SYSCTL_INT(_kern_cam_da, OID_AUTO, poll_period, CTLFLAG_RWTUN,
            &da_poll_period, 0, "Media polling period in seconds");
 SYSCTL_INT(_kern_cam_da, OID_AUTO, retry_count, CTLFLAG_RWTUN,
            &da_retry_count, 0, "Normal I/O retry count");
 SYSCTL_INT(_kern_cam_da, OID_AUTO, default_timeout, CTLFLAG_RWTUN,
            &da_default_timeout, 0, "Normal I/O timeout (in seconds)");
 SYSCTL_INT(_kern_cam_da, OID_AUTO, send_ordered, CTLFLAG_RWTUN,
            &da_send_ordered, 0, "Send Ordered Tags");
 
 /*
  * DA_ORDEREDTAG_INTERVAL determines how often, relative
  * to the default timeout, we check to see whether an ordered
  * tagged transaction is appropriate to prevent simple tag
  * starvation.  Since we'd like to ensure that there is at least
  * 1/2 of the timeout length left for a starved transaction to
  * complete after we've sent an ordered tag, we must poll at least
  * four times in every timeout period.  This takes care of the worst
  * case where a starved transaction starts during an interval that
  * meets the requirement "don't send an ordered tag" test so it takes
  * us two intervals to determine that a tag must be sent.
  */
 #ifndef DA_ORDEREDTAG_INTERVAL
 #define DA_ORDEREDTAG_INTERVAL 4
 #endif
 
 static struct periph_driver dadriver =
 {
 	dainit, "da",
 	TAILQ_HEAD_INITIALIZER(dadriver.units), /* generation */ 0
 };
 
 PERIPHDRIVER_DECLARE(da, dadriver);
 
 static MALLOC_DEFINE(M_SCSIDA, "scsi_da", "scsi_da buffers");
 
 static int
 daopen(struct disk *dp)
 {
 	struct cam_periph *periph;
 	struct da_softc *softc;
 	int error;
 
 	periph = (struct cam_periph *)dp->d_drv1;
 	if (cam_periph_acquire(periph) != CAM_REQ_CMP) {
 		return (ENXIO);
 	}
 
 	cam_periph_lock(periph);
 	if ((error = cam_periph_hold(periph, PRIBIO|PCATCH)) != 0) {
 		cam_periph_unlock(periph);
 		cam_periph_release(periph);
 		return (error);
 	}
 
 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE | CAM_DEBUG_PERIPH,
 	    ("daopen\n"));
 
 	softc = (struct da_softc *)periph->softc;
 	dareprobe(periph);
 
 	/* Wait for the disk size update.  */
 	error = cam_periph_sleep(periph, &softc->disk->d_mediasize, PRIBIO,
 	    "dareprobe", 0);
 	if (error != 0)
 		xpt_print(periph->path, "unable to retrieve capacity data\n");
 
 	if (periph->flags & CAM_PERIPH_INVALID)
 		error = ENXIO;
 
 	if (error == 0 && (softc->flags & DA_FLAG_PACK_REMOVABLE) != 0 &&
 	    (softc->quirks & DA_Q_NO_PREVENT) == 0)
 		daprevent(periph, PR_PREVENT);
 
 	if (error == 0) {
 		softc->flags &= ~DA_FLAG_PACK_INVALID;
 		softc->flags |= DA_FLAG_OPEN;
 	}
 
 	cam_periph_unhold(periph);
 	cam_periph_unlock(periph);
 
 	if (error != 0)
 		cam_periph_release(periph);
 
 	return (error);
 }
 
 static int
 daclose(struct disk *dp)
 {
 	struct	cam_periph *periph;
 	struct	da_softc *softc;
 	union	ccb *ccb;
 	int error;
 
 	periph = (struct cam_periph *)dp->d_drv1;
 	softc = (struct da_softc *)periph->softc;
 	cam_periph_lock(periph);
 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE | CAM_DEBUG_PERIPH,
 	    ("daclose\n"));
 
 	if (cam_periph_hold(periph, PRIBIO) == 0) {
 
 		/* Flush disk cache. */
 		if ((softc->flags & DA_FLAG_DIRTY) != 0 &&
 		    (softc->quirks & DA_Q_NO_SYNC_CACHE) == 0 &&
 		    (softc->flags & DA_FLAG_PACK_INVALID) == 0) {
 			ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
 			scsi_synchronize_cache(&ccb->csio, /*retries*/1,
 			    /*cbfcnp*/dadone, MSG_SIMPLE_Q_TAG,
 			    /*begin_lba*/0, /*lb_count*/0, SSD_FULL_SIZE,
 			    5 * 60 * 1000);
 			error = cam_periph_runccb(ccb, daerror, /*cam_flags*/0,
 			    /*sense_flags*/SF_RETRY_UA | SF_QUIET_IR,
 			    softc->disk->d_devstat);
 			if (error == 0)
 				softc->flags &= ~DA_FLAG_DIRTY;
 			xpt_release_ccb(ccb);
 		}
 
 		/* Allow medium removal. */
 		if ((softc->flags & DA_FLAG_PACK_REMOVABLE) != 0 &&
 		    (softc->quirks & DA_Q_NO_PREVENT) == 0)
 			daprevent(periph, PR_ALLOW);
 
 		cam_periph_unhold(periph);
 	}
 
 	/*
 	 * If we've got removeable media, mark the blocksize as
 	 * unavailable, since it could change when new media is
 	 * inserted.
 	 */
 	if ((softc->flags & DA_FLAG_PACK_REMOVABLE) != 0)
 		softc->disk->d_devstat->flags |= DEVSTAT_BS_UNAVAILABLE;
 
 	softc->flags &= ~DA_FLAG_OPEN;
 	while (softc->refcount != 0)
 		cam_periph_sleep(periph, &softc->refcount, PRIBIO, "daclose", 1);
 	cam_periph_unlock(periph);
 	cam_periph_release(periph);
 	return (0);
 }
 
 static void
 daschedule(struct cam_periph *periph)
 {
 	struct da_softc *softc = (struct da_softc *)periph->softc;
 
 	if (softc->state != DA_STATE_NORMAL)
 		return;
 
 	/* Check if we have more work to do. */
 	if (bioq_first(&softc->bio_queue) ||
 	    (!softc->delete_running && bioq_first(&softc->delete_queue)) ||
 	    softc->tur) {
 		xpt_schedule(periph, CAM_PRIORITY_NORMAL);
 	}
 }
 
 /*
  * Actually translate the requested transfer into one the physical driver
  * can understand.  The transfer is described by a buf and will include
  * only one physical transfer.
  */
 static void
 dastrategy(struct bio *bp)
 {
 	struct cam_periph *periph;
 	struct da_softc *softc;
 	
 	periph = (struct cam_periph *)bp->bio_disk->d_drv1;
 	softc = (struct da_softc *)periph->softc;
 
 	cam_periph_lock(periph);
 
 	/*
 	 * If the device has been made invalid, error out
 	 */
 	if ((softc->flags & DA_FLAG_PACK_INVALID)) {
 		cam_periph_unlock(periph);
 		biofinish(bp, NULL, ENXIO);
 		return;
 	}
 
 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dastrategy(%p)\n", bp));
 
 	/*
 	 * Place it in the queue of disk activities for this disk
 	 */
 	if (bp->bio_cmd == BIO_DELETE) {
 		bioq_disksort(&softc->delete_queue, bp);
 	} else if (DA_SIO) {
 		bioq_disksort(&softc->bio_queue, bp);
 	} else {
 		bioq_insert_tail(&softc->bio_queue, bp);
 	}
 
 	/*
 	 * Schedule ourselves for performing the work.
 	 */
 	daschedule(periph);
 	cam_periph_unlock(periph);
 
 	return;
 }
 
 static int
 dadump(void *arg, void *virtual, vm_offset_t physical, off_t offset, size_t length)
 {
 	struct	    cam_periph *periph;
 	struct	    da_softc *softc;
 	u_int	    secsize;
 	struct	    ccb_scsiio csio;
 	struct	    disk *dp;
 	int	    error = 0;
 
 	dp = arg;
 	periph = dp->d_drv1;
 	softc = (struct da_softc *)periph->softc;
 	cam_periph_lock(periph);
 	secsize = softc->params.secsize;
 	
 	if ((softc->flags & DA_FLAG_PACK_INVALID) != 0) {
 		cam_periph_unlock(periph);
 		return (ENXIO);
 	}
 
 	if (length > 0) {
 		xpt_setup_ccb(&csio.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
 		csio.ccb_h.ccb_state = DA_CCB_DUMP;
 		scsi_read_write(&csio,
 				/*retries*/0,
 				dadone,
 				MSG_ORDERED_Q_TAG,
 				/*read*/SCSI_RW_WRITE,
 				/*byte2*/0,
 				/*minimum_cmd_size*/ softc->minimum_cmd_size,
 				offset / secsize,
 				length / secsize,
 				/*data_ptr*/(u_int8_t *) virtual,
 				/*dxfer_len*/length,
 				/*sense_len*/SSD_FULL_SIZE,
 				da_default_timeout * 1000);
 		xpt_polled_action((union ccb *)&csio);
 
 		error = cam_periph_error((union ccb *)&csio,
 		    0, SF_NO_RECOVERY | SF_NO_RETRY, NULL);
 		if ((csio.ccb_h.status & CAM_DEV_QFRZN) != 0)
 			cam_release_devq(csio.ccb_h.path, /*relsim_flags*/0,
 			    /*reduction*/0, /*timeout*/0, /*getcount_only*/0);
 		if (error != 0)
 			printf("Aborting dump due to I/O error.\n");
 		cam_periph_unlock(periph);
 		return (error);
 	}
 		
 	/*
 	 * Sync the disk cache contents to the physical media.
 	 */
 	if ((softc->quirks & DA_Q_NO_SYNC_CACHE) == 0) {
 
 		xpt_setup_ccb(&csio.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
 		csio.ccb_h.ccb_state = DA_CCB_DUMP;
 		scsi_synchronize_cache(&csio,
 				       /*retries*/0,
 				       /*cbfcnp*/dadone,
 				       MSG_SIMPLE_Q_TAG,
 				       /*begin_lba*/0,/* Cover the whole disk */
 				       /*lb_count*/0,
 				       SSD_FULL_SIZE,
 				       5 * 60 * 1000);
 		xpt_polled_action((union ccb *)&csio);
 
 		error = cam_periph_error((union ccb *)&csio,
 		    0, SF_NO_RECOVERY | SF_NO_RETRY | SF_QUIET_IR, NULL);
 		if ((csio.ccb_h.status & CAM_DEV_QFRZN) != 0)
 			cam_release_devq(csio.ccb_h.path, /*relsim_flags*/0,
 			    /*reduction*/0, /*timeout*/0, /*getcount_only*/0);
 		if (error != 0)
 			xpt_print(periph->path, "Synchronize cache failed\n");
 	}
 	cam_periph_unlock(periph);
 	return (error);
 }
 
 static int
 dagetattr(struct bio *bp)
 {
 	int ret;
 	struct cam_periph *periph;
 
 	periph = (struct cam_periph *)bp->bio_disk->d_drv1;
 	cam_periph_lock(periph);
 	ret = xpt_getattr(bp->bio_data, bp->bio_length, bp->bio_attribute,
 	    periph->path);
 	cam_periph_unlock(periph);
 	if (ret == 0)
 		bp->bio_completed = bp->bio_length;
 	return ret;
 }
 
 static void
 dainit(void)
 {
 	cam_status status;
 
 	/*
 	 * Install a global async callback.  This callback will
 	 * receive async callbacks like "new device found".
 	 */
 	status = xpt_register_async(AC_FOUND_DEVICE, daasync, NULL, NULL);
 
 	if (status != CAM_REQ_CMP) {
 		printf("da: Failed to attach master async callback "
 		       "due to status 0x%x!\n", status);
 	} else if (da_send_ordered) {
 
 		/* Register our shutdown event handler */
 		if ((EVENTHANDLER_REGISTER(shutdown_post_sync, dashutdown, 
 					   NULL, SHUTDOWN_PRI_DEFAULT)) == NULL)
 		    printf("dainit: shutdown event registration failed!\n");
 	}
 }
 
 /*
  * Callback from GEOM, called when it has finished cleaning up its
  * resources.
  */
 static void
 dadiskgonecb(struct disk *dp)
 {
 	struct cam_periph *periph;
 
 	periph = (struct cam_periph *)dp->d_drv1;
 	cam_periph_release(periph);
 }
 
 static void
 daoninvalidate(struct cam_periph *periph)
 {
 	struct da_softc *softc;
 
 	softc = (struct da_softc *)periph->softc;
 
 	/*
 	 * De-register any async callbacks.
 	 */
 	xpt_register_async(0, daasync, periph, periph->path);
 
 	softc->flags |= DA_FLAG_PACK_INVALID;
 
 	/*
 	 * Return all queued I/O with ENXIO.
 	 * XXX Handle any transactions queued to the card
 	 *     with XPT_ABORT_CCB.
 	 */
 	bioq_flush(&softc->bio_queue, NULL, ENXIO);
 	bioq_flush(&softc->delete_queue, NULL, ENXIO);
 
 	/*
 	 * Tell GEOM that we've gone away, we'll get a callback when it is
 	 * done cleaning up its resources.
 	 */
 	disk_gone(softc->disk);
 }
 
 static void
 dacleanup(struct cam_periph *periph)
 {
 	struct da_softc *softc;
 
 	softc = (struct da_softc *)periph->softc;
 
 	cam_periph_unlock(periph);
 
 	/*
 	 * If we can't free the sysctl tree, oh well...
 	 */
 	if ((softc->flags & DA_FLAG_SCTX_INIT) != 0
 	    && sysctl_ctx_free(&softc->sysctl_ctx) != 0) {
 		xpt_print(periph->path, "can't remove sysctl context\n");
 	}
 
 	callout_drain(&softc->mediapoll_c);
 	disk_destroy(softc->disk);
 	callout_drain(&softc->sendordered_c);
 	free(softc, M_DEVBUF);
 	cam_periph_lock(periph);
 }
 
 static void
 daasync(void *callback_arg, u_int32_t code,
 	struct cam_path *path, void *arg)
 {
 	struct cam_periph *periph;
 	struct da_softc *softc;
 
 	periph = (struct cam_periph *)callback_arg;
 	switch (code) {
 	case AC_FOUND_DEVICE:
 	{
 		struct ccb_getdev *cgd;
 		cam_status status;
  
 		cgd = (struct ccb_getdev *)arg;
 		if (cgd == NULL)
 			break;
 
 		if (cgd->protocol != PROTO_SCSI)
 			break;
 
 		if (SID_TYPE(&cgd->inq_data) != T_DIRECT
 		    && SID_TYPE(&cgd->inq_data) != T_RBC
 		    && SID_TYPE(&cgd->inq_data) != T_OPTICAL)
 			break;
 
 		/*
 		 * Allocate a peripheral instance for
 		 * this device and start the probe
 		 * process.
 		 */
 		status = cam_periph_alloc(daregister, daoninvalidate,
 					  dacleanup, dastart,
 					  "da", CAM_PERIPH_BIO,
 					  path, daasync,
 					  AC_FOUND_DEVICE, cgd);
 
 		if (status != CAM_REQ_CMP
 		 && status != CAM_REQ_INPROG)
 			printf("daasync: Unable to attach to new device "
 				"due to status 0x%x\n", status);
 		return;
 	}
 	case AC_ADVINFO_CHANGED:
 	{
 		uintptr_t buftype;
 
 		buftype = (uintptr_t)arg;
 		if (buftype == CDAI_TYPE_PHYS_PATH) {
 			struct da_softc *softc;
 
 			softc = periph->softc;
 			disk_attr_changed(softc->disk, "GEOM::physpath",
 					  M_NOWAIT);
 		}
 		break;
 	}
 	case AC_UNIT_ATTENTION:
 	{
 		union ccb *ccb;
 		int error_code, sense_key, asc, ascq;
 
 		softc = (struct da_softc *)periph->softc;
 		ccb = (union ccb *)arg;
 
 		/*
 		 * Handle all UNIT ATTENTIONs except our own,
 		 * as they will be handled by daerror().
 		 */
 		if (xpt_path_periph(ccb->ccb_h.path) != periph &&
 		    scsi_extract_sense_ccb(ccb,
 		     &error_code, &sense_key, &asc, &ascq)) {
 			if (asc == 0x2A && ascq == 0x09) {
 				xpt_print(ccb->ccb_h.path,
 				    "Capacity data has changed\n");
 				softc->flags &= ~DA_FLAG_PROBED;
 				dareprobe(periph);
 			} else if (asc == 0x28 && ascq == 0x00) {
 				softc->flags &= ~DA_FLAG_PROBED;
 				disk_media_changed(softc->disk, M_NOWAIT);
 			} else if (asc == 0x3F && ascq == 0x03) {
 				xpt_print(ccb->ccb_h.path,
 				    "INQUIRY data has changed\n");
 				softc->flags &= ~DA_FLAG_PROBED;
 				dareprobe(periph);
 			}
 		}
 		cam_periph_async(periph, code, path, arg);
 		break;
 	}
 	case AC_SCSI_AEN:
 		softc = (struct da_softc *)periph->softc;
 		if (!softc->tur) {
 			if (cam_periph_acquire(periph) == CAM_REQ_CMP) {
 				softc->tur = 1;
 				daschedule(periph);
 			}
 		}
 		/* FALLTHROUGH */
 	case AC_SENT_BDR:
 	case AC_BUS_RESET:
 	{
 		struct ccb_hdr *ccbh;
 
 		softc = (struct da_softc *)periph->softc;
 		/*
 		 * Don't fail on the expected unit attention
 		 * that will occur.
 		 */
 		softc->flags |= DA_FLAG_RETRY_UA;
 		LIST_FOREACH(ccbh, &softc->pending_ccbs, periph_links.le)
 			ccbh->ccb_state |= DA_CCB_RETRY_UA;
 		break;
 	}
 	default:
 		break;
 	}
 	cam_periph_async(periph, code, path, arg);
 }
 
 static void
 dasysctlinit(void *context, int pending)
 {
 	struct cam_periph *periph;
 	struct da_softc *softc;
 	char tmpstr[80], tmpstr2[80];
 	struct ccb_trans_settings cts;
 
 	periph = (struct cam_periph *)context;
 	/*
 	 * periph was held for us when this task was enqueued
 	 */
 	if (periph->flags & CAM_PERIPH_INVALID) {
 		cam_periph_release(periph);
 		return;
 	}
 
 	softc = (struct da_softc *)periph->softc;
 	snprintf(tmpstr, sizeof(tmpstr), "CAM DA unit %d", periph->unit_number);
 	snprintf(tmpstr2, sizeof(tmpstr2), "%d", periph->unit_number);
 
 	sysctl_ctx_init(&softc->sysctl_ctx);
 	softc->flags |= DA_FLAG_SCTX_INIT;
 	softc->sysctl_tree = SYSCTL_ADD_NODE(&softc->sysctl_ctx,
 		SYSCTL_STATIC_CHILDREN(_kern_cam_da), OID_AUTO, tmpstr2,
 		CTLFLAG_RD, 0, tmpstr);
 	if (softc->sysctl_tree == NULL) {
 		printf("dasysctlinit: unable to allocate sysctl tree\n");
 		cam_periph_release(periph);
 		return;
 	}
 
 	/*
 	 * Now register the sysctl handler, so the user can change the value on
 	 * the fly.
 	 */
 	SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
 		OID_AUTO, "delete_method", CTLTYPE_STRING | CTLFLAG_RW,
 		softc, 0, dadeletemethodsysctl, "A",
 		"BIO_DELETE execution method");
 	SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
 		OID_AUTO, "delete_max", CTLTYPE_U64 | CTLFLAG_RW,
 		softc, 0, dadeletemaxsysctl, "Q",
 		"Maximum BIO_DELETE size");
 	SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
 		OID_AUTO, "minimum_cmd_size", CTLTYPE_INT | CTLFLAG_RW,
 		&softc->minimum_cmd_size, 0, dacmdsizesysctl, "I",
 		"Minimum CDB size");
 	SYSCTL_ADD_INT(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
 		OID_AUTO, "sort_io_queue", CTLFLAG_RW, &softc->sort_io_queue, 0,
 		"Sort IO queue to try and optimise disk access patterns");
 
 	SYSCTL_ADD_INT(&softc->sysctl_ctx,
 		       SYSCTL_CHILDREN(softc->sysctl_tree),
 		       OID_AUTO,
 		       "error_inject",
 		       CTLFLAG_RW,
 		       &softc->error_inject,
 		       0,
 		       "error_inject leaf");
 
 
 	/*
 	 * Add some addressing info.
 	 */
 	memset(&cts, 0, sizeof (cts));
 	xpt_setup_ccb(&cts.ccb_h, periph->path, CAM_PRIORITY_NONE);
 	cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
 	cts.type = CTS_TYPE_CURRENT_SETTINGS;
 	cam_periph_lock(periph);
 	xpt_action((union ccb *)&cts);
 	cam_periph_unlock(periph);
 	if (cts.ccb_h.status != CAM_REQ_CMP) {
 		cam_periph_release(periph);
 		return;
 	}
 	if (cts.protocol == PROTO_SCSI && cts.transport == XPORT_FC) {
 		struct ccb_trans_settings_fc *fc = &cts.xport_specific.fc;
 		if (fc->valid & CTS_FC_VALID_WWPN) {
 			softc->wwpn = fc->wwpn;
 			SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
 			    SYSCTL_CHILDREN(softc->sysctl_tree),
 			    OID_AUTO, "wwpn", CTLFLAG_RD,
 			    &softc->wwpn, "World Wide Port Name");
 		}
 	}
 	cam_periph_release(periph);
 }
 
 static int
 dadeletemaxsysctl(SYSCTL_HANDLER_ARGS)
 {
 	int error;
 	uint64_t value;
 	struct da_softc *softc;
 
 	softc = (struct da_softc *)arg1;
 
 	value = softc->disk->d_delmaxsize;
 	error = sysctl_handle_64(oidp, &value, 0, req);
 	if ((error != 0) || (req->newptr == NULL))
 		return (error);
 
 	/* only accept values smaller than the calculated value */
 	if (value > dadeletemaxsize(softc, softc->delete_method)) {
 		return (EINVAL);
 	}
 	softc->disk->d_delmaxsize = value;
 
 	return (0);
 }
 
 static int
 dacmdsizesysctl(SYSCTL_HANDLER_ARGS)
 {
 	int error, value;
 
 	value = *(int *)arg1;
 
 	error = sysctl_handle_int(oidp, &value, 0, req);
 
 	if ((error != 0)
 	 || (req->newptr == NULL))
 		return (error);
 
 	/*
 	 * Acceptable values here are 6, 10, 12 or 16.
 	 */
 	if (value < 6)
 		value = 6;
 	else if ((value > 6)
 	      && (value <= 10))
 		value = 10;
 	else if ((value > 10)
 	      && (value <= 12))
 		value = 12;
 	else if (value > 12)
 		value = 16;
 
 	*(int *)arg1 = value;
 
 	return (0);
 }
 
 static void
 dadeletemethodset(struct da_softc *softc, da_delete_methods delete_method)
 {
 
 
 	softc->delete_method = delete_method;
 	softc->disk->d_delmaxsize = dadeletemaxsize(softc, delete_method);
 	softc->delete_func = da_delete_functions[delete_method];
 
 	if (softc->delete_method > DA_DELETE_DISABLE)
 		softc->disk->d_flags |= DISKFLAG_CANDELETE;
 	else
 		softc->disk->d_flags &= ~DISKFLAG_CANDELETE;
 }
 
 static off_t
 dadeletemaxsize(struct da_softc *softc, da_delete_methods delete_method)
 {
 	off_t sectors;
 
 	switch(delete_method) {
 	case DA_DELETE_UNMAP:
 		sectors = (off_t)softc->unmap_max_lba;
 		break;
 	case DA_DELETE_ATA_TRIM:
 		sectors = (off_t)ATA_DSM_RANGE_MAX * softc->trim_max_ranges;
 		break;
 	case DA_DELETE_WS16:
-		sectors = (off_t)min(softc->ws_max_blks, WS16_MAX_BLKS);
+		sectors = omin(softc->ws_max_blks, WS16_MAX_BLKS);
 		break;
 	case DA_DELETE_ZERO:
 	case DA_DELETE_WS10:
-		sectors = (off_t)min(softc->ws_max_blks, WS10_MAX_BLKS);
+		sectors = omin(softc->ws_max_blks, WS10_MAX_BLKS);
 		break;
 	default:
 		return 0;
 	}
 
 	return (off_t)softc->params.secsize *
-	    min(sectors, (off_t)softc->params.sectors);
+	    omin(sectors, softc->params.sectors);
 }
 
 static void
 daprobedone(struct cam_periph *periph, union ccb *ccb)
 {
 	struct da_softc *softc;
 
 	softc = (struct da_softc *)periph->softc;
 
 	dadeletemethodchoose(softc, DA_DELETE_NONE);
 
 	if (bootverbose && (softc->flags & DA_FLAG_ANNOUNCED) == 0) {
 		char buf[80];
 		int i, sep;
 
 		snprintf(buf, sizeof(buf), "Delete methods: <");
 		sep = 0;
 		for (i = DA_DELETE_MIN; i <= DA_DELETE_MAX; i++) {
 			if (softc->delete_available & (1 << i)) {
 				if (sep) {
 					strlcat(buf, ",", sizeof(buf));
 				} else {
 				    sep = 1;
 				}
 				strlcat(buf, da_delete_method_names[i],
 				    sizeof(buf));
 				if (i == softc->delete_method) {
 					strlcat(buf, "(*)", sizeof(buf));
 				}
 			}
 		}
 		if (sep == 0) {
 			if (softc->delete_method == DA_DELETE_NONE) 
 				strlcat(buf, "NONE(*)", sizeof(buf));
 			else
 				strlcat(buf, "DISABLED(*)", sizeof(buf));
 		}
 		strlcat(buf, ">", sizeof(buf));
 		printf("%s%d: %s\n", periph->periph_name,
 		    periph->unit_number, buf);
 	}
 
 	/*
 	 * Since our peripheral may be invalidated by an error
 	 * above or an external event, we must release our CCB
 	 * before releasing the probe lock on the peripheral.
 	 * The peripheral will only go away once the last lock
 	 * is removed, and we need it around for the CCB release
 	 * operation.
 	 */
 	xpt_release_ccb(ccb);
 	softc->state = DA_STATE_NORMAL;
 	softc->flags |= DA_FLAG_PROBED;
 	daschedule(periph);
 	wakeup(&softc->disk->d_mediasize);
 	if ((softc->flags & DA_FLAG_ANNOUNCED) == 0) {
 		softc->flags |= DA_FLAG_ANNOUNCED;
 		cam_periph_unhold(periph);
 	} else
 		cam_periph_release_locked(periph);
 }
 
 static void
 dadeletemethodchoose(struct da_softc *softc, da_delete_methods default_method)
 {
 	int i, delete_method;
 
 	delete_method = default_method;
 
 	/*
 	 * Use the pre-defined order to choose the best
 	 * performing delete.
 	 */
 	for (i = DA_DELETE_MIN; i <= DA_DELETE_MAX; i++) {
 		if (softc->delete_available & (1 << i)) {
 			dadeletemethodset(softc, i);
 			return;
 		}
 	}
 	dadeletemethodset(softc, delete_method);
 }
 
 static int
 dadeletemethodsysctl(SYSCTL_HANDLER_ARGS)
 {
 	char buf[16];
 	const char *p;
 	struct da_softc *softc;
 	int i, error, methods, value;
 
 	softc = (struct da_softc *)arg1;
 
 	value = softc->delete_method;
 	if (value < 0 || value > DA_DELETE_MAX)
 		p = "UNKNOWN";
 	else
 		p = da_delete_method_names[value];
 	strncpy(buf, p, sizeof(buf));
 	error = sysctl_handle_string(oidp, buf, sizeof(buf), req);
 	if (error != 0 || req->newptr == NULL)
 		return (error);
 	methods = softc->delete_available | (1 << DA_DELETE_DISABLE);
 	for (i = 0; i <= DA_DELETE_MAX; i++) {
 		if (!(methods & (1 << i)) ||
 		    strcmp(buf, da_delete_method_names[i]) != 0)
 			continue;
 		dadeletemethodset(softc, i);
 		return (0);
 	}
 	return (EINVAL);
 }
 
 static cam_status
 daregister(struct cam_periph *periph, void *arg)
 {
 	struct da_softc *softc;
 	struct ccb_pathinq cpi;
 	struct ccb_getdev *cgd;
 	char tmpstr[80];
 	caddr_t match;
 
 	cgd = (struct ccb_getdev *)arg;
 	if (cgd == NULL) {
 		printf("daregister: no getdev CCB, can't register device\n");
 		return(CAM_REQ_CMP_ERR);
 	}
 
 	softc = (struct da_softc *)malloc(sizeof(*softc), M_DEVBUF,
 	    M_NOWAIT|M_ZERO);
 
 	if (softc == NULL) {
 		printf("daregister: Unable to probe new device. "
 		       "Unable to allocate softc\n");				
 		return(CAM_REQ_CMP_ERR);
 	}
 
 	LIST_INIT(&softc->pending_ccbs);
 	softc->state = DA_STATE_PROBE_RC;
 	bioq_init(&softc->bio_queue);
 	bioq_init(&softc->delete_queue);
 	bioq_init(&softc->delete_run_queue);
 	if (SID_IS_REMOVABLE(&cgd->inq_data))
 		softc->flags |= DA_FLAG_PACK_REMOVABLE;
 	softc->unmap_max_ranges = UNMAP_MAX_RANGES;
 	softc->unmap_max_lba = UNMAP_RANGE_MAX;
 	softc->ws_max_blks = WS16_MAX_BLKS;
 	softc->trim_max_ranges = ATA_TRIM_MAX_RANGES;
 	softc->sort_io_queue = -1;
 
 	periph->softc = softc;
 
 	/*
 	 * See if this device has any quirks.
 	 */
 	match = cam_quirkmatch((caddr_t)&cgd->inq_data,
 			       (caddr_t)da_quirk_table,
 			       sizeof(da_quirk_table)/sizeof(*da_quirk_table),
 			       sizeof(*da_quirk_table), scsi_inquiry_match);
 
 	if (match != NULL)
 		softc->quirks = ((struct da_quirk_entry *)match)->quirks;
 	else
 		softc->quirks = DA_Q_NONE;
 
 	/* Check if the SIM does not want 6 byte commands */
 	bzero(&cpi, sizeof(cpi));
 	xpt_setup_ccb(&cpi.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
 	cpi.ccb_h.func_code = XPT_PATH_INQ;
 	xpt_action((union ccb *)&cpi);
 	if (cpi.ccb_h.status == CAM_REQ_CMP && (cpi.hba_misc & PIM_NO_6_BYTE))
 		softc->quirks |= DA_Q_NO_6_BYTE;
 
 	TASK_INIT(&softc->sysctl_task, 0, dasysctlinit, periph);
 
 	/*
 	 * Take an exclusive refcount on the periph while dastart is called
 	 * to finish the probe.  The reference will be dropped in dadone at
 	 * the end of probe.
 	 */
 	(void)cam_periph_hold(periph, PRIBIO);
 
 	/*
 	 * Schedule a periodic event to occasionally send an
 	 * ordered tag to a device.
 	 */
 	callout_init_mtx(&softc->sendordered_c, cam_periph_mtx(periph), 0);
 	callout_reset(&softc->sendordered_c,
 	    (da_default_timeout * hz) / DA_ORDEREDTAG_INTERVAL,
 	    dasendorderedtag, softc);
 
 	cam_periph_unlock(periph);
 	/*
 	 * RBC devices don't have to support READ(6), only READ(10).
 	 */
 	if (softc->quirks & DA_Q_NO_6_BYTE || SID_TYPE(&cgd->inq_data) == T_RBC)
 		softc->minimum_cmd_size = 10;
 	else
 		softc->minimum_cmd_size = 6;
 
 	/*
 	 * Load the user's default, if any.
 	 */
 	snprintf(tmpstr, sizeof(tmpstr), "kern.cam.da.%d.minimum_cmd_size",
 		 periph->unit_number);
 	TUNABLE_INT_FETCH(tmpstr, &softc->minimum_cmd_size);
 
 	/*
 	 * 6, 10, 12 and 16 are the currently permissible values.
 	 */
 	if (softc->minimum_cmd_size < 6)
 		softc->minimum_cmd_size = 6;
 	else if ((softc->minimum_cmd_size > 6)
 	      && (softc->minimum_cmd_size <= 10))
 		softc->minimum_cmd_size = 10;
 	else if ((softc->minimum_cmd_size > 10)
 	      && (softc->minimum_cmd_size <= 12))
 		softc->minimum_cmd_size = 12;
 	else if (softc->minimum_cmd_size > 12)
 		softc->minimum_cmd_size = 16;
 
 	/* Predict whether device may support READ CAPACITY(16). */
 	if (SID_ANSI_REV(&cgd->inq_data) >= SCSI_REV_SPC3 &&
 	    (softc->quirks & DA_Q_NO_RC16) == 0) {
 		softc->flags |= DA_FLAG_CAN_RC16;
 		softc->state = DA_STATE_PROBE_RC16;
 	}
 
 	/*
 	 * Register this media as a disk.
 	 */
 	softc->disk = disk_alloc();
 	softc->disk->d_devstat = devstat_new_entry(periph->periph_name,
 			  periph->unit_number, 0,
 			  DEVSTAT_BS_UNAVAILABLE,
 			  SID_TYPE(&cgd->inq_data) |
 			  XPORT_DEVSTAT_TYPE(cpi.transport),
 			  DEVSTAT_PRIORITY_DISK);
 	softc->disk->d_open = daopen;
 	softc->disk->d_close = daclose;
 	softc->disk->d_strategy = dastrategy;
 	softc->disk->d_dump = dadump;
 	softc->disk->d_getattr = dagetattr;
 	softc->disk->d_gone = dadiskgonecb;
 	softc->disk->d_name = "da";
 	softc->disk->d_drv1 = periph;
 	if (cpi.maxio == 0)
 		softc->maxio = DFLTPHYS;	/* traditional default */
 	else if (cpi.maxio > MAXPHYS)
 		softc->maxio = MAXPHYS;		/* for safety */
 	else
 		softc->maxio = cpi.maxio;
 	softc->disk->d_maxsize = softc->maxio;
 	softc->disk->d_unit = periph->unit_number;
 	softc->disk->d_flags = DISKFLAG_DIRECT_COMPLETION;
 	if ((softc->quirks & DA_Q_NO_SYNC_CACHE) == 0)
 		softc->disk->d_flags |= DISKFLAG_CANFLUSHCACHE;
 	if ((cpi.hba_misc & PIM_UNMAPPED) != 0)
 		softc->disk->d_flags |= DISKFLAG_UNMAPPED_BIO;
 	cam_strvis(softc->disk->d_descr, cgd->inq_data.vendor,
 	    sizeof(cgd->inq_data.vendor), sizeof(softc->disk->d_descr));
 	strlcat(softc->disk->d_descr, " ", sizeof(softc->disk->d_descr));
 	cam_strvis(&softc->disk->d_descr[strlen(softc->disk->d_descr)],
 	    cgd->inq_data.product, sizeof(cgd->inq_data.product),
 	    sizeof(softc->disk->d_descr) - strlen(softc->disk->d_descr));
 	softc->disk->d_hba_vendor = cpi.hba_vendor;
 	softc->disk->d_hba_device = cpi.hba_device;
 	softc->disk->d_hba_subvendor = cpi.hba_subvendor;
 	softc->disk->d_hba_subdevice = cpi.hba_subdevice;
 
 	/*
 	 * Acquire a reference to the periph before we register with GEOM.
 	 * We'll release this reference once GEOM calls us back (via
 	 * dadiskgonecb()) telling us that our provider has been freed.
 	 */
 	if (cam_periph_acquire(periph) != CAM_REQ_CMP) {
 		xpt_print(periph->path, "%s: lost periph during "
 			  "registration!\n", __func__);
 		cam_periph_lock(periph);
 		return (CAM_REQ_CMP_ERR);
 	}
 
 	disk_create(softc->disk, DISK_VERSION);
 	cam_periph_lock(periph);
 
 	/*
 	 * Add async callbacks for events of interest.
 	 * I don't bother checking if this fails as,
 	 * in most cases, the system will function just
 	 * fine without them and the only alternative
 	 * would be to not attach the device on failure.
 	 */
 	xpt_register_async(AC_SENT_BDR | AC_BUS_RESET | AC_LOST_DEVICE |
 	    AC_ADVINFO_CHANGED | AC_SCSI_AEN | AC_UNIT_ATTENTION,
 	    daasync, periph, periph->path);
 
 	/*
 	 * Emit an attribute changed notification just in case 
 	 * physical path information arrived before our async
 	 * event handler was registered, but after anyone attaching
 	 * to our disk device polled it.
 	 */
 	disk_attr_changed(softc->disk, "GEOM::physpath", M_NOWAIT);
 
 	/*
 	 * Schedule a periodic media polling events.
 	 */
 	callout_init_mtx(&softc->mediapoll_c, cam_periph_mtx(periph), 0);
 	if ((softc->flags & DA_FLAG_PACK_REMOVABLE) &&
 	    (cgd->inq_flags & SID_AEN) == 0 &&
 	    da_poll_period != 0)
 		callout_reset(&softc->mediapoll_c, da_poll_period * hz,
 		    damediapoll, periph);
 
 	xpt_schedule(periph, CAM_PRIORITY_DEV);
 
 	return(CAM_REQ_CMP);
 }
 
 static void
 dastart(struct cam_periph *periph, union ccb *start_ccb)
 {
 	struct da_softc *softc;
 
 	softc = (struct da_softc *)periph->softc;
 
 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dastart\n"));
 
 skipstate:
 	switch (softc->state) {
 	case DA_STATE_NORMAL:
 	{
 		struct bio *bp;
 		uint8_t tag_code;
 
 		/* Run BIO_DELETE if not running yet. */
 		if (!softc->delete_running &&
 		    (bp = bioq_first(&softc->delete_queue)) != NULL) {
 			if (softc->delete_func != NULL) {
 				softc->delete_func(periph, start_ccb, bp);
 				goto out;
 			} else {
 				bioq_flush(&softc->delete_queue, NULL, 0);
 				/* FALLTHROUGH */
 			}
 		}
 
 		/* Run regular command. */
 		bp = bioq_takefirst(&softc->bio_queue);
 		if (bp == NULL) {
 			if (softc->tur) {
 				softc->tur = 0;
 				scsi_test_unit_ready(&start_ccb->csio,
 				     /*retries*/ da_retry_count,
 				     dadone,
 				     MSG_SIMPLE_Q_TAG,
 				     SSD_FULL_SIZE,
 				     da_default_timeout * 1000);
 				start_ccb->ccb_h.ccb_bp = NULL;
 				start_ccb->ccb_h.ccb_state = DA_CCB_TUR;
 				xpt_action(start_ccb);
 			} else
 				xpt_release_ccb(start_ccb);
 			break;
 		}
 		if (softc->tur) {
 			softc->tur = 0;
 			cam_periph_release_locked(periph);
 		}
 
 		if ((bp->bio_flags & BIO_ORDERED) != 0 ||
 		    (softc->flags & DA_FLAG_NEED_OTAG) != 0) {
 			softc->flags &= ~DA_FLAG_NEED_OTAG;
 			softc->flags |= DA_FLAG_WAS_OTAG;
 			tag_code = MSG_ORDERED_Q_TAG;
 		} else {
 			tag_code = MSG_SIMPLE_Q_TAG;
 		}
 
 		switch (bp->bio_cmd) {
 		case BIO_WRITE:
 			softc->flags |= DA_FLAG_DIRTY;
 			/* FALLTHROUGH */
 		case BIO_READ:
 			scsi_read_write(&start_ccb->csio,
 					/*retries*/da_retry_count,
 					/*cbfcnp*/dadone,
 					/*tag_action*/tag_code,
 					/*read_op*/(bp->bio_cmd == BIO_READ ?
 					SCSI_RW_READ : SCSI_RW_WRITE) |
 					((bp->bio_flags & BIO_UNMAPPED) != 0 ?
 					SCSI_RW_BIO : 0),
 					/*byte2*/0,
 					softc->minimum_cmd_size,
 					/*lba*/bp->bio_pblkno,
 					/*block_count*/bp->bio_bcount /
 					softc->params.secsize,
 					/*data_ptr*/ (bp->bio_flags &
 					BIO_UNMAPPED) != 0 ? (void *)bp :
 					bp->bio_data,
 					/*dxfer_len*/ bp->bio_bcount,
 					/*sense_len*/SSD_FULL_SIZE,
 					da_default_timeout * 1000);
 			break;
 		case BIO_FLUSH:
 			/*
 			 * BIO_FLUSH doesn't currently communicate
 			 * range data, so we synchronize the cache
 			 * over the whole disk.  We also force
 			 * ordered tag semantics the flush applies
 			 * to all previously queued I/O.
 			 */
 			scsi_synchronize_cache(&start_ccb->csio,
 					       /*retries*/1,
 					       /*cbfcnp*/dadone,
 					       MSG_ORDERED_Q_TAG,
 					       /*begin_lba*/0,
 					       /*lb_count*/0,
 					       SSD_FULL_SIZE,
 					       da_default_timeout*1000);
 			break;
 		}
 		start_ccb->ccb_h.ccb_state = DA_CCB_BUFFER_IO;
 		start_ccb->ccb_h.flags |= CAM_UNLOCKED;
 
 out:
 		LIST_INSERT_HEAD(&softc->pending_ccbs,
 				 &start_ccb->ccb_h, periph_links.le);
 
 		/* We expect a unit attention from this device */
 		if ((softc->flags & DA_FLAG_RETRY_UA) != 0) {
 			start_ccb->ccb_h.ccb_state |= DA_CCB_RETRY_UA;
 			softc->flags &= ~DA_FLAG_RETRY_UA;
 		}
 
 		start_ccb->ccb_h.ccb_bp = bp;
 		softc->refcount++;
 		cam_periph_unlock(periph);
 		xpt_action(start_ccb);
 		cam_periph_lock(periph);
 		softc->refcount--;
 
 		/* May have more work to do, so ensure we stay scheduled */
 		daschedule(periph);
 		break;
 	}
 	case DA_STATE_PROBE_RC:
 	{
 		struct scsi_read_capacity_data *rcap;
 
 		rcap = (struct scsi_read_capacity_data *)
 		    malloc(sizeof(*rcap), M_SCSIDA, M_NOWAIT|M_ZERO);
 		if (rcap == NULL) {
 			printf("dastart: Couldn't malloc read_capacity data\n");
 			/* da_free_periph??? */
 			break;
 		}
 		scsi_read_capacity(&start_ccb->csio,
 				   /*retries*/da_retry_count,
 				   dadone,
 				   MSG_SIMPLE_Q_TAG,
 				   rcap,
 				   SSD_FULL_SIZE,
 				   /*timeout*/5000);
 		start_ccb->ccb_h.ccb_bp = NULL;
 		start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_RC;
 		xpt_action(start_ccb);
 		break;
 	}
 	case DA_STATE_PROBE_RC16:
 	{
 		struct scsi_read_capacity_data_long *rcaplong;
 
 		rcaplong = (struct scsi_read_capacity_data_long *)
 			malloc(sizeof(*rcaplong), M_SCSIDA, M_NOWAIT|M_ZERO);
 		if (rcaplong == NULL) {
 			printf("dastart: Couldn't malloc read_capacity data\n");
 			/* da_free_periph??? */
 			break;
 		}
 		scsi_read_capacity_16(&start_ccb->csio,
 				      /*retries*/ da_retry_count,
 				      /*cbfcnp*/ dadone,
 				      /*tag_action*/ MSG_SIMPLE_Q_TAG,
 				      /*lba*/ 0,
 				      /*reladr*/ 0,
 				      /*pmi*/ 0,
 				      /*rcap_buf*/ (uint8_t *)rcaplong,
 				      /*rcap_buf_len*/ sizeof(*rcaplong),
 				      /*sense_len*/ SSD_FULL_SIZE,
 				      /*timeout*/ da_default_timeout * 1000);
 		start_ccb->ccb_h.ccb_bp = NULL;
 		start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_RC16;
 		xpt_action(start_ccb);
 		break;
 	}
 	case DA_STATE_PROBE_LBP:
 	{
 		struct scsi_vpd_logical_block_prov *lbp;
 
 		if (!scsi_vpd_supported_page(periph, SVPD_LBP)) {
 			/*
 			 * If we get here we don't support any SBC-3 delete
 			 * methods with UNMAP as the Logical Block Provisioning
 			 * VPD page support is required for devices which
 			 * support it according to T10/1799-D Revision 31
 			 * however older revisions of the spec don't mandate
 			 * this so we currently don't remove these methods
 			 * from the available set.
 			 */
 			softc->state = DA_STATE_PROBE_BLK_LIMITS;
 			goto skipstate;
 		}
 
 		lbp = (struct scsi_vpd_logical_block_prov *)
 			malloc(sizeof(*lbp), M_SCSIDA, M_NOWAIT|M_ZERO);
 
 		if (lbp == NULL) {
 			printf("dastart: Couldn't malloc lbp data\n");
 			/* da_free_periph??? */
 			break;
 		}
 
 		scsi_inquiry(&start_ccb->csio,
 			     /*retries*/da_retry_count,
 			     /*cbfcnp*/dadone,
 			     /*tag_action*/MSG_SIMPLE_Q_TAG,
 			     /*inq_buf*/(u_int8_t *)lbp,
 			     /*inq_len*/sizeof(*lbp),
 			     /*evpd*/TRUE,
 			     /*page_code*/SVPD_LBP,
 			     /*sense_len*/SSD_MIN_SIZE,
 			     /*timeout*/da_default_timeout * 1000);
 		start_ccb->ccb_h.ccb_bp = NULL;
 		start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_LBP;
 		xpt_action(start_ccb);
 		break;
 	}
 	case DA_STATE_PROBE_BLK_LIMITS:
 	{
 		struct scsi_vpd_block_limits *block_limits;
 
 		if (!scsi_vpd_supported_page(periph, SVPD_BLOCK_LIMITS)) {
 			/* Not supported skip to next probe */
 			softc->state = DA_STATE_PROBE_BDC;
 			goto skipstate;
 		}
 
 		block_limits = (struct scsi_vpd_block_limits *)
 			malloc(sizeof(*block_limits), M_SCSIDA, M_NOWAIT|M_ZERO);
 
 		if (block_limits == NULL) {
 			printf("dastart: Couldn't malloc block_limits data\n");
 			/* da_free_periph??? */
 			break;
 		}
 
 		scsi_inquiry(&start_ccb->csio,
 			     /*retries*/da_retry_count,
 			     /*cbfcnp*/dadone,
 			     /*tag_action*/MSG_SIMPLE_Q_TAG,
 			     /*inq_buf*/(u_int8_t *)block_limits,
 			     /*inq_len*/sizeof(*block_limits),
 			     /*evpd*/TRUE,
 			     /*page_code*/SVPD_BLOCK_LIMITS,
 			     /*sense_len*/SSD_MIN_SIZE,
 			     /*timeout*/da_default_timeout * 1000);
 		start_ccb->ccb_h.ccb_bp = NULL;
 		start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_BLK_LIMITS;
 		xpt_action(start_ccb);
 		break;
 	}
 	case DA_STATE_PROBE_BDC:
 	{
 		struct scsi_vpd_block_characteristics *bdc;
 
 		if (!scsi_vpd_supported_page(periph, SVPD_BDC)) {
 			softc->state = DA_STATE_PROBE_ATA;
 			goto skipstate;
 		}
 
 		bdc = (struct scsi_vpd_block_characteristics *)
 			malloc(sizeof(*bdc), M_SCSIDA, M_NOWAIT|M_ZERO);
 
 		if (bdc == NULL) {
 			printf("dastart: Couldn't malloc bdc data\n");
 			/* da_free_periph??? */
 			break;
 		}
 
 		scsi_inquiry(&start_ccb->csio,
 			     /*retries*/da_retry_count,
 			     /*cbfcnp*/dadone,
 			     /*tag_action*/MSG_SIMPLE_Q_TAG,
 			     /*inq_buf*/(u_int8_t *)bdc,
 			     /*inq_len*/sizeof(*bdc),
 			     /*evpd*/TRUE,
 			     /*page_code*/SVPD_BDC,
 			     /*sense_len*/SSD_MIN_SIZE,
 			     /*timeout*/da_default_timeout * 1000);
 		start_ccb->ccb_h.ccb_bp = NULL;
 		start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_BDC;
 		xpt_action(start_ccb);
 		break;
 	}
 	case DA_STATE_PROBE_ATA:
 	{
 		struct ata_params *ata_params;
 
 		if (!scsi_vpd_supported_page(periph, SVPD_ATA_INFORMATION)) {
 			daprobedone(periph, start_ccb);
 			break;
 		}
 
 		ata_params = (struct ata_params*)
 			malloc(sizeof(*ata_params), M_SCSIDA, M_NOWAIT|M_ZERO);
 
 		if (ata_params == NULL) {
 			printf("dastart: Couldn't malloc ata_params data\n");
 			/* da_free_periph??? */
 			break;
 		}
 
 		scsi_ata_identify(&start_ccb->csio,
 				  /*retries*/da_retry_count,
 				  /*cbfcnp*/dadone,
                                   /*tag_action*/MSG_SIMPLE_Q_TAG,
 				  /*data_ptr*/(u_int8_t *)ata_params,
 				  /*dxfer_len*/sizeof(*ata_params),
 				  /*sense_len*/SSD_FULL_SIZE,
 				  /*timeout*/da_default_timeout * 1000);
 		start_ccb->ccb_h.ccb_bp = NULL;
 		start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_ATA;
 		xpt_action(start_ccb);
 		break;
 	}
 	}
 }
 
 /*
  * In each of the methods below, while its the caller's
  * responsibility to ensure the request will fit into a
  * single device request, we might have changed the delete
  * method due to the device incorrectly advertising either
  * its supported methods or limits.
  * 
  * To prevent this causing further issues we validate the
  * against the methods limits, and warn which would
  * otherwise be unnecessary.
  */
 static void
 da_delete_unmap(struct cam_periph *periph, union ccb *ccb, struct bio *bp)
 {
 	struct da_softc *softc = (struct da_softc *)periph->softc;;
 	struct bio *bp1;
 	uint8_t *buf = softc->unmap_buf;
 	uint64_t lba, lastlba = (uint64_t)-1;
 	uint64_t totalcount = 0;
 	uint64_t count;
 	uint32_t lastcount = 0, c;
 	uint32_t off, ranges = 0;
 
 	/*
 	 * Currently this doesn't take the UNMAP
 	 * Granularity and Granularity Alignment
 	 * fields into account.
 	 *
 	 * This could result in both unoptimal unmap
 	 * requests as as well as UNMAP calls unmapping
 	 * fewer LBA's than requested.
 	 */
 
 	softc->delete_running = 1;
 	bzero(softc->unmap_buf, sizeof(softc->unmap_buf));
 	bp1 = bp;
 	do {
 		bioq_remove(&softc->delete_queue, bp1);
 		if (bp1 != bp)
 			bioq_insert_tail(&softc->delete_run_queue, bp1);
 		lba = bp1->bio_pblkno;
 		count = bp1->bio_bcount / softc->params.secsize;
 
 		/* Try to extend the previous range. */
 		if (lba == lastlba) {
 			c = omin(count, UNMAP_RANGE_MAX - lastcount);
 			lastcount += c;
 			off = ((ranges - 1) * UNMAP_RANGE_SIZE) +
 			      UNMAP_HEAD_SIZE;
 			scsi_ulto4b(lastcount, &buf[off + 8]);
 			count -= c;
 			lba +=c;
 			totalcount += c;
 		}
 
 		while (count > 0) {
 			c = omin(count, UNMAP_RANGE_MAX);
 			if (totalcount + c > softc->unmap_max_lba ||
 			    ranges >= softc->unmap_max_ranges) {
 				xpt_print(periph->path,
 				    "%s issuing short delete %ld > %ld"
 				    "|| %d >= %d",
 				    da_delete_method_desc[softc->delete_method],
 				    totalcount + c, softc->unmap_max_lba,
 				    ranges, softc->unmap_max_ranges);
 				break;
 			}
 			off = (ranges * UNMAP_RANGE_SIZE) + UNMAP_HEAD_SIZE;
 			scsi_u64to8b(lba, &buf[off + 0]);
 			scsi_ulto4b(c, &buf[off + 8]);
 			lba += c;
 			totalcount += c;
 			ranges++;
 			count -= c;
 			lastcount = c;
 		}
 		lastlba = lba;
 		bp1 = bioq_first(&softc->delete_queue);
 		if (bp1 == NULL || ranges >= softc->unmap_max_ranges ||
 		    totalcount + bp1->bio_bcount /
 		    softc->params.secsize > softc->unmap_max_lba)
 			break;
 	} while (1);
 	scsi_ulto2b(ranges * 16 + 6, &buf[0]);
 	scsi_ulto2b(ranges * 16, &buf[2]);
 
 	scsi_unmap(&ccb->csio,
 		   /*retries*/da_retry_count,
 		   /*cbfcnp*/dadone,
 		   /*tag_action*/MSG_SIMPLE_Q_TAG,
 		   /*byte2*/0,
 		   /*data_ptr*/ buf,
 		   /*dxfer_len*/ ranges * 16 + 8,
 		   /*sense_len*/SSD_FULL_SIZE,
 		   da_default_timeout * 1000);
 	ccb->ccb_h.ccb_state = DA_CCB_DELETE;
 	ccb->ccb_h.flags |= CAM_UNLOCKED;
 }
 
 static void
 da_delete_trim(struct cam_periph *periph, union ccb *ccb, struct bio *bp)
 {
 	struct da_softc *softc = (struct da_softc *)periph->softc;
 	struct bio *bp1;
 	uint8_t *buf = softc->unmap_buf;
 	uint64_t lastlba = (uint64_t)-1;
 	uint64_t count;
 	uint64_t lba;
 	uint32_t lastcount = 0, c, requestcount;
 	int ranges = 0, off, block_count;
 
 	softc->delete_running = 1;
 	bzero(softc->unmap_buf, sizeof(softc->unmap_buf));
 	bp1 = bp;
 	do {
 		bioq_remove(&softc->delete_queue, bp1);
 		if (bp1 != bp)
 			bioq_insert_tail(&softc->delete_run_queue, bp1);
 		lba = bp1->bio_pblkno;
 		count = bp1->bio_bcount / softc->params.secsize;
 		requestcount = count;
 
 		/* Try to extend the previous range. */
 		if (lba == lastlba) {
-			c = min(count, ATA_DSM_RANGE_MAX - lastcount);
+			c = omin(count, ATA_DSM_RANGE_MAX - lastcount);
 			lastcount += c;
 			off = (ranges - 1) * 8;
 			buf[off + 6] = lastcount & 0xff;
 			buf[off + 7] = (lastcount >> 8) & 0xff;
 			count -= c;
 			lba += c;
 		}
 
 		while (count > 0) {
-			c = min(count, ATA_DSM_RANGE_MAX);
+			c = omin(count, ATA_DSM_RANGE_MAX);
 			off = ranges * 8;
 
 			buf[off + 0] = lba & 0xff;
 			buf[off + 1] = (lba >> 8) & 0xff;
 			buf[off + 2] = (lba >> 16) & 0xff;
 			buf[off + 3] = (lba >> 24) & 0xff;
 			buf[off + 4] = (lba >> 32) & 0xff;
 			buf[off + 5] = (lba >> 40) & 0xff;
 			buf[off + 6] = c & 0xff;
 			buf[off + 7] = (c >> 8) & 0xff;
 			lba += c;
 			ranges++;
 			count -= c;
 			lastcount = c;
 			if (count != 0 && ranges == softc->trim_max_ranges) {
 				xpt_print(periph->path,
 				    "%s issuing short delete %ld > %ld\n",
 				    da_delete_method_desc[softc->delete_method],
 				    requestcount,
 				    (softc->trim_max_ranges - ranges) *
 				    ATA_DSM_RANGE_MAX);
 				break;
 			}
 		}
 		lastlba = lba;
 		bp1 = bioq_first(&softc->delete_queue);
 		if (bp1 == NULL || bp1->bio_bcount / softc->params.secsize >
 		    (softc->trim_max_ranges - ranges) * ATA_DSM_RANGE_MAX)
 			break;
 	} while (1);
 
 	block_count = (ranges + ATA_DSM_BLK_RANGES - 1) / ATA_DSM_BLK_RANGES;
 	scsi_ata_trim(&ccb->csio,
 		      /*retries*/da_retry_count,
 		      /*cbfcnp*/dadone,
 		      /*tag_action*/MSG_SIMPLE_Q_TAG,
 		      block_count,
 		      /*data_ptr*/buf,
 		      /*dxfer_len*/block_count * ATA_DSM_BLK_SIZE,
 		      /*sense_len*/SSD_FULL_SIZE,
 		      da_default_timeout * 1000);
 	ccb->ccb_h.ccb_state = DA_CCB_DELETE;
 	ccb->ccb_h.flags |= CAM_UNLOCKED;
 }
 
 /*
  * We calculate ws_max_blks here based off d_delmaxsize instead
  * of using softc->ws_max_blks as it is absolute max for the
  * device not the protocol max which may well be lower.
  */
 static void
 da_delete_ws(struct cam_periph *periph, union ccb *ccb, struct bio *bp)
 {
 	struct da_softc *softc;
 	struct bio *bp1;
 	uint64_t ws_max_blks;
 	uint64_t lba;
 	uint64_t count; /* forward compat with WS32 */
 
 	softc = (struct da_softc *)periph->softc;
 	ws_max_blks = softc->disk->d_delmaxsize / softc->params.secsize;
 	softc->delete_running = 1;
 	lba = bp->bio_pblkno;
 	count = 0;
 	bp1 = bp;
 	do {
 		bioq_remove(&softc->delete_queue, bp1);
 		if (bp1 != bp)
 			bioq_insert_tail(&softc->delete_run_queue, bp1);
 		count += bp1->bio_bcount / softc->params.secsize;
 		if (count > ws_max_blks) {
 			xpt_print(periph->path,
 			    "%s issuing short delete %ld > %ld\n",
 			    da_delete_method_desc[softc->delete_method],
 			    count, ws_max_blks);
-			count = min(count, ws_max_blks);
+			count = omin(count, ws_max_blks);
 			break;
 		}
 		bp1 = bioq_first(&softc->delete_queue);
 		if (bp1 == NULL || lba + count != bp1->bio_pblkno ||
 		    count + bp1->bio_bcount /
 		    softc->params.secsize > ws_max_blks)
 			break;
 	} while (1);
 
 	scsi_write_same(&ccb->csio,
 			/*retries*/da_retry_count,
 			/*cbfcnp*/dadone,
 			/*tag_action*/MSG_SIMPLE_Q_TAG,
 			/*byte2*/softc->delete_method ==
 			    DA_DELETE_ZERO ? 0 : SWS_UNMAP,
 			softc->delete_method == DA_DELETE_WS16 ? 16 : 10,
 			/*lba*/lba,
 			/*block_count*/count,
 			/*data_ptr*/ __DECONST(void *, zero_region),
 			/*dxfer_len*/ softc->params.secsize,
 			/*sense_len*/SSD_FULL_SIZE,
 			da_default_timeout * 1000);
 	ccb->ccb_h.ccb_state = DA_CCB_DELETE;
 	ccb->ccb_h.flags |= CAM_UNLOCKED;
 }
 
 static int
 cmd6workaround(union ccb *ccb)
 {
 	struct scsi_rw_6 cmd6;
 	struct scsi_rw_10 *cmd10;
 	struct da_softc *softc;
 	u_int8_t *cdb;
 	struct bio *bp;
 	int frozen;
 
 	cdb = ccb->csio.cdb_io.cdb_bytes;
 	softc = (struct da_softc *)xpt_path_periph(ccb->ccb_h.path)->softc;
 
 	if (ccb->ccb_h.ccb_state == DA_CCB_DELETE) {
 		da_delete_methods old_method = softc->delete_method;
 
 		/*
 		 * Typically there are two reasons for failure here
 		 * 1. Delete method was detected as supported but isn't
 		 * 2. Delete failed due to invalid params e.g. too big
 		 *
 		 * While we will attempt to choose an alternative delete method
 		 * this may result in short deletes if the existing delete
 		 * requests from geom are big for the new method choosen.
 		 *
 		 * This method assumes that the error which triggered this
 		 * will not retry the io otherwise a panic will occur
 		 */
 		dadeleteflag(softc, old_method, 0);
 		dadeletemethodchoose(softc, DA_DELETE_DISABLE);
 		if (softc->delete_method == DA_DELETE_DISABLE)
 			xpt_print(ccb->ccb_h.path,
 				  "%s failed, disabling BIO_DELETE\n",
 				  da_delete_method_desc[old_method]);
 		else
 			xpt_print(ccb->ccb_h.path,
 				  "%s failed, switching to %s BIO_DELETE\n",
 				  da_delete_method_desc[old_method],
 				  da_delete_method_desc[softc->delete_method]);
 
 		while ((bp = bioq_takefirst(&softc->delete_run_queue)) != NULL)
 			bioq_disksort(&softc->delete_queue, bp);
 		bioq_disksort(&softc->delete_queue,
 		    (struct bio *)ccb->ccb_h.ccb_bp);
 		ccb->ccb_h.ccb_bp = NULL;
 		return (0);
 	}
 
 	/* Detect unsupported PREVENT ALLOW MEDIUM REMOVAL. */
 	if ((ccb->ccb_h.flags & CAM_CDB_POINTER) == 0 &&
 	    (*cdb == PREVENT_ALLOW) &&
 	    (softc->quirks & DA_Q_NO_PREVENT) == 0) {
 		if (bootverbose)
 			xpt_print(ccb->ccb_h.path,
 			    "PREVENT ALLOW MEDIUM REMOVAL not supported.\n");
 		softc->quirks |= DA_Q_NO_PREVENT;
 		return (0);
 	}
 
 	/* Detect unsupported SYNCHRONIZE CACHE(10). */
 	if ((ccb->ccb_h.flags & CAM_CDB_POINTER) == 0 &&
 	    (*cdb == SYNCHRONIZE_CACHE) &&
 	    (softc->quirks & DA_Q_NO_SYNC_CACHE) == 0) {
 		if (bootverbose)
 			xpt_print(ccb->ccb_h.path,
 			    "SYNCHRONIZE CACHE(10) not supported.\n");
 		softc->quirks |= DA_Q_NO_SYNC_CACHE;
 		softc->disk->d_flags &= ~DISKFLAG_CANFLUSHCACHE;
 		return (0);
 	}
 
 	/* Translation only possible if CDB is an array and cmd is R/W6 */
 	if ((ccb->ccb_h.flags & CAM_CDB_POINTER) != 0 ||
 	    (*cdb != READ_6 && *cdb != WRITE_6))
 		return 0;
 
 	xpt_print(ccb->ccb_h.path, "READ(6)/WRITE(6) not supported, "
 	    "increasing minimum_cmd_size to 10.\n");
  	softc->minimum_cmd_size = 10;
 
 	bcopy(cdb, &cmd6, sizeof(struct scsi_rw_6));
 	cmd10 = (struct scsi_rw_10 *)cdb;
 	cmd10->opcode = (cmd6.opcode == READ_6) ? READ_10 : WRITE_10;
 	cmd10->byte2 = 0;
 	scsi_ulto4b(scsi_3btoul(cmd6.addr), cmd10->addr);
 	cmd10->reserved = 0;
 	scsi_ulto2b(cmd6.length, cmd10->length);
 	cmd10->control = cmd6.control;
 	ccb->csio.cdb_len = sizeof(*cmd10);
 
 	/* Requeue request, unfreezing queue if necessary */
 	frozen = (ccb->ccb_h.status & CAM_DEV_QFRZN) != 0;
  	ccb->ccb_h.status = CAM_REQUEUE_REQ;
 	xpt_action(ccb);
 	if (frozen) {
 		cam_release_devq(ccb->ccb_h.path,
 				 /*relsim_flags*/0,
 				 /*reduction*/0,
 				 /*timeout*/0,
 				 /*getcount_only*/0);
 	}
 	return (ERESTART);
 }
 
 static void
 dadone(struct cam_periph *periph, union ccb *done_ccb)
 {
 	struct da_softc *softc;
 	struct ccb_scsiio *csio;
 	u_int32_t  priority;
 	da_ccb_state state;
 
 	softc = (struct da_softc *)periph->softc;
 	priority = done_ccb->ccb_h.pinfo.priority;
 
 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone\n"));
 
 	csio = &done_ccb->csio;
 	state = csio->ccb_h.ccb_state & DA_CCB_TYPE_MASK;
 	switch (state) {
 	case DA_CCB_BUFFER_IO:
 	case DA_CCB_DELETE:
 	{
 		struct bio *bp, *bp1;
 
 		cam_periph_lock(periph);
 		bp = (struct bio *)done_ccb->ccb_h.ccb_bp;
 		if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
 			int error;
 			int sf;
 
 			if ((csio->ccb_h.ccb_state & DA_CCB_RETRY_UA) != 0)
 				sf = SF_RETRY_UA;
 			else
 				sf = 0;
 
 			error = daerror(done_ccb, CAM_RETRY_SELTO, sf);
 			if (error == ERESTART) {
 				/*
 				 * A retry was scheduled, so
 				 * just return.
 				 */
 				cam_periph_unlock(periph);
 				return;
 			}
 			bp = (struct bio *)done_ccb->ccb_h.ccb_bp;
 			if (error != 0) {
 				int queued_error;
 
 				/*
 				 * return all queued I/O with EIO, so that
 				 * the client can retry these I/Os in the
 				 * proper order should it attempt to recover.
 				 */
 				queued_error = EIO;
 
 				if (error == ENXIO
 				 && (softc->flags & DA_FLAG_PACK_INVALID)== 0) {
 					/*
 					 * Catastrophic error.  Mark our pack as
 					 * invalid.
 					 */
 					/*
 					 * XXX See if this is really a media
 					 * XXX change first?
 					 */
 					xpt_print(periph->path,
 					    "Invalidating pack\n");
 					softc->flags |= DA_FLAG_PACK_INVALID;
 					queued_error = ENXIO;
 				}
 				bioq_flush(&softc->bio_queue, NULL,
 					   queued_error);
 				if (bp != NULL) {
 					bp->bio_error = error;
 					bp->bio_resid = bp->bio_bcount;
 					bp->bio_flags |= BIO_ERROR;
 				}
 			} else if (bp != NULL) {
 				if (state == DA_CCB_DELETE)
 					bp->bio_resid = 0;
 				else
 					bp->bio_resid = csio->resid;
 				bp->bio_error = 0;
 				if (bp->bio_resid != 0)
 					bp->bio_flags |= BIO_ERROR;
 			}
 			if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
 				cam_release_devq(done_ccb->ccb_h.path,
 						 /*relsim_flags*/0,
 						 /*reduction*/0,
 						 /*timeout*/0,
 						 /*getcount_only*/0);
 		} else if (bp != NULL) {
 			if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
 				panic("REQ_CMP with QFRZN");
 			if (state == DA_CCB_DELETE)
 				bp->bio_resid = 0;
 			else
 				bp->bio_resid = csio->resid;
 			if (csio->resid > 0)
 				bp->bio_flags |= BIO_ERROR;
 			if (softc->error_inject != 0) {
 				bp->bio_error = softc->error_inject;
 				bp->bio_resid = bp->bio_bcount;
 				bp->bio_flags |= BIO_ERROR;
 				softc->error_inject = 0;
 			}
 		}
 
 		LIST_REMOVE(&done_ccb->ccb_h, periph_links.le);
 		if (LIST_EMPTY(&softc->pending_ccbs))
 			softc->flags |= DA_FLAG_WAS_OTAG;
 
 		xpt_release_ccb(done_ccb);
 		if (state == DA_CCB_DELETE) {
 			TAILQ_HEAD(, bio) queue;
 
 			TAILQ_INIT(&queue);
 			TAILQ_CONCAT(&queue, &softc->delete_run_queue.queue, bio_queue);
 			softc->delete_run_queue.insert_point = NULL;
 			/*
 			 * Normally, the xpt_release_ccb() above would make sure
 			 * that when we have more work to do, that work would
 			 * get kicked off. However, we specifically keep
 			 * delete_running set to 0 before the call above to
 			 * allow other I/O to progress when many BIO_DELETE
 			 * requests are pushed down. We set delete_running to 0
 			 * and call daschedule again so that we don't stall if
 			 * there are no other I/Os pending apart from BIO_DELETEs.
 			 */
 			softc->delete_running = 0;
 			daschedule(periph);
 			cam_periph_unlock(periph);
 			while ((bp1 = TAILQ_FIRST(&queue)) != NULL) {
 				TAILQ_REMOVE(&queue, bp1, bio_queue);
 				bp1->bio_error = bp->bio_error;
 				if (bp->bio_flags & BIO_ERROR) {
 					bp1->bio_flags |= BIO_ERROR;
 					bp1->bio_resid = bp1->bio_bcount;
 				} else
 					bp1->bio_resid = 0;
 				biodone(bp1);
 			}
 		} else
 			cam_periph_unlock(periph);
 		if (bp != NULL)
 			biodone(bp);
 		return;
 	}
 	case DA_CCB_PROBE_RC:
 	case DA_CCB_PROBE_RC16:
 	{
 		struct	   scsi_read_capacity_data *rdcap;
 		struct     scsi_read_capacity_data_long *rcaplong;
 		char	   announce_buf[80];
 		int	   lbp;
 
 		lbp = 0;
 		rdcap = NULL;
 		rcaplong = NULL;
 		if (state == DA_CCB_PROBE_RC)
 			rdcap =(struct scsi_read_capacity_data *)csio->data_ptr;
 		else
 			rcaplong = (struct scsi_read_capacity_data_long *)
 				csio->data_ptr;
 
 		if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
 			struct disk_params *dp;
 			uint32_t block_size;
 			uint64_t maxsector;
 			u_int lalba;	/* Lowest aligned LBA. */
 
 			if (state == DA_CCB_PROBE_RC) {
 				block_size = scsi_4btoul(rdcap->length);
 				maxsector = scsi_4btoul(rdcap->addr);
 				lalba = 0;
 
 				/*
 				 * According to SBC-2, if the standard 10
 				 * byte READ CAPACITY command returns 2^32,
 				 * we should issue the 16 byte version of
 				 * the command, since the device in question
 				 * has more sectors than can be represented
 				 * with the short version of the command.
 				 */
 				if (maxsector == 0xffffffff) {
 					free(rdcap, M_SCSIDA);
 					xpt_release_ccb(done_ccb);
 					softc->state = DA_STATE_PROBE_RC16;
 					xpt_schedule(periph, priority);
 					return;
 				}
 			} else {
 				block_size = scsi_4btoul(rcaplong->length);
 				maxsector = scsi_8btou64(rcaplong->addr);
 				lalba = scsi_2btoul(rcaplong->lalba_lbp);
 			}
 
 			/*
 			 * Because GEOM code just will panic us if we
 			 * give them an 'illegal' value we'll avoid that
 			 * here.
 			 */
 			if (block_size == 0) {
 				block_size = 512;
 				if (maxsector == 0)
 					maxsector = -1;
 			}
 			if (block_size >= MAXPHYS) {
 				xpt_print(periph->path,
 				    "unsupportable block size %ju\n",
 				    (uintmax_t) block_size);
 				announce_buf[0] = '\0';
 				cam_periph_invalidate(periph);
 			} else {
 				/*
 				 * We pass rcaplong into dasetgeom(),
 				 * because it will only use it if it is
 				 * non-NULL.
 				 */
 				dasetgeom(periph, block_size, maxsector,
 					  rcaplong, sizeof(*rcaplong));
 				lbp = (lalba & SRC16_LBPME_A);
 				dp = &softc->params;
 				snprintf(announce_buf, sizeof(announce_buf),
 				        "%juMB (%ju %u byte sectors: %dH %dS/T "
                                         "%dC)", (uintmax_t)
 	                                (((uintmax_t)dp->secsize *
 				        dp->sectors) / (1024*1024)),
 			                (uintmax_t)dp->sectors,
 				        dp->secsize, dp->heads,
                                         dp->secs_per_track, dp->cylinders);
 			}
 		} else {
 			int	error;
 
 			announce_buf[0] = '\0';
 
 			/*
 			 * Retry any UNIT ATTENTION type errors.  They
 			 * are expected at boot.
 			 */
 			error = daerror(done_ccb, CAM_RETRY_SELTO,
 					SF_RETRY_UA|SF_NO_PRINT);
 			if (error == ERESTART) {
 				/*
 				 * A retry was scheuled, so
 				 * just return.
 				 */
 				return;
 			} else if (error != 0) {
 				int asc, ascq;
 				int sense_key, error_code;
 				int have_sense;
 				cam_status status;
 				struct ccb_getdev cgd;
 
 				/* Don't wedge this device's queue */
 				status = done_ccb->ccb_h.status;
 				if ((status & CAM_DEV_QFRZN) != 0)
 					cam_release_devq(done_ccb->ccb_h.path,
 							 /*relsim_flags*/0,
 							 /*reduction*/0,
 							 /*timeout*/0,
 							 /*getcount_only*/0);
 
 
 				xpt_setup_ccb(&cgd.ccb_h, 
 					      done_ccb->ccb_h.path,
 					      CAM_PRIORITY_NORMAL);
 				cgd.ccb_h.func_code = XPT_GDEV_TYPE;
 				xpt_action((union ccb *)&cgd);
 
 				if (scsi_extract_sense_ccb(done_ccb,
 				    &error_code, &sense_key, &asc, &ascq))
 					have_sense = TRUE;
 				else
 					have_sense = FALSE;
 
 				/*
 				 * If we tried READ CAPACITY(16) and failed,
 				 * fallback to READ CAPACITY(10).
 				 */
 				if ((state == DA_CCB_PROBE_RC16) &&
 				    (softc->flags & DA_FLAG_CAN_RC16) &&
 				    (((csio->ccb_h.status & CAM_STATUS_MASK) ==
 					CAM_REQ_INVALID) ||
 				     ((have_sense) &&
 				      (error_code == SSD_CURRENT_ERROR) &&
 				      (sense_key == SSD_KEY_ILLEGAL_REQUEST)))) {
 					softc->flags &= ~DA_FLAG_CAN_RC16;
 					free(rdcap, M_SCSIDA);
 					xpt_release_ccb(done_ccb);
 					softc->state = DA_STATE_PROBE_RC;
 					xpt_schedule(periph, priority);
 					return;
 				} else
 				/*
 				 * Attach to anything that claims to be a
 				 * direct access or optical disk device,
 				 * as long as it doesn't return a "Logical
 				 * unit not supported" (0x25) error.
 				 */
 				if ((have_sense) && (asc != 0x25)
 				 && (error_code == SSD_CURRENT_ERROR)) {
 					const char *sense_key_desc;
 					const char *asc_desc;
 
 					dasetgeom(periph, 512, -1, NULL, 0);
 					scsi_sense_desc(sense_key, asc, ascq,
 							&cgd.inq_data,
 							&sense_key_desc,
 							&asc_desc);
 					snprintf(announce_buf,
 					    sizeof(announce_buf),
 						"Attempt to query device "
 						"size failed: %s, %s",
 						sense_key_desc,
 						asc_desc);
 				} else { 
 					if (have_sense)
 						scsi_sense_print(
 							&done_ccb->csio);
 					else {
 						xpt_print(periph->path,
 						    "got CAM status %#x\n",
 						    done_ccb->ccb_h.status);
 					}
 
 					xpt_print(periph->path, "fatal error, "
 					    "failed to attach to device\n");
 
 					/*
 					 * Free up resources.
 					 */
 					cam_periph_invalidate(periph);
 				} 
 			}
 		}
 		free(csio->data_ptr, M_SCSIDA);
 		if (announce_buf[0] != '\0' &&
 		    ((softc->flags & DA_FLAG_ANNOUNCED) == 0)) {
 			/*
 			 * Create our sysctl variables, now that we know
 			 * we have successfully attached.
 			 */
 			/* increase the refcount */
 			if (cam_periph_acquire(periph) == CAM_REQ_CMP) {
 				taskqueue_enqueue(taskqueue_thread,
 						  &softc->sysctl_task);
 				xpt_announce_periph(periph, announce_buf);
 				xpt_announce_quirks(periph, softc->quirks,
 				    DA_Q_BIT_STRING);
 			} else {
 				xpt_print(periph->path, "fatal error, "
 				    "could not acquire reference count\n");
 			}
 		}
 
 		/* We already probed the device. */
 		if (softc->flags & DA_FLAG_PROBED) {
 			daprobedone(periph, done_ccb);
 			return;
 		}
 
 		/* Ensure re-probe doesn't see old delete. */
 		softc->delete_available = 0;
 		if (lbp && (softc->quirks & DA_Q_NO_UNMAP) == 0) {
 			/*
 			 * Based on older SBC-3 spec revisions
 			 * any of the UNMAP methods "may" be
 			 * available via LBP given this flag so
 			 * we flag all of them as availble and
 			 * then remove those which further
 			 * probes confirm aren't available
 			 * later.
 			 *
 			 * We could also check readcap(16) p_type
 			 * flag to exclude one or more invalid
 			 * write same (X) types here
 			 */
 			dadeleteflag(softc, DA_DELETE_WS16, 1);
 			dadeleteflag(softc, DA_DELETE_WS10, 1);
 			dadeleteflag(softc, DA_DELETE_ZERO, 1);
 			dadeleteflag(softc, DA_DELETE_UNMAP, 1);
 
 			xpt_release_ccb(done_ccb);
 			softc->state = DA_STATE_PROBE_LBP;
 			xpt_schedule(periph, priority);
 			return;
 		}
 
 		xpt_release_ccb(done_ccb);
 		softc->state = DA_STATE_PROBE_BDC;
 		xpt_schedule(periph, priority);
 		return;
 	}
 	case DA_CCB_PROBE_LBP:
 	{
 		struct scsi_vpd_logical_block_prov *lbp;
 
 		lbp = (struct scsi_vpd_logical_block_prov *)csio->data_ptr;
 
 		if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
 			/*
 			 * T10/1799-D Revision 31 states at least one of these
 			 * must be supported but we don't currently enforce this.
 			 */
 			dadeleteflag(softc, DA_DELETE_WS16,
 				     (lbp->flags & SVPD_LBP_WS16));
 			dadeleteflag(softc, DA_DELETE_WS10,
 				     (lbp->flags & SVPD_LBP_WS10));
 			dadeleteflag(softc, DA_DELETE_ZERO,
 				     (lbp->flags & SVPD_LBP_WS10));
 			dadeleteflag(softc, DA_DELETE_UNMAP,
 				     (lbp->flags & SVPD_LBP_UNMAP));
 		} else {
 			int error;
 			error = daerror(done_ccb, CAM_RETRY_SELTO,
 					SF_RETRY_UA|SF_NO_PRINT);
 			if (error == ERESTART)
 				return;
 			else if (error != 0) {
 				if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
 					/* Don't wedge this device's queue */
 					cam_release_devq(done_ccb->ccb_h.path,
 							 /*relsim_flags*/0,
 							 /*reduction*/0,
 							 /*timeout*/0,
 							 /*getcount_only*/0);
 				}
 
 				/*
 				 * Failure indicates we don't support any SBC-3
 				 * delete methods with UNMAP
 				 */
 			}
 		}
 
 		free(lbp, M_SCSIDA);
 		xpt_release_ccb(done_ccb);
 		softc->state = DA_STATE_PROBE_BLK_LIMITS;
 		xpt_schedule(periph, priority);
 		return;
 	}
 	case DA_CCB_PROBE_BLK_LIMITS:
 	{
 		struct scsi_vpd_block_limits *block_limits;
 
 		block_limits = (struct scsi_vpd_block_limits *)csio->data_ptr;
 
 		if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
 			uint32_t max_txfer_len = scsi_4btoul(
 				block_limits->max_txfer_len);
 			uint32_t max_unmap_lba_cnt = scsi_4btoul(
 				block_limits->max_unmap_lba_cnt);
 			uint32_t max_unmap_blk_cnt = scsi_4btoul(
 				block_limits->max_unmap_blk_cnt);
 			uint64_t ws_max_blks = scsi_8btou64(
 				block_limits->max_write_same_length);
 
 			if (max_txfer_len != 0) {
 				softc->disk->d_maxsize = MIN(softc->maxio,
 				    (off_t)max_txfer_len * softc->params.secsize);
 			}
 
 			/*
 			 * We should already support UNMAP but we check lba
 			 * and block count to be sure
 			 */
 			if (max_unmap_lba_cnt != 0x00L &&
 			    max_unmap_blk_cnt != 0x00L) {
 				softc->unmap_max_lba = max_unmap_lba_cnt;
 				softc->unmap_max_ranges = min(max_unmap_blk_cnt,
 					UNMAP_MAX_RANGES);
 			} else {
 				/*
 				 * Unexpected UNMAP limits which means the
 				 * device doesn't actually support UNMAP
 				 */
 				dadeleteflag(softc, DA_DELETE_UNMAP, 0);
 			}
 
 			if (ws_max_blks != 0x00L)
 				softc->ws_max_blks = ws_max_blks;
 		} else {
 			int error;
 			error = daerror(done_ccb, CAM_RETRY_SELTO,
 					SF_RETRY_UA|SF_NO_PRINT);
 			if (error == ERESTART)
 				return;
 			else if (error != 0) {
 				if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
 					/* Don't wedge this device's queue */
 					cam_release_devq(done_ccb->ccb_h.path,
 							 /*relsim_flags*/0,
 							 /*reduction*/0,
 							 /*timeout*/0,
 							 /*getcount_only*/0);
 				}
 
 				/*
 				 * Failure here doesn't mean UNMAP is not
 				 * supported as this is an optional page.
 				 */
 				softc->unmap_max_lba = 1;
 				softc->unmap_max_ranges = 1;
 			}
 		}
 
 		free(block_limits, M_SCSIDA);
 		xpt_release_ccb(done_ccb);
 		softc->state = DA_STATE_PROBE_BDC;
 		xpt_schedule(periph, priority);
 		return;
 	}
 	case DA_CCB_PROBE_BDC:
 	{
 		struct scsi_vpd_block_characteristics *bdc;
 
 		bdc = (struct scsi_vpd_block_characteristics *)csio->data_ptr;
 
 		if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
 			/*
 			 * Disable queue sorting for non-rotational media
 			 * by default.
 			 */
 			u_int16_t old_rate = softc->disk->d_rotation_rate;
 
 			softc->disk->d_rotation_rate =
 				scsi_2btoul(bdc->medium_rotation_rate);
 			if (softc->disk->d_rotation_rate ==
 			    SVPD_BDC_RATE_NON_ROTATING) {
 				softc->sort_io_queue = 0;
 			}
 			if (softc->disk->d_rotation_rate != old_rate) {
 				disk_attr_changed(softc->disk,
 				    "GEOM::rotation_rate", M_NOWAIT);
 			}
 		} else {
 			int error;
 			error = daerror(done_ccb, CAM_RETRY_SELTO,
 					SF_RETRY_UA|SF_NO_PRINT);
 			if (error == ERESTART)
 				return;
 			else if (error != 0) {
 				if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
 					/* Don't wedge this device's queue */
 					cam_release_devq(done_ccb->ccb_h.path,
 							 /*relsim_flags*/0,
 							 /*reduction*/0,
 							 /*timeout*/0,
 							 /*getcount_only*/0);
 				}
 			}
 		}
 
 		free(bdc, M_SCSIDA);
 		xpt_release_ccb(done_ccb);
 		softc->state = DA_STATE_PROBE_ATA;
 		xpt_schedule(periph, priority);
 		return;
 	}
 	case DA_CCB_PROBE_ATA:
 	{
 		int i;
 		struct ata_params *ata_params;
 		int16_t *ptr;
 
 		ata_params = (struct ata_params *)csio->data_ptr;
 		ptr = (uint16_t *)ata_params;
 
 		if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
 			uint16_t old_rate;
 
 			for (i = 0; i < sizeof(*ata_params) / 2; i++)
 				ptr[i] = le16toh(ptr[i]);
 			if (ata_params->support_dsm & ATA_SUPPORT_DSM_TRIM &&
 			    (softc->quirks & DA_Q_NO_UNMAP) == 0) {
 				dadeleteflag(softc, DA_DELETE_ATA_TRIM, 1);
 				if (ata_params->max_dsm_blocks != 0)
 					softc->trim_max_ranges = min(
 					  softc->trim_max_ranges,
 					  ata_params->max_dsm_blocks *
 					  ATA_DSM_BLK_RANGES);
 			}
 			/*
 			 * Disable queue sorting for non-rotational media
 			 * by default.
 			 */
 			old_rate = softc->disk->d_rotation_rate;
 			softc->disk->d_rotation_rate =
 			    ata_params->media_rotation_rate;
 			if (softc->disk->d_rotation_rate ==
 			    ATA_RATE_NON_ROTATING) {
 				softc->sort_io_queue = 0;
 			}
 
 			if (softc->disk->d_rotation_rate != old_rate) {
 				disk_attr_changed(softc->disk,
 				    "GEOM::rotation_rate", M_NOWAIT);
 			}
 		} else {
 			int error;
 			error = daerror(done_ccb, CAM_RETRY_SELTO,
 					SF_RETRY_UA|SF_NO_PRINT);
 			if (error == ERESTART)
 				return;
 			else if (error != 0) {
 				if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
 					/* Don't wedge this device's queue */
 					cam_release_devq(done_ccb->ccb_h.path,
 							 /*relsim_flags*/0,
 							 /*reduction*/0,
 							 /*timeout*/0,
 							 /*getcount_only*/0);
 				}
 			}
 		}
 
 		free(ata_params, M_SCSIDA);
 		daprobedone(periph, done_ccb);
 		return;
 	}
 	case DA_CCB_DUMP:
 		/* No-op.  We're polling */
 		return;
 	case DA_CCB_TUR:
 	{
 		if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
 
 			if (daerror(done_ccb, CAM_RETRY_SELTO,
 			    SF_RETRY_UA | SF_NO_RECOVERY | SF_NO_PRINT) ==
 			    ERESTART)
 				return;
 			if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
 				cam_release_devq(done_ccb->ccb_h.path,
 						 /*relsim_flags*/0,
 						 /*reduction*/0,
 						 /*timeout*/0,
 						 /*getcount_only*/0);
 		}
 		xpt_release_ccb(done_ccb);
 		cam_periph_release_locked(periph);
 		return;
 	}
 	default:
 		break;
 	}
 	xpt_release_ccb(done_ccb);
 }
 
 static void
 dareprobe(struct cam_periph *periph)
 {
 	struct da_softc	  *softc;
 	cam_status status;
 
 	softc = (struct da_softc *)periph->softc;
 
 	/* Probe in progress; don't interfere. */
 	if (softc->state != DA_STATE_NORMAL)
 		return;
 
 	status = cam_periph_acquire(periph);
 	KASSERT(status == CAM_REQ_CMP,
 	    ("dareprobe: cam_periph_acquire failed"));
 
 	if (softc->flags & DA_FLAG_CAN_RC16)
 		softc->state = DA_STATE_PROBE_RC16;
 	else
 		softc->state = DA_STATE_PROBE_RC;
 
 	xpt_schedule(periph, CAM_PRIORITY_DEV);
 }
 
 static int
 daerror(union ccb *ccb, u_int32_t cam_flags, u_int32_t sense_flags)
 {
 	struct da_softc	  *softc;
 	struct cam_periph *periph;
 	int error, error_code, sense_key, asc, ascq;
 
 	periph = xpt_path_periph(ccb->ccb_h.path);
 	softc = (struct da_softc *)periph->softc;
 
  	/*
 	 * Automatically detect devices that do not support
  	 * READ(6)/WRITE(6) and upgrade to using 10 byte cdbs.
  	 */
 	error = 0;
 	if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_INVALID) {
 		error = cmd6workaround(ccb);
 	} else if (scsi_extract_sense_ccb(ccb,
 	    &error_code, &sense_key, &asc, &ascq)) {
 		if (sense_key == SSD_KEY_ILLEGAL_REQUEST)
  			error = cmd6workaround(ccb);
 		/*
 		 * If the target replied with CAPACITY DATA HAS CHANGED UA,
 		 * query the capacity and notify upper layers.
 		 */
 		else if (sense_key == SSD_KEY_UNIT_ATTENTION &&
 		    asc == 0x2A && ascq == 0x09) {
 			xpt_print(periph->path, "Capacity data has changed\n");
 			softc->flags &= ~DA_FLAG_PROBED;
 			dareprobe(periph);
 			sense_flags |= SF_NO_PRINT;
 		} else if (sense_key == SSD_KEY_UNIT_ATTENTION &&
 		    asc == 0x28 && ascq == 0x00) {
 			softc->flags &= ~DA_FLAG_PROBED;
 			disk_media_changed(softc->disk, M_NOWAIT);
 		} else if (sense_key == SSD_KEY_UNIT_ATTENTION &&
 		    asc == 0x3F && ascq == 0x03) {
 			xpt_print(periph->path, "INQUIRY data has changed\n");
 			softc->flags &= ~DA_FLAG_PROBED;
 			dareprobe(periph);
 			sense_flags |= SF_NO_PRINT;
 		} else if (sense_key == SSD_KEY_NOT_READY &&
 		    asc == 0x3a && (softc->flags & DA_FLAG_PACK_INVALID) == 0) {
 			softc->flags |= DA_FLAG_PACK_INVALID;
 			disk_media_gone(softc->disk, M_NOWAIT);
 		}
 	}
 	if (error == ERESTART)
 		return (ERESTART);
 
 	/*
 	 * XXX
 	 * Until we have a better way of doing pack validation,
 	 * don't treat UAs as errors.
 	 */
 	sense_flags |= SF_RETRY_UA;
 	return(cam_periph_error(ccb, cam_flags, sense_flags,
 				&softc->saved_ccb));
 }
 
 static void
 damediapoll(void *arg)
 {
 	struct cam_periph *periph = arg;
 	struct da_softc *softc = periph->softc;
 
 	if (!softc->tur && LIST_EMPTY(&softc->pending_ccbs)) {
 		if (cam_periph_acquire(periph) == CAM_REQ_CMP) {
 			softc->tur = 1;
 			daschedule(periph);
 		}
 	}
 	/* Queue us up again */
 	if (da_poll_period != 0)
 		callout_schedule(&softc->mediapoll_c, da_poll_period * hz);
 }
 
 static void
 daprevent(struct cam_periph *periph, int action)
 {
 	struct	da_softc *softc;
 	union	ccb *ccb;		
 	int	error;
 		
 	softc = (struct da_softc *)periph->softc;
 
 	if (((action == PR_ALLOW)
 	  && (softc->flags & DA_FLAG_PACK_LOCKED) == 0)
 	 || ((action == PR_PREVENT)
 	  && (softc->flags & DA_FLAG_PACK_LOCKED) != 0)) {
 		return;
 	}
 
 	ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
 
 	scsi_prevent(&ccb->csio,
 		     /*retries*/1,
 		     /*cbcfp*/dadone,
 		     MSG_SIMPLE_Q_TAG,
 		     action,
 		     SSD_FULL_SIZE,
 		     5000);
 
 	error = cam_periph_runccb(ccb, daerror, CAM_RETRY_SELTO,
 	    SF_RETRY_UA | SF_NO_PRINT, softc->disk->d_devstat);
 
 	if (error == 0) {
 		if (action == PR_ALLOW)
 			softc->flags &= ~DA_FLAG_PACK_LOCKED;
 		else
 			softc->flags |= DA_FLAG_PACK_LOCKED;
 	}
 
 	xpt_release_ccb(ccb);
 }
 
 static void
 dasetgeom(struct cam_periph *periph, uint32_t block_len, uint64_t maxsector,
 	  struct scsi_read_capacity_data_long *rcaplong, size_t rcap_len)
 {
 	struct ccb_calc_geometry ccg;
 	struct da_softc *softc;
 	struct disk_params *dp;
 	u_int lbppbe, lalba;
 	int error;
 
 	softc = (struct da_softc *)periph->softc;
 
 	dp = &softc->params;
 	dp->secsize = block_len;
 	dp->sectors = maxsector + 1;
 	if (rcaplong != NULL) {
 		lbppbe = rcaplong->prot_lbppbe & SRC16_LBPPBE;
 		lalba = scsi_2btoul(rcaplong->lalba_lbp);
 		lalba &= SRC16_LALBA_A;
 	} else {
 		lbppbe = 0;
 		lalba = 0;
 	}
 
 	if (lbppbe > 0) {
 		dp->stripesize = block_len << lbppbe;
 		dp->stripeoffset = (dp->stripesize - block_len * lalba) %
 		    dp->stripesize;
 	} else if (softc->quirks & DA_Q_4K) {
 		dp->stripesize = 4096;
 		dp->stripeoffset = 0;
 	} else {
 		dp->stripesize = 0;
 		dp->stripeoffset = 0;
 	}
 	/*
 	 * Have the controller provide us with a geometry
 	 * for this disk.  The only time the geometry
 	 * matters is when we boot and the controller
 	 * is the only one knowledgeable enough to come
 	 * up with something that will make this a bootable
 	 * device.
 	 */
 	xpt_setup_ccb(&ccg.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
 	ccg.ccb_h.func_code = XPT_CALC_GEOMETRY;
 	ccg.block_size = dp->secsize;
 	ccg.volume_size = dp->sectors;
 	ccg.heads = 0;
 	ccg.secs_per_track = 0;
 	ccg.cylinders = 0;
 	xpt_action((union ccb*)&ccg);
 	if ((ccg.ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
 		/*
 		 * We don't know what went wrong here- but just pick
 		 * a geometry so we don't have nasty things like divide
 		 * by zero.
 		 */
 		dp->heads = 255;
 		dp->secs_per_track = 255;
 		dp->cylinders = dp->sectors / (255 * 255);
 		if (dp->cylinders == 0) {
 			dp->cylinders = 1;
 		}
 	} else {
 		dp->heads = ccg.heads;
 		dp->secs_per_track = ccg.secs_per_track;
 		dp->cylinders = ccg.cylinders;
 	}
 
 	/*
 	 * If the user supplied a read capacity buffer, and if it is
 	 * different than the previous buffer, update the data in the EDT.
 	 * If it's the same, we don't bother.  This avoids sending an
 	 * update every time someone opens this device.
 	 */
 	if ((rcaplong != NULL)
 	 && (bcmp(rcaplong, &softc->rcaplong,
 		  min(sizeof(softc->rcaplong), rcap_len)) != 0)) {
 		struct ccb_dev_advinfo cdai;
 
 		xpt_setup_ccb(&cdai.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
 		cdai.ccb_h.func_code = XPT_DEV_ADVINFO;
 		cdai.buftype = CDAI_TYPE_RCAPLONG;
 		cdai.flags |= CDAI_FLAG_STORE;
 		cdai.bufsiz = rcap_len;
 		cdai.buf = (uint8_t *)rcaplong;
 		xpt_action((union ccb *)&cdai);
 		if ((cdai.ccb_h.status & CAM_DEV_QFRZN) != 0)
 			cam_release_devq(cdai.ccb_h.path, 0, 0, 0, FALSE);
 		if (cdai.ccb_h.status != CAM_REQ_CMP) {
 			xpt_print(periph->path, "%s: failed to set read "
 				  "capacity advinfo\n", __func__);
 			/* Use cam_error_print() to decode the status */
 			cam_error_print((union ccb *)&cdai, CAM_ESF_CAM_STATUS,
 					CAM_EPF_ALL);
 		} else {
 			bcopy(rcaplong, &softc->rcaplong,
 			      min(sizeof(softc->rcaplong), rcap_len));
 		}
 	}
 
 	softc->disk->d_sectorsize = softc->params.secsize;
 	softc->disk->d_mediasize = softc->params.secsize * (off_t)softc->params.sectors;
 	softc->disk->d_stripesize = softc->params.stripesize;
 	softc->disk->d_stripeoffset = softc->params.stripeoffset;
 	/* XXX: these are not actually "firmware" values, so they may be wrong */
 	softc->disk->d_fwsectors = softc->params.secs_per_track;
 	softc->disk->d_fwheads = softc->params.heads;
 	softc->disk->d_devstat->block_size = softc->params.secsize;
 	softc->disk->d_devstat->flags &= ~DEVSTAT_BS_UNAVAILABLE;
 
 	error = disk_resize(softc->disk, M_NOWAIT);
 	if (error != 0)
 		xpt_print(periph->path, "disk_resize(9) failed, error = %d\n", error);
 }
 
 static void
 dasendorderedtag(void *arg)
 {
 	struct da_softc *softc = arg;
 
 	if (da_send_ordered) {
 		if (!LIST_EMPTY(&softc->pending_ccbs)) {
 			if ((softc->flags & DA_FLAG_WAS_OTAG) == 0)
 				softc->flags |= DA_FLAG_NEED_OTAG;
 			softc->flags &= ~DA_FLAG_WAS_OTAG;
 		}
 	}
 	/* Queue us up again */
 	callout_reset(&softc->sendordered_c,
 	    (da_default_timeout * hz) / DA_ORDEREDTAG_INTERVAL,
 	    dasendorderedtag, softc);
 }
 
 /*
  * Step through all DA peripheral drivers, and if the device is still open,
  * sync the disk cache to physical media.
  */
 static void
 dashutdown(void * arg, int howto)
 {
 	struct cam_periph *periph;
 	struct da_softc *softc;
 	union ccb *ccb;
 	int error;
 
 	CAM_PERIPH_FOREACH(periph, &dadriver) {
 		softc = (struct da_softc *)periph->softc;
 		if (SCHEDULER_STOPPED()) {
 			/* If we paniced with the lock held, do not recurse. */
 			if (!cam_periph_owned(periph) &&
 			    (softc->flags & DA_FLAG_OPEN)) {
 				dadump(softc->disk, NULL, 0, 0, 0);
 			}
 			continue;
 		}
 		cam_periph_lock(periph);
 
 		/*
 		 * We only sync the cache if the drive is still open, and
 		 * if the drive is capable of it..
 		 */
 		if (((softc->flags & DA_FLAG_OPEN) == 0)
 		 || (softc->quirks & DA_Q_NO_SYNC_CACHE)) {
 			cam_periph_unlock(periph);
 			continue;
 		}
 
 		ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
 		scsi_synchronize_cache(&ccb->csio,
 				       /*retries*/0,
 				       /*cbfcnp*/dadone,
 				       MSG_SIMPLE_Q_TAG,
 				       /*begin_lba*/0, /* whole disk */
 				       /*lb_count*/0,
 				       SSD_FULL_SIZE,
 				       60 * 60 * 1000);
 
 		error = cam_periph_runccb(ccb, daerror, /*cam_flags*/0,
 		    /*sense_flags*/ SF_NO_RECOVERY | SF_NO_RETRY | SF_QUIET_IR,
 		    softc->disk->d_devstat);
 		if (error != 0)
 			xpt_print(periph->path, "Synchronize cache failed\n");
 		xpt_release_ccb(ccb);
 		cam_periph_unlock(periph);
 	}
 }
 
 #else /* !_KERNEL */
 
 /*
  * XXX These are only left out of the kernel build to silence warnings.  If,
  * for some reason these functions are used in the kernel, the ifdefs should
  * be moved so they are included both in the kernel and userland.
  */
 void
 scsi_format_unit(struct ccb_scsiio *csio, u_int32_t retries,
 		 void (*cbfcnp)(struct cam_periph *, union ccb *),
 		 u_int8_t tag_action, u_int8_t byte2, u_int16_t ileave,
 		 u_int8_t *data_ptr, u_int32_t dxfer_len, u_int8_t sense_len,
 		 u_int32_t timeout)
 {
 	struct scsi_format_unit *scsi_cmd;
 
 	scsi_cmd = (struct scsi_format_unit *)&csio->cdb_io.cdb_bytes;
 	scsi_cmd->opcode = FORMAT_UNIT;
 	scsi_cmd->byte2 = byte2;
 	scsi_ulto2b(ileave, scsi_cmd->interleave);
 
 	cam_fill_csio(csio,
 		      retries,
 		      cbfcnp,
 		      /*flags*/ (dxfer_len > 0) ? CAM_DIR_OUT : CAM_DIR_NONE,
 		      tag_action,
 		      data_ptr,
 		      dxfer_len,
 		      sense_len,
 		      sizeof(*scsi_cmd),
 		      timeout);
 }
 
 void
 scsi_read_defects(struct ccb_scsiio *csio, uint32_t retries,
 		  void (*cbfcnp)(struct cam_periph *, union ccb *),
 		  uint8_t tag_action, uint8_t list_format,
 		  uint32_t addr_desc_index, uint8_t *data_ptr,
 		  uint32_t dxfer_len, int minimum_cmd_size, 
 		  uint8_t sense_len, uint32_t timeout)
 {
 	uint8_t cdb_len;
 
 	/*
 	 * These conditions allow using the 10 byte command.  Otherwise we
 	 * need to use the 12 byte command.
 	 */
 	if ((minimum_cmd_size <= 10)
 	 && (addr_desc_index == 0) 
 	 && (dxfer_len <= SRDD10_MAX_LENGTH)) {
 		struct scsi_read_defect_data_10 *cdb10;
 
 		cdb10 = (struct scsi_read_defect_data_10 *)
 			&csio->cdb_io.cdb_bytes;
 
 		cdb_len = sizeof(*cdb10);
 		bzero(cdb10, cdb_len);
                 cdb10->opcode = READ_DEFECT_DATA_10;
                 cdb10->format = list_format;
                 scsi_ulto2b(dxfer_len, cdb10->alloc_length);
 	} else {
 		struct scsi_read_defect_data_12 *cdb12;
 
 		cdb12 = (struct scsi_read_defect_data_12 *)
 			&csio->cdb_io.cdb_bytes;
 
 		cdb_len = sizeof(*cdb12);
 		bzero(cdb12, cdb_len);
                 cdb12->opcode = READ_DEFECT_DATA_12;
                 cdb12->format = list_format;
                 scsi_ulto4b(dxfer_len, cdb12->alloc_length);
 		scsi_ulto4b(addr_desc_index, cdb12->address_descriptor_index);
 	}
 
 	cam_fill_csio(csio,
 		      retries,
 		      cbfcnp,
 		      /*flags*/ CAM_DIR_IN,
 		      tag_action,
 		      data_ptr,
 		      dxfer_len,
 		      sense_len,
 		      cdb_len,
 		      timeout);
 }
 
 void
 scsi_sanitize(struct ccb_scsiio *csio, u_int32_t retries,
 	      void (*cbfcnp)(struct cam_periph *, union ccb *),
 	      u_int8_t tag_action, u_int8_t byte2, u_int16_t control,
 	      u_int8_t *data_ptr, u_int32_t dxfer_len, u_int8_t sense_len,
 	      u_int32_t timeout)
 {
 	struct scsi_sanitize *scsi_cmd;
 
 	scsi_cmd = (struct scsi_sanitize *)&csio->cdb_io.cdb_bytes;
 	scsi_cmd->opcode = SANITIZE;
 	scsi_cmd->byte2 = byte2;
 	scsi_cmd->control = control;
 	scsi_ulto2b(dxfer_len, scsi_cmd->length);
 
 	cam_fill_csio(csio,
 		      retries,
 		      cbfcnp,
 		      /*flags*/ (dxfer_len > 0) ? CAM_DIR_OUT : CAM_DIR_NONE,
 		      tag_action,
 		      data_ptr,
 		      dxfer_len,
 		      sense_len,
 		      sizeof(*scsi_cmd),
 		      timeout);
 }
 
 #endif /* _KERNEL */
Index: projects/clang360-import/sys/conf/kern.opts.mk
===================================================================
--- projects/clang360-import/sys/conf/kern.opts.mk	(revision 277777)
+++ projects/clang360-import/sys/conf/kern.opts.mk	(revision 277778)
@@ -1,99 +1,101 @@
 # $FreeBSD$
 
 # Options set in the build system that affect the kernel somehow.
 
 #
 # Define MK_* variables (which are either "yes" or "no") for users
 # to set via WITH_*/WITHOUT_* in /etc/src.conf and override in the
 # make(1) environment.
 # These should be tested with `== "no"' or `!= "no"' in makefiles.
 # The NO_* variables should only be set by makefiles for variables
 # that haven't been converted over.
 #
 
 # Note: bsd.own.mk must be included before the rest of kern.opts.mk to make
 # building on 10.x and earlier work. This should be removed when that's no
 # longer supported since it confounds the defaults (since it uses the host's
 # notion of defaults rather than what's default in current when building
 # within sys/modules).
 .include <bsd.own.mk>
 
 # These options are used by the kernel build process (kern.mk and kmod.mk)
 # They have to be listed here so we can build modules outside of the
 # src tree.
 
 __DEFAULT_YES_OPTIONS = \
+    AUTOFS \
+    BHYVE \
     BLUETOOTH \
     CCD \
     CDDL \
     CRYPT \
     CUSE \
     FORMAT_EXTENSIONS \
     INET \
     INET6 \
     IPFILTER \
     ISCSI \
     KERNEL_SYMBOLS \
     NETGRAPH \
     PF \
     SOURCELESS_HOST \
     SOURCELESS_UCODE \
     USB_GADGET_EXAMPLES \
     ZFS
 
 __DEFAULT_NO_OPTIONS = \
     EISA \
     NAND \
     OFED
 
 # expanded inline from bsd.mkopt.mk to avoid share/mk dependency
 
 # Those that default to yes
 .for var in ${__DEFAULT_YES_OPTIONS}
 .if !defined(MK_${var})
 .if defined(WITHOUT_${var})			# WITHOUT always wins
 MK_${var}:=	no
 .else
 MK_${var}:=	yes
 .endif
 .endif
 .endfor
 .undef __DEFAULT_YES_OPTIONS
 
 # Those that default to no
 .for var in ${__DEFAULT_NO_OPTIONS}
 .if !defined(MK_${var})
 .if defined(WITH_${var}) && !defined(WITHOUT_${var}) # WITHOUT always wins
 MK_${var}:=	yes
 .else
 MK_${var}:=	no
 .endif
 .endif
 .endfor
 .undef __DEFAULT_NO_OPTIONS
 
 #
 # MK_*_SUPPORT options which default to "yes" unless their corresponding
 # MK_* variable is set to "no".
 #
 .for var in \
     INET \
     INET6
 .if defined(WITHOUT_${var}_SUPPORT) || ${MK_${var}} == "no"
 MK_${var}_SUPPORT:= no
 .else
 .if defined(KERNBUILDDIR)	# See if there's an opt_foo.h
 OPT_${var}!= cat ${KERNBUILDDIR}/opt_${var:tl}.h; echo
 .if ${OPT_${var}} == ""		# nothing -> no
 MK_${var}_SUPPORT:= no
 .else
 MK_${var}_SUPPORT:= yes
 .endif
 .else				# otherwise, yes
 MK_${var}_SUPPORT:= yes
 .endif
 .endif
 .endfor
 
 
 
Index: projects/clang360-import/sys/conf
===================================================================
--- projects/clang360-import/sys/conf	(revision 277777)
+++ projects/clang360-import/sys/conf	(revision 277778)

Property changes on: projects/clang360-import/sys/conf
___________________________________________________________________
Modified: svn:mergeinfo
## -0,0 +0,1 ##
   Merged /head/sys/conf:r277719-277776
Index: projects/clang360-import/sys/dev/cxgbe/t4_main.c
===================================================================
--- projects/clang360-import/sys/dev/cxgbe/t4_main.c	(revision 277777)
+++ projects/clang360-import/sys/dev/cxgbe/t4_main.c	(revision 277778)
@@ -1,8524 +1,8530 @@
 /*-
  * Copyright (c) 2011 Chelsio Communications, Inc.
  * All rights reserved.
  * Written by: Navdeep Parhar <np@FreeBSD.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include "opt_inet.h"
 #include "opt_inet6.h"
 
 #include <sys/param.h>
 #include <sys/conf.h>
 #include <sys/priv.h>
 #include <sys/kernel.h>
 #include <sys/bus.h>
 #include <sys/module.h>
 #include <sys/malloc.h>
 #include <sys/queue.h>
 #include <sys/taskqueue.h>
 #include <sys/pciio.h>
 #include <dev/pci/pcireg.h>
 #include <dev/pci/pcivar.h>
 #include <dev/pci/pci_private.h>
 #include <sys/firmware.h>
 #include <sys/sbuf.h>
 #include <sys/smp.h>
 #include <sys/socket.h>
 #include <sys/sockio.h>
 #include <sys/sysctl.h>
 #include <net/ethernet.h>
 #include <net/if.h>
 #include <net/if_types.h>
 #include <net/if_dl.h>
 #include <net/if_vlan_var.h>
 #if defined(__i386__) || defined(__amd64__)
 #include <vm/vm.h>
 #include <vm/pmap.h>
 #endif
 
 #include "common/common.h"
 #include "common/t4_msg.h"
 #include "common/t4_regs.h"
 #include "common/t4_regs_values.h"
 #include "t4_ioctl.h"
 #include "t4_l2t.h"
 #include "t4_mp_ring.h"
 
 /* T4 bus driver interface */
 static int t4_probe(device_t);
 static int t4_attach(device_t);
 static int t4_detach(device_t);
 static device_method_t t4_methods[] = {
 	DEVMETHOD(device_probe,		t4_probe),
 	DEVMETHOD(device_attach,	t4_attach),
 	DEVMETHOD(device_detach,	t4_detach),
 
 	DEVMETHOD_END
 };
 static driver_t t4_driver = {
 	"t4nex",
 	t4_methods,
 	sizeof(struct adapter)
 };
 
 
 /* T4 port (cxgbe) interface */
 static int cxgbe_probe(device_t);
 static int cxgbe_attach(device_t);
 static int cxgbe_detach(device_t);
 static device_method_t cxgbe_methods[] = {
 	DEVMETHOD(device_probe,		cxgbe_probe),
 	DEVMETHOD(device_attach,	cxgbe_attach),
 	DEVMETHOD(device_detach,	cxgbe_detach),
 	{ 0, 0 }
 };
 static driver_t cxgbe_driver = {
 	"cxgbe",
 	cxgbe_methods,
 	sizeof(struct port_info)
 };
 
 static d_ioctl_t t4_ioctl;
 static d_open_t t4_open;
 static d_close_t t4_close;
 
 static struct cdevsw t4_cdevsw = {
        .d_version = D_VERSION,
        .d_flags = 0,
        .d_open = t4_open,
        .d_close = t4_close,
        .d_ioctl = t4_ioctl,
        .d_name = "t4nex",
 };
 
 /* T5 bus driver interface */
 static int t5_probe(device_t);
 static device_method_t t5_methods[] = {
 	DEVMETHOD(device_probe,		t5_probe),
 	DEVMETHOD(device_attach,	t4_attach),
 	DEVMETHOD(device_detach,	t4_detach),
 
 	DEVMETHOD_END
 };
 static driver_t t5_driver = {
 	"t5nex",
 	t5_methods,
 	sizeof(struct adapter)
 };
 
 
 /* T5 port (cxl) interface */
 static driver_t cxl_driver = {
 	"cxl",
 	cxgbe_methods,
 	sizeof(struct port_info)
 };
 
 static struct cdevsw t5_cdevsw = {
        .d_version = D_VERSION,
        .d_flags = 0,
        .d_open = t4_open,
        .d_close = t4_close,
        .d_ioctl = t4_ioctl,
        .d_name = "t5nex",
 };
 
 /* ifnet + media interface */
 static void cxgbe_init(void *);
 static int cxgbe_ioctl(struct ifnet *, unsigned long, caddr_t);
 static int cxgbe_transmit(struct ifnet *, struct mbuf *);
 static void cxgbe_qflush(struct ifnet *);
 static uint64_t cxgbe_get_counter(struct ifnet *, ift_counter);
 static int cxgbe_media_change(struct ifnet *);
 static void cxgbe_media_status(struct ifnet *, struct ifmediareq *);
 
 MALLOC_DEFINE(M_CXGBE, "cxgbe", "Chelsio T4/T5 Ethernet driver and services");
 
 /*
  * Correct lock order when you need to acquire multiple locks is t4_list_lock,
  * then ADAPTER_LOCK, then t4_uld_list_lock.
  */
 static struct sx t4_list_lock;
 SLIST_HEAD(, adapter) t4_list;
 #ifdef TCP_OFFLOAD
 static struct sx t4_uld_list_lock;
 SLIST_HEAD(, uld_info) t4_uld_list;
 #endif
 
 /*
  * Tunables.  See tweak_tunables() too.
  *
  * Each tunable is set to a default value here if it's known at compile-time.
  * Otherwise it is set to -1 as an indication to tweak_tunables() that it should
  * provide a reasonable default when the driver is loaded.
  *
  * Tunables applicable to both T4 and T5 are under hw.cxgbe.  Those specific to
  * T5 are under hw.cxl.
  */
 
 /*
  * Number of queues for tx and rx, 10G and 1G, NIC and offload.
  */
 #define NTXQ_10G 16
 static int t4_ntxq10g = -1;
 TUNABLE_INT("hw.cxgbe.ntxq10g", &t4_ntxq10g);
 
 #define NRXQ_10G 8
 static int t4_nrxq10g = -1;
 TUNABLE_INT("hw.cxgbe.nrxq10g", &t4_nrxq10g);
 
 #define NTXQ_1G 4
 static int t4_ntxq1g = -1;
 TUNABLE_INT("hw.cxgbe.ntxq1g", &t4_ntxq1g);
 
 #define NRXQ_1G 2
 static int t4_nrxq1g = -1;
 TUNABLE_INT("hw.cxgbe.nrxq1g", &t4_nrxq1g);
 
 static int t4_rsrv_noflowq = 0;
 TUNABLE_INT("hw.cxgbe.rsrv_noflowq", &t4_rsrv_noflowq);
 
 #ifdef TCP_OFFLOAD
 #define NOFLDTXQ_10G 8
 static int t4_nofldtxq10g = -1;
 TUNABLE_INT("hw.cxgbe.nofldtxq10g", &t4_nofldtxq10g);
 
 #define NOFLDRXQ_10G 2
 static int t4_nofldrxq10g = -1;
 TUNABLE_INT("hw.cxgbe.nofldrxq10g", &t4_nofldrxq10g);
 
 #define NOFLDTXQ_1G 2
 static int t4_nofldtxq1g = -1;
 TUNABLE_INT("hw.cxgbe.nofldtxq1g", &t4_nofldtxq1g);
 
 #define NOFLDRXQ_1G 1
 static int t4_nofldrxq1g = -1;
 TUNABLE_INT("hw.cxgbe.nofldrxq1g", &t4_nofldrxq1g);
 #endif
 
 #ifdef DEV_NETMAP
 #define NNMTXQ_10G 2
 static int t4_nnmtxq10g = -1;
 TUNABLE_INT("hw.cxgbe.nnmtxq10g", &t4_nnmtxq10g);
 
 #define NNMRXQ_10G 2
 static int t4_nnmrxq10g = -1;
 TUNABLE_INT("hw.cxgbe.nnmrxq10g", &t4_nnmrxq10g);
 
 #define NNMTXQ_1G 1
 static int t4_nnmtxq1g = -1;
 TUNABLE_INT("hw.cxgbe.nnmtxq1g", &t4_nnmtxq1g);
 
 #define NNMRXQ_1G 1
 static int t4_nnmrxq1g = -1;
 TUNABLE_INT("hw.cxgbe.nnmrxq1g", &t4_nnmrxq1g);
 #endif
 
 /*
  * Holdoff parameters for 10G and 1G ports.
  */
 #define TMR_IDX_10G 1
 static int t4_tmr_idx_10g = TMR_IDX_10G;
 TUNABLE_INT("hw.cxgbe.holdoff_timer_idx_10G", &t4_tmr_idx_10g);
 
 #define PKTC_IDX_10G (-1)
 static int t4_pktc_idx_10g = PKTC_IDX_10G;
 TUNABLE_INT("hw.cxgbe.holdoff_pktc_idx_10G", &t4_pktc_idx_10g);
 
 #define TMR_IDX_1G 1
 static int t4_tmr_idx_1g = TMR_IDX_1G;
 TUNABLE_INT("hw.cxgbe.holdoff_timer_idx_1G", &t4_tmr_idx_1g);
 
 #define PKTC_IDX_1G (-1)
 static int t4_pktc_idx_1g = PKTC_IDX_1G;
 TUNABLE_INT("hw.cxgbe.holdoff_pktc_idx_1G", &t4_pktc_idx_1g);
 
 /*
  * Size (# of entries) of each tx and rx queue.
  */
 static unsigned int t4_qsize_txq = TX_EQ_QSIZE;
 TUNABLE_INT("hw.cxgbe.qsize_txq", &t4_qsize_txq);
 
 static unsigned int t4_qsize_rxq = RX_IQ_QSIZE;
 TUNABLE_INT("hw.cxgbe.qsize_rxq", &t4_qsize_rxq);
 
 /*
  * Interrupt types allowed (bits 0, 1, 2 = INTx, MSI, MSI-X respectively).
  */
 static int t4_intr_types = INTR_MSIX | INTR_MSI | INTR_INTX;
 TUNABLE_INT("hw.cxgbe.interrupt_types", &t4_intr_types);
 
 /*
  * Configuration file.
  */
 #define DEFAULT_CF	"default"
 #define FLASH_CF	"flash"
 #define UWIRE_CF	"uwire"
 #define FPGA_CF		"fpga"
 static char t4_cfg_file[32] = DEFAULT_CF;
 TUNABLE_STR("hw.cxgbe.config_file", t4_cfg_file, sizeof(t4_cfg_file));
 
 /*
  * PAUSE settings (bit 0, 1 = rx_pause, tx_pause respectively).
  * rx_pause = 1 to heed incoming PAUSE frames, 0 to ignore them.
  * tx_pause = 1 to emit PAUSE frames when the rx FIFO reaches its high water
  *            mark or when signalled to do so, 0 to never emit PAUSE.
  */
 static int t4_pause_settings = PAUSE_TX | PAUSE_RX;
 TUNABLE_INT("hw.cxgbe.pause_settings", &t4_pause_settings);
 
 /*
  * Firmware auto-install by driver during attach (0, 1, 2 = prohibited, allowed,
  * encouraged respectively).
  */
 static unsigned int t4_fw_install = 1;
 TUNABLE_INT("hw.cxgbe.fw_install", &t4_fw_install);
 
 /*
  * ASIC features that will be used.  Disable the ones you don't want so that the
  * chip resources aren't wasted on features that will not be used.
  */
 static int t4_linkcaps_allowed = 0;	/* No DCBX, PPP, etc. by default */
 TUNABLE_INT("hw.cxgbe.linkcaps_allowed", &t4_linkcaps_allowed);
 
 static int t4_niccaps_allowed = FW_CAPS_CONFIG_NIC;
 TUNABLE_INT("hw.cxgbe.niccaps_allowed", &t4_niccaps_allowed);
 
 static int t4_toecaps_allowed = -1;
 TUNABLE_INT("hw.cxgbe.toecaps_allowed", &t4_toecaps_allowed);
 
 static int t4_rdmacaps_allowed = 0;
 TUNABLE_INT("hw.cxgbe.rdmacaps_allowed", &t4_rdmacaps_allowed);
 
 static int t4_iscsicaps_allowed = 0;
 TUNABLE_INT("hw.cxgbe.iscsicaps_allowed", &t4_iscsicaps_allowed);
 
 static int t4_fcoecaps_allowed = 0;
 TUNABLE_INT("hw.cxgbe.fcoecaps_allowed", &t4_fcoecaps_allowed);
 
 static int t5_write_combine = 0;
 TUNABLE_INT("hw.cxl.write_combine", &t5_write_combine);
 
 struct intrs_and_queues {
 	uint16_t intr_type;	/* INTx, MSI, or MSI-X */
 	uint16_t nirq;		/* Total # of vectors */
 	uint16_t intr_flags_10g;/* Interrupt flags for each 10G port */
 	uint16_t intr_flags_1g;	/* Interrupt flags for each 1G port */
 	uint16_t ntxq10g;	/* # of NIC txq's for each 10G port */
 	uint16_t nrxq10g;	/* # of NIC rxq's for each 10G port */
 	uint16_t ntxq1g;	/* # of NIC txq's for each 1G port */
 	uint16_t nrxq1g;	/* # of NIC rxq's for each 1G port */
 	uint16_t rsrv_noflowq;	/* Flag whether to reserve queue 0 */
 #ifdef TCP_OFFLOAD
 	uint16_t nofldtxq10g;	/* # of TOE txq's for each 10G port */
 	uint16_t nofldrxq10g;	/* # of TOE rxq's for each 10G port */
 	uint16_t nofldtxq1g;	/* # of TOE txq's for each 1G port */
 	uint16_t nofldrxq1g;	/* # of TOE rxq's for each 1G port */
 #endif
 #ifdef DEV_NETMAP
 	uint16_t nnmtxq10g;	/* # of netmap txq's for each 10G port */
 	uint16_t nnmrxq10g;	/* # of netmap rxq's for each 10G port */
 	uint16_t nnmtxq1g;	/* # of netmap txq's for each 1G port */
 	uint16_t nnmrxq1g;	/* # of netmap rxq's for each 1G port */
 #endif
 };
 
 struct filter_entry {
         uint32_t valid:1;	/* filter allocated and valid */
         uint32_t locked:1;	/* filter is administratively locked */
         uint32_t pending:1;	/* filter action is pending firmware reply */
 	uint32_t smtidx:8;	/* Source MAC Table index for smac */
 	struct l2t_entry *l2t;	/* Layer Two Table entry for dmac */
 
         struct t4_filter_specification fs;
 };
 
 static int map_bars_0_and_4(struct adapter *);
 static int map_bar_2(struct adapter *);
 static void setup_memwin(struct adapter *);
 static int validate_mem_range(struct adapter *, uint32_t, int);
 static int fwmtype_to_hwmtype(int);
 static int validate_mt_off_len(struct adapter *, int, uint32_t, int,
     uint32_t *);
 static void memwin_info(struct adapter *, int, uint32_t *, uint32_t *);
 static uint32_t position_memwin(struct adapter *, int, uint32_t);
 static int cfg_itype_and_nqueues(struct adapter *, int, int,
     struct intrs_and_queues *);
 static int prep_firmware(struct adapter *);
 static int partition_resources(struct adapter *, const struct firmware *,
     const char *);
 static int get_params__pre_init(struct adapter *);
 static int get_params__post_init(struct adapter *);
 static int set_params__post_init(struct adapter *);
 static void t4_set_desc(struct adapter *);
 static void build_medialist(struct port_info *, struct ifmedia *);
 static int cxgbe_init_synchronized(struct port_info *);
 static int cxgbe_uninit_synchronized(struct port_info *);
 static int setup_intr_handlers(struct adapter *);
 static void quiesce_txq(struct adapter *, struct sge_txq *);
 static void quiesce_wrq(struct adapter *, struct sge_wrq *);
 static void quiesce_iq(struct adapter *, struct sge_iq *);
 static void quiesce_fl(struct adapter *, struct sge_fl *);
 static int t4_alloc_irq(struct adapter *, struct irq *, int rid,
     driver_intr_t *, void *, char *);
 static int t4_free_irq(struct adapter *, struct irq *);
 static void reg_block_dump(struct adapter *, uint8_t *, unsigned int,
     unsigned int);
 static void t4_get_regs(struct adapter *, struct t4_regdump *, uint8_t *);
 static void cxgbe_refresh_stats(struct adapter *, struct port_info *);
 static void cxgbe_tick(void *);
 static void cxgbe_vlan_config(void *, struct ifnet *, uint16_t);
 static int cpl_not_handled(struct sge_iq *, const struct rss_header *,
     struct mbuf *);
 static int an_not_handled(struct sge_iq *, const struct rsp_ctrl *);
 static int fw_msg_not_handled(struct adapter *, const __be64 *);
 static int t4_sysctls(struct adapter *);
 static int cxgbe_sysctls(struct port_info *);
 static int sysctl_int_array(SYSCTL_HANDLER_ARGS);
 static int sysctl_bitfield(SYSCTL_HANDLER_ARGS);
 static int sysctl_btphy(SYSCTL_HANDLER_ARGS);
 static int sysctl_noflowq(SYSCTL_HANDLER_ARGS);
 static int sysctl_holdoff_tmr_idx(SYSCTL_HANDLER_ARGS);
 static int sysctl_holdoff_pktc_idx(SYSCTL_HANDLER_ARGS);
 static int sysctl_qsize_rxq(SYSCTL_HANDLER_ARGS);
 static int sysctl_qsize_txq(SYSCTL_HANDLER_ARGS);
 static int sysctl_pause_settings(SYSCTL_HANDLER_ARGS);
 static int sysctl_handle_t4_reg64(SYSCTL_HANDLER_ARGS);
 static int sysctl_temperature(SYSCTL_HANDLER_ARGS);
 #ifdef SBUF_DRAIN
 static int sysctl_cctrl(SYSCTL_HANDLER_ARGS);
 static int sysctl_cim_ibq_obq(SYSCTL_HANDLER_ARGS);
 static int sysctl_cim_la(SYSCTL_HANDLER_ARGS);
 static int sysctl_cim_ma_la(SYSCTL_HANDLER_ARGS);
 static int sysctl_cim_pif_la(SYSCTL_HANDLER_ARGS);
 static int sysctl_cim_qcfg(SYSCTL_HANDLER_ARGS);
 static int sysctl_cpl_stats(SYSCTL_HANDLER_ARGS);
 static int sysctl_ddp_stats(SYSCTL_HANDLER_ARGS);
 static int sysctl_devlog(SYSCTL_HANDLER_ARGS);
 static int sysctl_fcoe_stats(SYSCTL_HANDLER_ARGS);
 static int sysctl_hw_sched(SYSCTL_HANDLER_ARGS);
 static int sysctl_lb_stats(SYSCTL_HANDLER_ARGS);
 static int sysctl_linkdnrc(SYSCTL_HANDLER_ARGS);
 static int sysctl_meminfo(SYSCTL_HANDLER_ARGS);
 static int sysctl_mps_tcam(SYSCTL_HANDLER_ARGS);
 static int sysctl_path_mtus(SYSCTL_HANDLER_ARGS);
 static int sysctl_pm_stats(SYSCTL_HANDLER_ARGS);
 static int sysctl_rdma_stats(SYSCTL_HANDLER_ARGS);
 static int sysctl_tcp_stats(SYSCTL_HANDLER_ARGS);
 static int sysctl_tids(SYSCTL_HANDLER_ARGS);
 static int sysctl_tp_err_stats(SYSCTL_HANDLER_ARGS);
 static int sysctl_tp_la(SYSCTL_HANDLER_ARGS);
 static int sysctl_tx_rate(SYSCTL_HANDLER_ARGS);
 static int sysctl_ulprx_la(SYSCTL_HANDLER_ARGS);
 static int sysctl_wcwr_stats(SYSCTL_HANDLER_ARGS);
 #endif
 static uint32_t fconf_to_mode(uint32_t);
 static uint32_t mode_to_fconf(uint32_t);
 static uint32_t fspec_to_fconf(struct t4_filter_specification *);
 static int get_filter_mode(struct adapter *, uint32_t *);
 static int set_filter_mode(struct adapter *, uint32_t);
 static inline uint64_t get_filter_hits(struct adapter *, uint32_t);
 static int get_filter(struct adapter *, struct t4_filter *);
 static int set_filter(struct adapter *, struct t4_filter *);
 static int del_filter(struct adapter *, struct t4_filter *);
 static void clear_filter(struct filter_entry *);
 static int set_filter_wr(struct adapter *, int);
 static int del_filter_wr(struct adapter *, int);
 static int get_sge_context(struct adapter *, struct t4_sge_context *);
 static int load_fw(struct adapter *, struct t4_data *);
 static int read_card_mem(struct adapter *, int, struct t4_mem_range *);
 static int read_i2c(struct adapter *, struct t4_i2c_data *);
 static int set_sched_class(struct adapter *, struct t4_sched_params *);
 static int set_sched_queue(struct adapter *, struct t4_sched_queue *);
 #ifdef TCP_OFFLOAD
 static int toe_capability(struct port_info *, int);
 #endif
 static int mod_event(module_t, int, void *);
 
 struct {
 	uint16_t device;
 	char *desc;
 } t4_pciids[] = {
 	{0xa000, "Chelsio Terminator 4 FPGA"},
 	{0x4400, "Chelsio T440-dbg"},
 	{0x4401, "Chelsio T420-CR"},
 	{0x4402, "Chelsio T422-CR"},
 	{0x4403, "Chelsio T440-CR"},
 	{0x4404, "Chelsio T420-BCH"},
 	{0x4405, "Chelsio T440-BCH"},
 	{0x4406, "Chelsio T440-CH"},
 	{0x4407, "Chelsio T420-SO"},
 	{0x4408, "Chelsio T420-CX"},
 	{0x4409, "Chelsio T420-BT"},
 	{0x440a, "Chelsio T404-BT"},
 	{0x440e, "Chelsio T440-LP-CR"},
 }, t5_pciids[] = {
 	{0xb000, "Chelsio Terminator 5 FPGA"},
 	{0x5400, "Chelsio T580-dbg"},
 	{0x5401,  "Chelsio T520-CR"},		/* 2 x 10G */
 	{0x5402,  "Chelsio T522-CR"},		/* 2 x 10G, 2 X 1G */
 	{0x5403,  "Chelsio T540-CR"},		/* 4 x 10G */
 	{0x5407,  "Chelsio T520-SO"},		/* 2 x 10G, nomem */
 	{0x5409,  "Chelsio T520-BT"},		/* 2 x 10GBaseT */
 	{0x540a,  "Chelsio T504-BT"},		/* 4 x 1G */
 	{0x540d,  "Chelsio T580-CR"},		/* 2 x 40G */
 	{0x540e,  "Chelsio T540-LP-CR"},	/* 4 x 10G */
 	{0x5410,  "Chelsio T580-LP-CR"},	/* 2 x 40G */
 	{0x5411,  "Chelsio T520-LL-CR"},	/* 2 x 10G */
 	{0x5412,  "Chelsio T560-CR"},		/* 1 x 40G, 2 x 10G */
 	{0x5414,  "Chelsio T580-LP-SO-CR"},	/* 2 x 40G, nomem */
 	{0x5415,  "Chelsio T502-BT"},		/* 2 x 1G */
 #ifdef notyet
 	{0x5404,  "Chelsio T520-BCH"},
 	{0x5405,  "Chelsio T540-BCH"},
 	{0x5406,  "Chelsio T540-CH"},
 	{0x5408,  "Chelsio T520-CX"},
 	{0x540b,  "Chelsio B520-SR"},
 	{0x540c,  "Chelsio B504-BT"},
 	{0x540f,  "Chelsio Amsterdam"},
 	{0x5413,  "Chelsio T580-CHR"},
 #endif
 };
 
 #ifdef TCP_OFFLOAD
 /*
  * service_iq() has an iq and needs the fl.  Offset of fl from the iq should be
  * exactly the same for both rxq and ofld_rxq.
  */
 CTASSERT(offsetof(struct sge_ofld_rxq, iq) == offsetof(struct sge_rxq, iq));
 CTASSERT(offsetof(struct sge_ofld_rxq, fl) == offsetof(struct sge_rxq, fl));
 #endif
 
 /* No easy way to include t4_msg.h before adapter.h so we check this way */
 CTASSERT(nitems(((struct adapter *)0)->cpl_handler) == NUM_CPL_CMDS);
 CTASSERT(nitems(((struct adapter *)0)->fw_msg_handler) == NUM_FW6_TYPES);
 
 CTASSERT(sizeof(struct cluster_metadata) <= CL_METADATA_SIZE);
 
 static int
 t4_probe(device_t dev)
 {
 	int i;
 	uint16_t v = pci_get_vendor(dev);
 	uint16_t d = pci_get_device(dev);
 	uint8_t f = pci_get_function(dev);
 
 	if (v != PCI_VENDOR_ID_CHELSIO)
 		return (ENXIO);
 
 	/* Attach only to PF0 of the FPGA */
 	if (d == 0xa000 && f != 0)
 		return (ENXIO);
 
 	for (i = 0; i < nitems(t4_pciids); i++) {
 		if (d == t4_pciids[i].device) {
 			device_set_desc(dev, t4_pciids[i].desc);
 			return (BUS_PROBE_DEFAULT);
 		}
 	}
 
 	return (ENXIO);
 }
 
 static int
 t5_probe(device_t dev)
 {
 	int i;
 	uint16_t v = pci_get_vendor(dev);
 	uint16_t d = pci_get_device(dev);
 	uint8_t f = pci_get_function(dev);
 
 	if (v != PCI_VENDOR_ID_CHELSIO)
 		return (ENXIO);
 
 	/* Attach only to PF0 of the FPGA */
 	if (d == 0xb000 && f != 0)
 		return (ENXIO);
 
 	for (i = 0; i < nitems(t5_pciids); i++) {
 		if (d == t5_pciids[i].device) {
 			device_set_desc(dev, t5_pciids[i].desc);
 			return (BUS_PROBE_DEFAULT);
 		}
 	}
 
 	return (ENXIO);
 }
 
 static int
 t4_attach(device_t dev)
 {
 	struct adapter *sc;
 	int rc = 0, i, n10g, n1g, rqidx, tqidx;
 	struct intrs_and_queues iaq;
 	struct sge *s;
 #ifdef TCP_OFFLOAD
 	int ofld_rqidx, ofld_tqidx;
 #endif
 #ifdef DEV_NETMAP
 	int nm_rqidx, nm_tqidx;
 #endif
 	const char *pcie_ts;
 
 	sc = device_get_softc(dev);
 	sc->dev = dev;
 
 	pci_enable_busmaster(dev);
 	if (pci_find_cap(dev, PCIY_EXPRESS, &i) == 0) {
 		uint32_t v;
 
 		pci_set_max_read_req(dev, 4096);
 		v = pci_read_config(dev, i + PCIER_DEVICE_CTL, 2);
 		v |= PCIEM_CTL_RELAXED_ORD_ENABLE;
 		pci_write_config(dev, i + PCIER_DEVICE_CTL, v, 2);
 
 		sc->params.pci.mps = 128 << ((v & PCIEM_CTL_MAX_PAYLOAD) >> 5);
 	}
 
 	sc->traceq = -1;
 	mtx_init(&sc->ifp_lock, sc->ifp_lockname, 0, MTX_DEF);
 	snprintf(sc->ifp_lockname, sizeof(sc->ifp_lockname), "%s tracer",
 	    device_get_nameunit(dev));
 
 	snprintf(sc->lockname, sizeof(sc->lockname), "%s",
 	    device_get_nameunit(dev));
 	mtx_init(&sc->sc_lock, sc->lockname, 0, MTX_DEF);
 	sx_xlock(&t4_list_lock);
 	SLIST_INSERT_HEAD(&t4_list, sc, link);
 	sx_xunlock(&t4_list_lock);
 
 	mtx_init(&sc->sfl_lock, "starving freelists", 0, MTX_DEF);
 	TAILQ_INIT(&sc->sfl);
 	callout_init(&sc->sfl_callout, CALLOUT_MPSAFE);
 
 	mtx_init(&sc->regwin_lock, "register and memory window", 0, MTX_DEF);
 
 	rc = map_bars_0_and_4(sc);
 	if (rc != 0)
 		goto done; /* error message displayed already */
 
 	/*
 	 * This is the real PF# to which we're attaching.  Works from within PCI
 	 * passthrough environments too, where pci_get_function() could return a
 	 * different PF# depending on the passthrough configuration.  We need to
 	 * use the real PF# in all our communication with the firmware.
 	 */
 	sc->pf = G_SOURCEPF(t4_read_reg(sc, A_PL_WHOAMI));
 	sc->mbox = sc->pf;
 
 	memset(sc->chan_map, 0xff, sizeof(sc->chan_map));
 	sc->an_handler = an_not_handled;
 	for (i = 0; i < nitems(sc->cpl_handler); i++)
 		sc->cpl_handler[i] = cpl_not_handled;
 	for (i = 0; i < nitems(sc->fw_msg_handler); i++)
 		sc->fw_msg_handler[i] = fw_msg_not_handled;
 	t4_register_cpl_handler(sc, CPL_SET_TCB_RPL, t4_filter_rpl);
 	t4_register_cpl_handler(sc, CPL_TRACE_PKT, t4_trace_pkt);
 	t4_register_cpl_handler(sc, CPL_TRACE_PKT_T5, t5_trace_pkt);
 	t4_init_sge_cpl_handlers(sc);
 
 	/* Prepare the adapter for operation */
 	rc = -t4_prep_adapter(sc);
 	if (rc != 0) {
 		device_printf(dev, "failed to prepare adapter: %d.\n", rc);
 		goto done;
 	}
 
 	/*
 	 * Do this really early, with the memory windows set up even before the
 	 * character device.  The userland tool's register i/o and mem read
 	 * will work even in "recovery mode".
 	 */
 	setup_memwin(sc);
 	sc->cdev = make_dev(is_t4(sc) ? &t4_cdevsw : &t5_cdevsw,
 	    device_get_unit(dev), UID_ROOT, GID_WHEEL, 0600, "%s",
 	    device_get_nameunit(dev));
 	if (sc->cdev == NULL)
 		device_printf(dev, "failed to create nexus char device.\n");
 	else
 		sc->cdev->si_drv1 = sc;
 
 	/* Go no further if recovery mode has been requested. */
 	if (TUNABLE_INT_FETCH("hw.cxgbe.sos", &i) && i != 0) {
 		device_printf(dev, "recovery mode.\n");
 		goto done;
 	}
 
 #if defined(__i386__)
 	if ((cpu_feature & CPUID_CX8) == 0) {
 		device_printf(dev, "64 bit atomics not available.\n");
 		rc = ENOTSUP;
 		goto done;
 	}
 #endif
 
 	/* Prepare the firmware for operation */
 	rc = prep_firmware(sc);
 	if (rc != 0)
 		goto done; /* error message displayed already */
 
 	rc = get_params__post_init(sc);
 	if (rc != 0)
 		goto done; /* error message displayed already */
 
 	rc = set_params__post_init(sc);
 	if (rc != 0)
 		goto done; /* error message displayed already */
 
 	rc = map_bar_2(sc);
 	if (rc != 0)
 		goto done; /* error message displayed already */
 
 	rc = t4_create_dma_tag(sc);
 	if (rc != 0)
 		goto done; /* error message displayed already */
 
 	/*
 	 * First pass over all the ports - allocate VIs and initialize some
 	 * basic parameters like mac address, port type, etc.  We also figure
 	 * out whether a port is 10G or 1G and use that information when
 	 * calculating how many interrupts to attempt to allocate.
 	 */
 	n10g = n1g = 0;
 	for_each_port(sc, i) {
 		struct port_info *pi;
 
 		pi = malloc(sizeof(*pi), M_CXGBE, M_ZERO | M_WAITOK);
 		sc->port[i] = pi;
 
 		/* These must be set before t4_port_init */
 		pi->adapter = sc;
 		pi->port_id = i;
 
 		/* Allocate the vi and initialize parameters like mac addr */
 		rc = -t4_port_init(pi, sc->mbox, sc->pf, 0);
 		if (rc != 0) {
 			device_printf(dev, "unable to initialize port %d: %d\n",
 			    i, rc);
 			free(pi, M_CXGBE);
 			sc->port[i] = NULL;
 			goto done;
 		}
 
 		pi->link_cfg.requested_fc &= ~(PAUSE_TX | PAUSE_RX);
 		pi->link_cfg.requested_fc |= t4_pause_settings;
 		pi->link_cfg.fc &= ~(PAUSE_TX | PAUSE_RX);
 		pi->link_cfg.fc |= t4_pause_settings;
 
 		rc = -t4_link_start(sc, sc->mbox, pi->tx_chan, &pi->link_cfg);
 		if (rc != 0) {
 			device_printf(dev, "port %d l1cfg failed: %d\n", i, rc);
 			free(pi, M_CXGBE);
 			sc->port[i] = NULL;
 			goto done;
 		}
 
 		snprintf(pi->lockname, sizeof(pi->lockname), "%sp%d",
 		    device_get_nameunit(dev), i);
 		mtx_init(&pi->pi_lock, pi->lockname, 0, MTX_DEF);
 		sc->chan_map[pi->tx_chan] = i;
 
 		if (is_10G_port(pi) || is_40G_port(pi)) {
 			n10g++;
 			pi->tmr_idx = t4_tmr_idx_10g;
 			pi->pktc_idx = t4_pktc_idx_10g;
 		} else {
 			n1g++;
 			pi->tmr_idx = t4_tmr_idx_1g;
 			pi->pktc_idx = t4_pktc_idx_1g;
 		}
 
 		pi->xact_addr_filt = -1;
 		pi->linkdnrc = -1;
 
 		pi->qsize_rxq = t4_qsize_rxq;
 		pi->qsize_txq = t4_qsize_txq;
 
 		pi->dev = device_add_child(dev, is_t4(sc) ? "cxgbe" : "cxl", -1);
 		if (pi->dev == NULL) {
 			device_printf(dev,
 			    "failed to add device for port %d.\n", i);
 			rc = ENXIO;
 			goto done;
 		}
 		device_set_softc(pi->dev, pi);
 	}
 
 	/*
 	 * Interrupt type, # of interrupts, # of rx/tx queues, etc.
 	 */
 	rc = cfg_itype_and_nqueues(sc, n10g, n1g, &iaq);
 	if (rc != 0)
 		goto done; /* error message displayed already */
 
 	sc->intr_type = iaq.intr_type;
 	sc->intr_count = iaq.nirq;
 
 	s = &sc->sge;
 	s->nrxq = n10g * iaq.nrxq10g + n1g * iaq.nrxq1g;
 	s->ntxq = n10g * iaq.ntxq10g + n1g * iaq.ntxq1g;
 	s->neq = s->ntxq + s->nrxq;	/* the free list in an rxq is an eq */
 	s->neq += sc->params.nports + 1;/* ctrl queues: 1 per port + 1 mgmt */
 	s->niq = s->nrxq + 1;		/* 1 extra for firmware event queue */
 #ifdef TCP_OFFLOAD
 	if (is_offload(sc)) {
 		s->nofldrxq = n10g * iaq.nofldrxq10g + n1g * iaq.nofldrxq1g;
 		s->nofldtxq = n10g * iaq.nofldtxq10g + n1g * iaq.nofldtxq1g;
 		s->neq += s->nofldtxq + s->nofldrxq;
 		s->niq += s->nofldrxq;
 
 		s->ofld_rxq = malloc(s->nofldrxq * sizeof(struct sge_ofld_rxq),
 		    M_CXGBE, M_ZERO | M_WAITOK);
 		s->ofld_txq = malloc(s->nofldtxq * sizeof(struct sge_wrq),
 		    M_CXGBE, M_ZERO | M_WAITOK);
 	}
 #endif
 #ifdef DEV_NETMAP
 	s->nnmrxq = n10g * iaq.nnmrxq10g + n1g * iaq.nnmrxq1g;
 	s->nnmtxq = n10g * iaq.nnmtxq10g + n1g * iaq.nnmtxq1g;
 	s->neq += s->nnmtxq + s->nnmrxq;
 	s->niq += s->nnmrxq;
 
 	s->nm_rxq = malloc(s->nnmrxq * sizeof(struct sge_nm_rxq),
 	    M_CXGBE, M_ZERO | M_WAITOK);
 	s->nm_txq = malloc(s->nnmtxq * sizeof(struct sge_nm_txq),
 	    M_CXGBE, M_ZERO | M_WAITOK);
 #endif
 
 	s->ctrlq = malloc(sc->params.nports * sizeof(struct sge_wrq), M_CXGBE,
 	    M_ZERO | M_WAITOK);
 	s->rxq = malloc(s->nrxq * sizeof(struct sge_rxq), M_CXGBE,
 	    M_ZERO | M_WAITOK);
 	s->txq = malloc(s->ntxq * sizeof(struct sge_txq), M_CXGBE,
 	    M_ZERO | M_WAITOK);
 	s->iqmap = malloc(s->niq * sizeof(struct sge_iq *), M_CXGBE,
 	    M_ZERO | M_WAITOK);
 	s->eqmap = malloc(s->neq * sizeof(struct sge_eq *), M_CXGBE,
 	    M_ZERO | M_WAITOK);
 
 	sc->irq = malloc(sc->intr_count * sizeof(struct irq), M_CXGBE,
 	    M_ZERO | M_WAITOK);
 
 	t4_init_l2t(sc, M_WAITOK);
 
 	/*
 	 * Second pass over the ports.  This time we know the number of rx and
 	 * tx queues that each port should get.
 	 */
 	rqidx = tqidx = 0;
 #ifdef TCP_OFFLOAD
 	ofld_rqidx = ofld_tqidx = 0;
 #endif
 #ifdef DEV_NETMAP
 	nm_rqidx = nm_tqidx = 0;
 #endif
 	for_each_port(sc, i) {
 		struct port_info *pi = sc->port[i];
 
 		if (pi == NULL)
 			continue;
 
 		pi->first_rxq = rqidx;
 		pi->first_txq = tqidx;
 		if (is_10G_port(pi) || is_40G_port(pi)) {
 			pi->flags |= iaq.intr_flags_10g;
 			pi->nrxq = iaq.nrxq10g;
 			pi->ntxq = iaq.ntxq10g;
 		} else {
 			pi->flags |= iaq.intr_flags_1g;
 			pi->nrxq = iaq.nrxq1g;
 			pi->ntxq = iaq.ntxq1g;
 		}
 
 		if (pi->ntxq > 1)
 			pi->rsrv_noflowq = iaq.rsrv_noflowq ? 1 : 0;
 		else
 			pi->rsrv_noflowq = 0;
 
 		rqidx += pi->nrxq;
 		tqidx += pi->ntxq;
 #ifdef TCP_OFFLOAD
 		if (is_offload(sc)) {
 			pi->first_ofld_rxq = ofld_rqidx;
 			pi->first_ofld_txq = ofld_tqidx;
 			if (is_10G_port(pi) || is_40G_port(pi)) {
 				pi->nofldrxq = iaq.nofldrxq10g;
 				pi->nofldtxq = iaq.nofldtxq10g;
 			} else {
 				pi->nofldrxq = iaq.nofldrxq1g;
 				pi->nofldtxq = iaq.nofldtxq1g;
 			}
 			ofld_rqidx += pi->nofldrxq;
 			ofld_tqidx += pi->nofldtxq;
 		}
 #endif
 #ifdef DEV_NETMAP
 		pi->first_nm_rxq = nm_rqidx;
 		pi->first_nm_txq = nm_tqidx;
 		if (is_10G_port(pi) || is_40G_port(pi)) {
 			pi->nnmrxq = iaq.nnmrxq10g;
 			pi->nnmtxq = iaq.nnmtxq10g;
 		} else {
 			pi->nnmrxq = iaq.nnmrxq1g;
 			pi->nnmtxq = iaq.nnmtxq1g;
 		}
 		nm_rqidx += pi->nnmrxq;
 		nm_tqidx += pi->nnmtxq;
 #endif
 	}
 
 	rc = setup_intr_handlers(sc);
 	if (rc != 0) {
 		device_printf(dev,
 		    "failed to setup interrupt handlers: %d\n", rc);
 		goto done;
 	}
 
 	rc = bus_generic_attach(dev);
 	if (rc != 0) {
 		device_printf(dev,
 		    "failed to attach all child ports: %d\n", rc);
 		goto done;
 	}
 
 	switch (sc->params.pci.speed) {
 		case 0x1:
 			pcie_ts = "2.5";
 			break;
 		case 0x2:
 			pcie_ts = "5.0";
 			break;
 		case 0x3:
 			pcie_ts = "8.0";
 			break;
 		default:
 			pcie_ts = "??";
 			break;
 	}
 	device_printf(dev,
 	    "PCIe x%d (%s GTS/s) (%d), %d ports, %d %s interrupt%s, %d eq, %d iq\n",
 	    sc->params.pci.width, pcie_ts, sc->params.pci.speed,
 	    sc->params.nports, sc->intr_count,
 	    sc->intr_type == INTR_MSIX ? "MSI-X" :
 	    (sc->intr_type == INTR_MSI ? "MSI" : "INTx"),
 	    sc->intr_count > 1 ? "s" : "", sc->sge.neq, sc->sge.niq);
 
 	t4_set_desc(sc);
 
 done:
 	if (rc != 0 && sc->cdev) {
 		/* cdev was created and so cxgbetool works; recover that way. */
 		device_printf(dev,
 		    "error during attach, adapter is now in recovery mode.\n");
 		rc = 0;
 	}
 
 	if (rc != 0)
 		t4_detach(dev);
 	else
 		t4_sysctls(sc);
 
 	return (rc);
 }
 
 /*
  * Idempotent
  */
 static int
 t4_detach(device_t dev)
 {
 	struct adapter *sc;
 	struct port_info *pi;
 	int i, rc;
 
 	sc = device_get_softc(dev);
 
 	if (sc->flags & FULL_INIT_DONE)
 		t4_intr_disable(sc);
 
 	if (sc->cdev) {
 		destroy_dev(sc->cdev);
 		sc->cdev = NULL;
 	}
 
 	rc = bus_generic_detach(dev);
 	if (rc) {
 		device_printf(dev,
 		    "failed to detach child devices: %d\n", rc);
 		return (rc);
 	}
 
 	for (i = 0; i < sc->intr_count; i++)
 		t4_free_irq(sc, &sc->irq[i]);
 
 	for (i = 0; i < MAX_NPORTS; i++) {
 		pi = sc->port[i];
 		if (pi) {
 			t4_free_vi(sc, sc->mbox, sc->pf, 0, pi->viid);
 			if (pi->dev)
 				device_delete_child(dev, pi->dev);
 
 			mtx_destroy(&pi->pi_lock);
 			free(pi, M_CXGBE);
 		}
 	}
 
 	if (sc->flags & FULL_INIT_DONE)
 		adapter_full_uninit(sc);
 
 	if (sc->flags & FW_OK)
 		t4_fw_bye(sc, sc->mbox);
 
 	if (sc->intr_type == INTR_MSI || sc->intr_type == INTR_MSIX)
 		pci_release_msi(dev);
 
 	if (sc->regs_res)
 		bus_release_resource(dev, SYS_RES_MEMORY, sc->regs_rid,
 		    sc->regs_res);
 
 	if (sc->udbs_res)
 		bus_release_resource(dev, SYS_RES_MEMORY, sc->udbs_rid,
 		    sc->udbs_res);
 
 	if (sc->msix_res)
 		bus_release_resource(dev, SYS_RES_MEMORY, sc->msix_rid,
 		    sc->msix_res);
 
 	if (sc->l2t)
 		t4_free_l2t(sc->l2t);
 
 #ifdef TCP_OFFLOAD
 	free(sc->sge.ofld_rxq, M_CXGBE);
 	free(sc->sge.ofld_txq, M_CXGBE);
 #endif
 #ifdef DEV_NETMAP
 	free(sc->sge.nm_rxq, M_CXGBE);
 	free(sc->sge.nm_txq, M_CXGBE);
 #endif
 	free(sc->irq, M_CXGBE);
 	free(sc->sge.rxq, M_CXGBE);
 	free(sc->sge.txq, M_CXGBE);
 	free(sc->sge.ctrlq, M_CXGBE);
 	free(sc->sge.iqmap, M_CXGBE);
 	free(sc->sge.eqmap, M_CXGBE);
 	free(sc->tids.ftid_tab, M_CXGBE);
 	t4_destroy_dma_tag(sc);
 	if (mtx_initialized(&sc->sc_lock)) {
 		sx_xlock(&t4_list_lock);
 		SLIST_REMOVE(&t4_list, sc, adapter, link);
 		sx_xunlock(&t4_list_lock);
 		mtx_destroy(&sc->sc_lock);
 	}
 
 	if (mtx_initialized(&sc->tids.ftid_lock))
 		mtx_destroy(&sc->tids.ftid_lock);
 	if (mtx_initialized(&sc->sfl_lock))
 		mtx_destroy(&sc->sfl_lock);
 	if (mtx_initialized(&sc->ifp_lock))
 		mtx_destroy(&sc->ifp_lock);
 	if (mtx_initialized(&sc->regwin_lock))
 		mtx_destroy(&sc->regwin_lock);
 
 	bzero(sc, sizeof(*sc));
 
 	return (0);
 }
 
 static int
 cxgbe_probe(device_t dev)
 {
 	char buf[128];
 	struct port_info *pi = device_get_softc(dev);
 
 	snprintf(buf, sizeof(buf), "port %d", pi->port_id);
 	device_set_desc_copy(dev, buf);
 
 	return (BUS_PROBE_DEFAULT);
 }
 
 #define T4_CAP (IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU | IFCAP_HWCSUM | \
     IFCAP_VLAN_HWCSUM | IFCAP_TSO | IFCAP_JUMBO_MTU | IFCAP_LRO | \
     IFCAP_VLAN_HWTSO | IFCAP_LINKSTATE | IFCAP_HWCSUM_IPV6 | IFCAP_HWSTATS)
 #define T4_CAP_ENABLE (T4_CAP)
 
 static int
 cxgbe_attach(device_t dev)
 {
 	struct port_info *pi = device_get_softc(dev);
 	struct ifnet *ifp;
 	char *s;
 	int n, o;
 
 	/* Allocate an ifnet and set it up */
 	ifp = if_alloc(IFT_ETHER);
 	if (ifp == NULL) {
 		device_printf(dev, "Cannot allocate ifnet\n");
 		return (ENOMEM);
 	}
 	pi->ifp = ifp;
 	ifp->if_softc = pi;
 
 	callout_init(&pi->tick, CALLOUT_MPSAFE);
 
 	if_initname(ifp, device_get_name(dev), device_get_unit(dev));
 	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 
 	ifp->if_init = cxgbe_init;
 	ifp->if_ioctl = cxgbe_ioctl;
 	ifp->if_transmit = cxgbe_transmit;
 	ifp->if_qflush = cxgbe_qflush;
 	ifp->if_get_counter = cxgbe_get_counter;
 
 	ifp->if_capabilities = T4_CAP;
 #ifdef TCP_OFFLOAD
 	if (is_offload(pi->adapter))
 		ifp->if_capabilities |= IFCAP_TOE;
 #endif
 	ifp->if_capenable = T4_CAP_ENABLE;
 	ifp->if_hwassist = CSUM_TCP | CSUM_UDP | CSUM_IP | CSUM_TSO |
 	    CSUM_UDP_IPV6 | CSUM_TCP_IPV6;
 
 	ifp->if_hw_tsomax = 65536 - (ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN);
 	ifp->if_hw_tsomaxsegcount = TX_SGL_SEGS;
 	ifp->if_hw_tsomaxsegsize = 65536;
 
 	/* Initialize ifmedia for this port */
 	ifmedia_init(&pi->media, IFM_IMASK, cxgbe_media_change,
 	    cxgbe_media_status);
 	build_medialist(pi, &pi->media);
 
 	pi->vlan_c = EVENTHANDLER_REGISTER(vlan_config, cxgbe_vlan_config, ifp,
 	    EVENTHANDLER_PRI_ANY);
 
 	ether_ifattach(ifp, pi->hw_addr);
 
 	n = 128;
 	s = malloc(n, M_CXGBE, M_WAITOK);
 	o = snprintf(s, n, "%d txq, %d rxq (NIC)", pi->ntxq, pi->nrxq);
 	MPASS(n > o);
 #ifdef TCP_OFFLOAD
 	if (is_offload(pi->adapter)) {
 		o += snprintf(s + o, n - o, "; %d txq, %d rxq (TOE)",
 		    pi->nofldtxq, pi->nofldrxq);
 		MPASS(n > o);
 	}
 #endif
 #ifdef DEV_NETMAP
 	o += snprintf(s + o, n - o, "; %d txq, %d rxq (netmap)", pi->nnmtxq,
 	    pi->nnmrxq);
 	MPASS(n > o);
 #endif
 	device_printf(dev, "%s\n", s);
 	free(s, M_CXGBE);
 
 #ifdef DEV_NETMAP
 	/* nm_media handled here to keep implementation private to this file */
 	ifmedia_init(&pi->nm_media, IFM_IMASK, cxgbe_media_change,
 	    cxgbe_media_status);
 	build_medialist(pi, &pi->nm_media);
 	create_netmap_ifnet(pi);	/* logs errors it something fails */
 #endif
 	cxgbe_sysctls(pi);
 
 	return (0);
 }
 
 static int
 cxgbe_detach(device_t dev)
 {
 	struct port_info *pi = device_get_softc(dev);
 	struct adapter *sc = pi->adapter;
 	struct ifnet *ifp = pi->ifp;
 
 	/* Tell if_ioctl and if_init that the port is going away */
 	ADAPTER_LOCK(sc);
 	SET_DOOMED(pi);
 	wakeup(&sc->flags);
 	while (IS_BUSY(sc))
 		mtx_sleep(&sc->flags, &sc->sc_lock, 0, "t4detach", 0);
 	SET_BUSY(sc);
 #ifdef INVARIANTS
 	sc->last_op = "t4detach";
 	sc->last_op_thr = curthread;
 #endif
 	ADAPTER_UNLOCK(sc);
 
 	if (pi->flags & HAS_TRACEQ) {
 		sc->traceq = -1;	/* cloner should not create ifnet */
 		t4_tracer_port_detach(sc);
 	}
 
 	if (pi->vlan_c)
 		EVENTHANDLER_DEREGISTER(vlan_config, pi->vlan_c);
 
 	PORT_LOCK(pi);
 	ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
 	callout_stop(&pi->tick);
 	PORT_UNLOCK(pi);
 	callout_drain(&pi->tick);
 
 	/* Let detach proceed even if these fail. */
 	cxgbe_uninit_synchronized(pi);
 	port_full_uninit(pi);
 
 	ifmedia_removeall(&pi->media);
 	ether_ifdetach(pi->ifp);
 	if_free(pi->ifp);
 
 #ifdef DEV_NETMAP
 	/* XXXNM: equivalent of cxgbe_uninit_synchronized to ifdown nm_ifp */
 	destroy_netmap_ifnet(pi);
 #endif
 
 	ADAPTER_LOCK(sc);
 	CLR_BUSY(sc);
 	wakeup(&sc->flags);
 	ADAPTER_UNLOCK(sc);
 
 	return (0);
 }
 
 static void
 cxgbe_init(void *arg)
 {
 	struct port_info *pi = arg;
 	struct adapter *sc = pi->adapter;
 
 	if (begin_synchronized_op(sc, pi, SLEEP_OK | INTR_OK, "t4init") != 0)
 		return;
 	cxgbe_init_synchronized(pi);
 	end_synchronized_op(sc, 0);
 }
 
 static int
 cxgbe_ioctl(struct ifnet *ifp, unsigned long cmd, caddr_t data)
 {
 	int rc = 0, mtu, flags, can_sleep;
 	struct port_info *pi = ifp->if_softc;
 	struct adapter *sc = pi->adapter;
 	struct ifreq *ifr = (struct ifreq *)data;
 	uint32_t mask;
 
 	switch (cmd) {
 	case SIOCSIFMTU:
 		mtu = ifr->ifr_mtu;
 		if ((mtu < ETHERMIN) || (mtu > ETHERMTU_JUMBO))
 			return (EINVAL);
 
 		rc = begin_synchronized_op(sc, pi, SLEEP_OK | INTR_OK, "t4mtu");
 		if (rc)
 			return (rc);
 		ifp->if_mtu = mtu;
 		if (pi->flags & PORT_INIT_DONE) {
 			t4_update_fl_bufsize(ifp);
 			if (ifp->if_drv_flags & IFF_DRV_RUNNING)
 				rc = update_mac_settings(ifp, XGMAC_MTU);
 		}
 		end_synchronized_op(sc, 0);
 		break;
 
 	case SIOCSIFFLAGS:
 		can_sleep = 0;
 redo_sifflags:
 		rc = begin_synchronized_op(sc, pi,
 		    can_sleep ? (SLEEP_OK | INTR_OK) : HOLD_LOCK, "t4flg");
 		if (rc)
 			return (rc);
 
 		if (ifp->if_flags & IFF_UP) {
 			if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
 				flags = pi->if_flags;
 				if ((ifp->if_flags ^ flags) &
 				    (IFF_PROMISC | IFF_ALLMULTI)) {
 					if (can_sleep == 1) {
 						end_synchronized_op(sc, 0);
 						can_sleep = 0;
 						goto redo_sifflags;
 					}
 					rc = update_mac_settings(ifp,
 					    XGMAC_PROMISC | XGMAC_ALLMULTI);
 				}
 			} else {
 				if (can_sleep == 0) {
 					end_synchronized_op(sc, LOCK_HELD);
 					can_sleep = 1;
 					goto redo_sifflags;
 				}
 				rc = cxgbe_init_synchronized(pi);
 			}
 			pi->if_flags = ifp->if_flags;
 		} else if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
 			if (can_sleep == 0) {
 				end_synchronized_op(sc, LOCK_HELD);
 				can_sleep = 1;
 				goto redo_sifflags;
 			}
 			rc = cxgbe_uninit_synchronized(pi);
 		}
 		end_synchronized_op(sc, can_sleep ? 0 : LOCK_HELD);
 		break;
 
 	case SIOCADDMULTI:
 	case SIOCDELMULTI: /* these two are called with a mutex held :-( */
 		rc = begin_synchronized_op(sc, pi, HOLD_LOCK, "t4multi");
 		if (rc)
 			return (rc);
 		if (ifp->if_drv_flags & IFF_DRV_RUNNING)
 			rc = update_mac_settings(ifp, XGMAC_MCADDRS);
 		end_synchronized_op(sc, LOCK_HELD);
 		break;
 
 	case SIOCSIFCAP:
 		rc = begin_synchronized_op(sc, pi, SLEEP_OK | INTR_OK, "t4cap");
 		if (rc)
 			return (rc);
 
 		mask = ifr->ifr_reqcap ^ ifp->if_capenable;
 		if (mask & IFCAP_TXCSUM) {
 			ifp->if_capenable ^= IFCAP_TXCSUM;
 			ifp->if_hwassist ^= (CSUM_TCP | CSUM_UDP | CSUM_IP);
 
 			if (IFCAP_TSO4 & ifp->if_capenable &&
 			    !(IFCAP_TXCSUM & ifp->if_capenable)) {
 				ifp->if_capenable &= ~IFCAP_TSO4;
 				if_printf(ifp,
 				    "tso4 disabled due to -txcsum.\n");
 			}
 		}
 		if (mask & IFCAP_TXCSUM_IPV6) {
 			ifp->if_capenable ^= IFCAP_TXCSUM_IPV6;
 			ifp->if_hwassist ^= (CSUM_UDP_IPV6 | CSUM_TCP_IPV6);
 
 			if (IFCAP_TSO6 & ifp->if_capenable &&
 			    !(IFCAP_TXCSUM_IPV6 & ifp->if_capenable)) {
 				ifp->if_capenable &= ~IFCAP_TSO6;
 				if_printf(ifp,
 				    "tso6 disabled due to -txcsum6.\n");
 			}
 		}
 		if (mask & IFCAP_RXCSUM)
 			ifp->if_capenable ^= IFCAP_RXCSUM;
 		if (mask & IFCAP_RXCSUM_IPV6)
 			ifp->if_capenable ^= IFCAP_RXCSUM_IPV6;
 
 		/*
 		 * Note that we leave CSUM_TSO alone (it is always set).  The
 		 * kernel takes both IFCAP_TSOx and CSUM_TSO into account before
 		 * sending a TSO request our way, so it's sufficient to toggle
 		 * IFCAP_TSOx only.
 		 */
 		if (mask & IFCAP_TSO4) {
 			if (!(IFCAP_TSO4 & ifp->if_capenable) &&
 			    !(IFCAP_TXCSUM & ifp->if_capenable)) {
 				if_printf(ifp, "enable txcsum first.\n");
 				rc = EAGAIN;
 				goto fail;
 			}
 			ifp->if_capenable ^= IFCAP_TSO4;
 		}
 		if (mask & IFCAP_TSO6) {
 			if (!(IFCAP_TSO6 & ifp->if_capenable) &&
 			    !(IFCAP_TXCSUM_IPV6 & ifp->if_capenable)) {
 				if_printf(ifp, "enable txcsum6 first.\n");
 				rc = EAGAIN;
 				goto fail;
 			}
 			ifp->if_capenable ^= IFCAP_TSO6;
 		}
 		if (mask & IFCAP_LRO) {
 #if defined(INET) || defined(INET6)
 			int i;
 			struct sge_rxq *rxq;
 
 			ifp->if_capenable ^= IFCAP_LRO;
 			for_each_rxq(pi, i, rxq) {
 				if (ifp->if_capenable & IFCAP_LRO)
 					rxq->iq.flags |= IQ_LRO_ENABLED;
 				else
 					rxq->iq.flags &= ~IQ_LRO_ENABLED;
 			}
 #endif
 		}
 #ifdef TCP_OFFLOAD
 		if (mask & IFCAP_TOE) {
 			int enable = (ifp->if_capenable ^ mask) & IFCAP_TOE;
 
 			rc = toe_capability(pi, enable);
 			if (rc != 0)
 				goto fail;
 
 			ifp->if_capenable ^= mask;
 		}
 #endif
 		if (mask & IFCAP_VLAN_HWTAGGING) {
 			ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING;
 			if (ifp->if_drv_flags & IFF_DRV_RUNNING)
 				rc = update_mac_settings(ifp, XGMAC_VLANEX);
 		}
 		if (mask & IFCAP_VLAN_MTU) {
 			ifp->if_capenable ^= IFCAP_VLAN_MTU;
 
 			/* Need to find out how to disable auto-mtu-inflation */
 		}
 		if (mask & IFCAP_VLAN_HWTSO)
 			ifp->if_capenable ^= IFCAP_VLAN_HWTSO;
 		if (mask & IFCAP_VLAN_HWCSUM)
 			ifp->if_capenable ^= IFCAP_VLAN_HWCSUM;
 
 #ifdef VLAN_CAPABILITIES
 		VLAN_CAPABILITIES(ifp);
 #endif
 fail:
 		end_synchronized_op(sc, 0);
 		break;
 
 	case SIOCSIFMEDIA:
 	case SIOCGIFMEDIA:
 		ifmedia_ioctl(ifp, ifr, &pi->media, cmd);
 		break;
 
 	case SIOCGI2C: {
 		struct ifi2creq i2c;
 
 		rc = copyin(ifr->ifr_data, &i2c, sizeof(i2c));
 		if (rc != 0)
 			break;
 		if (i2c.dev_addr != 0xA0 && i2c.dev_addr != 0xA2) {
 			rc = EPERM;
 			break;
 		}
 		if (i2c.len > sizeof(i2c.data)) {
 			rc = EINVAL;
 			break;
 		}
 		rc = begin_synchronized_op(sc, pi, SLEEP_OK | INTR_OK, "t4i2c");
 		if (rc)
 			return (rc);
 		rc = -t4_i2c_rd(sc, sc->mbox, pi->port_id, i2c.dev_addr,
 		    i2c.offset, i2c.len, &i2c.data[0]);
 		end_synchronized_op(sc, 0);
 		if (rc == 0)
 			rc = copyout(&i2c, ifr->ifr_data, sizeof(i2c));
 		break;
 	}
 
 	default:
 		rc = ether_ioctl(ifp, cmd, data);
 	}
 
 	return (rc);
 }
 
 static int
 cxgbe_transmit(struct ifnet *ifp, struct mbuf *m)
 {
 	struct port_info *pi = ifp->if_softc;
 	struct adapter *sc = pi->adapter;
 	struct sge_txq *txq;
 	void *items[1];
 	int rc;
 
 	M_ASSERTPKTHDR(m);
 	MPASS(m->m_nextpkt == NULL);	/* not quite ready for this yet */
 
 	if (__predict_false(pi->link_cfg.link_ok == 0)) {
 		m_freem(m);
 		return (ENETDOWN);
 	}
 
 	rc = parse_pkt(&m);
 	if (__predict_false(rc != 0)) {
 		MPASS(m == NULL);			/* was freed already */
 		atomic_add_int(&pi->tx_parse_error, 1);	/* rare, atomic is ok */
 		return (rc);
 	}
 
 	/* Select a txq. */
 	txq = &sc->sge.txq[pi->first_txq];
 	if (M_HASHTYPE_GET(m) != M_HASHTYPE_NONE)
 		txq += ((m->m_pkthdr.flowid % (pi->ntxq - pi->rsrv_noflowq)) +
 		    pi->rsrv_noflowq);
 
 	items[0] = m;
 	rc = mp_ring_enqueue(txq->r, items, 1, 4096);
 	if (__predict_false(rc != 0))
 		m_freem(m);
 
 	return (rc);
 }
 
 static void
 cxgbe_qflush(struct ifnet *ifp)
 {
 	struct port_info *pi = ifp->if_softc;
 	struct sge_txq *txq;
 	int i;
 
 	/* queues do not exist if !PORT_INIT_DONE. */
 	if (pi->flags & PORT_INIT_DONE) {
 		for_each_txq(pi, i, txq) {
 			TXQ_LOCK(txq);
 			txq->eq.flags &= ~EQ_ENABLED;
 			TXQ_UNLOCK(txq);
 			while (!mp_ring_is_idle(txq->r)) {
 				mp_ring_check_drainage(txq->r, 0);
 				pause("qflush", 1);
 			}
 		}
 	}
 	if_qflush(ifp);
 }
 
 static uint64_t
 cxgbe_get_counter(struct ifnet *ifp, ift_counter c)
 {
 	struct port_info *pi = ifp->if_softc;
 	struct adapter *sc = pi->adapter;
 	struct port_stats *s = &pi->stats;
 
 	cxgbe_refresh_stats(sc, pi);
 
 	switch (c) {
 	case IFCOUNTER_IPACKETS:
 		return (s->rx_frames - s->rx_pause);
 
 	case IFCOUNTER_IERRORS:
 		return (s->rx_jabber + s->rx_runt + s->rx_too_long +
 		    s->rx_fcs_err + s->rx_len_err);
 
 	case IFCOUNTER_OPACKETS:
 		return (s->tx_frames - s->tx_pause);
 
 	case IFCOUNTER_OERRORS:
 		return (s->tx_error_frames);
 
 	case IFCOUNTER_IBYTES:
 		return (s->rx_octets - s->rx_pause * 64);
 
 	case IFCOUNTER_OBYTES:
 		return (s->tx_octets - s->tx_pause * 64);
 
 	case IFCOUNTER_IMCASTS:
 		return (s->rx_mcast_frames - s->rx_pause);
 
 	case IFCOUNTER_OMCASTS:
 		return (s->tx_mcast_frames - s->tx_pause);
 
 	case IFCOUNTER_IQDROPS:
 		return (s->rx_ovflow0 + s->rx_ovflow1 + s->rx_ovflow2 +
 		    s->rx_ovflow3 + s->rx_trunc0 + s->rx_trunc1 + s->rx_trunc2 +
 		    s->rx_trunc3 + pi->tnl_cong_drops);
 
 	case IFCOUNTER_OQDROPS: {
 		uint64_t drops;
 
 		drops = s->tx_drop;
 		if (pi->flags & PORT_INIT_DONE) {
 			int i;
 			struct sge_txq *txq;
 
 			for_each_txq(pi, i, txq)
 				drops += counter_u64_fetch(txq->r->drops);
 		}
 
 		return (drops);
 
 	}
 
 	default:
 		return (if_get_counter_default(ifp, c));
 	}
 }
 
 static int
 cxgbe_media_change(struct ifnet *ifp)
 {
 	struct port_info *pi = ifp->if_softc;
 
 	device_printf(pi->dev, "%s unimplemented.\n", __func__);
 
 	return (EOPNOTSUPP);
 }
 
 static void
 cxgbe_media_status(struct ifnet *ifp, struct ifmediareq *ifmr)
 {
 	struct port_info *pi = ifp->if_softc;
 	struct ifmedia *media = NULL;
 	struct ifmedia_entry *cur;
 	int speed = pi->link_cfg.speed;
 #ifdef INVARIANTS
 	int data = (pi->port_type << 8) | pi->mod_type;
 #endif
 
 	if (ifp == pi->ifp)
 		media = &pi->media;
 #ifdef DEV_NETMAP
 	else if (ifp == pi->nm_ifp)
 		media = &pi->nm_media;
 #endif
 	MPASS(media != NULL);
 
 	cur = media->ifm_cur;
 	MPASS(cur->ifm_data == data);
 
 	ifmr->ifm_status = IFM_AVALID;
 	if (!pi->link_cfg.link_ok)
 		return;
 
 	ifmr->ifm_status |= IFM_ACTIVE;
 
 	/* active and current will differ iff current media is autoselect. */
 	if (IFM_SUBTYPE(cur->ifm_media) != IFM_AUTO)
 		return;
 
 	ifmr->ifm_active = IFM_ETHER | IFM_FDX;
 	if (speed == SPEED_10000)
 		ifmr->ifm_active |= IFM_10G_T;
 	else if (speed == SPEED_1000)
 		ifmr->ifm_active |= IFM_1000_T;
 	else if (speed == SPEED_100)
 		ifmr->ifm_active |= IFM_100_TX;
 	else if (speed == SPEED_10)
 		ifmr->ifm_active |= IFM_10_T;
 	else
 		KASSERT(0, ("%s: link up but speed unknown (%u)", __func__,
 			    speed));
 }
 
 void
 t4_fatal_err(struct adapter *sc)
 {
 	t4_set_reg_field(sc, A_SGE_CONTROL, F_GLOBALENABLE, 0);
 	t4_intr_disable(sc);
 	log(LOG_EMERG, "%s: encountered fatal error, adapter stopped.\n",
 	    device_get_nameunit(sc->dev));
 }
 
 static int
 map_bars_0_and_4(struct adapter *sc)
 {
 	sc->regs_rid = PCIR_BAR(0);
 	sc->regs_res = bus_alloc_resource_any(sc->dev, SYS_RES_MEMORY,
 	    &sc->regs_rid, RF_ACTIVE);
 	if (sc->regs_res == NULL) {
 		device_printf(sc->dev, "cannot map registers.\n");
 		return (ENXIO);
 	}
 	sc->bt = rman_get_bustag(sc->regs_res);
 	sc->bh = rman_get_bushandle(sc->regs_res);
 	sc->mmio_len = rman_get_size(sc->regs_res);
 	setbit(&sc->doorbells, DOORBELL_KDB);
 
 	sc->msix_rid = PCIR_BAR(4);
 	sc->msix_res = bus_alloc_resource_any(sc->dev, SYS_RES_MEMORY,
 	    &sc->msix_rid, RF_ACTIVE);
 	if (sc->msix_res == NULL) {
 		device_printf(sc->dev, "cannot map MSI-X BAR.\n");
 		return (ENXIO);
 	}
 
 	return (0);
 }
 
 static int
 map_bar_2(struct adapter *sc)
 {
 
 	/*
 	 * T4: only iWARP driver uses the userspace doorbells.  There is no need
 	 * to map it if RDMA is disabled.
 	 */
 	if (is_t4(sc) && sc->rdmacaps == 0)
 		return (0);
 
 	sc->udbs_rid = PCIR_BAR(2);
 	sc->udbs_res = bus_alloc_resource_any(sc->dev, SYS_RES_MEMORY,
 	    &sc->udbs_rid, RF_ACTIVE);
 	if (sc->udbs_res == NULL) {
 		device_printf(sc->dev, "cannot map doorbell BAR.\n");
 		return (ENXIO);
 	}
 	sc->udbs_base = rman_get_virtual(sc->udbs_res);
 
 	if (is_t5(sc)) {
 		setbit(&sc->doorbells, DOORBELL_UDB);
 #if defined(__i386__) || defined(__amd64__)
 		if (t5_write_combine) {
 			int rc;
 
 			/*
 			 * Enable write combining on BAR2.  This is the
 			 * userspace doorbell BAR and is split into 128B
 			 * (UDBS_SEG_SIZE) doorbell regions, each associated
 			 * with an egress queue.  The first 64B has the doorbell
 			 * and the second 64B can be used to submit a tx work
 			 * request with an implicit doorbell.
 			 */
 
 			rc = pmap_change_attr((vm_offset_t)sc->udbs_base,
 			    rman_get_size(sc->udbs_res), PAT_WRITE_COMBINING);
 			if (rc == 0) {
 				clrbit(&sc->doorbells, DOORBELL_UDB);
 				setbit(&sc->doorbells, DOORBELL_WCWR);
 				setbit(&sc->doorbells, DOORBELL_UDBWC);
 			} else {
 				device_printf(sc->dev,
 				    "couldn't enable write combining: %d\n",
 				    rc);
 			}
 
 			t4_write_reg(sc, A_SGE_STAT_CFG,
 			    V_STATSOURCE_T5(7) | V_STATMODE(0));
 		}
 #endif
 	}
 
 	return (0);
 }
 
 static const struct memwin t4_memwin[] = {
 	{ MEMWIN0_BASE, MEMWIN0_APERTURE },
 	{ MEMWIN1_BASE, MEMWIN1_APERTURE },
 	{ MEMWIN2_BASE_T4, MEMWIN2_APERTURE_T4 }
 };
 
 static const struct memwin t5_memwin[] = {
 	{ MEMWIN0_BASE, MEMWIN0_APERTURE },
 	{ MEMWIN1_BASE, MEMWIN1_APERTURE },
 	{ MEMWIN2_BASE_T5, MEMWIN2_APERTURE_T5 },
 };
 
 static void
 setup_memwin(struct adapter *sc)
 {
 	const struct memwin *mw;
 	int i, n;
 	uint32_t bar0;
 
 	if (is_t4(sc)) {
 		/*
 		 * Read low 32b of bar0 indirectly via the hardware backdoor
 		 * mechanism.  Works from within PCI passthrough environments
 		 * too, where rman_get_start() can return a different value.  We
 		 * need to program the T4 memory window decoders with the actual
 		 * addresses that will be coming across the PCIe link.
 		 */
 		bar0 = t4_hw_pci_read_cfg4(sc, PCIR_BAR(0));
 		bar0 &= (uint32_t) PCIM_BAR_MEM_BASE;
 
 		mw = &t4_memwin[0];
 		n = nitems(t4_memwin);
 	} else {
 		/* T5 uses the relative offset inside the PCIe BAR */
 		bar0 = 0;
 
 		mw = &t5_memwin[0];
 		n = nitems(t5_memwin);
 	}
 
 	for (i = 0; i < n; i++, mw++) {
 		t4_write_reg(sc,
 		    PCIE_MEM_ACCESS_REG(A_PCIE_MEM_ACCESS_BASE_WIN, i),
 		    (mw->base + bar0) | V_BIR(0) |
 		    V_WINDOW(ilog2(mw->aperture) - 10));
 	}
 
 	/* flush */
 	t4_read_reg(sc, PCIE_MEM_ACCESS_REG(A_PCIE_MEM_ACCESS_BASE_WIN, 2));
 }
 
 /*
  * Verify that the memory range specified by the addr/len pair is valid and lies
  * entirely within a single region (EDCx or MCx).
  */
 static int
 validate_mem_range(struct adapter *sc, uint32_t addr, int len)
 {
 	uint32_t em, addr_len, maddr, mlen;
 
 	/* Memory can only be accessed in naturally aligned 4 byte units */
 	if (addr & 3 || len & 3 || len == 0)
 		return (EINVAL);
 
 	/* Enabled memories */
 	em = t4_read_reg(sc, A_MA_TARGET_MEM_ENABLE);
 	if (em & F_EDRAM0_ENABLE) {
 		addr_len = t4_read_reg(sc, A_MA_EDRAM0_BAR);
 		maddr = G_EDRAM0_BASE(addr_len) << 20;
 		mlen = G_EDRAM0_SIZE(addr_len) << 20;
 		if (mlen > 0 && addr >= maddr && addr < maddr + mlen &&
 		    addr + len <= maddr + mlen)
 			return (0);
 	}
 	if (em & F_EDRAM1_ENABLE) {
 		addr_len = t4_read_reg(sc, A_MA_EDRAM1_BAR);
 		maddr = G_EDRAM1_BASE(addr_len) << 20;
 		mlen = G_EDRAM1_SIZE(addr_len) << 20;
 		if (mlen > 0 && addr >= maddr && addr < maddr + mlen &&
 		    addr + len <= maddr + mlen)
 			return (0);
 	}
 	if (em & F_EXT_MEM_ENABLE) {
 		addr_len = t4_read_reg(sc, A_MA_EXT_MEMORY_BAR);
 		maddr = G_EXT_MEM_BASE(addr_len) << 20;
 		mlen = G_EXT_MEM_SIZE(addr_len) << 20;
 		if (mlen > 0 && addr >= maddr && addr < maddr + mlen &&
 		    addr + len <= maddr + mlen)
 			return (0);
 	}
 	if (!is_t4(sc) && em & F_EXT_MEM1_ENABLE) {
 		addr_len = t4_read_reg(sc, A_MA_EXT_MEMORY1_BAR);
 		maddr = G_EXT_MEM1_BASE(addr_len) << 20;
 		mlen = G_EXT_MEM1_SIZE(addr_len) << 20;
 		if (mlen > 0 && addr >= maddr && addr < maddr + mlen &&
 		    addr + len <= maddr + mlen)
 			return (0);
 	}
 
 	return (EFAULT);
 }
 
 static int
 fwmtype_to_hwmtype(int mtype)
 {
 
 	switch (mtype) {
 	case FW_MEMTYPE_EDC0:
 		return (MEM_EDC0);
 	case FW_MEMTYPE_EDC1:
 		return (MEM_EDC1);
 	case FW_MEMTYPE_EXTMEM:
 		return (MEM_MC0);
 	case FW_MEMTYPE_EXTMEM1:
 		return (MEM_MC1);
 	default:
 		panic("%s: cannot translate fw mtype %d.", __func__, mtype);
 	}
 }
 
 /*
  * Verify that the memory range specified by the memtype/offset/len pair is
  * valid and lies entirely within the memtype specified.  The global address of
  * the start of the range is returned in addr.
  */
 static int
 validate_mt_off_len(struct adapter *sc, int mtype, uint32_t off, int len,
     uint32_t *addr)
 {
 	uint32_t em, addr_len, maddr, mlen;
 
 	/* Memory can only be accessed in naturally aligned 4 byte units */
 	if (off & 3 || len & 3 || len == 0)
 		return (EINVAL);
 
 	em = t4_read_reg(sc, A_MA_TARGET_MEM_ENABLE);
 	switch (fwmtype_to_hwmtype(mtype)) {
 	case MEM_EDC0:
 		if (!(em & F_EDRAM0_ENABLE))
 			return (EINVAL);
 		addr_len = t4_read_reg(sc, A_MA_EDRAM0_BAR);
 		maddr = G_EDRAM0_BASE(addr_len) << 20;
 		mlen = G_EDRAM0_SIZE(addr_len) << 20;
 		break;
 	case MEM_EDC1:
 		if (!(em & F_EDRAM1_ENABLE))
 			return (EINVAL);
 		addr_len = t4_read_reg(sc, A_MA_EDRAM1_BAR);
 		maddr = G_EDRAM1_BASE(addr_len) << 20;
 		mlen = G_EDRAM1_SIZE(addr_len) << 20;
 		break;
 	case MEM_MC:
 		if (!(em & F_EXT_MEM_ENABLE))
 			return (EINVAL);
 		addr_len = t4_read_reg(sc, A_MA_EXT_MEMORY_BAR);
 		maddr = G_EXT_MEM_BASE(addr_len) << 20;
 		mlen = G_EXT_MEM_SIZE(addr_len) << 20;
 		break;
 	case MEM_MC1:
 		if (is_t4(sc) || !(em & F_EXT_MEM1_ENABLE))
 			return (EINVAL);
 		addr_len = t4_read_reg(sc, A_MA_EXT_MEMORY1_BAR);
 		maddr = G_EXT_MEM1_BASE(addr_len) << 20;
 		mlen = G_EXT_MEM1_SIZE(addr_len) << 20;
 		break;
 	default:
 		return (EINVAL);
 	}
 
 	if (mlen > 0 && off < mlen && off + len <= mlen) {
 		*addr = maddr + off;	/* global address */
 		return (0);
 	}
 
 	return (EFAULT);
 }
 
 static void
 memwin_info(struct adapter *sc, int win, uint32_t *base, uint32_t *aperture)
 {
 	const struct memwin *mw;
 
 	if (is_t4(sc)) {
 		KASSERT(win >= 0 && win < nitems(t4_memwin),
 		    ("%s: incorrect memwin# (%d)", __func__, win));
 		mw = &t4_memwin[win];
 	} else {
 		KASSERT(win >= 0 && win < nitems(t5_memwin),
 		    ("%s: incorrect memwin# (%d)", __func__, win));
 		mw = &t5_memwin[win];
 	}
 
 	if (base != NULL)
 		*base = mw->base;
 	if (aperture != NULL)
 		*aperture = mw->aperture;
 }
 
 /*
  * Positions the memory window such that it can be used to access the specified
  * address in the chip's address space.  The return value is the offset of addr
  * from the start of the window.
  */
 static uint32_t
 position_memwin(struct adapter *sc, int n, uint32_t addr)
 {
 	uint32_t start, pf;
 	uint32_t reg;
 
 	KASSERT(n >= 0 && n <= 3,
 	    ("%s: invalid window %d.", __func__, n));
 	KASSERT((addr & 3) == 0,
 	    ("%s: addr (0x%x) is not at a 4B boundary.", __func__, addr));
 
 	if (is_t4(sc)) {
 		pf = 0;
 		start = addr & ~0xf;	/* start must be 16B aligned */
 	} else {
 		pf = V_PFNUM(sc->pf);
 		start = addr & ~0x7f;	/* start must be 128B aligned */
 	}
 	reg = PCIE_MEM_ACCESS_REG(A_PCIE_MEM_ACCESS_OFFSET, n);
 
 	t4_write_reg(sc, reg, start | pf);
 	t4_read_reg(sc, reg);
 
 	return (addr - start);
 }
 
 static int
 cfg_itype_and_nqueues(struct adapter *sc, int n10g, int n1g,
     struct intrs_and_queues *iaq)
 {
 	int rc, itype, navail, nrxq10g, nrxq1g, n;
 	int nofldrxq10g = 0, nofldrxq1g = 0;
 	int nnmrxq10g = 0, nnmrxq1g = 0;
 
 	bzero(iaq, sizeof(*iaq));
 
 	iaq->ntxq10g = t4_ntxq10g;
 	iaq->ntxq1g = t4_ntxq1g;
 	iaq->nrxq10g = nrxq10g = t4_nrxq10g;
 	iaq->nrxq1g = nrxq1g = t4_nrxq1g;
 	iaq->rsrv_noflowq = t4_rsrv_noflowq;
 #ifdef TCP_OFFLOAD
 	if (is_offload(sc)) {
 		iaq->nofldtxq10g = t4_nofldtxq10g;
 		iaq->nofldtxq1g = t4_nofldtxq1g;
 		iaq->nofldrxq10g = nofldrxq10g = t4_nofldrxq10g;
 		iaq->nofldrxq1g = nofldrxq1g = t4_nofldrxq1g;
 	}
 #endif
 #ifdef DEV_NETMAP
 	iaq->nnmtxq10g = t4_nnmtxq10g;
 	iaq->nnmtxq1g = t4_nnmtxq1g;
 	iaq->nnmrxq10g = nnmrxq10g = t4_nnmrxq10g;
 	iaq->nnmrxq1g = nnmrxq1g = t4_nnmrxq1g;
 #endif
 
 	for (itype = INTR_MSIX; itype; itype >>= 1) {
 
 		if ((itype & t4_intr_types) == 0)
 			continue;	/* not allowed */
 
 		if (itype == INTR_MSIX)
 			navail = pci_msix_count(sc->dev);
 		else if (itype == INTR_MSI)
 			navail = pci_msi_count(sc->dev);
 		else
 			navail = 1;
 restart:
 		if (navail == 0)
 			continue;
 
 		iaq->intr_type = itype;
 		iaq->intr_flags_10g = 0;
 		iaq->intr_flags_1g = 0;
 
 		/*
 		 * Best option: an interrupt vector for errors, one for the
 		 * firmware event queue, and one for every rxq (NIC, TOE, and
 		 * netmap).
 		 */
 		iaq->nirq = T4_EXTRA_INTR;
 		iaq->nirq += n10g * (nrxq10g + nofldrxq10g + nnmrxq10g);
 		iaq->nirq += n1g * (nrxq1g + nofldrxq1g + nnmrxq1g);
 		if (iaq->nirq <= navail &&
 		    (itype != INTR_MSI || powerof2(iaq->nirq))) {
 			iaq->intr_flags_10g = INTR_ALL;
 			iaq->intr_flags_1g = INTR_ALL;
 			goto allocate;
 		}
 
 		/*
 		 * Second best option: a vector for errors, one for the firmware
 		 * event queue, and vectors for either all the NIC rx queues or
 		 * all the TOE rx queues.  The queues that don't get vectors
 		 * will forward their interrupts to those that do.
 		 *
 		 * Note: netmap rx queues cannot be created early and so they
 		 * can't be setup to receive forwarded interrupts for others.
 		 */
 		iaq->nirq = T4_EXTRA_INTR;
 		if (nrxq10g >= nofldrxq10g) {
 			iaq->intr_flags_10g = INTR_RXQ;
 			iaq->nirq += n10g * nrxq10g;
 #ifdef DEV_NETMAP
 			iaq->nnmrxq10g = min(nnmrxq10g, nrxq10g);
 #endif
 		} else {
 			iaq->intr_flags_10g = INTR_OFLD_RXQ;
 			iaq->nirq += n10g * nofldrxq10g;
 #ifdef DEV_NETMAP
 			iaq->nnmrxq10g = min(nnmrxq10g, nofldrxq10g);
 #endif
 		}
 		if (nrxq1g >= nofldrxq1g) {
 			iaq->intr_flags_1g = INTR_RXQ;
 			iaq->nirq += n1g * nrxq1g;
 #ifdef DEV_NETMAP
 			iaq->nnmrxq1g = min(nnmrxq1g, nrxq1g);
 #endif
 		} else {
 			iaq->intr_flags_1g = INTR_OFLD_RXQ;
 			iaq->nirq += n1g * nofldrxq1g;
 #ifdef DEV_NETMAP
 			iaq->nnmrxq1g = min(nnmrxq1g, nofldrxq1g);
 #endif
 		}
 		if (iaq->nirq <= navail &&
 		    (itype != INTR_MSI || powerof2(iaq->nirq)))
 			goto allocate;
 
 		/*
 		 * Next best option: an interrupt vector for errors, one for the
 		 * firmware event queue, and at least one per port.  At this
 		 * point we know we'll have to downsize nrxq and/or nofldrxq
 		 * and/or nnmrxq to fit what's available to us.
 		 */
 		iaq->nirq = T4_EXTRA_INTR;
 		iaq->nirq += n10g + n1g;
 		if (iaq->nirq <= navail) {
 			int leftover = navail - iaq->nirq;
 
 			if (n10g > 0) {
 				int target = max(nrxq10g, nofldrxq10g);
 
 				iaq->intr_flags_10g = nrxq10g >= nofldrxq10g ?
 				    INTR_RXQ : INTR_OFLD_RXQ;
 
 				n = 1;
 				while (n < target && leftover >= n10g) {
 					leftover -= n10g;
 					iaq->nirq += n10g;
 					n++;
 				}
 				iaq->nrxq10g = min(n, nrxq10g);
 #ifdef TCP_OFFLOAD
 				iaq->nofldrxq10g = min(n, nofldrxq10g);
 #endif
 #ifdef DEV_NETMAP
 				iaq->nnmrxq10g = min(n, nnmrxq10g);
 #endif
 			}
 
 			if (n1g > 0) {
 				int target = max(nrxq1g, nofldrxq1g);
 
 				iaq->intr_flags_1g = nrxq1g >= nofldrxq1g ?
 				    INTR_RXQ : INTR_OFLD_RXQ;
 
 				n = 1;
 				while (n < target && leftover >= n1g) {
 					leftover -= n1g;
 					iaq->nirq += n1g;
 					n++;
 				}
 				iaq->nrxq1g = min(n, nrxq1g);
 #ifdef TCP_OFFLOAD
 				iaq->nofldrxq1g = min(n, nofldrxq1g);
 #endif
 #ifdef DEV_NETMAP
 				iaq->nnmrxq1g = min(n, nnmrxq1g);
 #endif
 			}
 
 			if (itype != INTR_MSI || powerof2(iaq->nirq))
 				goto allocate;
 		}
 
 		/*
 		 * Least desirable option: one interrupt vector for everything.
 		 */
 		iaq->nirq = iaq->nrxq10g = iaq->nrxq1g = 1;
 		iaq->intr_flags_10g = iaq->intr_flags_1g = 0;
 #ifdef TCP_OFFLOAD
 		if (is_offload(sc))
 			iaq->nofldrxq10g = iaq->nofldrxq1g = 1;
 #endif
 #ifdef DEV_NETMAP
 		iaq->nnmrxq10g = iaq->nnmrxq1g = 1;
 #endif
 
 allocate:
 		navail = iaq->nirq;
 		rc = 0;
 		if (itype == INTR_MSIX)
 			rc = pci_alloc_msix(sc->dev, &navail);
 		else if (itype == INTR_MSI)
 			rc = pci_alloc_msi(sc->dev, &navail);
 
 		if (rc == 0) {
 			if (navail == iaq->nirq)
 				return (0);
 
 			/*
 			 * Didn't get the number requested.  Use whatever number
 			 * the kernel is willing to allocate (it's in navail).
 			 */
 			device_printf(sc->dev, "fewer vectors than requested, "
 			    "type=%d, req=%d, rcvd=%d; will downshift req.\n",
 			    itype, iaq->nirq, navail);
 			pci_release_msi(sc->dev);
 			goto restart;
 		}
 
 		device_printf(sc->dev,
 		    "failed to allocate vectors:%d, type=%d, req=%d, rcvd=%d\n",
 		    itype, rc, iaq->nirq, navail);
 	}
 
 	device_printf(sc->dev,
 	    "failed to find a usable interrupt type.  "
 	    "allowed=%d, msi-x=%d, msi=%d, intx=1", t4_intr_types,
 	    pci_msix_count(sc->dev), pci_msi_count(sc->dev));
 
 	return (ENXIO);
 }
 
 #define FW_VERSION(chip) ( \
     V_FW_HDR_FW_VER_MAJOR(chip##FW_VERSION_MAJOR) | \
     V_FW_HDR_FW_VER_MINOR(chip##FW_VERSION_MINOR) | \
     V_FW_HDR_FW_VER_MICRO(chip##FW_VERSION_MICRO) | \
     V_FW_HDR_FW_VER_BUILD(chip##FW_VERSION_BUILD))
 #define FW_INTFVER(chip, intf) (chip##FW_HDR_INTFVER_##intf)
 
 struct fw_info {
 	uint8_t chip;
 	char *kld_name;
 	char *fw_mod_name;
 	struct fw_hdr fw_hdr;	/* XXX: waste of space, need a sparse struct */
 } fw_info[] = {
 	{
 		.chip = CHELSIO_T4,
 		.kld_name = "t4fw_cfg",
 		.fw_mod_name = "t4fw",
 		.fw_hdr = {
 			.chip = FW_HDR_CHIP_T4,
 			.fw_ver = htobe32_const(FW_VERSION(T4)),
 			.intfver_nic = FW_INTFVER(T4, NIC),
 			.intfver_vnic = FW_INTFVER(T4, VNIC),
 			.intfver_ofld = FW_INTFVER(T4, OFLD),
 			.intfver_ri = FW_INTFVER(T4, RI),
 			.intfver_iscsipdu = FW_INTFVER(T4, ISCSIPDU),
 			.intfver_iscsi = FW_INTFVER(T4, ISCSI),
 			.intfver_fcoepdu = FW_INTFVER(T4, FCOEPDU),
 			.intfver_fcoe = FW_INTFVER(T4, FCOE),
 		},
 	}, {
 		.chip = CHELSIO_T5,
 		.kld_name = "t5fw_cfg",
 		.fw_mod_name = "t5fw",
 		.fw_hdr = {
 			.chip = FW_HDR_CHIP_T5,
 			.fw_ver = htobe32_const(FW_VERSION(T5)),
 			.intfver_nic = FW_INTFVER(T5, NIC),
 			.intfver_vnic = FW_INTFVER(T5, VNIC),
 			.intfver_ofld = FW_INTFVER(T5, OFLD),
 			.intfver_ri = FW_INTFVER(T5, RI),
 			.intfver_iscsipdu = FW_INTFVER(T5, ISCSIPDU),
 			.intfver_iscsi = FW_INTFVER(T5, ISCSI),
 			.intfver_fcoepdu = FW_INTFVER(T5, FCOEPDU),
 			.intfver_fcoe = FW_INTFVER(T5, FCOE),
 		},
 	}
 };
 
 static struct fw_info *
 find_fw_info(int chip)
 {
 	int i;
 
 	for (i = 0; i < nitems(fw_info); i++) {
 		if (fw_info[i].chip == chip)
 			return (&fw_info[i]);
 	}
 	return (NULL);
 }
 
 /*
  * Is the given firmware API compatible with the one the driver was compiled
  * with?
  */
 static int
 fw_compatible(const struct fw_hdr *hdr1, const struct fw_hdr *hdr2)
 {
 
 	/* short circuit if it's the exact same firmware version */
 	if (hdr1->chip == hdr2->chip && hdr1->fw_ver == hdr2->fw_ver)
 		return (1);
 
 	/*
 	 * XXX: Is this too conservative?  Perhaps I should limit this to the
 	 * features that are supported in the driver.
 	 */
 #define SAME_INTF(x) (hdr1->intfver_##x == hdr2->intfver_##x)
 	if (hdr1->chip == hdr2->chip && SAME_INTF(nic) && SAME_INTF(vnic) &&
 	    SAME_INTF(ofld) && SAME_INTF(ri) && SAME_INTF(iscsipdu) &&
 	    SAME_INTF(iscsi) && SAME_INTF(fcoepdu) && SAME_INTF(fcoe))
 		return (1);
 #undef SAME_INTF
 
 	return (0);
 }
 
 /*
  * The firmware in the KLD is usable, but should it be installed?  This routine
  * explains itself in detail if it indicates the KLD firmware should be
  * installed.
  */
 static int
 should_install_kld_fw(struct adapter *sc, int card_fw_usable, int k, int c)
 {
 	const char *reason;
 
 	if (!card_fw_usable) {
 		reason = "incompatible or unusable";
 		goto install;
 	}
 
 	if (k > c) {
 		reason = "older than the version bundled with this driver";
 		goto install;
 	}
 
 	if (t4_fw_install == 2 && k != c) {
 		reason = "different than the version bundled with this driver";
 		goto install;
 	}
 
 	return (0);
 
 install:
 	if (t4_fw_install == 0) {
 		device_printf(sc->dev, "firmware on card (%u.%u.%u.%u) is %s, "
 		    "but the driver is prohibited from installing a different "
 		    "firmware on the card.\n",
 		    G_FW_HDR_FW_VER_MAJOR(c), G_FW_HDR_FW_VER_MINOR(c),
 		    G_FW_HDR_FW_VER_MICRO(c), G_FW_HDR_FW_VER_BUILD(c), reason);
 
 		return (0);
 	}
 
 	device_printf(sc->dev, "firmware on card (%u.%u.%u.%u) is %s, "
 	    "installing firmware %u.%u.%u.%u on card.\n",
 	    G_FW_HDR_FW_VER_MAJOR(c), G_FW_HDR_FW_VER_MINOR(c),
 	    G_FW_HDR_FW_VER_MICRO(c), G_FW_HDR_FW_VER_BUILD(c), reason,
 	    G_FW_HDR_FW_VER_MAJOR(k), G_FW_HDR_FW_VER_MINOR(k),
 	    G_FW_HDR_FW_VER_MICRO(k), G_FW_HDR_FW_VER_BUILD(k));
 
 	return (1);
 }
 /*
  * Establish contact with the firmware and determine if we are the master driver
  * or not, and whether we are responsible for chip initialization.
  */
 static int
 prep_firmware(struct adapter *sc)
 {
 	const struct firmware *fw = NULL, *default_cfg;
 	int rc, pf, card_fw_usable, kld_fw_usable, need_fw_reset = 1;
 	enum dev_state state;
 	struct fw_info *fw_info;
 	struct fw_hdr *card_fw;		/* fw on the card */
 	const struct fw_hdr *kld_fw;	/* fw in the KLD */
 	const struct fw_hdr *drv_fw;	/* fw header the driver was compiled
 					   against */
 
 	/* Contact firmware. */
 	rc = t4_fw_hello(sc, sc->mbox, sc->mbox, MASTER_MAY, &state);
 	if (rc < 0 || state == DEV_STATE_ERR) {
 		rc = -rc;
 		device_printf(sc->dev,
 		    "failed to connect to the firmware: %d, %d.\n", rc, state);
 		return (rc);
 	}
 	pf = rc;
 	if (pf == sc->mbox)
 		sc->flags |= MASTER_PF;
 	else if (state == DEV_STATE_UNINIT) {
 		/*
 		 * We didn't get to be the master so we definitely won't be
 		 * configuring the chip.  It's a bug if someone else hasn't
 		 * configured it already.
 		 */
 		device_printf(sc->dev, "couldn't be master(%d), "
 		    "device not already initialized either(%d).\n", rc, state);
 		return (EDOOFUS);
 	}
 
 	/* This is the firmware whose headers the driver was compiled against */
 	fw_info = find_fw_info(chip_id(sc));
 	if (fw_info == NULL) {
 		device_printf(sc->dev,
 		    "unable to look up firmware information for chip %d.\n",
 		    chip_id(sc));
 		return (EINVAL);
 	}
 	drv_fw = &fw_info->fw_hdr;
 
 	/*
 	 * The firmware KLD contains many modules.  The KLD name is also the
 	 * name of the module that contains the default config file.
 	 */
 	default_cfg = firmware_get(fw_info->kld_name);
 
 	/* Read the header of the firmware on the card */
 	card_fw = malloc(sizeof(*card_fw), M_CXGBE, M_ZERO | M_WAITOK);
 	rc = -t4_read_flash(sc, FLASH_FW_START,
 	    sizeof (*card_fw) / sizeof (uint32_t), (uint32_t *)card_fw, 1);
 	if (rc == 0)
 		card_fw_usable = fw_compatible(drv_fw, (const void*)card_fw);
 	else {
 		device_printf(sc->dev,
 		    "Unable to read card's firmware header: %d\n", rc);
 		card_fw_usable = 0;
 	}
 
 	/* This is the firmware in the KLD */
 	fw = firmware_get(fw_info->fw_mod_name);
 	if (fw != NULL) {
 		kld_fw = (const void *)fw->data;
 		kld_fw_usable = fw_compatible(drv_fw, kld_fw);
 	} else {
 		kld_fw = NULL;
 		kld_fw_usable = 0;
 	}
 
 	if (card_fw_usable && card_fw->fw_ver == drv_fw->fw_ver &&
 	    (!kld_fw_usable || kld_fw->fw_ver == drv_fw->fw_ver)) {
 		/*
 		 * Common case: the firmware on the card is an exact match and
 		 * the KLD is an exact match too, or the KLD is
 		 * absent/incompatible.  Note that t4_fw_install = 2 is ignored
 		 * here -- use cxgbetool loadfw if you want to reinstall the
 		 * same firmware as the one on the card.
 		 */
 	} else if (kld_fw_usable && state == DEV_STATE_UNINIT &&
 	    should_install_kld_fw(sc, card_fw_usable, be32toh(kld_fw->fw_ver),
 	    be32toh(card_fw->fw_ver))) {
 
 		rc = -t4_fw_upgrade(sc, sc->mbox, fw->data, fw->datasize, 0);
 		if (rc != 0) {
 			device_printf(sc->dev,
 			    "failed to install firmware: %d\n", rc);
 			goto done;
 		}
 
 		/* Installed successfully, update the cached header too. */
 		memcpy(card_fw, kld_fw, sizeof(*card_fw));
 		card_fw_usable = 1;
 		need_fw_reset = 0;	/* already reset as part of load_fw */
 	}
 
 	if (!card_fw_usable) {
 		uint32_t d, c, k;
 
 		d = ntohl(drv_fw->fw_ver);
 		c = ntohl(card_fw->fw_ver);
 		k = kld_fw ? ntohl(kld_fw->fw_ver) : 0;
 
 		device_printf(sc->dev, "Cannot find a usable firmware: "
 		    "fw_install %d, chip state %d, "
 		    "driver compiled with %d.%d.%d.%d, "
 		    "card has %d.%d.%d.%d, KLD has %d.%d.%d.%d\n",
 		    t4_fw_install, state,
 		    G_FW_HDR_FW_VER_MAJOR(d), G_FW_HDR_FW_VER_MINOR(d),
 		    G_FW_HDR_FW_VER_MICRO(d), G_FW_HDR_FW_VER_BUILD(d),
 		    G_FW_HDR_FW_VER_MAJOR(c), G_FW_HDR_FW_VER_MINOR(c),
 		    G_FW_HDR_FW_VER_MICRO(c), G_FW_HDR_FW_VER_BUILD(c),
 		    G_FW_HDR_FW_VER_MAJOR(k), G_FW_HDR_FW_VER_MINOR(k),
 		    G_FW_HDR_FW_VER_MICRO(k), G_FW_HDR_FW_VER_BUILD(k));
 		rc = EINVAL;
 		goto done;
 	}
 
 	/* We're using whatever's on the card and it's known to be good. */
 	sc->params.fw_vers = ntohl(card_fw->fw_ver);
 	snprintf(sc->fw_version, sizeof(sc->fw_version), "%u.%u.%u.%u",
 	    G_FW_HDR_FW_VER_MAJOR(sc->params.fw_vers),
 	    G_FW_HDR_FW_VER_MINOR(sc->params.fw_vers),
 	    G_FW_HDR_FW_VER_MICRO(sc->params.fw_vers),
 	    G_FW_HDR_FW_VER_BUILD(sc->params.fw_vers));
 	t4_get_tp_version(sc, &sc->params.tp_vers);
 
 	/* Reset device */
 	if (need_fw_reset &&
 	    (rc = -t4_fw_reset(sc, sc->mbox, F_PIORSTMODE | F_PIORST)) != 0) {
 		device_printf(sc->dev, "firmware reset failed: %d.\n", rc);
 		if (rc != ETIMEDOUT && rc != EIO)
 			t4_fw_bye(sc, sc->mbox);
 		goto done;
 	}
 	sc->flags |= FW_OK;
 
 	rc = get_params__pre_init(sc);
 	if (rc != 0)
 		goto done; /* error message displayed already */
 
 	/* Partition adapter resources as specified in the config file. */
 	if (state == DEV_STATE_UNINIT) {
 
 		KASSERT(sc->flags & MASTER_PF,
 		    ("%s: trying to change chip settings when not master.",
 		    __func__));
 
 		rc = partition_resources(sc, default_cfg, fw_info->kld_name);
 		if (rc != 0)
 			goto done;	/* error message displayed already */
 
 		t4_tweak_chip_settings(sc);
 
 		/* get basic stuff going */
 		rc = -t4_fw_initialize(sc, sc->mbox);
 		if (rc != 0) {
 			device_printf(sc->dev, "fw init failed: %d.\n", rc);
 			goto done;
 		}
 	} else {
 		snprintf(sc->cfg_file, sizeof(sc->cfg_file), "pf%d", pf);
 		sc->cfcsum = 0;
 	}
 
 done:
 	free(card_fw, M_CXGBE);
 	if (fw != NULL)
 		firmware_put(fw, FIRMWARE_UNLOAD);
 	if (default_cfg != NULL)
 		firmware_put(default_cfg, FIRMWARE_UNLOAD);
 
 	return (rc);
 }
 
 #define FW_PARAM_DEV(param) \
 	(V_FW_PARAMS_MNEM(FW_PARAMS_MNEM_DEV) | \
 	 V_FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_DEV_##param))
 #define FW_PARAM_PFVF(param) \
 	(V_FW_PARAMS_MNEM(FW_PARAMS_MNEM_PFVF) | \
 	 V_FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_PFVF_##param))
 
 /*
  * Partition chip resources for use between various PFs, VFs, etc.
  */
 static int
 partition_resources(struct adapter *sc, const struct firmware *default_cfg,
     const char *name_prefix)
 {
 	const struct firmware *cfg = NULL;
 	int rc = 0;
 	struct fw_caps_config_cmd caps;
 	uint32_t mtype, moff, finicsum, cfcsum;
 
 	/*
 	 * Figure out what configuration file to use.  Pick the default config
 	 * file for the card if the user hasn't specified one explicitly.
 	 */
 	snprintf(sc->cfg_file, sizeof(sc->cfg_file), "%s", t4_cfg_file);
 	if (strncmp(t4_cfg_file, DEFAULT_CF, sizeof(t4_cfg_file)) == 0) {
 		/* Card specific overrides go here. */
 		if (pci_get_device(sc->dev) == 0x440a)
 			snprintf(sc->cfg_file, sizeof(sc->cfg_file), UWIRE_CF);
 		if (is_fpga(sc))
 			snprintf(sc->cfg_file, sizeof(sc->cfg_file), FPGA_CF);
 	}
 
 	/*
 	 * We need to load another module if the profile is anything except
 	 * "default" or "flash".
 	 */
 	if (strncmp(sc->cfg_file, DEFAULT_CF, sizeof(sc->cfg_file)) != 0 &&
 	    strncmp(sc->cfg_file, FLASH_CF, sizeof(sc->cfg_file)) != 0) {
 		char s[32];
 
 		snprintf(s, sizeof(s), "%s_%s", name_prefix, sc->cfg_file);
 		cfg = firmware_get(s);
 		if (cfg == NULL) {
 			if (default_cfg != NULL) {
 				device_printf(sc->dev,
 				    "unable to load module \"%s\" for "
 				    "configuration profile \"%s\", will use "
 				    "the default config file instead.\n",
 				    s, sc->cfg_file);
 				snprintf(sc->cfg_file, sizeof(sc->cfg_file),
 				    "%s", DEFAULT_CF);
 			} else {
 				device_printf(sc->dev,
 				    "unable to load module \"%s\" for "
 				    "configuration profile \"%s\", will use "
 				    "the config file on the card's flash "
 				    "instead.\n", s, sc->cfg_file);
 				snprintf(sc->cfg_file, sizeof(sc->cfg_file),
 				    "%s", FLASH_CF);
 			}
 		}
 	}
 
 	if (strncmp(sc->cfg_file, DEFAULT_CF, sizeof(sc->cfg_file)) == 0 &&
 	    default_cfg == NULL) {
 		device_printf(sc->dev,
 		    "default config file not available, will use the config "
 		    "file on the card's flash instead.\n");
 		snprintf(sc->cfg_file, sizeof(sc->cfg_file), "%s", FLASH_CF);
 	}
 
 	if (strncmp(sc->cfg_file, FLASH_CF, sizeof(sc->cfg_file)) != 0) {
 		u_int cflen, i, n;
 		const uint32_t *cfdata;
 		uint32_t param, val, addr, off, mw_base, mw_aperture;
 
 		KASSERT(cfg != NULL || default_cfg != NULL,
 		    ("%s: no config to upload", __func__));
 
 		/*
 		 * Ask the firmware where it wants us to upload the config file.
 		 */
 		param = FW_PARAM_DEV(CF);
 		rc = -t4_query_params(sc, sc->mbox, sc->pf, 0, 1, &param, &val);
 		if (rc != 0) {
 			/* No support for config file?  Shouldn't happen. */
 			device_printf(sc->dev,
 			    "failed to query config file location: %d.\n", rc);
 			goto done;
 		}
 		mtype = G_FW_PARAMS_PARAM_Y(val);
 		moff = G_FW_PARAMS_PARAM_Z(val) << 16;
 
 		/*
 		 * XXX: sheer laziness.  We deliberately added 4 bytes of
 		 * useless stuffing/comments at the end of the config file so
 		 * it's ok to simply throw away the last remaining bytes when
 		 * the config file is not an exact multiple of 4.  This also
 		 * helps with the validate_mt_off_len check.
 		 */
 		if (cfg != NULL) {
 			cflen = cfg->datasize & ~3;
 			cfdata = cfg->data;
 		} else {
 			cflen = default_cfg->datasize & ~3;
 			cfdata = default_cfg->data;
 		}
 
 		if (cflen > FLASH_CFG_MAX_SIZE) {
 			device_printf(sc->dev,
 			    "config file too long (%d, max allowed is %d).  "
 			    "Will try to use the config on the card, if any.\n",
 			    cflen, FLASH_CFG_MAX_SIZE);
 			goto use_config_on_flash;
 		}
 
 		rc = validate_mt_off_len(sc, mtype, moff, cflen, &addr);
 		if (rc != 0) {
 			device_printf(sc->dev,
 			    "%s: addr (%d/0x%x) or len %d is not valid: %d.  "
 			    "Will try to use the config on the card, if any.\n",
 			    __func__, mtype, moff, cflen, rc);
 			goto use_config_on_flash;
 		}
 
 		memwin_info(sc, 2, &mw_base, &mw_aperture);
 		while (cflen) {
 			off = position_memwin(sc, 2, addr);
 			n = min(cflen, mw_aperture - off);
 			for (i = 0; i < n; i += 4)
 				t4_write_reg(sc, mw_base + off + i, *cfdata++);
 			cflen -= n;
 			addr += n;
 		}
 	} else {
 use_config_on_flash:
 		mtype = FW_MEMTYPE_FLASH;
 		moff = t4_flash_cfg_addr(sc);
 	}
 
 	bzero(&caps, sizeof(caps));
 	caps.op_to_write = htobe32(V_FW_CMD_OP(FW_CAPS_CONFIG_CMD) |
 	    F_FW_CMD_REQUEST | F_FW_CMD_READ);
 	caps.cfvalid_to_len16 = htobe32(F_FW_CAPS_CONFIG_CMD_CFVALID |
 	    V_FW_CAPS_CONFIG_CMD_MEMTYPE_CF(mtype) |
 	    V_FW_CAPS_CONFIG_CMD_MEMADDR64K_CF(moff >> 16) | FW_LEN16(caps));
 	rc = -t4_wr_mbox(sc, sc->mbox, &caps, sizeof(caps), &caps);
 	if (rc != 0) {
 		device_printf(sc->dev,
 		    "failed to pre-process config file: %d "
 		    "(mtype %d, moff 0x%x).\n", rc, mtype, moff);
 		goto done;
 	}
 
 	finicsum = be32toh(caps.finicsum);
 	cfcsum = be32toh(caps.cfcsum);
 	if (finicsum != cfcsum) {
 		device_printf(sc->dev,
 		    "WARNING: config file checksum mismatch: %08x %08x\n",
 		    finicsum, cfcsum);
 	}
 	sc->cfcsum = cfcsum;
 
 #define LIMIT_CAPS(x) do { \
 	caps.x &= htobe16(t4_##x##_allowed); \
 } while (0)
 
 	/*
 	 * Let the firmware know what features will (not) be used so it can tune
 	 * things accordingly.
 	 */
 	LIMIT_CAPS(linkcaps);
 	LIMIT_CAPS(niccaps);
 	LIMIT_CAPS(toecaps);
 	LIMIT_CAPS(rdmacaps);
 	LIMIT_CAPS(iscsicaps);
 	LIMIT_CAPS(fcoecaps);
 #undef LIMIT_CAPS
 
 	caps.op_to_write = htobe32(V_FW_CMD_OP(FW_CAPS_CONFIG_CMD) |
 	    F_FW_CMD_REQUEST | F_FW_CMD_WRITE);
 	caps.cfvalid_to_len16 = htobe32(FW_LEN16(caps));
 	rc = -t4_wr_mbox(sc, sc->mbox, &caps, sizeof(caps), NULL);
 	if (rc != 0) {
 		device_printf(sc->dev,
 		    "failed to process config file: %d.\n", rc);
 	}
 done:
 	if (cfg != NULL)
 		firmware_put(cfg, FIRMWARE_UNLOAD);
 	return (rc);
 }
 
 /*
  * Retrieve parameters that are needed (or nice to have) very early.
  */
 static int
 get_params__pre_init(struct adapter *sc)
 {
 	int rc;
 	uint32_t param[2], val[2];
 	struct fw_devlog_cmd cmd;
 	struct devlog_params *dlog = &sc->params.devlog;
 
 	param[0] = FW_PARAM_DEV(PORTVEC);
 	param[1] = FW_PARAM_DEV(CCLK);
 	rc = -t4_query_params(sc, sc->mbox, sc->pf, 0, 2, param, val);
 	if (rc != 0) {
 		device_printf(sc->dev,
 		    "failed to query parameters (pre_init): %d.\n", rc);
 		return (rc);
 	}
 
 	sc->params.portvec = val[0];
 	sc->params.nports = bitcount32(val[0]);
 	sc->params.vpd.cclk = val[1];
 
 	/* Read device log parameters. */
 	bzero(&cmd, sizeof(cmd));
 	cmd.op_to_write = htobe32(V_FW_CMD_OP(FW_DEVLOG_CMD) |
 	    F_FW_CMD_REQUEST | F_FW_CMD_READ);
 	cmd.retval_len16 = htobe32(FW_LEN16(cmd));
 	rc = -t4_wr_mbox(sc, sc->mbox, &cmd, sizeof(cmd), &cmd);
 	if (rc != 0) {
 		device_printf(sc->dev,
 		    "failed to get devlog parameters: %d.\n", rc);
 		bzero(dlog, sizeof (*dlog));
 		rc = 0;	/* devlog isn't critical for device operation */
 	} else {
 		val[0] = be32toh(cmd.memtype_devlog_memaddr16_devlog);
 		dlog->memtype = G_FW_DEVLOG_CMD_MEMTYPE_DEVLOG(val[0]);
 		dlog->start = G_FW_DEVLOG_CMD_MEMADDR16_DEVLOG(val[0]) << 4;
 		dlog->size = be32toh(cmd.memsize_devlog);
 	}
 
 	return (rc);
 }
 
 /*
  * Retrieve various parameters that are of interest to the driver.  The device
  * has been initialized by the firmware at this point.
  */
 static int
 get_params__post_init(struct adapter *sc)
 {
 	int rc;
 	uint32_t param[7], val[7];
 	struct fw_caps_config_cmd caps;
 
 	param[0] = FW_PARAM_PFVF(IQFLINT_START);
 	param[1] = FW_PARAM_PFVF(EQ_START);
 	param[2] = FW_PARAM_PFVF(FILTER_START);
 	param[3] = FW_PARAM_PFVF(FILTER_END);
 	param[4] = FW_PARAM_PFVF(L2T_START);
 	param[5] = FW_PARAM_PFVF(L2T_END);
 	rc = -t4_query_params(sc, sc->mbox, sc->pf, 0, 6, param, val);
 	if (rc != 0) {
 		device_printf(sc->dev,
 		    "failed to query parameters (post_init): %d.\n", rc);
 		return (rc);
 	}
 
 	sc->sge.iq_start = val[0];
 	sc->sge.eq_start = val[1];
 	sc->tids.ftid_base = val[2];
 	sc->tids.nftids = val[3] - val[2] + 1;
 	sc->params.ftid_min = val[2];
 	sc->params.ftid_max = val[3];
 	sc->vres.l2t.start = val[4];
 	sc->vres.l2t.size = val[5] - val[4] + 1;
 	KASSERT(sc->vres.l2t.size <= L2T_SIZE,
 	    ("%s: L2 table size (%u) larger than expected (%u)",
 	    __func__, sc->vres.l2t.size, L2T_SIZE));
 
 	/* get capabilites */
 	bzero(&caps, sizeof(caps));
 	caps.op_to_write = htobe32(V_FW_CMD_OP(FW_CAPS_CONFIG_CMD) |
 	    F_FW_CMD_REQUEST | F_FW_CMD_READ);
 	caps.cfvalid_to_len16 = htobe32(FW_LEN16(caps));
 	rc = -t4_wr_mbox(sc, sc->mbox, &caps, sizeof(caps), &caps);
 	if (rc != 0) {
 		device_printf(sc->dev,
 		    "failed to get card capabilities: %d.\n", rc);
 		return (rc);
 	}
 
 #define READ_CAPS(x) do { \
 	sc->x = htobe16(caps.x); \
 } while (0)
 	READ_CAPS(linkcaps);
 	READ_CAPS(niccaps);
 	READ_CAPS(toecaps);
 	READ_CAPS(rdmacaps);
 	READ_CAPS(iscsicaps);
 	READ_CAPS(fcoecaps);
 
 	if (sc->niccaps & FW_CAPS_CONFIG_NIC_ETHOFLD) {
 		param[0] = FW_PARAM_PFVF(ETHOFLD_START);
 		param[1] = FW_PARAM_PFVF(ETHOFLD_END);
 		param[2] = FW_PARAM_DEV(FLOWC_BUFFIFO_SZ);
 		rc = -t4_query_params(sc, sc->mbox, sc->pf, 0, 3, param, val);
 		if (rc != 0) {
 			device_printf(sc->dev,
 			    "failed to query NIC parameters: %d.\n", rc);
 			return (rc);
 		}
 		sc->tids.etid_base = val[0];
 		sc->params.etid_min = val[0];
 		sc->tids.netids = val[1] - val[0] + 1;
 		sc->params.netids = sc->tids.netids;
 		sc->params.eo_wr_cred = val[2];
 		sc->params.ethoffload = 1;
 	}
 
 	if (sc->toecaps) {
 		/* query offload-related parameters */
 		param[0] = FW_PARAM_DEV(NTID);
 		param[1] = FW_PARAM_PFVF(SERVER_START);
 		param[2] = FW_PARAM_PFVF(SERVER_END);
 		param[3] = FW_PARAM_PFVF(TDDP_START);
 		param[4] = FW_PARAM_PFVF(TDDP_END);
 		param[5] = FW_PARAM_DEV(FLOWC_BUFFIFO_SZ);
 		rc = -t4_query_params(sc, sc->mbox, sc->pf, 0, 6, param, val);
 		if (rc != 0) {
 			device_printf(sc->dev,
 			    "failed to query TOE parameters: %d.\n", rc);
 			return (rc);
 		}
 		sc->tids.ntids = val[0];
 		sc->tids.natids = min(sc->tids.ntids / 2, MAX_ATIDS);
 		sc->tids.stid_base = val[1];
 		sc->tids.nstids = val[2] - val[1] + 1;
 		sc->vres.ddp.start = val[3];
 		sc->vres.ddp.size = val[4] - val[3] + 1;
 		sc->params.ofldq_wr_cred = val[5];
 		sc->params.offload = 1;
 	}
 	if (sc->rdmacaps) {
 		param[0] = FW_PARAM_PFVF(STAG_START);
 		param[1] = FW_PARAM_PFVF(STAG_END);
 		param[2] = FW_PARAM_PFVF(RQ_START);
 		param[3] = FW_PARAM_PFVF(RQ_END);
 		param[4] = FW_PARAM_PFVF(PBL_START);
 		param[5] = FW_PARAM_PFVF(PBL_END);
 		rc = -t4_query_params(sc, sc->mbox, sc->pf, 0, 6, param, val);
 		if (rc != 0) {
 			device_printf(sc->dev,
 			    "failed to query RDMA parameters(1): %d.\n", rc);
 			return (rc);
 		}
 		sc->vres.stag.start = val[0];
 		sc->vres.stag.size = val[1] - val[0] + 1;
 		sc->vres.rq.start = val[2];
 		sc->vres.rq.size = val[3] - val[2] + 1;
 		sc->vres.pbl.start = val[4];
 		sc->vres.pbl.size = val[5] - val[4] + 1;
 
 		param[0] = FW_PARAM_PFVF(SQRQ_START);
 		param[1] = FW_PARAM_PFVF(SQRQ_END);
 		param[2] = FW_PARAM_PFVF(CQ_START);
 		param[3] = FW_PARAM_PFVF(CQ_END);
 		param[4] = FW_PARAM_PFVF(OCQ_START);
 		param[5] = FW_PARAM_PFVF(OCQ_END);
 		rc = -t4_query_params(sc, sc->mbox, sc->pf, 0, 6, param, val);
 		if (rc != 0) {
 			device_printf(sc->dev,
 			    "failed to query RDMA parameters(2): %d.\n", rc);
 			return (rc);
 		}
 		sc->vres.qp.start = val[0];
 		sc->vres.qp.size = val[1] - val[0] + 1;
 		sc->vres.cq.start = val[2];
 		sc->vres.cq.size = val[3] - val[2] + 1;
 		sc->vres.ocq.start = val[4];
 		sc->vres.ocq.size = val[5] - val[4] + 1;
 	}
 	if (sc->iscsicaps) {
 		param[0] = FW_PARAM_PFVF(ISCSI_START);
 		param[1] = FW_PARAM_PFVF(ISCSI_END);
 		rc = -t4_query_params(sc, sc->mbox, sc->pf, 0, 2, param, val);
 		if (rc != 0) {
 			device_printf(sc->dev,
 			    "failed to query iSCSI parameters: %d.\n", rc);
 			return (rc);
 		}
 		sc->vres.iscsi.start = val[0];
 		sc->vres.iscsi.size = val[1] - val[0] + 1;
 	}
 
 	/*
 	 * We've got the params we wanted to query via the firmware.  Now grab
 	 * some others directly from the chip.
 	 */
 	rc = t4_read_chip_settings(sc);
 
 	return (rc);
 }
 
 static int
 set_params__post_init(struct adapter *sc)
 {
 	uint32_t param, val;
 
 	/* ask for encapsulated CPLs */
 	param = FW_PARAM_PFVF(CPLFW4MSG_ENCAP);
 	val = 1;
 	(void)t4_set_params(sc, sc->mbox, sc->pf, 0, 1, &param, &val);
 
 	return (0);
 }
 
 #undef FW_PARAM_PFVF
 #undef FW_PARAM_DEV
 
 static void
 t4_set_desc(struct adapter *sc)
 {
 	char buf[128];
 	struct adapter_params *p = &sc->params;
 
 	snprintf(buf, sizeof(buf), "Chelsio %s %sNIC (rev %d), S/N:%s, "
 	    "P/N:%s, E/C:%s", p->vpd.id, is_offload(sc) ? "R" : "",
 	    chip_rev(sc), p->vpd.sn, p->vpd.pn, p->vpd.ec);
 
 	device_set_desc_copy(sc->dev, buf);
 }
 
 static void
 build_medialist(struct port_info *pi, struct ifmedia *media)
 {
 	int data, m;
 
 	PORT_LOCK(pi);
 
 	ifmedia_removeall(media);
 
 	m = IFM_ETHER | IFM_FDX;
 	data = (pi->port_type << 8) | pi->mod_type;
 
 	switch(pi->port_type) {
 	case FW_PORT_TYPE_BT_XFI:
 		ifmedia_add(media, m | IFM_10G_T, data, NULL);
 		break;
 
 	case FW_PORT_TYPE_BT_XAUI:
 		ifmedia_add(media, m | IFM_10G_T, data, NULL);
 		/* fall through */
 
 	case FW_PORT_TYPE_BT_SGMII:
 		ifmedia_add(media, m | IFM_1000_T, data, NULL);
 		ifmedia_add(media, m | IFM_100_TX, data, NULL);
 		ifmedia_add(media, IFM_ETHER | IFM_AUTO, data, NULL);
 		ifmedia_set(media, IFM_ETHER | IFM_AUTO);
 		break;
 
 	case FW_PORT_TYPE_CX4:
 		ifmedia_add(media, m | IFM_10G_CX4, data, NULL);
 		ifmedia_set(media, m | IFM_10G_CX4);
 		break;
 
 	case FW_PORT_TYPE_QSFP_10G:
 	case FW_PORT_TYPE_SFP:
 	case FW_PORT_TYPE_FIBER_XFI:
 	case FW_PORT_TYPE_FIBER_XAUI:
 		switch (pi->mod_type) {
 
 		case FW_PORT_MOD_TYPE_LR:
 			ifmedia_add(media, m | IFM_10G_LR, data, NULL);
 			ifmedia_set(media, m | IFM_10G_LR);
 			break;
 
 		case FW_PORT_MOD_TYPE_SR:
 			ifmedia_add(media, m | IFM_10G_SR, data, NULL);
 			ifmedia_set(media, m | IFM_10G_SR);
 			break;
 
 		case FW_PORT_MOD_TYPE_LRM:
 			ifmedia_add(media, m | IFM_10G_LRM, data, NULL);
 			ifmedia_set(media, m | IFM_10G_LRM);
 			break;
 
 		case FW_PORT_MOD_TYPE_TWINAX_PASSIVE:
 		case FW_PORT_MOD_TYPE_TWINAX_ACTIVE:
 			ifmedia_add(media, m | IFM_10G_TWINAX, data, NULL);
 			ifmedia_set(media, m | IFM_10G_TWINAX);
 			break;
 
 		case FW_PORT_MOD_TYPE_NONE:
 			m &= ~IFM_FDX;
 			ifmedia_add(media, m | IFM_NONE, data, NULL);
 			ifmedia_set(media, m | IFM_NONE);
 			break;
 
 		case FW_PORT_MOD_TYPE_NA:
 		case FW_PORT_MOD_TYPE_ER:
 		default:
 			device_printf(pi->dev,
 			    "unknown port_type (%d), mod_type (%d)\n",
 			    pi->port_type, pi->mod_type);
 			ifmedia_add(media, m | IFM_UNKNOWN, data, NULL);
 			ifmedia_set(media, m | IFM_UNKNOWN);
 			break;
 		}
 		break;
 
 	case FW_PORT_TYPE_QSFP:
 		switch (pi->mod_type) {
 
 		case FW_PORT_MOD_TYPE_LR:
 			ifmedia_add(media, m | IFM_40G_LR4, data, NULL);
 			ifmedia_set(media, m | IFM_40G_LR4);
 			break;
 
 		case FW_PORT_MOD_TYPE_SR:
 			ifmedia_add(media, m | IFM_40G_SR4, data, NULL);
 			ifmedia_set(media, m | IFM_40G_SR4);
 			break;
 
 		case FW_PORT_MOD_TYPE_TWINAX_PASSIVE:
 		case FW_PORT_MOD_TYPE_TWINAX_ACTIVE:
 			ifmedia_add(media, m | IFM_40G_CR4, data, NULL);
 			ifmedia_set(media, m | IFM_40G_CR4);
 			break;
 
 		case FW_PORT_MOD_TYPE_NONE:
 			m &= ~IFM_FDX;
 			ifmedia_add(media, m | IFM_NONE, data, NULL);
 			ifmedia_set(media, m | IFM_NONE);
 			break;
 
 		default:
 			device_printf(pi->dev,
 			    "unknown port_type (%d), mod_type (%d)\n",
 			    pi->port_type, pi->mod_type);
 			ifmedia_add(media, m | IFM_UNKNOWN, data, NULL);
 			ifmedia_set(media, m | IFM_UNKNOWN);
 			break;
 		}
 		break;
 
 	default:
 		device_printf(pi->dev,
 		    "unknown port_type (%d), mod_type (%d)\n", pi->port_type,
 		    pi->mod_type);
 		ifmedia_add(media, m | IFM_UNKNOWN, data, NULL);
 		ifmedia_set(media, m | IFM_UNKNOWN);
 		break;
 	}
 
 	PORT_UNLOCK(pi);
 }
 
 #define FW_MAC_EXACT_CHUNK	7
 
 /*
  * Program the port's XGMAC based on parameters in ifnet.  The caller also
  * indicates which parameters should be programmed (the rest are left alone).
  */
 int
 update_mac_settings(struct ifnet *ifp, int flags)
 {
 	int rc = 0;
 	struct port_info *pi = ifp->if_softc;
 	struct adapter *sc = pi->adapter;
 	int mtu = -1, promisc = -1, allmulti = -1, vlanex = -1;
 	uint16_t viid = 0xffff;
 	int16_t *xact_addr_filt = NULL;
 
 	ASSERT_SYNCHRONIZED_OP(sc);
 	KASSERT(flags, ("%s: not told what to update.", __func__));
 
 	if (ifp == pi->ifp) {
 		viid = pi->viid;
 		xact_addr_filt = &pi->xact_addr_filt;
 	}
 #ifdef DEV_NETMAP
 	else if (ifp == pi->nm_ifp) {
 		viid = pi->nm_viid;
 		xact_addr_filt = &pi->nm_xact_addr_filt;
 	}
 #endif
 	if (flags & XGMAC_MTU)
 		mtu = ifp->if_mtu;
 
 	if (flags & XGMAC_PROMISC)
 		promisc = ifp->if_flags & IFF_PROMISC ? 1 : 0;
 
 	if (flags & XGMAC_ALLMULTI)
 		allmulti = ifp->if_flags & IFF_ALLMULTI ? 1 : 0;
 
 	if (flags & XGMAC_VLANEX)
 		vlanex = ifp->if_capenable & IFCAP_VLAN_HWTAGGING ? 1 : 0;
 
 	if (flags & (XGMAC_MTU|XGMAC_PROMISC|XGMAC_ALLMULTI|XGMAC_VLANEX)) {
 		rc = -t4_set_rxmode(sc, sc->mbox, viid, mtu, promisc, allmulti,
 		    1, vlanex, false);
 		if (rc) {
 			if_printf(ifp, "set_rxmode (%x) failed: %d\n", flags,
 			    rc);
 			return (rc);
 		}
 	}
 
 	if (flags & XGMAC_UCADDR) {
 		uint8_t ucaddr[ETHER_ADDR_LEN];
 
 		bcopy(IF_LLADDR(ifp), ucaddr, sizeof(ucaddr));
 		rc = t4_change_mac(sc, sc->mbox, viid, *xact_addr_filt, ucaddr,
 		    true, true);
 		if (rc < 0) {
 			rc = -rc;
 			if_printf(ifp, "change_mac failed: %d\n", rc);
 			return (rc);
 		} else {
 			*xact_addr_filt = rc;
 			rc = 0;
 		}
 	}
 
 	if (flags & XGMAC_MCADDRS) {
 		const uint8_t *mcaddr[FW_MAC_EXACT_CHUNK];
 		int del = 1;
 		uint64_t hash = 0;
 		struct ifmultiaddr *ifma;
 		int i = 0, j;
 
 		if_maddr_rlock(ifp);
 		TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 			if (ifma->ifma_addr->sa_family != AF_LINK)
 				continue;
 			mcaddr[i] =
 			    LLADDR((struct sockaddr_dl *)ifma->ifma_addr);
 			MPASS(ETHER_IS_MULTICAST(mcaddr[i]));
 			i++;
 
 			if (i == FW_MAC_EXACT_CHUNK) {
 				rc = t4_alloc_mac_filt(sc, sc->mbox, viid, del,
 				    i, mcaddr, NULL, &hash, 0);
 				if (rc < 0) {
 					rc = -rc;
 					for (j = 0; j < i; j++) {
 						if_printf(ifp,
 						    "failed to add mc address"
 						    " %02x:%02x:%02x:"
 						    "%02x:%02x:%02x rc=%d\n",
 						    mcaddr[j][0], mcaddr[j][1],
 						    mcaddr[j][2], mcaddr[j][3],
 						    mcaddr[j][4], mcaddr[j][5],
 						    rc);
 					}
 					goto mcfail;
 				}
 				del = 0;
 				i = 0;
 			}
 		}
 		if (i > 0) {
 			rc = t4_alloc_mac_filt(sc, sc->mbox, viid, del, i,
 			    mcaddr, NULL, &hash, 0);
 			if (rc < 0) {
 				rc = -rc;
 				for (j = 0; j < i; j++) {
 					if_printf(ifp,
 					    "failed to add mc address"
 					    " %02x:%02x:%02x:"
 					    "%02x:%02x:%02x rc=%d\n",
 					    mcaddr[j][0], mcaddr[j][1],
 					    mcaddr[j][2], mcaddr[j][3],
 					    mcaddr[j][4], mcaddr[j][5],
 					    rc);
 				}
 				goto mcfail;
 			}
 		}
 
 		rc = -t4_set_addr_hash(sc, sc->mbox, viid, 0, hash, 0);
 		if (rc != 0)
 			if_printf(ifp, "failed to set mc address hash: %d", rc);
 mcfail:
 		if_maddr_runlock(ifp);
 	}
 
 	return (rc);
 }
 
 int
 begin_synchronized_op(struct adapter *sc, struct port_info *pi, int flags,
     char *wmesg)
 {
 	int rc, pri;
 
 #ifdef WITNESS
 	/* the caller thinks it's ok to sleep, but is it really? */
 	if (flags & SLEEP_OK)
 		pause("t4slptst", 1);
 #endif
 
 	if (INTR_OK)
 		pri = PCATCH;
 	else
 		pri = 0;
 
 	ADAPTER_LOCK(sc);
 	for (;;) {
 
 		if (pi && IS_DOOMED(pi)) {
 			rc = ENXIO;
 			goto done;
 		}
 
 		if (!IS_BUSY(sc)) {
 			rc = 0;
 			break;
 		}
 
 		if (!(flags & SLEEP_OK)) {
 			rc = EBUSY;
 			goto done;
 		}
 
 		if (mtx_sleep(&sc->flags, &sc->sc_lock, pri, wmesg, 0)) {
 			rc = EINTR;
 			goto done;
 		}
 	}
 
 	KASSERT(!IS_BUSY(sc), ("%s: controller busy.", __func__));
 	SET_BUSY(sc);
 #ifdef INVARIANTS
 	sc->last_op = wmesg;
 	sc->last_op_thr = curthread;
 #endif
 
 done:
 	if (!(flags & HOLD_LOCK) || rc)
 		ADAPTER_UNLOCK(sc);
 
 	return (rc);
 }
 
 void
 end_synchronized_op(struct adapter *sc, int flags)
 {
 
 	if (flags & LOCK_HELD)
 		ADAPTER_LOCK_ASSERT_OWNED(sc);
 	else
 		ADAPTER_LOCK(sc);
 
 	KASSERT(IS_BUSY(sc), ("%s: controller not busy.", __func__));
 	CLR_BUSY(sc);
 	wakeup(&sc->flags);
 	ADAPTER_UNLOCK(sc);
 }
 
 static int
 cxgbe_init_synchronized(struct port_info *pi)
 {
 	struct adapter *sc = pi->adapter;
 	struct ifnet *ifp = pi->ifp;
 	int rc = 0, i;
 	struct sge_txq *txq;
 
 	ASSERT_SYNCHRONIZED_OP(sc);
 
 	if (isset(&sc->open_device_map, pi->port_id)) {
 		KASSERT(ifp->if_drv_flags & IFF_DRV_RUNNING,
 		    ("mismatch between open_device_map and if_drv_flags"));
 		return (0);	/* already running */
 	}
 
 	if (!(sc->flags & FULL_INIT_DONE) &&
 	    ((rc = adapter_full_init(sc)) != 0))
 		return (rc);	/* error message displayed already */
 
 	if (!(pi->flags & PORT_INIT_DONE) &&
 	    ((rc = port_full_init(pi)) != 0))
 		return (rc); /* error message displayed already */
 
 	rc = update_mac_settings(ifp, XGMAC_ALL);
 	if (rc)
 		goto done;	/* error message displayed already */
 
 	rc = -t4_enable_vi(sc, sc->mbox, pi->viid, true, true);
 	if (rc != 0) {
 		if_printf(ifp, "enable_vi failed: %d\n", rc);
 		goto done;
 	}
 
 	/*
 	 * Can't fail from this point onwards.  Review cxgbe_uninit_synchronized
 	 * if this changes.
 	 */
 
 	for_each_txq(pi, i, txq) {
 		TXQ_LOCK(txq);
 		txq->eq.flags |= EQ_ENABLED;
 		TXQ_UNLOCK(txq);
 	}
 
 	/*
 	 * The first iq of the first port to come up is used for tracing.
 	 */
 	if (sc->traceq < 0) {
 		sc->traceq = sc->sge.rxq[pi->first_rxq].iq.abs_id;
 		t4_write_reg(sc, is_t4(sc) ?  A_MPS_TRC_RSS_CONTROL :
 		    A_MPS_T5_TRC_RSS_CONTROL, V_RSSCONTROL(pi->tx_chan) |
 		    V_QUEUENUMBER(sc->traceq));
 		pi->flags |= HAS_TRACEQ;
 	}
 
 	/* all ok */
 	setbit(&sc->open_device_map, pi->port_id);
 	PORT_LOCK(pi);
 	ifp->if_drv_flags |= IFF_DRV_RUNNING;
 	PORT_UNLOCK(pi);
 
 	callout_reset(&pi->tick, hz, cxgbe_tick, pi);
 done:
 	if (rc != 0)
 		cxgbe_uninit_synchronized(pi);
 
 	return (rc);
 }
 
 /*
  * Idempotent.
  */
 static int
 cxgbe_uninit_synchronized(struct port_info *pi)
 {
 	struct adapter *sc = pi->adapter;
 	struct ifnet *ifp = pi->ifp;
 	int rc, i;
 	struct sge_txq *txq;
 
 	ASSERT_SYNCHRONIZED_OP(sc);
 
+	if (!(pi->flags & PORT_INIT_DONE)) {
+		KASSERT(!(ifp->if_drv_flags & IFF_DRV_RUNNING),
+		    ("uninited port is running"));
+		return (0);
+	}
+
 	/*
 	 * Disable the VI so that all its data in either direction is discarded
 	 * by the MPS.  Leave everything else (the queues, interrupts, and 1Hz
 	 * tick) intact as the TP can deliver negative advice or data that it's
 	 * holding in its RAM (for an offloaded connection) even after the VI is
 	 * disabled.
 	 */
 	rc = -t4_enable_vi(sc, sc->mbox, pi->viid, false, false);
 	if (rc) {
 		if_printf(ifp, "disable_vi failed: %d\n", rc);
 		return (rc);
 	}
 
 	for_each_txq(pi, i, txq) {
 		TXQ_LOCK(txq);
 		txq->eq.flags &= ~EQ_ENABLED;
 		TXQ_UNLOCK(txq);
 	}
 
 	clrbit(&sc->open_device_map, pi->port_id);
 	PORT_LOCK(pi);
 	ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
 	PORT_UNLOCK(pi);
 
 	pi->link_cfg.link_ok = 0;
 	pi->link_cfg.speed = 0;
 	pi->linkdnrc = -1;
 	t4_os_link_changed(sc, pi->port_id, 0, -1);
 
 	return (0);
 }
 
 /*
  * It is ok for this function to fail midway and return right away.  t4_detach
  * will walk the entire sc->irq list and clean up whatever is valid.
  */
 static int
 setup_intr_handlers(struct adapter *sc)
 {
 	int rc, rid, p, q;
 	char s[8];
 	struct irq *irq;
 	struct port_info *pi;
 	struct sge_rxq *rxq;
 #ifdef TCP_OFFLOAD
 	struct sge_ofld_rxq *ofld_rxq;
 #endif
 #ifdef DEV_NETMAP
 	struct sge_nm_rxq *nm_rxq;
 #endif
 
 	/*
 	 * Setup interrupts.
 	 */
 	irq = &sc->irq[0];
 	rid = sc->intr_type == INTR_INTX ? 0 : 1;
 	if (sc->intr_count == 1)
 		return (t4_alloc_irq(sc, irq, rid, t4_intr_all, sc, "all"));
 
 	/* Multiple interrupts. */
 	KASSERT(sc->intr_count >= T4_EXTRA_INTR + sc->params.nports,
 	    ("%s: too few intr.", __func__));
 
 	/* The first one is always error intr */
 	rc = t4_alloc_irq(sc, irq, rid, t4_intr_err, sc, "err");
 	if (rc != 0)
 		return (rc);
 	irq++;
 	rid++;
 
 	/* The second one is always the firmware event queue */
 	rc = t4_alloc_irq(sc, irq, rid, t4_intr_evt, &sc->sge.fwq, "evt");
 	if (rc != 0)
 		return (rc);
 	irq++;
 	rid++;
 
 	for_each_port(sc, p) {
 		pi = sc->port[p];
 
 		if (pi->flags & INTR_RXQ) {
 			for_each_rxq(pi, q, rxq) {
 				snprintf(s, sizeof(s), "%d.%d", p, q);
 				rc = t4_alloc_irq(sc, irq, rid, t4_intr, rxq,
 				    s);
 				if (rc != 0)
 					return (rc);
 				irq++;
 				rid++;
 			}
 		}
 #ifdef TCP_OFFLOAD
 		if (pi->flags & INTR_OFLD_RXQ) {
 			for_each_ofld_rxq(pi, q, ofld_rxq) {
 				snprintf(s, sizeof(s), "%d,%d", p, q);
 				rc = t4_alloc_irq(sc, irq, rid, t4_intr,
 				    ofld_rxq, s);
 				if (rc != 0)
 					return (rc);
 				irq++;
 				rid++;
 			}
 		}
 #endif
 #ifdef DEV_NETMAP
 		if (pi->flags & INTR_NM_RXQ) {
 			for_each_nm_rxq(pi, q, nm_rxq) {
 				snprintf(s, sizeof(s), "%d-%d", p, q);
 				rc = t4_alloc_irq(sc, irq, rid, t4_nm_intr,
 				    nm_rxq, s);
 				if (rc != 0)
 					return (rc);
 				irq++;
 				rid++;
 			}
 		}
 #endif
 	}
 	MPASS(irq == &sc->irq[sc->intr_count]);
 
 	return (0);
 }
 
 int
 adapter_full_init(struct adapter *sc)
 {
 	int rc, i;
 
 	ADAPTER_LOCK_ASSERT_NOTOWNED(sc);
 	KASSERT((sc->flags & FULL_INIT_DONE) == 0,
 	    ("%s: FULL_INIT_DONE already", __func__));
 
 	/*
 	 * queues that belong to the adapter (not any particular port).
 	 */
 	rc = t4_setup_adapter_queues(sc);
 	if (rc != 0)
 		goto done;
 
 	for (i = 0; i < nitems(sc->tq); i++) {
 		sc->tq[i] = taskqueue_create("t4 taskq", M_NOWAIT,
 		    taskqueue_thread_enqueue, &sc->tq[i]);
 		if (sc->tq[i] == NULL) {
 			device_printf(sc->dev,
 			    "failed to allocate task queue %d\n", i);
 			rc = ENOMEM;
 			goto done;
 		}
 		taskqueue_start_threads(&sc->tq[i], 1, PI_NET, "%s tq%d",
 		    device_get_nameunit(sc->dev), i);
 	}
 
 	t4_intr_enable(sc);
 	sc->flags |= FULL_INIT_DONE;
 done:
 	if (rc != 0)
 		adapter_full_uninit(sc);
 
 	return (rc);
 }
 
 int
 adapter_full_uninit(struct adapter *sc)
 {
 	int i;
 
 	ADAPTER_LOCK_ASSERT_NOTOWNED(sc);
 
 	t4_teardown_adapter_queues(sc);
 
 	for (i = 0; i < nitems(sc->tq) && sc->tq[i]; i++) {
 		taskqueue_free(sc->tq[i]);
 		sc->tq[i] = NULL;
 	}
 
 	sc->flags &= ~FULL_INIT_DONE;
 
 	return (0);
 }
 
 int
 port_full_init(struct port_info *pi)
 {
 	struct adapter *sc = pi->adapter;
 	struct ifnet *ifp = pi->ifp;
 	uint16_t *rss;
 	struct sge_rxq *rxq;
 	int rc, i, j;
 
 	ASSERT_SYNCHRONIZED_OP(sc);
 	KASSERT((pi->flags & PORT_INIT_DONE) == 0,
 	    ("%s: PORT_INIT_DONE already", __func__));
 
 	sysctl_ctx_init(&pi->ctx);
 	pi->flags |= PORT_SYSCTL_CTX;
 
 	/*
 	 * Allocate tx/rx/fl queues for this port.
 	 */
 	rc = t4_setup_port_queues(pi);
 	if (rc != 0)
 		goto done;	/* error message displayed already */
 
 	/*
 	 * Setup RSS for this port.  Save a copy of the RSS table for later use.
 	 */
 	rss = malloc(pi->rss_size * sizeof (*rss), M_CXGBE, M_ZERO | M_WAITOK);
 	for (i = 0; i < pi->rss_size;) {
 		for_each_rxq(pi, j, rxq) {
 			rss[i++] = rxq->iq.abs_id;
 			if (i == pi->rss_size)
 				break;
 		}
 	}
 
 	rc = -t4_config_rss_range(sc, sc->mbox, pi->viid, 0, pi->rss_size, rss,
 	    pi->rss_size);
 	if (rc != 0) {
 		if_printf(ifp, "rss_config failed: %d\n", rc);
 		goto done;
 	}
 
 	pi->rss = rss;
 	pi->flags |= PORT_INIT_DONE;
 done:
 	if (rc != 0)
 		port_full_uninit(pi);
 
 	return (rc);
 }
 
 /*
  * Idempotent.
  */
 int
 port_full_uninit(struct port_info *pi)
 {
 	struct adapter *sc = pi->adapter;
 	int i;
 	struct sge_rxq *rxq;
 	struct sge_txq *txq;
 #ifdef TCP_OFFLOAD
 	struct sge_ofld_rxq *ofld_rxq;
 	struct sge_wrq *ofld_txq;
 #endif
 
 	if (pi->flags & PORT_INIT_DONE) {
 
 		/* Need to quiesce queues.  */
 
 		quiesce_wrq(sc, &sc->sge.ctrlq[pi->port_id]);
 
 		for_each_txq(pi, i, txq) {
 			quiesce_txq(sc, txq);
 		}
 
 #ifdef TCP_OFFLOAD
 		for_each_ofld_txq(pi, i, ofld_txq) {
 			quiesce_wrq(sc, ofld_txq);
 		}
 #endif
 
 		for_each_rxq(pi, i, rxq) {
 			quiesce_iq(sc, &rxq->iq);
 			quiesce_fl(sc, &rxq->fl);
 		}
 
 #ifdef TCP_OFFLOAD
 		for_each_ofld_rxq(pi, i, ofld_rxq) {
 			quiesce_iq(sc, &ofld_rxq->iq);
 			quiesce_fl(sc, &ofld_rxq->fl);
 		}
 #endif
 		free(pi->rss, M_CXGBE);
 	}
 
 	t4_teardown_port_queues(pi);
 	pi->flags &= ~PORT_INIT_DONE;
 
 	return (0);
 }
 
 static void
 quiesce_txq(struct adapter *sc, struct sge_txq *txq)
 {
 	struct sge_eq *eq = &txq->eq;
 	struct sge_qstat *spg = (void *)&eq->desc[eq->sidx];
 
 	(void) sc;	/* unused */
 
 #ifdef INVARIANTS
 	TXQ_LOCK(txq);
 	MPASS((eq->flags & EQ_ENABLED) == 0);
 	TXQ_UNLOCK(txq);
 #endif
 
 	/* Wait for the mp_ring to empty. */
 	while (!mp_ring_is_idle(txq->r)) {
 		mp_ring_check_drainage(txq->r, 0);
 		pause("rquiesce", 1);
 	}
 
 	/* Then wait for the hardware to finish. */
 	while (spg->cidx != htobe16(eq->pidx))
 		pause("equiesce", 1);
 
 	/* Finally, wait for the driver to reclaim all descriptors. */
 	while (eq->cidx != eq->pidx)
 		pause("dquiesce", 1);
 }
 
 static void
 quiesce_wrq(struct adapter *sc, struct sge_wrq *wrq)
 {
 
 	/* XXXTX */
 }
 
 static void
 quiesce_iq(struct adapter *sc, struct sge_iq *iq)
 {
 	(void) sc;	/* unused */
 
 	/* Synchronize with the interrupt handler */
 	while (!atomic_cmpset_int(&iq->state, IQS_IDLE, IQS_DISABLED))
 		pause("iqfree", 1);
 }
 
 static void
 quiesce_fl(struct adapter *sc, struct sge_fl *fl)
 {
 	mtx_lock(&sc->sfl_lock);
 	FL_LOCK(fl);
 	fl->flags |= FL_DOOMED;
 	FL_UNLOCK(fl);
 	mtx_unlock(&sc->sfl_lock);
 
 	callout_drain(&sc->sfl_callout);
 	KASSERT((fl->flags & FL_STARVING) == 0,
 	    ("%s: still starving", __func__));
 }
 
 static int
 t4_alloc_irq(struct adapter *sc, struct irq *irq, int rid,
     driver_intr_t *handler, void *arg, char *name)
 {
 	int rc;
 
 	irq->rid = rid;
 	irq->res = bus_alloc_resource_any(sc->dev, SYS_RES_IRQ, &irq->rid,
 	    RF_SHAREABLE | RF_ACTIVE);
 	if (irq->res == NULL) {
 		device_printf(sc->dev,
 		    "failed to allocate IRQ for rid %d, name %s.\n", rid, name);
 		return (ENOMEM);
 	}
 
 	rc = bus_setup_intr(sc->dev, irq->res, INTR_MPSAFE | INTR_TYPE_NET,
 	    NULL, handler, arg, &irq->tag);
 	if (rc != 0) {
 		device_printf(sc->dev,
 		    "failed to setup interrupt for rid %d, name %s: %d\n",
 		    rid, name, rc);
 	} else if (name)
 		bus_describe_intr(sc->dev, irq->res, irq->tag, name);
 
 	return (rc);
 }
 
 static int
 t4_free_irq(struct adapter *sc, struct irq *irq)
 {
 	if (irq->tag)
 		bus_teardown_intr(sc->dev, irq->res, irq->tag);
 	if (irq->res)
 		bus_release_resource(sc->dev, SYS_RES_IRQ, irq->rid, irq->res);
 
 	bzero(irq, sizeof(*irq));
 
 	return (0);
 }
 
 static void
 reg_block_dump(struct adapter *sc, uint8_t *buf, unsigned int start,
     unsigned int end)
 {
 	uint32_t *p = (uint32_t *)(buf + start);
 
 	for ( ; start <= end; start += sizeof(uint32_t))
 		*p++ = t4_read_reg(sc, start);
 }
 
 static void
 t4_get_regs(struct adapter *sc, struct t4_regdump *regs, uint8_t *buf)
 {
 	int i, n;
 	const unsigned int *reg_ranges;
 	static const unsigned int t4_reg_ranges[] = {
 		0x1008, 0x1108,
 		0x1180, 0x11b4,
 		0x11fc, 0x123c,
 		0x1300, 0x173c,
 		0x1800, 0x18fc,
 		0x3000, 0x30d8,
 		0x30e0, 0x5924,
 		0x5960, 0x59d4,
 		0x5a00, 0x5af8,
 		0x6000, 0x6098,
 		0x6100, 0x6150,
 		0x6200, 0x6208,
 		0x6240, 0x6248,
 		0x6280, 0x6338,
 		0x6370, 0x638c,
 		0x6400, 0x643c,
 		0x6500, 0x6524,
 		0x6a00, 0x6a38,
 		0x6a60, 0x6a78,
 		0x6b00, 0x6b84,
 		0x6bf0, 0x6c84,
 		0x6cf0, 0x6d84,
 		0x6df0, 0x6e84,
 		0x6ef0, 0x6f84,
 		0x6ff0, 0x7084,
 		0x70f0, 0x7184,
 		0x71f0, 0x7284,
 		0x72f0, 0x7384,
 		0x73f0, 0x7450,
 		0x7500, 0x7530,
 		0x7600, 0x761c,
 		0x7680, 0x76cc,
 		0x7700, 0x7798,
 		0x77c0, 0x77fc,
 		0x7900, 0x79fc,
 		0x7b00, 0x7c38,
 		0x7d00, 0x7efc,
 		0x8dc0, 0x8e1c,
 		0x8e30, 0x8e78,
 		0x8ea0, 0x8f6c,
 		0x8fc0, 0x9074,
 		0x90fc, 0x90fc,
 		0x9400, 0x9458,
 		0x9600, 0x96bc,
 		0x9800, 0x9808,
 		0x9820, 0x983c,
 		0x9850, 0x9864,
 		0x9c00, 0x9c6c,
 		0x9c80, 0x9cec,
 		0x9d00, 0x9d6c,
 		0x9d80, 0x9dec,
 		0x9e00, 0x9e6c,
 		0x9e80, 0x9eec,
 		0x9f00, 0x9f6c,
 		0x9f80, 0x9fec,
 		0xd004, 0xd03c,
 		0xdfc0, 0xdfe0,
 		0xe000, 0xea7c,
 		0xf000, 0x11110,
 		0x11118, 0x11190,
 		0x19040, 0x1906c,
 		0x19078, 0x19080,
 		0x1908c, 0x19124,
 		0x19150, 0x191b0,
 		0x191d0, 0x191e8,
 		0x19238, 0x1924c,
 		0x193f8, 0x19474,
 		0x19490, 0x194f8,
 		0x19800, 0x19f30,
 		0x1a000, 0x1a06c,
 		0x1a0b0, 0x1a120,
 		0x1a128, 0x1a138,
 		0x1a190, 0x1a1c4,
 		0x1a1fc, 0x1a1fc,
 		0x1e040, 0x1e04c,
 		0x1e284, 0x1e28c,
 		0x1e2c0, 0x1e2c0,
 		0x1e2e0, 0x1e2e0,
 		0x1e300, 0x1e384,
 		0x1e3c0, 0x1e3c8,
 		0x1e440, 0x1e44c,
 		0x1e684, 0x1e68c,
 		0x1e6c0, 0x1e6c0,
 		0x1e6e0, 0x1e6e0,
 		0x1e700, 0x1e784,
 		0x1e7c0, 0x1e7c8,
 		0x1e840, 0x1e84c,
 		0x1ea84, 0x1ea8c,
 		0x1eac0, 0x1eac0,
 		0x1eae0, 0x1eae0,
 		0x1eb00, 0x1eb84,
 		0x1ebc0, 0x1ebc8,
 		0x1ec40, 0x1ec4c,
 		0x1ee84, 0x1ee8c,
 		0x1eec0, 0x1eec0,
 		0x1eee0, 0x1eee0,
 		0x1ef00, 0x1ef84,
 		0x1efc0, 0x1efc8,
 		0x1f040, 0x1f04c,
 		0x1f284, 0x1f28c,
 		0x1f2c0, 0x1f2c0,
 		0x1f2e0, 0x1f2e0,
 		0x1f300, 0x1f384,
 		0x1f3c0, 0x1f3c8,
 		0x1f440, 0x1f44c,
 		0x1f684, 0x1f68c,
 		0x1f6c0, 0x1f6c0,
 		0x1f6e0, 0x1f6e0,
 		0x1f700, 0x1f784,
 		0x1f7c0, 0x1f7c8,
 		0x1f840, 0x1f84c,
 		0x1fa84, 0x1fa8c,
 		0x1fac0, 0x1fac0,
 		0x1fae0, 0x1fae0,
 		0x1fb00, 0x1fb84,
 		0x1fbc0, 0x1fbc8,
 		0x1fc40, 0x1fc4c,
 		0x1fe84, 0x1fe8c,
 		0x1fec0, 0x1fec0,
 		0x1fee0, 0x1fee0,
 		0x1ff00, 0x1ff84,
 		0x1ffc0, 0x1ffc8,
 		0x20000, 0x2002c,
 		0x20100, 0x2013c,
 		0x20190, 0x201c8,
 		0x20200, 0x20318,
 		0x20400, 0x20528,
 		0x20540, 0x20614,
 		0x21000, 0x21040,
 		0x2104c, 0x21060,
 		0x210c0, 0x210ec,
 		0x21200, 0x21268,
 		0x21270, 0x21284,
 		0x212fc, 0x21388,
 		0x21400, 0x21404,
 		0x21500, 0x21518,
 		0x2152c, 0x2153c,
 		0x21550, 0x21554,
 		0x21600, 0x21600,
 		0x21608, 0x21628,
 		0x21630, 0x2163c,
 		0x21700, 0x2171c,
 		0x21780, 0x2178c,
 		0x21800, 0x21c38,
 		0x21c80, 0x21d7c,
 		0x21e00, 0x21e04,
 		0x22000, 0x2202c,
 		0x22100, 0x2213c,
 		0x22190, 0x221c8,
 		0x22200, 0x22318,
 		0x22400, 0x22528,
 		0x22540, 0x22614,
 		0x23000, 0x23040,
 		0x2304c, 0x23060,
 		0x230c0, 0x230ec,
 		0x23200, 0x23268,
 		0x23270, 0x23284,
 		0x232fc, 0x23388,
 		0x23400, 0x23404,
 		0x23500, 0x23518,
 		0x2352c, 0x2353c,
 		0x23550, 0x23554,
 		0x23600, 0x23600,
 		0x23608, 0x23628,
 		0x23630, 0x2363c,
 		0x23700, 0x2371c,
 		0x23780, 0x2378c,
 		0x23800, 0x23c38,
 		0x23c80, 0x23d7c,
 		0x23e00, 0x23e04,
 		0x24000, 0x2402c,
 		0x24100, 0x2413c,
 		0x24190, 0x241c8,
 		0x24200, 0x24318,
 		0x24400, 0x24528,
 		0x24540, 0x24614,
 		0x25000, 0x25040,
 		0x2504c, 0x25060,
 		0x250c0, 0x250ec,
 		0x25200, 0x25268,
 		0x25270, 0x25284,
 		0x252fc, 0x25388,
 		0x25400, 0x25404,
 		0x25500, 0x25518,
 		0x2552c, 0x2553c,
 		0x25550, 0x25554,
 		0x25600, 0x25600,
 		0x25608, 0x25628,
 		0x25630, 0x2563c,
 		0x25700, 0x2571c,
 		0x25780, 0x2578c,
 		0x25800, 0x25c38,
 		0x25c80, 0x25d7c,
 		0x25e00, 0x25e04,
 		0x26000, 0x2602c,
 		0x26100, 0x2613c,
 		0x26190, 0x261c8,
 		0x26200, 0x26318,
 		0x26400, 0x26528,
 		0x26540, 0x26614,
 		0x27000, 0x27040,
 		0x2704c, 0x27060,
 		0x270c0, 0x270ec,
 		0x27200, 0x27268,
 		0x27270, 0x27284,
 		0x272fc, 0x27388,
 		0x27400, 0x27404,
 		0x27500, 0x27518,
 		0x2752c, 0x2753c,
 		0x27550, 0x27554,
 		0x27600, 0x27600,
 		0x27608, 0x27628,
 		0x27630, 0x2763c,
 		0x27700, 0x2771c,
 		0x27780, 0x2778c,
 		0x27800, 0x27c38,
 		0x27c80, 0x27d7c,
 		0x27e00, 0x27e04
 	};
 	static const unsigned int t5_reg_ranges[] = {
 		0x1008, 0x1148,
 		0x1180, 0x11b4,
 		0x11fc, 0x123c,
 		0x1280, 0x173c,
 		0x1800, 0x18fc,
 		0x3000, 0x3028,
 		0x3060, 0x30d8,
 		0x30e0, 0x30fc,
 		0x3140, 0x357c,
 		0x35a8, 0x35cc,
 		0x35ec, 0x35ec,
 		0x3600, 0x5624,
 		0x56cc, 0x575c,
 		0x580c, 0x5814,
 		0x5890, 0x58bc,
 		0x5940, 0x59dc,
 		0x59fc, 0x5a18,
 		0x5a60, 0x5a9c,
 		0x5b94, 0x5bfc,
 		0x6000, 0x6040,
 		0x6058, 0x614c,
 		0x7700, 0x7798,
 		0x77c0, 0x78fc,
 		0x7b00, 0x7c54,
 		0x7d00, 0x7efc,
 		0x8dc0, 0x8de0,
 		0x8df8, 0x8e84,
 		0x8ea0, 0x8f84,
 		0x8fc0, 0x90f8,
 		0x9400, 0x9470,
 		0x9600, 0x96f4,
 		0x9800, 0x9808,
 		0x9820, 0x983c,
 		0x9850, 0x9864,
 		0x9c00, 0x9c6c,
 		0x9c80, 0x9cec,
 		0x9d00, 0x9d6c,
 		0x9d80, 0x9dec,
 		0x9e00, 0x9e6c,
 		0x9e80, 0x9eec,
 		0x9f00, 0x9f6c,
 		0x9f80, 0xa020,
 		0xd004, 0xd03c,
 		0xdfc0, 0xdfe0,
 		0xe000, 0x11088,
 		0x1109c, 0x11110,
 		0x11118, 0x1117c,
 		0x11190, 0x11204,
 		0x19040, 0x1906c,
 		0x19078, 0x19080,
 		0x1908c, 0x19124,
 		0x19150, 0x191b0,
 		0x191d0, 0x191e8,
 		0x19238, 0x19290,
 		0x193f8, 0x19474,
 		0x19490, 0x194cc,
 		0x194f0, 0x194f8,
 		0x19c00, 0x19c60,
 		0x19c94, 0x19e10,
 		0x19e50, 0x19f34,
 		0x19f40, 0x19f50,
 		0x19f90, 0x19fe4,
 		0x1a000, 0x1a06c,
 		0x1a0b0, 0x1a120,
 		0x1a128, 0x1a138,
 		0x1a190, 0x1a1c4,
 		0x1a1fc, 0x1a1fc,
 		0x1e008, 0x1e00c,
 		0x1e040, 0x1e04c,
 		0x1e284, 0x1e290,
 		0x1e2c0, 0x1e2c0,
 		0x1e2e0, 0x1e2e0,
 		0x1e300, 0x1e384,
 		0x1e3c0, 0x1e3c8,
 		0x1e408, 0x1e40c,
 		0x1e440, 0x1e44c,
 		0x1e684, 0x1e690,
 		0x1e6c0, 0x1e6c0,
 		0x1e6e0, 0x1e6e0,
 		0x1e700, 0x1e784,
 		0x1e7c0, 0x1e7c8,
 		0x1e808, 0x1e80c,
 		0x1e840, 0x1e84c,
 		0x1ea84, 0x1ea90,
 		0x1eac0, 0x1eac0,
 		0x1eae0, 0x1eae0,
 		0x1eb00, 0x1eb84,
 		0x1ebc0, 0x1ebc8,
 		0x1ec08, 0x1ec0c,
 		0x1ec40, 0x1ec4c,
 		0x1ee84, 0x1ee90,
 		0x1eec0, 0x1eec0,
 		0x1eee0, 0x1eee0,
 		0x1ef00, 0x1ef84,
 		0x1efc0, 0x1efc8,
 		0x1f008, 0x1f00c,
 		0x1f040, 0x1f04c,
 		0x1f284, 0x1f290,
 		0x1f2c0, 0x1f2c0,
 		0x1f2e0, 0x1f2e0,
 		0x1f300, 0x1f384,
 		0x1f3c0, 0x1f3c8,
 		0x1f408, 0x1f40c,
 		0x1f440, 0x1f44c,
 		0x1f684, 0x1f690,
 		0x1f6c0, 0x1f6c0,
 		0x1f6e0, 0x1f6e0,
 		0x1f700, 0x1f784,
 		0x1f7c0, 0x1f7c8,
 		0x1f808, 0x1f80c,
 		0x1f840, 0x1f84c,
 		0x1fa84, 0x1fa90,
 		0x1fac0, 0x1fac0,
 		0x1fae0, 0x1fae0,
 		0x1fb00, 0x1fb84,
 		0x1fbc0, 0x1fbc8,
 		0x1fc08, 0x1fc0c,
 		0x1fc40, 0x1fc4c,
 		0x1fe84, 0x1fe90,
 		0x1fec0, 0x1fec0,
 		0x1fee0, 0x1fee0,
 		0x1ff00, 0x1ff84,
 		0x1ffc0, 0x1ffc8,
 		0x30000, 0x30030,
 		0x30100, 0x30144,
 		0x30190, 0x301d0,
 		0x30200, 0x30318,
 		0x30400, 0x3052c,
 		0x30540, 0x3061c,
 		0x30800, 0x30834,
 		0x308c0, 0x30908,
 		0x30910, 0x309ac,
 		0x30a00, 0x30a2c,
 		0x30a44, 0x30a50,
 		0x30a74, 0x30c24,
 		0x30d00, 0x30d00,
 		0x30d08, 0x30d14,
 		0x30d1c, 0x30d20,
 		0x30d3c, 0x30d50,
 		0x31200, 0x3120c,
 		0x31220, 0x31220,
 		0x31240, 0x31240,
 		0x31600, 0x3160c,
 		0x31a00, 0x31a1c,
 		0x31e00, 0x31e20,
 		0x31e38, 0x31e3c,
 		0x31e80, 0x31e80,
 		0x31e88, 0x31ea8,
 		0x31eb0, 0x31eb4,
 		0x31ec8, 0x31ed4,
 		0x31fb8, 0x32004,
 		0x32200, 0x32200,
 		0x32208, 0x32240,
 		0x32248, 0x32280,
 		0x32288, 0x322c0,
 		0x322c8, 0x322fc,
 		0x32600, 0x32630,
 		0x32a00, 0x32abc,
 		0x32b00, 0x32b70,
 		0x33000, 0x33048,
 		0x33060, 0x3309c,
 		0x330f0, 0x33148,
 		0x33160, 0x3319c,
 		0x331f0, 0x332e4,
 		0x332f8, 0x333e4,
 		0x333f8, 0x33448,
 		0x33460, 0x3349c,
 		0x334f0, 0x33548,
 		0x33560, 0x3359c,
 		0x335f0, 0x336e4,
 		0x336f8, 0x337e4,
 		0x337f8, 0x337fc,
 		0x33814, 0x33814,
 		0x3382c, 0x3382c,
 		0x33880, 0x3388c,
 		0x338e8, 0x338ec,
 		0x33900, 0x33948,
 		0x33960, 0x3399c,
 		0x339f0, 0x33ae4,
 		0x33af8, 0x33b10,
 		0x33b28, 0x33b28,
 		0x33b3c, 0x33b50,
 		0x33bf0, 0x33c10,
 		0x33c28, 0x33c28,
 		0x33c3c, 0x33c50,
 		0x33cf0, 0x33cfc,
 		0x34000, 0x34030,
 		0x34100, 0x34144,
 		0x34190, 0x341d0,
 		0x34200, 0x34318,
 		0x34400, 0x3452c,
 		0x34540, 0x3461c,
 		0x34800, 0x34834,
 		0x348c0, 0x34908,
 		0x34910, 0x349ac,
 		0x34a00, 0x34a2c,
 		0x34a44, 0x34a50,
 		0x34a74, 0x34c24,
 		0x34d00, 0x34d00,
 		0x34d08, 0x34d14,
 		0x34d1c, 0x34d20,
 		0x34d3c, 0x34d50,
 		0x35200, 0x3520c,
 		0x35220, 0x35220,
 		0x35240, 0x35240,
 		0x35600, 0x3560c,
 		0x35a00, 0x35a1c,
 		0x35e00, 0x35e20,
 		0x35e38, 0x35e3c,
 		0x35e80, 0x35e80,
 		0x35e88, 0x35ea8,
 		0x35eb0, 0x35eb4,
 		0x35ec8, 0x35ed4,
 		0x35fb8, 0x36004,
 		0x36200, 0x36200,
 		0x36208, 0x36240,
 		0x36248, 0x36280,
 		0x36288, 0x362c0,
 		0x362c8, 0x362fc,
 		0x36600, 0x36630,
 		0x36a00, 0x36abc,
 		0x36b00, 0x36b70,
 		0x37000, 0x37048,
 		0x37060, 0x3709c,
 		0x370f0, 0x37148,
 		0x37160, 0x3719c,
 		0x371f0, 0x372e4,
 		0x372f8, 0x373e4,
 		0x373f8, 0x37448,
 		0x37460, 0x3749c,
 		0x374f0, 0x37548,
 		0x37560, 0x3759c,
 		0x375f0, 0x376e4,
 		0x376f8, 0x377e4,
 		0x377f8, 0x377fc,
 		0x37814, 0x37814,
 		0x3782c, 0x3782c,
 		0x37880, 0x3788c,
 		0x378e8, 0x378ec,
 		0x37900, 0x37948,
 		0x37960, 0x3799c,
 		0x379f0, 0x37ae4,
 		0x37af8, 0x37b10,
 		0x37b28, 0x37b28,
 		0x37b3c, 0x37b50,
 		0x37bf0, 0x37c10,
 		0x37c28, 0x37c28,
 		0x37c3c, 0x37c50,
 		0x37cf0, 0x37cfc,
 		0x38000, 0x38030,
 		0x38100, 0x38144,
 		0x38190, 0x381d0,
 		0x38200, 0x38318,
 		0x38400, 0x3852c,
 		0x38540, 0x3861c,
 		0x38800, 0x38834,
 		0x388c0, 0x38908,
 		0x38910, 0x389ac,
 		0x38a00, 0x38a2c,
 		0x38a44, 0x38a50,
 		0x38a74, 0x38c24,
 		0x38d00, 0x38d00,
 		0x38d08, 0x38d14,
 		0x38d1c, 0x38d20,
 		0x38d3c, 0x38d50,
 		0x39200, 0x3920c,
 		0x39220, 0x39220,
 		0x39240, 0x39240,
 		0x39600, 0x3960c,
 		0x39a00, 0x39a1c,
 		0x39e00, 0x39e20,
 		0x39e38, 0x39e3c,
 		0x39e80, 0x39e80,
 		0x39e88, 0x39ea8,
 		0x39eb0, 0x39eb4,
 		0x39ec8, 0x39ed4,
 		0x39fb8, 0x3a004,
 		0x3a200, 0x3a200,
 		0x3a208, 0x3a240,
 		0x3a248, 0x3a280,
 		0x3a288, 0x3a2c0,
 		0x3a2c8, 0x3a2fc,
 		0x3a600, 0x3a630,
 		0x3aa00, 0x3aabc,
 		0x3ab00, 0x3ab70,
 		0x3b000, 0x3b048,
 		0x3b060, 0x3b09c,
 		0x3b0f0, 0x3b148,
 		0x3b160, 0x3b19c,
 		0x3b1f0, 0x3b2e4,
 		0x3b2f8, 0x3b3e4,
 		0x3b3f8, 0x3b448,
 		0x3b460, 0x3b49c,
 		0x3b4f0, 0x3b548,
 		0x3b560, 0x3b59c,
 		0x3b5f0, 0x3b6e4,
 		0x3b6f8, 0x3b7e4,
 		0x3b7f8, 0x3b7fc,
 		0x3b814, 0x3b814,
 		0x3b82c, 0x3b82c,
 		0x3b880, 0x3b88c,
 		0x3b8e8, 0x3b8ec,
 		0x3b900, 0x3b948,
 		0x3b960, 0x3b99c,
 		0x3b9f0, 0x3bae4,
 		0x3baf8, 0x3bb10,
 		0x3bb28, 0x3bb28,
 		0x3bb3c, 0x3bb50,
 		0x3bbf0, 0x3bc10,
 		0x3bc28, 0x3bc28,
 		0x3bc3c, 0x3bc50,
 		0x3bcf0, 0x3bcfc,
 		0x3c000, 0x3c030,
 		0x3c100, 0x3c144,
 		0x3c190, 0x3c1d0,
 		0x3c200, 0x3c318,
 		0x3c400, 0x3c52c,
 		0x3c540, 0x3c61c,
 		0x3c800, 0x3c834,
 		0x3c8c0, 0x3c908,
 		0x3c910, 0x3c9ac,
 		0x3ca00, 0x3ca2c,
 		0x3ca44, 0x3ca50,
 		0x3ca74, 0x3cc24,
 		0x3cd00, 0x3cd00,
 		0x3cd08, 0x3cd14,
 		0x3cd1c, 0x3cd20,
 		0x3cd3c, 0x3cd50,
 		0x3d200, 0x3d20c,
 		0x3d220, 0x3d220,
 		0x3d240, 0x3d240,
 		0x3d600, 0x3d60c,
 		0x3da00, 0x3da1c,
 		0x3de00, 0x3de20,
 		0x3de38, 0x3de3c,
 		0x3de80, 0x3de80,
 		0x3de88, 0x3dea8,
 		0x3deb0, 0x3deb4,
 		0x3dec8, 0x3ded4,
 		0x3dfb8, 0x3e004,
 		0x3e200, 0x3e200,
 		0x3e208, 0x3e240,
 		0x3e248, 0x3e280,
 		0x3e288, 0x3e2c0,
 		0x3e2c8, 0x3e2fc,
 		0x3e600, 0x3e630,
 		0x3ea00, 0x3eabc,
 		0x3eb00, 0x3eb70,
 		0x3f000, 0x3f048,
 		0x3f060, 0x3f09c,
 		0x3f0f0, 0x3f148,
 		0x3f160, 0x3f19c,
 		0x3f1f0, 0x3f2e4,
 		0x3f2f8, 0x3f3e4,
 		0x3f3f8, 0x3f448,
 		0x3f460, 0x3f49c,
 		0x3f4f0, 0x3f548,
 		0x3f560, 0x3f59c,
 		0x3f5f0, 0x3f6e4,
 		0x3f6f8, 0x3f7e4,
 		0x3f7f8, 0x3f7fc,
 		0x3f814, 0x3f814,
 		0x3f82c, 0x3f82c,
 		0x3f880, 0x3f88c,
 		0x3f8e8, 0x3f8ec,
 		0x3f900, 0x3f948,
 		0x3f960, 0x3f99c,
 		0x3f9f0, 0x3fae4,
 		0x3faf8, 0x3fb10,
 		0x3fb28, 0x3fb28,
 		0x3fb3c, 0x3fb50,
 		0x3fbf0, 0x3fc10,
 		0x3fc28, 0x3fc28,
 		0x3fc3c, 0x3fc50,
 		0x3fcf0, 0x3fcfc,
 		0x40000, 0x4000c,
 		0x40040, 0x40068,
 		0x4007c, 0x40144,
 		0x40180, 0x4018c,
 		0x40200, 0x40298,
 		0x402ac, 0x4033c,
 		0x403f8, 0x403fc,
 		0x41304, 0x413c4,
 		0x41400, 0x4141c,
 		0x41480, 0x414d0,
 		0x44000, 0x44078,
 		0x440c0, 0x44278,
 		0x442c0, 0x44478,
 		0x444c0, 0x44678,
 		0x446c0, 0x44878,
 		0x448c0, 0x449fc,
 		0x45000, 0x45068,
 		0x45080, 0x45084,
 		0x450a0, 0x450b0,
 		0x45200, 0x45268,
 		0x45280, 0x45284,
 		0x452a0, 0x452b0,
 		0x460c0, 0x460e4,
 		0x47000, 0x4708c,
 		0x47200, 0x47250,
 		0x47400, 0x47420,
 		0x47600, 0x47618,
 		0x47800, 0x47814,
 		0x48000, 0x4800c,
 		0x48040, 0x48068,
 		0x4807c, 0x48144,
 		0x48180, 0x4818c,
 		0x48200, 0x48298,
 		0x482ac, 0x4833c,
 		0x483f8, 0x483fc,
 		0x49304, 0x493c4,
 		0x49400, 0x4941c,
 		0x49480, 0x494d0,
 		0x4c000, 0x4c078,
 		0x4c0c0, 0x4c278,
 		0x4c2c0, 0x4c478,
 		0x4c4c0, 0x4c678,
 		0x4c6c0, 0x4c878,
 		0x4c8c0, 0x4c9fc,
 		0x4d000, 0x4d068,
 		0x4d080, 0x4d084,
 		0x4d0a0, 0x4d0b0,
 		0x4d200, 0x4d268,
 		0x4d280, 0x4d284,
 		0x4d2a0, 0x4d2b0,
 		0x4e0c0, 0x4e0e4,
 		0x4f000, 0x4f08c,
 		0x4f200, 0x4f250,
 		0x4f400, 0x4f420,
 		0x4f600, 0x4f618,
 		0x4f800, 0x4f814,
 		0x50000, 0x500cc,
 		0x50400, 0x50400,
 		0x50800, 0x508cc,
 		0x50c00, 0x50c00,
 		0x51000, 0x5101c,
 		0x51300, 0x51308,
 	};
 
 	if (is_t4(sc)) {
 		reg_ranges = &t4_reg_ranges[0];
 		n = nitems(t4_reg_ranges);
 	} else {
 		reg_ranges = &t5_reg_ranges[0];
 		n = nitems(t5_reg_ranges);
 	}
 
 	regs->version = chip_id(sc) | chip_rev(sc) << 10;
 	for (i = 0; i < n; i += 2)
 		reg_block_dump(sc, buf, reg_ranges[i], reg_ranges[i + 1]);
 }
 
 static void
 cxgbe_refresh_stats(struct adapter *sc, struct port_info *pi)
 {
 	int i;
 	u_int v, tnl_cong_drops;
 	struct timeval tv;
 	const struct timeval interval = {0, 250000};	/* 250ms */
 
 	getmicrotime(&tv);
 	timevalsub(&tv, &interval);
 	if (timevalcmp(&tv, &pi->last_refreshed, <))
 		return;
 
 	tnl_cong_drops = 0;
 	t4_get_port_stats(sc, pi->tx_chan, &pi->stats);
 	for (i = 0; i < NCHAN; i++) {
 		if (pi->rx_chan_map & (1 << i)) {
 			mtx_lock(&sc->regwin_lock);
 			t4_read_indirect(sc, A_TP_MIB_INDEX, A_TP_MIB_DATA, &v,
 			    1, A_TP_MIB_TNL_CNG_DROP_0 + i);
 			mtx_unlock(&sc->regwin_lock);
 			tnl_cong_drops += v;
 		}
 	}
 	pi->tnl_cong_drops = tnl_cong_drops;
 	getmicrotime(&pi->last_refreshed);
 }
 
 static void
 cxgbe_tick(void *arg)
 {
 	struct port_info *pi = arg;
 	struct adapter *sc = pi->adapter;
 	struct ifnet *ifp = pi->ifp;
 
 	PORT_LOCK(pi);
 	if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
 		PORT_UNLOCK(pi);
 		return;	/* without scheduling another callout */
 	}
 
 	cxgbe_refresh_stats(sc, pi);
 
 	callout_schedule(&pi->tick, hz);
 	PORT_UNLOCK(pi);
 }
 
 static void
 cxgbe_vlan_config(void *arg, struct ifnet *ifp, uint16_t vid)
 {
 	struct ifnet *vlan;
 
 	if (arg != ifp || ifp->if_type != IFT_ETHER)
 		return;
 
 	vlan = VLAN_DEVAT(ifp, vid);
 	VLAN_SETCOOKIE(vlan, ifp);
 }
 
 static int
 cpl_not_handled(struct sge_iq *iq, const struct rss_header *rss, struct mbuf *m)
 {
 
 #ifdef INVARIANTS
 	panic("%s: opcode 0x%02x on iq %p with payload %p",
 	    __func__, rss->opcode, iq, m);
 #else
 	log(LOG_ERR, "%s: opcode 0x%02x on iq %p with payload %p\n",
 	    __func__, rss->opcode, iq, m);
 	m_freem(m);
 #endif
 	return (EDOOFUS);
 }
 
 int
 t4_register_cpl_handler(struct adapter *sc, int opcode, cpl_handler_t h)
 {
 	uintptr_t *loc, new;
 
 	if (opcode >= nitems(sc->cpl_handler))
 		return (EINVAL);
 
 	new = h ? (uintptr_t)h : (uintptr_t)cpl_not_handled;
 	loc = (uintptr_t *) &sc->cpl_handler[opcode];
 	atomic_store_rel_ptr(loc, new);
 
 	return (0);
 }
 
 static int
 an_not_handled(struct sge_iq *iq, const struct rsp_ctrl *ctrl)
 {
 
 #ifdef INVARIANTS
 	panic("%s: async notification on iq %p (ctrl %p)", __func__, iq, ctrl);
 #else
 	log(LOG_ERR, "%s: async notification on iq %p (ctrl %p)\n",
 	    __func__, iq, ctrl);
 #endif
 	return (EDOOFUS);
 }
 
 int
 t4_register_an_handler(struct adapter *sc, an_handler_t h)
 {
 	uintptr_t *loc, new;
 
 	new = h ? (uintptr_t)h : (uintptr_t)an_not_handled;
 	loc = (uintptr_t *) &sc->an_handler;
 	atomic_store_rel_ptr(loc, new);
 
 	return (0);
 }
 
 static int
 fw_msg_not_handled(struct adapter *sc, const __be64 *rpl)
 {
 	const struct cpl_fw6_msg *cpl =
 	    __containerof(rpl, struct cpl_fw6_msg, data[0]);
 
 #ifdef INVARIANTS
 	panic("%s: fw_msg type %d", __func__, cpl->type);
 #else
 	log(LOG_ERR, "%s: fw_msg type %d\n", __func__, cpl->type);
 #endif
 	return (EDOOFUS);
 }
 
 int
 t4_register_fw_msg_handler(struct adapter *sc, int type, fw_msg_handler_t h)
 {
 	uintptr_t *loc, new;
 
 	if (type >= nitems(sc->fw_msg_handler))
 		return (EINVAL);
 
 	/*
 	 * These are dispatched by the handler for FW{4|6}_CPL_MSG using the CPL
 	 * handler dispatch table.  Reject any attempt to install a handler for
 	 * this subtype.
 	 */
 	if (type == FW_TYPE_RSSCPL || type == FW6_TYPE_RSSCPL)
 		return (EINVAL);
 
 	new = h ? (uintptr_t)h : (uintptr_t)fw_msg_not_handled;
 	loc = (uintptr_t *) &sc->fw_msg_handler[type];
 	atomic_store_rel_ptr(loc, new);
 
 	return (0);
 }
 
 static int
 t4_sysctls(struct adapter *sc)
 {
 	struct sysctl_ctx_list *ctx;
 	struct sysctl_oid *oid;
 	struct sysctl_oid_list *children, *c0;
 	static char *caps[] = {
 		"\20\1PPP\2QFC\3DCBX",			/* caps[0] linkcaps */
 		"\20\1NIC\2VM\3IDS\4UM\5UM_ISGL"	/* caps[1] niccaps */
 		    "\6HASHFILTER\7ETHOFLD",
 		"\20\1TOE",				/* caps[2] toecaps */
 		"\20\1RDDP\2RDMAC",			/* caps[3] rdmacaps */
 		"\20\1INITIATOR_PDU\2TARGET_PDU"	/* caps[4] iscsicaps */
 		    "\3INITIATOR_CNXOFLD\4TARGET_CNXOFLD"
 		    "\5INITIATOR_SSNOFLD\6TARGET_SSNOFLD",
 		"\20\1INITIATOR\2TARGET\3CTRL_OFLD"	/* caps[5] fcoecaps */
 		    "\4PO_INITIAOR\5PO_TARGET"
 	};
 	static char *doorbells = {"\20\1UDB\2WCWR\3UDBWC\4KDB"};
 
 	ctx = device_get_sysctl_ctx(sc->dev);
 
 	/*
 	 * dev.t4nex.X.
 	 */
 	oid = device_get_sysctl_tree(sc->dev);
 	c0 = children = SYSCTL_CHILDREN(oid);
 
 	sc->sc_do_rxcopy = 1;
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO, "do_rx_copy", CTLFLAG_RW,
 	    &sc->sc_do_rxcopy, 1, "Do RX copy of small frames");
 
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO, "nports", CTLFLAG_RD, NULL,
 	    sc->params.nports, "# of ports");
 
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO, "hw_revision", CTLFLAG_RD,
 	    NULL, chip_rev(sc), "chip hardware revision");
 
 	SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "firmware_version",
 	    CTLFLAG_RD, sc->fw_version, 0, "firmware version");
 
 	SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "cf",
 	    CTLFLAG_RD, sc->cfg_file, 0, "configuration file");
 
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "cfcsum", CTLFLAG_RD, NULL,
 	    sc->cfcsum, "config file checksum");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "doorbells",
 	    CTLTYPE_STRING | CTLFLAG_RD, doorbells, sc->doorbells,
 	    sysctl_bitfield, "A", "available doorbells");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "linkcaps",
 	    CTLTYPE_STRING | CTLFLAG_RD, caps[0], sc->linkcaps,
 	    sysctl_bitfield, "A", "available link capabilities");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "niccaps",
 	    CTLTYPE_STRING | CTLFLAG_RD, caps[1], sc->niccaps,
 	    sysctl_bitfield, "A", "available NIC capabilities");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "toecaps",
 	    CTLTYPE_STRING | CTLFLAG_RD, caps[2], sc->toecaps,
 	    sysctl_bitfield, "A", "available TCP offload capabilities");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rdmacaps",
 	    CTLTYPE_STRING | CTLFLAG_RD, caps[3], sc->rdmacaps,
 	    sysctl_bitfield, "A", "available RDMA capabilities");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "iscsicaps",
 	    CTLTYPE_STRING | CTLFLAG_RD, caps[4], sc->iscsicaps,
 	    sysctl_bitfield, "A", "available iSCSI capabilities");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "fcoecaps",
 	    CTLTYPE_STRING | CTLFLAG_RD, caps[5], sc->fcoecaps,
 	    sysctl_bitfield, "A", "available FCoE capabilities");
 
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO, "core_clock", CTLFLAG_RD, NULL,
 	    sc->params.vpd.cclk, "core clock frequency (in KHz)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "holdoff_timers",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc->sge.timer_val,
 	    sizeof(sc->sge.timer_val), sysctl_int_array, "A",
 	    "interrupt holdoff timer values (us)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "holdoff_pkt_counts",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc->sge.counter_val,
 	    sizeof(sc->sge.counter_val), sysctl_int_array, "A",
 	    "interrupt holdoff packet counter values");
 
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO, "nfilters", CTLFLAG_RD,
 	    NULL, sc->tids.nftids, "number of filters");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "temperature", CTLTYPE_INT |
 	    CTLFLAG_RD, sc, 0, sysctl_temperature, "I",
 	    "chip temperature (in Celsius)");
 
 	t4_sge_sysctls(sc, ctx, children);
 
 	sc->lro_timeout = 100;
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO, "lro_timeout", CTLFLAG_RW,
 	    &sc->lro_timeout, 0, "lro inactive-flush timeout (in us)");
 
 #ifdef SBUF_DRAIN
 	/*
 	 * dev.t4nex.X.misc.  Marked CTLFLAG_SKIP to avoid information overload.
 	 */
 	oid = SYSCTL_ADD_NODE(ctx, c0, OID_AUTO, "misc",
 	    CTLFLAG_RD | CTLFLAG_SKIP, NULL,
 	    "logs and miscellaneous information");
 	children = SYSCTL_CHILDREN(oid);
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cctrl",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_cctrl, "A", "congestion control");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_tp0",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_cim_ibq_obq, "A", "CIM IBQ 0 (TP0)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_tp1",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 1,
 	    sysctl_cim_ibq_obq, "A", "CIM IBQ 1 (TP1)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_ulp",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 2,
 	    sysctl_cim_ibq_obq, "A", "CIM IBQ 2 (ULP)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_sge0",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 3,
 	    sysctl_cim_ibq_obq, "A", "CIM IBQ 3 (SGE0)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_sge1",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 4,
 	    sysctl_cim_ibq_obq, "A", "CIM IBQ 4 (SGE1)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ibq_ncsi",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 5,
 	    sysctl_cim_ibq_obq, "A", "CIM IBQ 5 (NCSI)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_la",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_cim_la, "A", "CIM logic analyzer");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_ma_la",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_cim_ma_la, "A", "CIM MA logic analyzer");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_ulp0",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0 + CIM_NUM_IBQ,
 	    sysctl_cim_ibq_obq, "A", "CIM OBQ 0 (ULP0)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_ulp1",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 1 + CIM_NUM_IBQ,
 	    sysctl_cim_ibq_obq, "A", "CIM OBQ 1 (ULP1)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_ulp2",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 2 + CIM_NUM_IBQ,
 	    sysctl_cim_ibq_obq, "A", "CIM OBQ 2 (ULP2)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_ulp3",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 3 + CIM_NUM_IBQ,
 	    sysctl_cim_ibq_obq, "A", "CIM OBQ 3 (ULP3)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_sge",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 4 + CIM_NUM_IBQ,
 	    sysctl_cim_ibq_obq, "A", "CIM OBQ 4 (SGE)");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_ncsi",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 5 + CIM_NUM_IBQ,
 	    sysctl_cim_ibq_obq, "A", "CIM OBQ 5 (NCSI)");
 
 	if (is_t5(sc)) {
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_sge0_rx",
 		    CTLTYPE_STRING | CTLFLAG_RD, sc, 6 + CIM_NUM_IBQ,
 		    sysctl_cim_ibq_obq, "A", "CIM OBQ 6 (SGE0-RX)");
 
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_obq_sge1_rx",
 		    CTLTYPE_STRING | CTLFLAG_RD, sc, 7 + CIM_NUM_IBQ,
 		    sysctl_cim_ibq_obq, "A", "CIM OBQ 7 (SGE1-RX)");
 	}
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_pif_la",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_cim_pif_la, "A", "CIM PIF logic analyzer");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cim_qcfg",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_cim_qcfg, "A", "CIM queue configuration");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "cpl_stats",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_cpl_stats, "A", "CPL statistics");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "ddp_stats",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_ddp_stats, "A", "non-TCP DDP statistics");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "devlog",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_devlog, "A", "firmware's device log");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "fcoe_stats",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_fcoe_stats, "A", "FCoE statistics");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "hw_sched",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_hw_sched, "A", "hardware scheduler ");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "l2t",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_l2t, "A", "hardware L2 table");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "lb_stats",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_lb_stats, "A", "loopback statistics");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "meminfo",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_meminfo, "A", "memory regions");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "mps_tcam",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_mps_tcam, "A", "MPS TCAM entries");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "path_mtus",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_path_mtus, "A", "path MTUs");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "pm_stats",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_pm_stats, "A", "PM statistics");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rdma_stats",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_rdma_stats, "A", "RDMA statistics");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tcp_stats",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_tcp_stats, "A", "TCP statistics");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tids",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_tids, "A", "TID information");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tp_err_stats",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_tp_err_stats, "A", "TP error statistics");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tp_la",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_tp_la, "A", "TP logic analyzer");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tx_rate",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_tx_rate, "A", "Tx rate");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "ulprx_la",
 	    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 	    sysctl_ulprx_la, "A", "ULPRX logic analyzer");
 
 	if (is_t5(sc)) {
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "wcwr_stats",
 		    CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
 		    sysctl_wcwr_stats, "A", "write combined work requests");
 	}
 #endif
 
 #ifdef TCP_OFFLOAD
 	if (is_offload(sc)) {
 		/*
 		 * dev.t4nex.X.toe.
 		 */
 		oid = SYSCTL_ADD_NODE(ctx, c0, OID_AUTO, "toe", CTLFLAG_RD,
 		    NULL, "TOE parameters");
 		children = SYSCTL_CHILDREN(oid);
 
 		sc->tt.sndbuf = 256 * 1024;
 		SYSCTL_ADD_INT(ctx, children, OID_AUTO, "sndbuf", CTLFLAG_RW,
 		    &sc->tt.sndbuf, 0, "max hardware send buffer size");
 
 		sc->tt.ddp = 0;
 		SYSCTL_ADD_INT(ctx, children, OID_AUTO, "ddp", CTLFLAG_RW,
 		    &sc->tt.ddp, 0, "DDP allowed");
 
 		sc->tt.indsz = G_INDICATESIZE(t4_read_reg(sc, A_TP_PARA_REG5));
 		SYSCTL_ADD_INT(ctx, children, OID_AUTO, "indsz", CTLFLAG_RW,
 		    &sc->tt.indsz, 0, "DDP max indicate size allowed");
 
 		sc->tt.ddp_thres =
 		    G_RXCOALESCESIZE(t4_read_reg(sc, A_TP_PARA_REG2));
 		SYSCTL_ADD_INT(ctx, children, OID_AUTO, "ddp_thres", CTLFLAG_RW,
 		    &sc->tt.ddp_thres, 0, "DDP threshold");
 
 		sc->tt.rx_coalesce = 1;
 		SYSCTL_ADD_INT(ctx, children, OID_AUTO, "rx_coalesce",
 		    CTLFLAG_RW, &sc->tt.rx_coalesce, 0, "receive coalescing");
 
 		sc->tt.tx_align = 1;
 		SYSCTL_ADD_INT(ctx, children, OID_AUTO, "tx_align",
 		    CTLFLAG_RW, &sc->tt.tx_align, 0, "chop and align payload");
 	}
 #endif
 
 
 	return (0);
 }
 
 static int
 cxgbe_sysctls(struct port_info *pi)
 {
 	struct sysctl_ctx_list *ctx;
 	struct sysctl_oid *oid;
 	struct sysctl_oid_list *children;
 	struct adapter *sc = pi->adapter;
 
 	ctx = device_get_sysctl_ctx(pi->dev);
 
 	/*
 	 * dev.cxgbe.X.
 	 */
 	oid = device_get_sysctl_tree(pi->dev);
 	children = SYSCTL_CHILDREN(oid);
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "linkdnrc", CTLTYPE_STRING |
 	   CTLFLAG_RD, pi, 0, sysctl_linkdnrc, "A", "reason why link is down");
 	if (pi->port_type == FW_PORT_TYPE_BT_XAUI) {
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "temperature",
 		    CTLTYPE_INT | CTLFLAG_RD, pi, 0, sysctl_btphy, "I",
 		    "PHY temperature (in Celsius)");
 		SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "fw_version",
 		    CTLTYPE_INT | CTLFLAG_RD, pi, 1, sysctl_btphy, "I",
 		    "PHY firmware version");
 	}
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO, "nrxq", CTLFLAG_RD,
 	    &pi->nrxq, 0, "# of rx queues");
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO, "ntxq", CTLFLAG_RD,
 	    &pi->ntxq, 0, "# of tx queues");
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO, "first_rxq", CTLFLAG_RD,
 	    &pi->first_rxq, 0, "index of first rx queue");
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO, "first_txq", CTLFLAG_RD,
 	    &pi->first_txq, 0, "index of first tx queue");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rsrv_noflowq", CTLTYPE_INT |
 	    CTLFLAG_RW, pi, 0, sysctl_noflowq, "IU",
 	    "Reserve queue 0 for non-flowid packets");
 
 #ifdef TCP_OFFLOAD
 	if (is_offload(sc)) {
 		SYSCTL_ADD_INT(ctx, children, OID_AUTO, "nofldrxq", CTLFLAG_RD,
 		    &pi->nofldrxq, 0,
 		    "# of rx queues for offloaded TCP connections");
 		SYSCTL_ADD_INT(ctx, children, OID_AUTO, "nofldtxq", CTLFLAG_RD,
 		    &pi->nofldtxq, 0,
 		    "# of tx queues for offloaded TCP connections");
 		SYSCTL_ADD_INT(ctx, children, OID_AUTO, "first_ofld_rxq",
 		    CTLFLAG_RD, &pi->first_ofld_rxq, 0,
 		    "index of first TOE rx queue");
 		SYSCTL_ADD_INT(ctx, children, OID_AUTO, "first_ofld_txq",
 		    CTLFLAG_RD, &pi->first_ofld_txq, 0,
 		    "index of first TOE tx queue");
 	}
 #endif
 #ifdef DEV_NETMAP
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO, "nnmrxq", CTLFLAG_RD,
 	    &pi->nnmrxq, 0, "# of rx queues for netmap");
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO, "nnmtxq", CTLFLAG_RD,
 	    &pi->nnmtxq, 0, "# of tx queues for netmap");
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO, "first_nm_rxq",
 	    CTLFLAG_RD, &pi->first_nm_rxq, 0,
 	    "index of first netmap rx queue");
 	SYSCTL_ADD_INT(ctx, children, OID_AUTO, "first_nm_txq",
 	    CTLFLAG_RD, &pi->first_nm_txq, 0,
 	    "index of first netmap tx queue");
 #endif
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "holdoff_tmr_idx",
 	    CTLTYPE_INT | CTLFLAG_RW, pi, 0, sysctl_holdoff_tmr_idx, "I",
 	    "holdoff timer index");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "holdoff_pktc_idx",
 	    CTLTYPE_INT | CTLFLAG_RW, pi, 0, sysctl_holdoff_pktc_idx, "I",
 	    "holdoff packet counter index");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "qsize_rxq",
 	    CTLTYPE_INT | CTLFLAG_RW, pi, 0, sysctl_qsize_rxq, "I",
 	    "rx queue size");
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "qsize_txq",
 	    CTLTYPE_INT | CTLFLAG_RW, pi, 0, sysctl_qsize_txq, "I",
 	    "tx queue size");
 
 	SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "pause_settings",
 	    CTLTYPE_STRING | CTLFLAG_RW, pi, PAUSE_TX, sysctl_pause_settings,
 	    "A", "PAUSE settings (bit 0 = rx_pause, bit 1 = tx_pause)");
 
 	/*
 	 * dev.cxgbe.X.stats.
 	 */
 	oid = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "stats", CTLFLAG_RD,
 	    NULL, "port statistics");
 	children = SYSCTL_CHILDREN(oid);
 	SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "tx_parse_error", CTLFLAG_RD,
 	    &pi->tx_parse_error, 0,
 	    "# of tx packets with invalid length or # of segments");
 
 #define SYSCTL_ADD_T4_REG64(pi, name, desc, reg) \
 	SYSCTL_ADD_OID(ctx, children, OID_AUTO, name, \
 	    CTLTYPE_U64 | CTLFLAG_RD, sc, reg, \
 	    sysctl_handle_t4_reg64, "QU", desc)
 
 	SYSCTL_ADD_T4_REG64(pi, "tx_octets", "# of octets in good frames",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_BYTES_L));
 	SYSCTL_ADD_T4_REG64(pi, "tx_frames", "total # of good frames",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_FRAMES_L));
 	SYSCTL_ADD_T4_REG64(pi, "tx_bcast_frames", "# of broadcast frames",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_BCAST_L));
 	SYSCTL_ADD_T4_REG64(pi, "tx_mcast_frames", "# of multicast frames",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_MCAST_L));
 	SYSCTL_ADD_T4_REG64(pi, "tx_ucast_frames", "# of unicast frames",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_UCAST_L));
 	SYSCTL_ADD_T4_REG64(pi, "tx_error_frames", "# of error frames",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_ERROR_L));
 	SYSCTL_ADD_T4_REG64(pi, "tx_frames_64",
 	    "# of tx frames in this range",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_64B_L));
 	SYSCTL_ADD_T4_REG64(pi, "tx_frames_65_127",
 	    "# of tx frames in this range",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_65B_127B_L));
 	SYSCTL_ADD_T4_REG64(pi, "tx_frames_128_255",
 	    "# of tx frames in this range",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_128B_255B_L));
 	SYSCTL_ADD_T4_REG64(pi, "tx_frames_256_511",
 	    "# of tx frames in this range",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_256B_511B_L));
 	SYSCTL_ADD_T4_REG64(pi, "tx_frames_512_1023",
 	    "# of tx frames in this range",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_512B_1023B_L));
 	SYSCTL_ADD_T4_REG64(pi, "tx_frames_1024_1518",
 	    "# of tx frames in this range",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_1024B_1518B_L));
 	SYSCTL_ADD_T4_REG64(pi, "tx_frames_1519_max",
 	    "# of tx frames in this range",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_1519B_MAX_L));
 	SYSCTL_ADD_T4_REG64(pi, "tx_drop", "# of dropped tx frames",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_DROP_L));
 	SYSCTL_ADD_T4_REG64(pi, "tx_pause", "# of pause frames transmitted",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_PAUSE_L));
 	SYSCTL_ADD_T4_REG64(pi, "tx_ppp0", "# of PPP prio 0 frames transmitted",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_PPP0_L));
 	SYSCTL_ADD_T4_REG64(pi, "tx_ppp1", "# of PPP prio 1 frames transmitted",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_PPP1_L));
 	SYSCTL_ADD_T4_REG64(pi, "tx_ppp2", "# of PPP prio 2 frames transmitted",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_PPP2_L));
 	SYSCTL_ADD_T4_REG64(pi, "tx_ppp3", "# of PPP prio 3 frames transmitted",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_PPP3_L));
 	SYSCTL_ADD_T4_REG64(pi, "tx_ppp4", "# of PPP prio 4 frames transmitted",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_PPP4_L));
 	SYSCTL_ADD_T4_REG64(pi, "tx_ppp5", "# of PPP prio 5 frames transmitted",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_PPP5_L));
 	SYSCTL_ADD_T4_REG64(pi, "tx_ppp6", "# of PPP prio 6 frames transmitted",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_PPP6_L));
 	SYSCTL_ADD_T4_REG64(pi, "tx_ppp7", "# of PPP prio 7 frames transmitted",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_TX_PORT_PPP7_L));
 
 	SYSCTL_ADD_T4_REG64(pi, "rx_octets", "# of octets in good frames",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_BYTES_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_frames", "total # of good frames",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_FRAMES_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_bcast_frames", "# of broadcast frames",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_BCAST_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_mcast_frames", "# of multicast frames",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_MCAST_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_ucast_frames", "# of unicast frames",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_UCAST_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_too_long", "# of frames exceeding MTU",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_MTU_ERROR_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_jabber", "# of jabber frames",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_MTU_CRC_ERROR_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_fcs_err",
 	    "# of frames received with bad FCS",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_CRC_ERROR_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_len_err",
 	    "# of frames received with length error",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_LEN_ERROR_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_symbol_err", "symbol errors",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_SYM_ERROR_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_runt", "# of short frames received",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_LESS_64B_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_frames_64",
 	    "# of rx frames in this range",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_64B_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_frames_65_127",
 	    "# of rx frames in this range",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_65B_127B_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_frames_128_255",
 	    "# of rx frames in this range",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_128B_255B_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_frames_256_511",
 	    "# of rx frames in this range",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_256B_511B_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_frames_512_1023",
 	    "# of rx frames in this range",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_512B_1023B_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_frames_1024_1518",
 	    "# of rx frames in this range",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_1024B_1518B_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_frames_1519_max",
 	    "# of rx frames in this range",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_1519B_MAX_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_pause", "# of pause frames received",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_PAUSE_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_ppp0", "# of PPP prio 0 frames received",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_PPP0_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_ppp1", "# of PPP prio 1 frames received",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_PPP1_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_ppp2", "# of PPP prio 2 frames received",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_PPP2_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_ppp3", "# of PPP prio 3 frames received",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_PPP3_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_ppp4", "# of PPP prio 4 frames received",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_PPP4_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_ppp5", "# of PPP prio 5 frames received",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_PPP5_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_ppp6", "# of PPP prio 6 frames received",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_PPP6_L));
 	SYSCTL_ADD_T4_REG64(pi, "rx_ppp7", "# of PPP prio 7 frames received",
 	    PORT_REG(pi->tx_chan, A_MPS_PORT_STAT_RX_PORT_PPP7_L));
 
 #undef SYSCTL_ADD_T4_REG64
 
 #define SYSCTL_ADD_T4_PORTSTAT(name, desc) \
 	SYSCTL_ADD_UQUAD(ctx, children, OID_AUTO, #name, CTLFLAG_RD, \
 	    &pi->stats.name, desc)
 
 	/* We get these from port_stats and they may be stale by upto 1s */
 	SYSCTL_ADD_T4_PORTSTAT(rx_ovflow0,
 	    "# drops due to buffer-group 0 overflows");
 	SYSCTL_ADD_T4_PORTSTAT(rx_ovflow1,
 	    "# drops due to buffer-group 1 overflows");
 	SYSCTL_ADD_T4_PORTSTAT(rx_ovflow2,
 	    "# drops due to buffer-group 2 overflows");
 	SYSCTL_ADD_T4_PORTSTAT(rx_ovflow3,
 	    "# drops due to buffer-group 3 overflows");
 	SYSCTL_ADD_T4_PORTSTAT(rx_trunc0,
 	    "# of buffer-group 0 truncated packets");
 	SYSCTL_ADD_T4_PORTSTAT(rx_trunc1,
 	    "# of buffer-group 1 truncated packets");
 	SYSCTL_ADD_T4_PORTSTAT(rx_trunc2,
 	    "# of buffer-group 2 truncated packets");
 	SYSCTL_ADD_T4_PORTSTAT(rx_trunc3,
 	    "# of buffer-group 3 truncated packets");
 
 #undef SYSCTL_ADD_T4_PORTSTAT
 
 	return (0);
 }
 
 static int
 sysctl_int_array(SYSCTL_HANDLER_ARGS)
 {
 	int rc, *i;
 	struct sbuf sb;
 
 	sbuf_new(&sb, NULL, 32, SBUF_AUTOEXTEND);
 	for (i = arg1; arg2; arg2 -= sizeof(int), i++)
 		sbuf_printf(&sb, "%d ", *i);
 	sbuf_trim(&sb);
 	sbuf_finish(&sb);
 	rc = sysctl_handle_string(oidp, sbuf_data(&sb), sbuf_len(&sb), req);
 	sbuf_delete(&sb);
 	return (rc);
 }
 
 static int
 sysctl_bitfield(SYSCTL_HANDLER_ARGS)
 {
 	int rc;
 	struct sbuf *sb;
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return(rc);
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, 128, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	sbuf_printf(sb, "%b", (int)arg2, (char *)arg1);
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 
 	return (rc);
 }
 
 static int
 sysctl_btphy(SYSCTL_HANDLER_ARGS)
 {
 	struct port_info *pi = arg1;
 	int op = arg2;
 	struct adapter *sc = pi->adapter;
 	u_int v;
 	int rc;
 
 	rc = begin_synchronized_op(sc, pi, SLEEP_OK | INTR_OK, "t4btt");
 	if (rc)
 		return (rc);
 	/* XXX: magic numbers */
 	rc = -t4_mdio_rd(sc, sc->mbox, pi->mdio_addr, 0x1e, op ? 0x20 : 0xc820,
 	    &v);
 	end_synchronized_op(sc, 0);
 	if (rc)
 		return (rc);
 	if (op == 0)
 		v /= 256;
 
 	rc = sysctl_handle_int(oidp, &v, 0, req);
 	return (rc);
 }
 
 static int
 sysctl_noflowq(SYSCTL_HANDLER_ARGS)
 {
 	struct port_info *pi = arg1;
 	int rc, val;
 
 	val = pi->rsrv_noflowq;
 	rc = sysctl_handle_int(oidp, &val, 0, req);
 	if (rc != 0 || req->newptr == NULL)
 		return (rc);
 
 	if ((val >= 1) && (pi->ntxq > 1))
 		pi->rsrv_noflowq = 1;
 	else
 		pi->rsrv_noflowq = 0;
 
 	return (rc);
 }
 
 static int
 sysctl_holdoff_tmr_idx(SYSCTL_HANDLER_ARGS)
 {
 	struct port_info *pi = arg1;
 	struct adapter *sc = pi->adapter;
 	int idx, rc, i;
 	struct sge_rxq *rxq;
 #ifdef TCP_OFFLOAD
 	struct sge_ofld_rxq *ofld_rxq;
 #endif
 	uint8_t v;
 
 	idx = pi->tmr_idx;
 
 	rc = sysctl_handle_int(oidp, &idx, 0, req);
 	if (rc != 0 || req->newptr == NULL)
 		return (rc);
 
 	if (idx < 0 || idx >= SGE_NTIMERS)
 		return (EINVAL);
 
 	rc = begin_synchronized_op(sc, pi, HOLD_LOCK | SLEEP_OK | INTR_OK,
 	    "t4tmr");
 	if (rc)
 		return (rc);
 
 	v = V_QINTR_TIMER_IDX(idx) | V_QINTR_CNT_EN(pi->pktc_idx != -1);
 	for_each_rxq(pi, i, rxq) {
 #ifdef atomic_store_rel_8
 		atomic_store_rel_8(&rxq->iq.intr_params, v);
 #else
 		rxq->iq.intr_params = v;
 #endif
 	}
 #ifdef TCP_OFFLOAD
 	for_each_ofld_rxq(pi, i, ofld_rxq) {
 #ifdef atomic_store_rel_8
 		atomic_store_rel_8(&ofld_rxq->iq.intr_params, v);
 #else
 		ofld_rxq->iq.intr_params = v;
 #endif
 	}
 #endif
 	pi->tmr_idx = idx;
 
 	end_synchronized_op(sc, LOCK_HELD);
 	return (0);
 }
 
 static int
 sysctl_holdoff_pktc_idx(SYSCTL_HANDLER_ARGS)
 {
 	struct port_info *pi = arg1;
 	struct adapter *sc = pi->adapter;
 	int idx, rc;
 
 	idx = pi->pktc_idx;
 
 	rc = sysctl_handle_int(oidp, &idx, 0, req);
 	if (rc != 0 || req->newptr == NULL)
 		return (rc);
 
 	if (idx < -1 || idx >= SGE_NCOUNTERS)
 		return (EINVAL);
 
 	rc = begin_synchronized_op(sc, pi, HOLD_LOCK | SLEEP_OK | INTR_OK,
 	    "t4pktc");
 	if (rc)
 		return (rc);
 
 	if (pi->flags & PORT_INIT_DONE)
 		rc = EBUSY; /* cannot be changed once the queues are created */
 	else
 		pi->pktc_idx = idx;
 
 	end_synchronized_op(sc, LOCK_HELD);
 	return (rc);
 }
 
 static int
 sysctl_qsize_rxq(SYSCTL_HANDLER_ARGS)
 {
 	struct port_info *pi = arg1;
 	struct adapter *sc = pi->adapter;
 	int qsize, rc;
 
 	qsize = pi->qsize_rxq;
 
 	rc = sysctl_handle_int(oidp, &qsize, 0, req);
 	if (rc != 0 || req->newptr == NULL)
 		return (rc);
 
 	if (qsize < 128 || (qsize & 7))
 		return (EINVAL);
 
 	rc = begin_synchronized_op(sc, pi, HOLD_LOCK | SLEEP_OK | INTR_OK,
 	    "t4rxqs");
 	if (rc)
 		return (rc);
 
 	if (pi->flags & PORT_INIT_DONE)
 		rc = EBUSY; /* cannot be changed once the queues are created */
 	else
 		pi->qsize_rxq = qsize;
 
 	end_synchronized_op(sc, LOCK_HELD);
 	return (rc);
 }
 
 static int
 sysctl_qsize_txq(SYSCTL_HANDLER_ARGS)
 {
 	struct port_info *pi = arg1;
 	struct adapter *sc = pi->adapter;
 	int qsize, rc;
 
 	qsize = pi->qsize_txq;
 
 	rc = sysctl_handle_int(oidp, &qsize, 0, req);
 	if (rc != 0 || req->newptr == NULL)
 		return (rc);
 
 	if (qsize < 128 || qsize > 65536)
 		return (EINVAL);
 
 	rc = begin_synchronized_op(sc, pi, HOLD_LOCK | SLEEP_OK | INTR_OK,
 	    "t4txqs");
 	if (rc)
 		return (rc);
 
 	if (pi->flags & PORT_INIT_DONE)
 		rc = EBUSY; /* cannot be changed once the queues are created */
 	else
 		pi->qsize_txq = qsize;
 
 	end_synchronized_op(sc, LOCK_HELD);
 	return (rc);
 }
 
 static int
 sysctl_pause_settings(SYSCTL_HANDLER_ARGS)
 {
 	struct port_info *pi = arg1;
 	struct adapter *sc = pi->adapter;
 	struct link_config *lc = &pi->link_cfg;
 	int rc;
 
 	if (req->newptr == NULL) {
 		struct sbuf *sb;
 		static char *bits = "\20\1PAUSE_RX\2PAUSE_TX";
 
 		rc = sysctl_wire_old_buffer(req, 0);
 		if (rc != 0)
 			return(rc);
 
 		sb = sbuf_new_for_sysctl(NULL, NULL, 128, req);
 		if (sb == NULL)
 			return (ENOMEM);
 
 		sbuf_printf(sb, "%b", lc->fc & (PAUSE_TX | PAUSE_RX), bits);
 		rc = sbuf_finish(sb);
 		sbuf_delete(sb);
 	} else {
 		char s[2];
 		int n;
 
 		s[0] = '0' + (lc->requested_fc & (PAUSE_TX | PAUSE_RX));
 		s[1] = 0;
 
 		rc = sysctl_handle_string(oidp, s, sizeof(s), req);
 		if (rc != 0)
 			return(rc);
 
 		if (s[1] != 0)
 			return (EINVAL);
 		if (s[0] < '0' || s[0] > '9')
 			return (EINVAL);	/* not a number */
 		n = s[0] - '0';
 		if (n & ~(PAUSE_TX | PAUSE_RX))
 			return (EINVAL);	/* some other bit is set too */
 
 		rc = begin_synchronized_op(sc, pi, SLEEP_OK | INTR_OK, "t4PAUSE");
 		if (rc)
 			return (rc);
 		if ((lc->requested_fc & (PAUSE_TX | PAUSE_RX)) != n) {
 			int link_ok = lc->link_ok;
 
 			lc->requested_fc &= ~(PAUSE_TX | PAUSE_RX);
 			lc->requested_fc |= n;
 			rc = -t4_link_start(sc, sc->mbox, pi->tx_chan, lc);
 			lc->link_ok = link_ok;	/* restore */
 		}
 		end_synchronized_op(sc, 0);
 	}
 
 	return (rc);
 }
 
 static int
 sysctl_handle_t4_reg64(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	int reg = arg2;
 	uint64_t val;
 
 	val = t4_read_reg64(sc, reg);
 
 	return (sysctl_handle_64(oidp, &val, 0, req));
 }
 
 static int
 sysctl_temperature(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	int rc, t;
 	uint32_t param, val;
 
 	rc = begin_synchronized_op(sc, NULL, SLEEP_OK | INTR_OK, "t4temp");
 	if (rc)
 		return (rc);
 	param = V_FW_PARAMS_MNEM(FW_PARAMS_MNEM_DEV) |
 	    V_FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_DEV_DIAG) |
 	    V_FW_PARAMS_PARAM_Y(FW_PARAM_DEV_DIAG_TMP);
 	rc = -t4_query_params(sc, sc->mbox, sc->pf, 0, 1, &param, &val);
 	end_synchronized_op(sc, 0);
 	if (rc)
 		return (rc);
 
 	/* unknown is returned as 0 but we display -1 in that case */
 	t = val == 0 ? -1 : val;
 
 	rc = sysctl_handle_int(oidp, &t, 0, req);
 	return (rc);
 }
 
 #ifdef SBUF_DRAIN
 static int
 sysctl_cctrl(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	struct sbuf *sb;
 	int rc, i;
 	uint16_t incr[NMTUS][NCCTRL_WIN];
 	static const char *dec_fac[] = {
 		"0.5", "0.5625", "0.625", "0.6875", "0.75", "0.8125", "0.875",
 		"0.9375"
 	};
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return (rc);
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, 4096, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	t4_read_cong_tbl(sc, incr);
 
 	for (i = 0; i < NCCTRL_WIN; ++i) {
 		sbuf_printf(sb, "%2d: %4u %4u %4u %4u %4u %4u %4u %4u\n", i,
 		    incr[0][i], incr[1][i], incr[2][i], incr[3][i], incr[4][i],
 		    incr[5][i], incr[6][i], incr[7][i]);
 		sbuf_printf(sb, "%8u %4u %4u %4u %4u %4u %4u %4u %5u %s\n",
 		    incr[8][i], incr[9][i], incr[10][i], incr[11][i],
 		    incr[12][i], incr[13][i], incr[14][i], incr[15][i],
 		    sc->params.a_wnd[i], dec_fac[sc->params.b_wnd[i]]);
 	}
 
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 
 	return (rc);
 }
 
 static const char *qname[CIM_NUM_IBQ + CIM_NUM_OBQ_T5] = {
 	"TP0", "TP1", "ULP", "SGE0", "SGE1", "NC-SI",	/* ibq's */
 	"ULP0", "ULP1", "ULP2", "ULP3", "SGE", "NC-SI",	/* obq's */
 	"SGE0-RX", "SGE1-RX"	/* additional obq's (T5 onwards) */
 };
 
 static int
 sysctl_cim_ibq_obq(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	struct sbuf *sb;
 	int rc, i, n, qid = arg2;
 	uint32_t *buf, *p;
 	char *qtype;
 	u_int cim_num_obq = is_t4(sc) ? CIM_NUM_OBQ : CIM_NUM_OBQ_T5;
 
 	KASSERT(qid >= 0 && qid < CIM_NUM_IBQ + cim_num_obq,
 	    ("%s: bad qid %d\n", __func__, qid));
 
 	if (qid < CIM_NUM_IBQ) {
 		/* inbound queue */
 		qtype = "IBQ";
 		n = 4 * CIM_IBQ_SIZE;
 		buf = malloc(n * sizeof(uint32_t), M_CXGBE, M_ZERO | M_WAITOK);
 		rc = t4_read_cim_ibq(sc, qid, buf, n);
 	} else {
 		/* outbound queue */
 		qtype = "OBQ";
 		qid -= CIM_NUM_IBQ;
 		n = 4 * cim_num_obq * CIM_OBQ_SIZE;
 		buf = malloc(n * sizeof(uint32_t), M_CXGBE, M_ZERO | M_WAITOK);
 		rc = t4_read_cim_obq(sc, qid, buf, n);
 	}
 
 	if (rc < 0) {
 		rc = -rc;
 		goto done;
 	}
 	n = rc * sizeof(uint32_t);	/* rc has # of words actually read */
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		goto done;
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, PAGE_SIZE, req);
 	if (sb == NULL) {
 		rc = ENOMEM;
 		goto done;
 	}
 
 	sbuf_printf(sb, "%s%d %s", qtype , qid, qname[arg2]);
 	for (i = 0, p = buf; i < n; i += 16, p += 4)
 		sbuf_printf(sb, "\n%#06x: %08x %08x %08x %08x", i, p[0], p[1],
 		    p[2], p[3]);
 
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 done:
 	free(buf, M_CXGBE);
 	return (rc);
 }
 
 static int
 sysctl_cim_la(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	u_int cfg;
 	struct sbuf *sb;
 	uint32_t *buf, *p;
 	int rc;
 
 	rc = -t4_cim_read(sc, A_UP_UP_DBG_LA_CFG, 1, &cfg);
 	if (rc != 0)
 		return (rc);
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return (rc);
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, 4096, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	buf = malloc(sc->params.cim_la_size * sizeof(uint32_t), M_CXGBE,
 	    M_ZERO | M_WAITOK);
 
 	rc = -t4_cim_read_la(sc, buf, NULL);
 	if (rc != 0)
 		goto done;
 
 	sbuf_printf(sb, "Status   Data      PC%s",
 	    cfg & F_UPDBGLACAPTPCONLY ? "" :
 	    "     LS0Stat  LS0Addr             LS0Data");
 
 	KASSERT((sc->params.cim_la_size & 7) == 0,
 	    ("%s: p will walk off the end of buf", __func__));
 
 	for (p = buf; p < &buf[sc->params.cim_la_size]; p += 8) {
 		if (cfg & F_UPDBGLACAPTPCONLY) {
 			sbuf_printf(sb, "\n  %02x   %08x %08x", p[5] & 0xff,
 			    p[6], p[7]);
 			sbuf_printf(sb, "\n  %02x   %02x%06x %02x%06x",
 			    (p[3] >> 8) & 0xff, p[3] & 0xff, p[4] >> 8,
 			    p[4] & 0xff, p[5] >> 8);
 			sbuf_printf(sb, "\n  %02x   %x%07x %x%07x",
 			    (p[0] >> 4) & 0xff, p[0] & 0xf, p[1] >> 4,
 			    p[1] & 0xf, p[2] >> 4);
 		} else {
 			sbuf_printf(sb,
 			    "\n  %02x   %x%07x %x%07x %08x %08x "
 			    "%08x%08x%08x%08x",
 			    (p[0] >> 4) & 0xff, p[0] & 0xf, p[1] >> 4,
 			    p[1] & 0xf, p[2] >> 4, p[2] & 0xf, p[3], p[4], p[5],
 			    p[6], p[7]);
 		}
 	}
 
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 done:
 	free(buf, M_CXGBE);
 	return (rc);
 }
 
 static int
 sysctl_cim_ma_la(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	u_int i;
 	struct sbuf *sb;
 	uint32_t *buf, *p;
 	int rc;
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return (rc);
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, 4096, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	buf = malloc(2 * CIM_MALA_SIZE * 5 * sizeof(uint32_t), M_CXGBE,
 	    M_ZERO | M_WAITOK);
 
 	t4_cim_read_ma_la(sc, buf, buf + 5 * CIM_MALA_SIZE);
 	p = buf;
 
 	for (i = 0; i < CIM_MALA_SIZE; i++, p += 5) {
 		sbuf_printf(sb, "\n%02x%08x%08x%08x%08x", p[4], p[3], p[2],
 		    p[1], p[0]);
 	}
 
 	sbuf_printf(sb, "\n\nCnt ID Tag UE       Data       RDY VLD");
 	for (i = 0; i < CIM_MALA_SIZE; i++, p += 5) {
 		sbuf_printf(sb, "\n%3u %2u  %x   %u %08x%08x  %u   %u",
 		    (p[2] >> 10) & 0xff, (p[2] >> 7) & 7,
 		    (p[2] >> 3) & 0xf, (p[2] >> 2) & 1,
 		    (p[1] >> 2) | ((p[2] & 3) << 30),
 		    (p[0] >> 2) | ((p[1] & 3) << 30), (p[0] >> 1) & 1,
 		    p[0] & 1);
 	}
 
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 	free(buf, M_CXGBE);
 	return (rc);
 }
 
 static int
 sysctl_cim_pif_la(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	u_int i;
 	struct sbuf *sb;
 	uint32_t *buf, *p;
 	int rc;
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return (rc);
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, 4096, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	buf = malloc(2 * CIM_PIFLA_SIZE * 6 * sizeof(uint32_t), M_CXGBE,
 	    M_ZERO | M_WAITOK);
 
 	t4_cim_read_pif_la(sc, buf, buf + 6 * CIM_PIFLA_SIZE, NULL, NULL);
 	p = buf;
 
 	sbuf_printf(sb, "Cntl ID DataBE   Addr                 Data");
 	for (i = 0; i < CIM_MALA_SIZE; i++, p += 6) {
 		sbuf_printf(sb, "\n %02x  %02x  %04x  %08x %08x%08x%08x%08x",
 		    (p[5] >> 22) & 0xff, (p[5] >> 16) & 0x3f, p[5] & 0xffff,
 		    p[4], p[3], p[2], p[1], p[0]);
 	}
 
 	sbuf_printf(sb, "\n\nCntl ID               Data");
 	for (i = 0; i < CIM_MALA_SIZE; i++, p += 6) {
 		sbuf_printf(sb, "\n %02x  %02x %08x%08x%08x%08x",
 		    (p[4] >> 6) & 0xff, p[4] & 0x3f, p[3], p[2], p[1], p[0]);
 	}
 
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 	free(buf, M_CXGBE);
 	return (rc);
 }
 
 static int
 sysctl_cim_qcfg(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	struct sbuf *sb;
 	int rc, i;
 	uint16_t base[CIM_NUM_IBQ + CIM_NUM_OBQ_T5];
 	uint16_t size[CIM_NUM_IBQ + CIM_NUM_OBQ_T5];
 	uint16_t thres[CIM_NUM_IBQ];
 	uint32_t obq_wr[2 * CIM_NUM_OBQ_T5], *wr = obq_wr;
 	uint32_t stat[4 * (CIM_NUM_IBQ + CIM_NUM_OBQ_T5)], *p = stat;
 	u_int cim_num_obq, ibq_rdaddr, obq_rdaddr, nq;
 
 	if (is_t4(sc)) {
 		cim_num_obq = CIM_NUM_OBQ;
 		ibq_rdaddr = A_UP_IBQ_0_RDADDR;
 		obq_rdaddr = A_UP_OBQ_0_REALADDR;
 	} else {
 		cim_num_obq = CIM_NUM_OBQ_T5;
 		ibq_rdaddr = A_UP_IBQ_0_SHADOW_RDADDR;
 		obq_rdaddr = A_UP_OBQ_0_SHADOW_REALADDR;
 	}
 	nq = CIM_NUM_IBQ + cim_num_obq;
 
 	rc = -t4_cim_read(sc, ibq_rdaddr, 4 * nq, stat);
 	if (rc == 0)
 		rc = -t4_cim_read(sc, obq_rdaddr, 2 * cim_num_obq, obq_wr);
 	if (rc != 0)
 		return (rc);
 
 	t4_read_cimq_cfg(sc, base, size, thres);
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return (rc);
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, PAGE_SIZE, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	sbuf_printf(sb, "Queue  Base  Size Thres RdPtr WrPtr  SOP  EOP Avail");
 
 	for (i = 0; i < CIM_NUM_IBQ; i++, p += 4)
 		sbuf_printf(sb, "\n%7s %5x %5u %5u %6x  %4x %4u %4u %5u",
 		    qname[i], base[i], size[i], thres[i], G_IBQRDADDR(p[0]),
 		    G_IBQWRADDR(p[1]), G_QUESOPCNT(p[3]), G_QUEEOPCNT(p[3]),
 		    G_QUEREMFLITS(p[2]) * 16);
 	for ( ; i < nq; i++, p += 4, wr += 2)
 		sbuf_printf(sb, "\n%7s %5x %5u %12x  %4x %4u %4u %5u", qname[i],
 		    base[i], size[i], G_QUERDADDR(p[0]) & 0x3fff,
 		    wr[0] - base[i], G_QUESOPCNT(p[3]), G_QUEEOPCNT(p[3]),
 		    G_QUEREMFLITS(p[2]) * 16);
 
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 
 	return (rc);
 }
 
 static int
 sysctl_cpl_stats(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	struct sbuf *sb;
 	int rc;
 	struct tp_cpl_stats stats;
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return (rc);
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, 256, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	t4_tp_get_cpl_stats(sc, &stats);
 
 	sbuf_printf(sb, "                 channel 0  channel 1  channel 2  "
 	    "channel 3\n");
 	sbuf_printf(sb, "CPL requests:   %10u %10u %10u %10u\n",
 		   stats.req[0], stats.req[1], stats.req[2], stats.req[3]);
 	sbuf_printf(sb, "CPL responses:  %10u %10u %10u %10u",
 		   stats.rsp[0], stats.rsp[1], stats.rsp[2], stats.rsp[3]);
 
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 
 	return (rc);
 }
 
 static int
 sysctl_ddp_stats(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	struct sbuf *sb;
 	int rc;
 	struct tp_usm_stats stats;
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return(rc);
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, 256, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	t4_get_usm_stats(sc, &stats);
 
 	sbuf_printf(sb, "Frames: %u\n", stats.frames);
 	sbuf_printf(sb, "Octets: %ju\n", stats.octets);
 	sbuf_printf(sb, "Drops:  %u", stats.drops);
 
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 
 	return (rc);
 }
 
 const char *devlog_level_strings[] = {
 	[FW_DEVLOG_LEVEL_EMERG]		= "EMERG",
 	[FW_DEVLOG_LEVEL_CRIT]		= "CRIT",
 	[FW_DEVLOG_LEVEL_ERR]		= "ERR",
 	[FW_DEVLOG_LEVEL_NOTICE]	= "NOTICE",
 	[FW_DEVLOG_LEVEL_INFO]		= "INFO",
 	[FW_DEVLOG_LEVEL_DEBUG]		= "DEBUG"
 };
 
 const char *devlog_facility_strings[] = {
 	[FW_DEVLOG_FACILITY_CORE]	= "CORE",
 	[FW_DEVLOG_FACILITY_CF]		= "CF",
 	[FW_DEVLOG_FACILITY_SCHED]	= "SCHED",
 	[FW_DEVLOG_FACILITY_TIMER]	= "TIMER",
 	[FW_DEVLOG_FACILITY_RES]	= "RES",
 	[FW_DEVLOG_FACILITY_HW]		= "HW",
 	[FW_DEVLOG_FACILITY_FLR]	= "FLR",
 	[FW_DEVLOG_FACILITY_DMAQ]	= "DMAQ",
 	[FW_DEVLOG_FACILITY_PHY]	= "PHY",
 	[FW_DEVLOG_FACILITY_MAC]	= "MAC",
 	[FW_DEVLOG_FACILITY_PORT]	= "PORT",
 	[FW_DEVLOG_FACILITY_VI]		= "VI",
 	[FW_DEVLOG_FACILITY_FILTER]	= "FILTER",
 	[FW_DEVLOG_FACILITY_ACL]	= "ACL",
 	[FW_DEVLOG_FACILITY_TM]		= "TM",
 	[FW_DEVLOG_FACILITY_QFC]	= "QFC",
 	[FW_DEVLOG_FACILITY_DCB]	= "DCB",
 	[FW_DEVLOG_FACILITY_ETH]	= "ETH",
 	[FW_DEVLOG_FACILITY_OFLD]	= "OFLD",
 	[FW_DEVLOG_FACILITY_RI]		= "RI",
 	[FW_DEVLOG_FACILITY_ISCSI]	= "ISCSI",
 	[FW_DEVLOG_FACILITY_FCOE]	= "FCOE",
 	[FW_DEVLOG_FACILITY_FOISCSI]	= "FOISCSI",
 	[FW_DEVLOG_FACILITY_FOFCOE]	= "FOFCOE"
 };
 
 static int
 sysctl_devlog(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	struct devlog_params *dparams = &sc->params.devlog;
 	struct fw_devlog_e *buf, *e;
 	int i, j, rc, nentries, first = 0, m;
 	struct sbuf *sb;
 	uint64_t ftstamp = UINT64_MAX;
 
 	if (dparams->start == 0) {
 		dparams->memtype = FW_MEMTYPE_EDC0;
 		dparams->start = 0x84000;
 		dparams->size = 32768;
 	}
 
 	nentries = dparams->size / sizeof(struct fw_devlog_e);
 
 	buf = malloc(dparams->size, M_CXGBE, M_NOWAIT);
 	if (buf == NULL)
 		return (ENOMEM);
 
 	m = fwmtype_to_hwmtype(dparams->memtype);
 	rc = -t4_mem_read(sc, m, dparams->start, dparams->size, (void *)buf);
 	if (rc != 0)
 		goto done;
 
 	for (i = 0; i < nentries; i++) {
 		e = &buf[i];
 
 		if (e->timestamp == 0)
 			break;	/* end */
 
 		e->timestamp = be64toh(e->timestamp);
 		e->seqno = be32toh(e->seqno);
 		for (j = 0; j < 8; j++)
 			e->params[j] = be32toh(e->params[j]);
 
 		if (e->timestamp < ftstamp) {
 			ftstamp = e->timestamp;
 			first = i;
 		}
 	}
 
 	if (buf[first].timestamp == 0)
 		goto done;	/* nothing in the log */
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		goto done;
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, 4096, req);
 	if (sb == NULL) {
 		rc = ENOMEM;
 		goto done;
 	}
 	sbuf_printf(sb, "%10s  %15s  %8s  %8s  %s\n",
 	    "Seq#", "Tstamp", "Level", "Facility", "Message");
 
 	i = first;
 	do {
 		e = &buf[i];
 		if (e->timestamp == 0)
 			break;	/* end */
 
 		sbuf_printf(sb, "%10d  %15ju  %8s  %8s  ",
 		    e->seqno, e->timestamp,
 		    (e->level < nitems(devlog_level_strings) ?
 			devlog_level_strings[e->level] : "UNKNOWN"),
 		    (e->facility < nitems(devlog_facility_strings) ?
 			devlog_facility_strings[e->facility] : "UNKNOWN"));
 		sbuf_printf(sb, e->fmt, e->params[0], e->params[1],
 		    e->params[2], e->params[3], e->params[4],
 		    e->params[5], e->params[6], e->params[7]);
 
 		if (++i == nentries)
 			i = 0;
 	} while (i != first);
 
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 done:
 	free(buf, M_CXGBE);
 	return (rc);
 }
 
 static int
 sysctl_fcoe_stats(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	struct sbuf *sb;
 	int rc;
 	struct tp_fcoe_stats stats[4];
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return (rc);
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, 256, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	t4_get_fcoe_stats(sc, 0, &stats[0]);
 	t4_get_fcoe_stats(sc, 1, &stats[1]);
 	t4_get_fcoe_stats(sc, 2, &stats[2]);
 	t4_get_fcoe_stats(sc, 3, &stats[3]);
 
 	sbuf_printf(sb, "                   channel 0        channel 1        "
 	    "channel 2        channel 3\n");
 	sbuf_printf(sb, "octetsDDP:  %16ju %16ju %16ju %16ju\n",
 	    stats[0].octetsDDP, stats[1].octetsDDP, stats[2].octetsDDP,
 	    stats[3].octetsDDP);
 	sbuf_printf(sb, "framesDDP:  %16u %16u %16u %16u\n", stats[0].framesDDP,
 	    stats[1].framesDDP, stats[2].framesDDP, stats[3].framesDDP);
 	sbuf_printf(sb, "framesDrop: %16u %16u %16u %16u",
 	    stats[0].framesDrop, stats[1].framesDrop, stats[2].framesDrop,
 	    stats[3].framesDrop);
 
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 
 	return (rc);
 }
 
 static int
 sysctl_hw_sched(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	struct sbuf *sb;
 	int rc, i;
 	unsigned int map, kbps, ipg, mode;
 	unsigned int pace_tab[NTX_SCHED];
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return (rc);
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, 256, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	map = t4_read_reg(sc, A_TP_TX_MOD_QUEUE_REQ_MAP);
 	mode = G_TIMERMODE(t4_read_reg(sc, A_TP_MOD_CONFIG));
 	t4_read_pace_tbl(sc, pace_tab);
 
 	sbuf_printf(sb, "Scheduler  Mode   Channel  Rate (Kbps)   "
 	    "Class IPG (0.1 ns)   Flow IPG (us)");
 
 	for (i = 0; i < NTX_SCHED; ++i, map >>= 2) {
 		t4_get_tx_sched(sc, i, &kbps, &ipg);
 		sbuf_printf(sb, "\n    %u      %-5s     %u     ", i,
 		    (mode & (1 << i)) ? "flow" : "class", map & 3);
 		if (kbps)
 			sbuf_printf(sb, "%9u     ", kbps);
 		else
 			sbuf_printf(sb, " disabled     ");
 
 		if (ipg)
 			sbuf_printf(sb, "%13u        ", ipg);
 		else
 			sbuf_printf(sb, "     disabled        ");
 
 		if (pace_tab[i])
 			sbuf_printf(sb, "%10u", pace_tab[i]);
 		else
 			sbuf_printf(sb, "  disabled");
 	}
 
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 
 	return (rc);
 }
 
 static int
 sysctl_lb_stats(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	struct sbuf *sb;
 	int rc, i, j;
 	uint64_t *p0, *p1;
 	struct lb_port_stats s[2];
 	static const char *stat_name[] = {
 		"OctetsOK:", "FramesOK:", "BcastFrames:", "McastFrames:",
 		"UcastFrames:", "ErrorFrames:", "Frames64:", "Frames65To127:",
 		"Frames128To255:", "Frames256To511:", "Frames512To1023:",
 		"Frames1024To1518:", "Frames1519ToMax:", "FramesDropped:",
 		"BG0FramesDropped:", "BG1FramesDropped:", "BG2FramesDropped:",
 		"BG3FramesDropped:", "BG0FramesTrunc:", "BG1FramesTrunc:",
 		"BG2FramesTrunc:", "BG3FramesTrunc:"
 	};
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return (rc);
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, 4096, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	memset(s, 0, sizeof(s));
 
 	for (i = 0; i < 4; i += 2) {
 		t4_get_lb_stats(sc, i, &s[0]);
 		t4_get_lb_stats(sc, i + 1, &s[1]);
 
 		p0 = &s[0].octets;
 		p1 = &s[1].octets;
 		sbuf_printf(sb, "%s                       Loopback %u"
 		    "           Loopback %u", i == 0 ? "" : "\n", i, i + 1);
 
 		for (j = 0; j < nitems(stat_name); j++)
 			sbuf_printf(sb, "\n%-17s %20ju %20ju", stat_name[j],
 				   *p0++, *p1++);
 	}
 
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 
 	return (rc);
 }
 
 static int
 sysctl_linkdnrc(SYSCTL_HANDLER_ARGS)
 {
 	int rc = 0;
 	struct port_info *pi = arg1;
 	struct sbuf *sb;
 	static const char *linkdnreasons[] = {
 		"non-specific", "remote fault", "autoneg failed", "reserved3",
 		"PHY overheated", "unknown", "rx los", "reserved7"
 	};
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return(rc);
 	sb = sbuf_new_for_sysctl(NULL, NULL, 64, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	if (pi->linkdnrc < 0)
 		sbuf_printf(sb, "n/a");
 	else if (pi->linkdnrc < nitems(linkdnreasons))
 		sbuf_printf(sb, "%s", linkdnreasons[pi->linkdnrc]);
 	else
 		sbuf_printf(sb, "%d", pi->linkdnrc);
 
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 
 	return (rc);
 }
 
 struct mem_desc {
 	unsigned int base;
 	unsigned int limit;
 	unsigned int idx;
 };
 
 static int
 mem_desc_cmp(const void *a, const void *b)
 {
 	return ((const struct mem_desc *)a)->base -
 	       ((const struct mem_desc *)b)->base;
 }
 
 static void
 mem_region_show(struct sbuf *sb, const char *name, unsigned int from,
     unsigned int to)
 {
 	unsigned int size;
 
 	size = to - from + 1;
 	if (size == 0)
 		return;
 
 	/* XXX: need humanize_number(3) in libkern for a more readable 'size' */
 	sbuf_printf(sb, "%-15s %#x-%#x [%u]\n", name, from, to, size);
 }
 
 static int
 sysctl_meminfo(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	struct sbuf *sb;
 	int rc, i, n;
 	uint32_t lo, hi, used, alloc;
 	static const char *memory[] = {"EDC0:", "EDC1:", "MC:", "MC0:", "MC1:"};
 	static const char *region[] = {
 		"DBQ contexts:", "IMSG contexts:", "FLM cache:", "TCBs:",
 		"Pstructs:", "Timers:", "Rx FL:", "Tx FL:", "Pstruct FL:",
 		"Tx payload:", "Rx payload:", "LE hash:", "iSCSI region:",
 		"TDDP region:", "TPT region:", "STAG region:", "RQ region:",
 		"RQUDP region:", "PBL region:", "TXPBL region:",
 		"DBVFIFO region:", "ULPRX state:", "ULPTX state:",
 		"On-chip queues:"
 	};
 	struct mem_desc avail[4];
 	struct mem_desc mem[nitems(region) + 3];	/* up to 3 holes */
 	struct mem_desc *md = mem;
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return (rc);
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, 4096, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	for (i = 0; i < nitems(mem); i++) {
 		mem[i].limit = 0;
 		mem[i].idx = i;
 	}
 
 	/* Find and sort the populated memory ranges */
 	i = 0;
 	lo = t4_read_reg(sc, A_MA_TARGET_MEM_ENABLE);
 	if (lo & F_EDRAM0_ENABLE) {
 		hi = t4_read_reg(sc, A_MA_EDRAM0_BAR);
 		avail[i].base = G_EDRAM0_BASE(hi) << 20;
 		avail[i].limit = avail[i].base + (G_EDRAM0_SIZE(hi) << 20);
 		avail[i].idx = 0;
 		i++;
 	}
 	if (lo & F_EDRAM1_ENABLE) {
 		hi = t4_read_reg(sc, A_MA_EDRAM1_BAR);
 		avail[i].base = G_EDRAM1_BASE(hi) << 20;
 		avail[i].limit = avail[i].base + (G_EDRAM1_SIZE(hi) << 20);
 		avail[i].idx = 1;
 		i++;
 	}
 	if (lo & F_EXT_MEM_ENABLE) {
 		hi = t4_read_reg(sc, A_MA_EXT_MEMORY_BAR);
 		avail[i].base = G_EXT_MEM_BASE(hi) << 20;
 		avail[i].limit = avail[i].base +
 		    (G_EXT_MEM_SIZE(hi) << 20);
 		avail[i].idx = is_t4(sc) ? 2 : 3;	/* Call it MC for T4 */
 		i++;
 	}
 	if (!is_t4(sc) && lo & F_EXT_MEM1_ENABLE) {
 		hi = t4_read_reg(sc, A_MA_EXT_MEMORY1_BAR);
 		avail[i].base = G_EXT_MEM1_BASE(hi) << 20;
 		avail[i].limit = avail[i].base +
 		    (G_EXT_MEM1_SIZE(hi) << 20);
 		avail[i].idx = 4;
 		i++;
 	}
 	if (!i)                                    /* no memory available */
 		return 0;
 	qsort(avail, i, sizeof(struct mem_desc), mem_desc_cmp);
 
 	(md++)->base = t4_read_reg(sc, A_SGE_DBQ_CTXT_BADDR);
 	(md++)->base = t4_read_reg(sc, A_SGE_IMSG_CTXT_BADDR);
 	(md++)->base = t4_read_reg(sc, A_SGE_FLM_CACHE_BADDR);
 	(md++)->base = t4_read_reg(sc, A_TP_CMM_TCB_BASE);
 	(md++)->base = t4_read_reg(sc, A_TP_CMM_MM_BASE);
 	(md++)->base = t4_read_reg(sc, A_TP_CMM_TIMER_BASE);
 	(md++)->base = t4_read_reg(sc, A_TP_CMM_MM_RX_FLST_BASE);
 	(md++)->base = t4_read_reg(sc, A_TP_CMM_MM_TX_FLST_BASE);
 	(md++)->base = t4_read_reg(sc, A_TP_CMM_MM_PS_FLST_BASE);
 
 	/* the next few have explicit upper bounds */
 	md->base = t4_read_reg(sc, A_TP_PMM_TX_BASE);
 	md->limit = md->base - 1 +
 		    t4_read_reg(sc, A_TP_PMM_TX_PAGE_SIZE) *
 		    G_PMTXMAXPAGE(t4_read_reg(sc, A_TP_PMM_TX_MAX_PAGE));
 	md++;
 
 	md->base = t4_read_reg(sc, A_TP_PMM_RX_BASE);
 	md->limit = md->base - 1 +
 		    t4_read_reg(sc, A_TP_PMM_RX_PAGE_SIZE) *
 		    G_PMRXMAXPAGE(t4_read_reg(sc, A_TP_PMM_RX_MAX_PAGE));
 	md++;
 
 	if (t4_read_reg(sc, A_LE_DB_CONFIG) & F_HASHEN) {
 		hi = t4_read_reg(sc, A_LE_DB_TID_HASHBASE) / 4;
 		md->base = t4_read_reg(sc, A_LE_DB_HASH_TID_BASE);
 		md->limit = (sc->tids.ntids - hi) * 16 + md->base - 1;
 	} else {
 		md->base = 0;
 		md->idx = nitems(region);  /* hide it */
 	}
 	md++;
 
 #define ulp_region(reg) \
 	md->base = t4_read_reg(sc, A_ULP_ ## reg ## _LLIMIT);\
 	(md++)->limit = t4_read_reg(sc, A_ULP_ ## reg ## _ULIMIT)
 
 	ulp_region(RX_ISCSI);
 	ulp_region(RX_TDDP);
 	ulp_region(TX_TPT);
 	ulp_region(RX_STAG);
 	ulp_region(RX_RQ);
 	ulp_region(RX_RQUDP);
 	ulp_region(RX_PBL);
 	ulp_region(TX_PBL);
 #undef ulp_region
 
 	md->base = 0;
 	md->idx = nitems(region);
 	if (!is_t4(sc) && t4_read_reg(sc, A_SGE_CONTROL2) & F_VFIFO_ENABLE) {
 		md->base = G_BASEADDR(t4_read_reg(sc, A_SGE_DBVFIFO_BADDR));
 		md->limit = md->base + (G_DBVFIFO_SIZE((t4_read_reg(sc,
 		    A_SGE_DBVFIFO_SIZE))) << 2) - 1;
 	}
 	md++;
 
 	md->base = t4_read_reg(sc, A_ULP_RX_CTX_BASE);
 	md->limit = md->base + sc->tids.ntids - 1;
 	md++;
 	md->base = t4_read_reg(sc, A_ULP_TX_ERR_TABLE_BASE);
 	md->limit = md->base + sc->tids.ntids - 1;
 	md++;
 
 	md->base = sc->vres.ocq.start;
 	if (sc->vres.ocq.size)
 		md->limit = md->base + sc->vres.ocq.size - 1;
 	else
 		md->idx = nitems(region);  /* hide it */
 	md++;
 
 	/* add any address-space holes, there can be up to 3 */
 	for (n = 0; n < i - 1; n++)
 		if (avail[n].limit < avail[n + 1].base)
 			(md++)->base = avail[n].limit;
 	if (avail[n].limit)
 		(md++)->base = avail[n].limit;
 
 	n = md - mem;
 	qsort(mem, n, sizeof(struct mem_desc), mem_desc_cmp);
 
 	for (lo = 0; lo < i; lo++)
 		mem_region_show(sb, memory[avail[lo].idx], avail[lo].base,
 				avail[lo].limit - 1);
 
 	sbuf_printf(sb, "\n");
 	for (i = 0; i < n; i++) {
 		if (mem[i].idx >= nitems(region))
 			continue;                        /* skip holes */
 		if (!mem[i].limit)
 			mem[i].limit = i < n - 1 ? mem[i + 1].base - 1 : ~0;
 		mem_region_show(sb, region[mem[i].idx], mem[i].base,
 				mem[i].limit);
 	}
 
 	sbuf_printf(sb, "\n");
 	lo = t4_read_reg(sc, A_CIM_SDRAM_BASE_ADDR);
 	hi = t4_read_reg(sc, A_CIM_SDRAM_ADDR_SIZE) + lo - 1;
 	mem_region_show(sb, "uP RAM:", lo, hi);
 
 	lo = t4_read_reg(sc, A_CIM_EXTMEM2_BASE_ADDR);
 	hi = t4_read_reg(sc, A_CIM_EXTMEM2_ADDR_SIZE) + lo - 1;
 	mem_region_show(sb, "uP Extmem2:", lo, hi);
 
 	lo = t4_read_reg(sc, A_TP_PMM_RX_MAX_PAGE);
 	sbuf_printf(sb, "\n%u Rx pages of size %uKiB for %u channels\n",
 		   G_PMRXMAXPAGE(lo),
 		   t4_read_reg(sc, A_TP_PMM_RX_PAGE_SIZE) >> 10,
 		   (lo & F_PMRXNUMCHN) ? 2 : 1);
 
 	lo = t4_read_reg(sc, A_TP_PMM_TX_MAX_PAGE);
 	hi = t4_read_reg(sc, A_TP_PMM_TX_PAGE_SIZE);
 	sbuf_printf(sb, "%u Tx pages of size %u%ciB for %u channels\n",
 		   G_PMTXMAXPAGE(lo),
 		   hi >= (1 << 20) ? (hi >> 20) : (hi >> 10),
 		   hi >= (1 << 20) ? 'M' : 'K', 1 << G_PMTXNUMCHN(lo));
 	sbuf_printf(sb, "%u p-structs\n",
 		   t4_read_reg(sc, A_TP_CMM_MM_MAX_PSTRUCT));
 
 	for (i = 0; i < 4; i++) {
 		lo = t4_read_reg(sc, A_MPS_RX_PG_RSV0 + i * 4);
 		if (is_t4(sc)) {
 			used = G_USED(lo);
 			alloc = G_ALLOC(lo);
 		} else {
 			used = G_T5_USED(lo);
 			alloc = G_T5_ALLOC(lo);
 		}
 		sbuf_printf(sb, "\nPort %d using %u pages out of %u allocated",
 			   i, used, alloc);
 	}
 	for (i = 0; i < 4; i++) {
 		lo = t4_read_reg(sc, A_MPS_RX_PG_RSV4 + i * 4);
 		if (is_t4(sc)) {
 			used = G_USED(lo);
 			alloc = G_ALLOC(lo);
 		} else {
 			used = G_T5_USED(lo);
 			alloc = G_T5_ALLOC(lo);
 		}
 		sbuf_printf(sb,
 			   "\nLoopback %d using %u pages out of %u allocated",
 			   i, used, alloc);
 	}
 
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 
 	return (rc);
 }
 
 static inline void
 tcamxy2valmask(uint64_t x, uint64_t y, uint8_t *addr, uint64_t *mask)
 {
 	*mask = x | y;
 	y = htobe64(y);
 	memcpy(addr, (char *)&y + 2, ETHER_ADDR_LEN);
 }
 
 static int
 sysctl_mps_tcam(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	struct sbuf *sb;
 	int rc, i, n;
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return (rc);
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, 4096, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	sbuf_printf(sb,
 	    "Idx  Ethernet address     Mask     Vld Ports PF"
 	    "  VF              Replication             P0 P1 P2 P3  ML");
 	n = is_t4(sc) ? NUM_MPS_CLS_SRAM_L_INSTANCES :
 	    NUM_MPS_T5_CLS_SRAM_L_INSTANCES;
 	for (i = 0; i < n; i++) {
 		uint64_t tcamx, tcamy, mask;
 		uint32_t cls_lo, cls_hi;
 		uint8_t addr[ETHER_ADDR_LEN];
 
 		tcamy = t4_read_reg64(sc, MPS_CLS_TCAM_Y_L(i));
 		tcamx = t4_read_reg64(sc, MPS_CLS_TCAM_X_L(i));
 		cls_lo = t4_read_reg(sc, MPS_CLS_SRAM_L(i));
 		cls_hi = t4_read_reg(sc, MPS_CLS_SRAM_H(i));
 
 		if (tcamx & tcamy)
 			continue;
 
 		tcamxy2valmask(tcamx, tcamy, addr, &mask);
 		sbuf_printf(sb, "\n%3u %02x:%02x:%02x:%02x:%02x:%02x %012jx"
 			   "  %c   %#x%4u%4d", i, addr[0], addr[1], addr[2],
 			   addr[3], addr[4], addr[5], (uintmax_t)mask,
 			   (cls_lo & F_SRAM_VLD) ? 'Y' : 'N',
 			   G_PORTMAP(cls_hi), G_PF(cls_lo),
 			   (cls_lo & F_VF_VALID) ? G_VF(cls_lo) : -1);
 
 		if (cls_lo & F_REPLICATE) {
 			struct fw_ldst_cmd ldst_cmd;
 
 			memset(&ldst_cmd, 0, sizeof(ldst_cmd));
 			ldst_cmd.op_to_addrspace =
 			    htobe32(V_FW_CMD_OP(FW_LDST_CMD) |
 				F_FW_CMD_REQUEST | F_FW_CMD_READ |
 				V_FW_LDST_CMD_ADDRSPACE(FW_LDST_ADDRSPC_MPS));
 			ldst_cmd.cycles_to_len16 = htobe32(FW_LEN16(ldst_cmd));
 			ldst_cmd.u.mps.fid_ctl =
 			    htobe16(V_FW_LDST_CMD_FID(FW_LDST_MPS_RPLC) |
 				V_FW_LDST_CMD_CTL(i));
 
 			rc = begin_synchronized_op(sc, NULL, SLEEP_OK | INTR_OK,
 			    "t4mps");
 			if (rc)
 				break;
 			rc = -t4_wr_mbox(sc, sc->mbox, &ldst_cmd,
 			    sizeof(ldst_cmd), &ldst_cmd);
 			end_synchronized_op(sc, 0);
 
 			if (rc != 0) {
 				sbuf_printf(sb,
 				    " ------------ error %3u ------------", rc);
 				rc = 0;
 			} else {
 				sbuf_printf(sb, " %08x %08x %08x %08x",
 				    be32toh(ldst_cmd.u.mps.rplc127_96),
 				    be32toh(ldst_cmd.u.mps.rplc95_64),
 				    be32toh(ldst_cmd.u.mps.rplc63_32),
 				    be32toh(ldst_cmd.u.mps.rplc31_0));
 			}
 		} else
 			sbuf_printf(sb, "%36s", "");
 
 		sbuf_printf(sb, "%4u%3u%3u%3u %#3x", G_SRAM_PRIO0(cls_lo),
 		    G_SRAM_PRIO1(cls_lo), G_SRAM_PRIO2(cls_lo),
 		    G_SRAM_PRIO3(cls_lo), (cls_lo >> S_MULTILISTEN0) & 0xf);
 	}
 
 	if (rc)
 		(void) sbuf_finish(sb);
 	else
 		rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 
 	return (rc);
 }
 
 static int
 sysctl_path_mtus(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	struct sbuf *sb;
 	int rc;
 	uint16_t mtus[NMTUS];
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return (rc);
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, 256, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	t4_read_mtu_tbl(sc, mtus, NULL);
 
 	sbuf_printf(sb, "%u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u",
 	    mtus[0], mtus[1], mtus[2], mtus[3], mtus[4], mtus[5], mtus[6],
 	    mtus[7], mtus[8], mtus[9], mtus[10], mtus[11], mtus[12], mtus[13],
 	    mtus[14], mtus[15]);
 
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 
 	return (rc);
 }
 
 static int
 sysctl_pm_stats(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	struct sbuf *sb;
 	int rc, i;
 	uint32_t cnt[PM_NSTATS];
 	uint64_t cyc[PM_NSTATS];
 	static const char *rx_stats[] = {
 		"Read:", "Write bypass:", "Write mem:", "Flush:"
 	};
 	static const char *tx_stats[] = {
 		"Read:", "Write bypass:", "Write mem:", "Bypass + mem:"
 	};
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return (rc);
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, 256, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	t4_pmtx_get_stats(sc, cnt, cyc);
 	sbuf_printf(sb, "                Tx pcmds             Tx bytes");
 	for (i = 0; i < ARRAY_SIZE(tx_stats); i++)
 		sbuf_printf(sb, "\n%-13s %10u %20ju", tx_stats[i], cnt[i],
 		    cyc[i]);
 
 	t4_pmrx_get_stats(sc, cnt, cyc);
 	sbuf_printf(sb, "\n                Rx pcmds             Rx bytes");
 	for (i = 0; i < ARRAY_SIZE(rx_stats); i++)
 		sbuf_printf(sb, "\n%-13s %10u %20ju", rx_stats[i], cnt[i],
 		    cyc[i]);
 
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 
 	return (rc);
 }
 
 static int
 sysctl_rdma_stats(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	struct sbuf *sb;
 	int rc;
 	struct tp_rdma_stats stats;
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return (rc);
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, 256, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	t4_tp_get_rdma_stats(sc, &stats);
 	sbuf_printf(sb, "NoRQEModDefferals: %u\n", stats.rqe_dfr_mod);
 	sbuf_printf(sb, "NoRQEPktDefferals: %u", stats.rqe_dfr_pkt);
 
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 
 	return (rc);
 }
 
 static int
 sysctl_tcp_stats(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	struct sbuf *sb;
 	int rc;
 	struct tp_tcp_stats v4, v6;
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return (rc);
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, 256, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	t4_tp_get_tcp_stats(sc, &v4, &v6);
 	sbuf_printf(sb,
 	    "                                IP                 IPv6\n");
 	sbuf_printf(sb, "OutRsts:      %20u %20u\n",
 	    v4.tcpOutRsts, v6.tcpOutRsts);
 	sbuf_printf(sb, "InSegs:       %20ju %20ju\n",
 	    v4.tcpInSegs, v6.tcpInSegs);
 	sbuf_printf(sb, "OutSegs:      %20ju %20ju\n",
 	    v4.tcpOutSegs, v6.tcpOutSegs);
 	sbuf_printf(sb, "RetransSegs:  %20ju %20ju",
 	    v4.tcpRetransSegs, v6.tcpRetransSegs);
 
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 
 	return (rc);
 }
 
 static int
 sysctl_tids(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	struct sbuf *sb;
 	int rc;
 	struct tid_info *t = &sc->tids;
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return (rc);
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, 256, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	if (t->natids) {
 		sbuf_printf(sb, "ATID range: 0-%u, in use: %u\n", t->natids - 1,
 		    t->atids_in_use);
 	}
 
 	if (t->ntids) {
 		if (t4_read_reg(sc, A_LE_DB_CONFIG) & F_HASHEN) {
 			uint32_t b = t4_read_reg(sc, A_LE_DB_SERVER_INDEX) / 4;
 
 			if (b) {
 				sbuf_printf(sb, "TID range: 0-%u, %u-%u", b - 1,
 				    t4_read_reg(sc, A_LE_DB_TID_HASHBASE) / 4,
 				    t->ntids - 1);
 			} else {
 				sbuf_printf(sb, "TID range: %u-%u",
 				    t4_read_reg(sc, A_LE_DB_TID_HASHBASE) / 4,
 				    t->ntids - 1);
 			}
 		} else
 			sbuf_printf(sb, "TID range: 0-%u", t->ntids - 1);
 		sbuf_printf(sb, ", in use: %u\n",
 		    atomic_load_acq_int(&t->tids_in_use));
 	}
 
 	if (t->nstids) {
 		sbuf_printf(sb, "STID range: %u-%u, in use: %u\n", t->stid_base,
 		    t->stid_base + t->nstids - 1, t->stids_in_use);
 	}
 
 	if (t->nftids) {
 		sbuf_printf(sb, "FTID range: %u-%u\n", t->ftid_base,
 		    t->ftid_base + t->nftids - 1);
 	}
 
 	if (t->netids) {
 		sbuf_printf(sb, "ETID range: %u-%u\n", t->etid_base,
 		    t->etid_base + t->netids - 1);
 	}
 
 	sbuf_printf(sb, "HW TID usage: %u IP users, %u IPv6 users",
 	    t4_read_reg(sc, A_LE_DB_ACT_CNT_IPV4),
 	    t4_read_reg(sc, A_LE_DB_ACT_CNT_IPV6));
 
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 
 	return (rc);
 }
 
 static int
 sysctl_tp_err_stats(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	struct sbuf *sb;
 	int rc;
 	struct tp_err_stats stats;
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return (rc);
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, 256, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	t4_tp_get_err_stats(sc, &stats);
 
 	sbuf_printf(sb, "                 channel 0  channel 1  channel 2  "
 		      "channel 3\n");
 	sbuf_printf(sb, "macInErrs:      %10u %10u %10u %10u\n",
 	    stats.macInErrs[0], stats.macInErrs[1], stats.macInErrs[2],
 	    stats.macInErrs[3]);
 	sbuf_printf(sb, "hdrInErrs:      %10u %10u %10u %10u\n",
 	    stats.hdrInErrs[0], stats.hdrInErrs[1], stats.hdrInErrs[2],
 	    stats.hdrInErrs[3]);
 	sbuf_printf(sb, "tcpInErrs:      %10u %10u %10u %10u\n",
 	    stats.tcpInErrs[0], stats.tcpInErrs[1], stats.tcpInErrs[2],
 	    stats.tcpInErrs[3]);
 	sbuf_printf(sb, "tcp6InErrs:     %10u %10u %10u %10u\n",
 	    stats.tcp6InErrs[0], stats.tcp6InErrs[1], stats.tcp6InErrs[2],
 	    stats.tcp6InErrs[3]);
 	sbuf_printf(sb, "tnlCongDrops:   %10u %10u %10u %10u\n",
 	    stats.tnlCongDrops[0], stats.tnlCongDrops[1], stats.tnlCongDrops[2],
 	    stats.tnlCongDrops[3]);
 	sbuf_printf(sb, "tnlTxDrops:     %10u %10u %10u %10u\n",
 	    stats.tnlTxDrops[0], stats.tnlTxDrops[1], stats.tnlTxDrops[2],
 	    stats.tnlTxDrops[3]);
 	sbuf_printf(sb, "ofldVlanDrops:  %10u %10u %10u %10u\n",
 	    stats.ofldVlanDrops[0], stats.ofldVlanDrops[1],
 	    stats.ofldVlanDrops[2], stats.ofldVlanDrops[3]);
 	sbuf_printf(sb, "ofldChanDrops:  %10u %10u %10u %10u\n\n",
 	    stats.ofldChanDrops[0], stats.ofldChanDrops[1],
 	    stats.ofldChanDrops[2], stats.ofldChanDrops[3]);
 	sbuf_printf(sb, "ofldNoNeigh:    %u\nofldCongDefer:  %u",
 	    stats.ofldNoNeigh, stats.ofldCongDefer);
 
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 
 	return (rc);
 }
 
 struct field_desc {
 	const char *name;
 	u_int start;
 	u_int width;
 };
 
 static void
 field_desc_show(struct sbuf *sb, uint64_t v, const struct field_desc *f)
 {
 	char buf[32];
 	int line_size = 0;
 
 	while (f->name) {
 		uint64_t mask = (1ULL << f->width) - 1;
 		int len = snprintf(buf, sizeof(buf), "%s: %ju", f->name,
 		    ((uintmax_t)v >> f->start) & mask);
 
 		if (line_size + len >= 79) {
 			line_size = 8;
 			sbuf_printf(sb, "\n        ");
 		}
 		sbuf_printf(sb, "%s ", buf);
 		line_size += len + 1;
 		f++;
 	}
 	sbuf_printf(sb, "\n");
 }
 
 static struct field_desc tp_la0[] = {
 	{ "RcfOpCodeOut", 60, 4 },
 	{ "State", 56, 4 },
 	{ "WcfState", 52, 4 },
 	{ "RcfOpcSrcOut", 50, 2 },
 	{ "CRxError", 49, 1 },
 	{ "ERxError", 48, 1 },
 	{ "SanityFailed", 47, 1 },
 	{ "SpuriousMsg", 46, 1 },
 	{ "FlushInputMsg", 45, 1 },
 	{ "FlushInputCpl", 44, 1 },
 	{ "RssUpBit", 43, 1 },
 	{ "RssFilterHit", 42, 1 },
 	{ "Tid", 32, 10 },
 	{ "InitTcb", 31, 1 },
 	{ "LineNumber", 24, 7 },
 	{ "Emsg", 23, 1 },
 	{ "EdataOut", 22, 1 },
 	{ "Cmsg", 21, 1 },
 	{ "CdataOut", 20, 1 },
 	{ "EreadPdu", 19, 1 },
 	{ "CreadPdu", 18, 1 },
 	{ "TunnelPkt", 17, 1 },
 	{ "RcfPeerFin", 16, 1 },
 	{ "RcfReasonOut", 12, 4 },
 	{ "TxCchannel", 10, 2 },
 	{ "RcfTxChannel", 8, 2 },
 	{ "RxEchannel", 6, 2 },
 	{ "RcfRxChannel", 5, 1 },
 	{ "RcfDataOutSrdy", 4, 1 },
 	{ "RxDvld", 3, 1 },
 	{ "RxOoDvld", 2, 1 },
 	{ "RxCongestion", 1, 1 },
 	{ "TxCongestion", 0, 1 },
 	{ NULL }
 };
 
 static struct field_desc tp_la1[] = {
 	{ "CplCmdIn", 56, 8 },
 	{ "CplCmdOut", 48, 8 },
 	{ "ESynOut", 47, 1 },
 	{ "EAckOut", 46, 1 },
 	{ "EFinOut", 45, 1 },
 	{ "ERstOut", 44, 1 },
 	{ "SynIn", 43, 1 },
 	{ "AckIn", 42, 1 },
 	{ "FinIn", 41, 1 },
 	{ "RstIn", 40, 1 },
 	{ "DataIn", 39, 1 },
 	{ "DataInVld", 38, 1 },
 	{ "PadIn", 37, 1 },
 	{ "RxBufEmpty", 36, 1 },
 	{ "RxDdp", 35, 1 },
 	{ "RxFbCongestion", 34, 1 },
 	{ "TxFbCongestion", 33, 1 },
 	{ "TxPktSumSrdy", 32, 1 },
 	{ "RcfUlpType", 28, 4 },
 	{ "Eread", 27, 1 },
 	{ "Ebypass", 26, 1 },
 	{ "Esave", 25, 1 },
 	{ "Static0", 24, 1 },
 	{ "Cread", 23, 1 },
 	{ "Cbypass", 22, 1 },
 	{ "Csave", 21, 1 },
 	{ "CPktOut", 20, 1 },
 	{ "RxPagePoolFull", 18, 2 },
 	{ "RxLpbkPkt", 17, 1 },
 	{ "TxLpbkPkt", 16, 1 },
 	{ "RxVfValid", 15, 1 },
 	{ "SynLearned", 14, 1 },
 	{ "SetDelEntry", 13, 1 },
 	{ "SetInvEntry", 12, 1 },
 	{ "CpcmdDvld", 11, 1 },
 	{ "CpcmdSave", 10, 1 },
 	{ "RxPstructsFull", 8, 2 },
 	{ "EpcmdDvld", 7, 1 },
 	{ "EpcmdFlush", 6, 1 },
 	{ "EpcmdTrimPrefix", 5, 1 },
 	{ "EpcmdTrimPostfix", 4, 1 },
 	{ "ERssIp4Pkt", 3, 1 },
 	{ "ERssIp6Pkt", 2, 1 },
 	{ "ERssTcpUdpPkt", 1, 1 },
 	{ "ERssFceFipPkt", 0, 1 },
 	{ NULL }
 };
 
 static struct field_desc tp_la2[] = {
 	{ "CplCmdIn", 56, 8 },
 	{ "MpsVfVld", 55, 1 },
 	{ "MpsPf", 52, 3 },
 	{ "MpsVf", 44, 8 },
 	{ "SynIn", 43, 1 },
 	{ "AckIn", 42, 1 },
 	{ "FinIn", 41, 1 },
 	{ "RstIn", 40, 1 },
 	{ "DataIn", 39, 1 },
 	{ "DataInVld", 38, 1 },
 	{ "PadIn", 37, 1 },
 	{ "RxBufEmpty", 36, 1 },
 	{ "RxDdp", 35, 1 },
 	{ "RxFbCongestion", 34, 1 },
 	{ "TxFbCongestion", 33, 1 },
 	{ "TxPktSumSrdy", 32, 1 },
 	{ "RcfUlpType", 28, 4 },
 	{ "Eread", 27, 1 },
 	{ "Ebypass", 26, 1 },
 	{ "Esave", 25, 1 },
 	{ "Static0", 24, 1 },
 	{ "Cread", 23, 1 },
 	{ "Cbypass", 22, 1 },
 	{ "Csave", 21, 1 },
 	{ "CPktOut", 20, 1 },
 	{ "RxPagePoolFull", 18, 2 },
 	{ "RxLpbkPkt", 17, 1 },
 	{ "TxLpbkPkt", 16, 1 },
 	{ "RxVfValid", 15, 1 },
 	{ "SynLearned", 14, 1 },
 	{ "SetDelEntry", 13, 1 },
 	{ "SetInvEntry", 12, 1 },
 	{ "CpcmdDvld", 11, 1 },
 	{ "CpcmdSave", 10, 1 },
 	{ "RxPstructsFull", 8, 2 },
 	{ "EpcmdDvld", 7, 1 },
 	{ "EpcmdFlush", 6, 1 },
 	{ "EpcmdTrimPrefix", 5, 1 },
 	{ "EpcmdTrimPostfix", 4, 1 },
 	{ "ERssIp4Pkt", 3, 1 },
 	{ "ERssIp6Pkt", 2, 1 },
 	{ "ERssTcpUdpPkt", 1, 1 },
 	{ "ERssFceFipPkt", 0, 1 },
 	{ NULL }
 };
 
 static void
 tp_la_show(struct sbuf *sb, uint64_t *p, int idx)
 {
 
 	field_desc_show(sb, *p, tp_la0);
 }
 
 static void
 tp_la_show2(struct sbuf *sb, uint64_t *p, int idx)
 {
 
 	if (idx)
 		sbuf_printf(sb, "\n");
 	field_desc_show(sb, p[0], tp_la0);
 	if (idx < (TPLA_SIZE / 2 - 1) || p[1] != ~0ULL)
 		field_desc_show(sb, p[1], tp_la0);
 }
 
 static void
 tp_la_show3(struct sbuf *sb, uint64_t *p, int idx)
 {
 
 	if (idx)
 		sbuf_printf(sb, "\n");
 	field_desc_show(sb, p[0], tp_la0);
 	if (idx < (TPLA_SIZE / 2 - 1) || p[1] != ~0ULL)
 		field_desc_show(sb, p[1], (p[0] & (1 << 17)) ? tp_la2 : tp_la1);
 }
 
 static int
 sysctl_tp_la(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	struct sbuf *sb;
 	uint64_t *buf, *p;
 	int rc;
 	u_int i, inc;
 	void (*show_func)(struct sbuf *, uint64_t *, int);
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return (rc);
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, 4096, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	buf = malloc(TPLA_SIZE * sizeof(uint64_t), M_CXGBE, M_ZERO | M_WAITOK);
 
 	t4_tp_read_la(sc, buf, NULL);
 	p = buf;
 
 	switch (G_DBGLAMODE(t4_read_reg(sc, A_TP_DBG_LA_CONFIG))) {
 	case 2:
 		inc = 2;
 		show_func = tp_la_show2;
 		break;
 	case 3:
 		inc = 2;
 		show_func = tp_la_show3;
 		break;
 	default:
 		inc = 1;
 		show_func = tp_la_show;
 	}
 
 	for (i = 0; i < TPLA_SIZE / inc; i++, p += inc)
 		(*show_func)(sb, p, i);
 
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 	free(buf, M_CXGBE);
 	return (rc);
 }
 
 static int
 sysctl_tx_rate(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	struct sbuf *sb;
 	int rc;
 	u64 nrate[NCHAN], orate[NCHAN];
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return (rc);
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, 256, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	t4_get_chan_txrate(sc, nrate, orate);
 	sbuf_printf(sb, "              channel 0   channel 1   channel 2   "
 		 "channel 3\n");
 	sbuf_printf(sb, "NIC B/s:     %10ju  %10ju  %10ju  %10ju\n",
 	    nrate[0], nrate[1], nrate[2], nrate[3]);
 	sbuf_printf(sb, "Offload B/s: %10ju  %10ju  %10ju  %10ju",
 	    orate[0], orate[1], orate[2], orate[3]);
 
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 
 	return (rc);
 }
 
 static int
 sysctl_ulprx_la(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	struct sbuf *sb;
 	uint32_t *buf, *p;
 	int rc, i;
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return (rc);
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, 4096, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	buf = malloc(ULPRX_LA_SIZE * 8 * sizeof(uint32_t), M_CXGBE,
 	    M_ZERO | M_WAITOK);
 
 	t4_ulprx_read_la(sc, buf);
 	p = buf;
 
 	sbuf_printf(sb, "      Pcmd        Type   Message"
 	    "                Data");
 	for (i = 0; i < ULPRX_LA_SIZE; i++, p += 8) {
 		sbuf_printf(sb, "\n%08x%08x  %4x  %08x  %08x%08x%08x%08x",
 		    p[1], p[0], p[2], p[3], p[7], p[6], p[5], p[4]);
 	}
 
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 	free(buf, M_CXGBE);
 	return (rc);
 }
 
 static int
 sysctl_wcwr_stats(SYSCTL_HANDLER_ARGS)
 {
 	struct adapter *sc = arg1;
 	struct sbuf *sb;
 	int rc, v;
 
 	rc = sysctl_wire_old_buffer(req, 0);
 	if (rc != 0)
 		return (rc);
 
 	sb = sbuf_new_for_sysctl(NULL, NULL, 4096, req);
 	if (sb == NULL)
 		return (ENOMEM);
 
 	v = t4_read_reg(sc, A_SGE_STAT_CFG);
 	if (G_STATSOURCE_T5(v) == 7) {
 		if (G_STATMODE(v) == 0) {
 			sbuf_printf(sb, "total %d, incomplete %d",
 			    t4_read_reg(sc, A_SGE_STAT_TOTAL),
 			    t4_read_reg(sc, A_SGE_STAT_MATCH));
 		} else if (G_STATMODE(v) == 1) {
 			sbuf_printf(sb, "total %d, data overflow %d",
 			    t4_read_reg(sc, A_SGE_STAT_TOTAL),
 			    t4_read_reg(sc, A_SGE_STAT_MATCH));
 		}
 	}
 	rc = sbuf_finish(sb);
 	sbuf_delete(sb);
 
 	return (rc);
 }
 #endif
 
 static uint32_t
 fconf_to_mode(uint32_t fconf)
 {
 	uint32_t mode;
 
 	mode = T4_FILTER_IPv4 | T4_FILTER_IPv6 | T4_FILTER_IP_SADDR |
 	    T4_FILTER_IP_DADDR | T4_FILTER_IP_SPORT | T4_FILTER_IP_DPORT;
 
 	if (fconf & F_FRAGMENTATION)
 		mode |= T4_FILTER_IP_FRAGMENT;
 
 	if (fconf & F_MPSHITTYPE)
 		mode |= T4_FILTER_MPS_HIT_TYPE;
 
 	if (fconf & F_MACMATCH)
 		mode |= T4_FILTER_MAC_IDX;
 
 	if (fconf & F_ETHERTYPE)
 		mode |= T4_FILTER_ETH_TYPE;
 
 	if (fconf & F_PROTOCOL)
 		mode |= T4_FILTER_IP_PROTO;
 
 	if (fconf & F_TOS)
 		mode |= T4_FILTER_IP_TOS;
 
 	if (fconf & F_VLAN)
 		mode |= T4_FILTER_VLAN;
 
 	if (fconf & F_VNIC_ID)
 		mode |= T4_FILTER_VNIC;
 
 	if (fconf & F_PORT)
 		mode |= T4_FILTER_PORT;
 
 	if (fconf & F_FCOE)
 		mode |= T4_FILTER_FCoE;
 
 	return (mode);
 }
 
 static uint32_t
 mode_to_fconf(uint32_t mode)
 {
 	uint32_t fconf = 0;
 
 	if (mode & T4_FILTER_IP_FRAGMENT)
 		fconf |= F_FRAGMENTATION;
 
 	if (mode & T4_FILTER_MPS_HIT_TYPE)
 		fconf |= F_MPSHITTYPE;
 
 	if (mode & T4_FILTER_MAC_IDX)
 		fconf |= F_MACMATCH;
 
 	if (mode & T4_FILTER_ETH_TYPE)
 		fconf |= F_ETHERTYPE;
 
 	if (mode & T4_FILTER_IP_PROTO)
 		fconf |= F_PROTOCOL;
 
 	if (mode & T4_FILTER_IP_TOS)
 		fconf |= F_TOS;
 
 	if (mode & T4_FILTER_VLAN)
 		fconf |= F_VLAN;
 
 	if (mode & T4_FILTER_VNIC)
 		fconf |= F_VNIC_ID;
 
 	if (mode & T4_FILTER_PORT)
 		fconf |= F_PORT;
 
 	if (mode & T4_FILTER_FCoE)
 		fconf |= F_FCOE;
 
 	return (fconf);
 }
 
 static uint32_t
 fspec_to_fconf(struct t4_filter_specification *fs)
 {
 	uint32_t fconf = 0;
 
 	if (fs->val.frag || fs->mask.frag)
 		fconf |= F_FRAGMENTATION;
 
 	if (fs->val.matchtype || fs->mask.matchtype)
 		fconf |= F_MPSHITTYPE;
 
 	if (fs->val.macidx || fs->mask.macidx)
 		fconf |= F_MACMATCH;
 
 	if (fs->val.ethtype || fs->mask.ethtype)
 		fconf |= F_ETHERTYPE;
 
 	if (fs->val.proto || fs->mask.proto)
 		fconf |= F_PROTOCOL;
 
 	if (fs->val.tos || fs->mask.tos)
 		fconf |= F_TOS;
 
 	if (fs->val.vlan_vld || fs->mask.vlan_vld)
 		fconf |= F_VLAN;
 
 	if (fs->val.vnic_vld || fs->mask.vnic_vld)
 		fconf |= F_VNIC_ID;
 
 	if (fs->val.iport || fs->mask.iport)
 		fconf |= F_PORT;
 
 	if (fs->val.fcoe || fs->mask.fcoe)
 		fconf |= F_FCOE;
 
 	return (fconf);
 }
 
 static int
 get_filter_mode(struct adapter *sc, uint32_t *mode)
 {
 	int rc;
 	uint32_t fconf;
 
 	rc = begin_synchronized_op(sc, NULL, HOLD_LOCK | SLEEP_OK | INTR_OK,
 	    "t4getfm");
 	if (rc)
 		return (rc);
 
 	t4_read_indirect(sc, A_TP_PIO_ADDR, A_TP_PIO_DATA, &fconf, 1,
 	    A_TP_VLAN_PRI_MAP);
 
 	if (sc->params.tp.vlan_pri_map != fconf) {
 		log(LOG_WARNING, "%s: cached filter mode out of sync %x %x.\n",
 		    device_get_nameunit(sc->dev), sc->params.tp.vlan_pri_map,
 		    fconf);
 		sc->params.tp.vlan_pri_map = fconf;
 	}
 
 	*mode = fconf_to_mode(sc->params.tp.vlan_pri_map);
 
 	end_synchronized_op(sc, LOCK_HELD);
 	return (0);
 }
 
 static int
 set_filter_mode(struct adapter *sc, uint32_t mode)
 {
 	uint32_t fconf;
 	int rc;
 
 	fconf = mode_to_fconf(mode);
 
 	rc = begin_synchronized_op(sc, NULL, HOLD_LOCK | SLEEP_OK | INTR_OK,
 	    "t4setfm");
 	if (rc)
 		return (rc);
 
 	if (sc->tids.ftids_in_use > 0) {
 		rc = EBUSY;
 		goto done;
 	}
 
 #ifdef TCP_OFFLOAD
 	if (sc->offload_map) {
 		rc = EBUSY;
 		goto done;
 	}
 #endif
 
 #ifdef notyet
 	rc = -t4_set_filter_mode(sc, fconf);
 	if (rc == 0)
 		sc->filter_mode = fconf;
 #else
 	rc = ENOTSUP;
 #endif
 
 done:
 	end_synchronized_op(sc, LOCK_HELD);
 	return (rc);
 }
 
 static inline uint64_t
 get_filter_hits(struct adapter *sc, uint32_t fid)
 {
 	uint32_t mw_base, off, tcb_base = t4_read_reg(sc, A_TP_CMM_TCB_BASE);
 	uint64_t hits;
 
 	memwin_info(sc, 0, &mw_base, NULL);
 	off = position_memwin(sc, 0,
 	    tcb_base + (fid + sc->tids.ftid_base) * TCB_SIZE);
 	if (is_t4(sc)) {
 		hits = t4_read_reg64(sc, mw_base + off + 16);
 		hits = be64toh(hits);
 	} else {
 		hits = t4_read_reg(sc, mw_base + off + 24);
 		hits = be32toh(hits);
 	}
 
 	return (hits);
 }
 
 static int
 get_filter(struct adapter *sc, struct t4_filter *t)
 {
 	int i, rc, nfilters = sc->tids.nftids;
 	struct filter_entry *f;
 
 	rc = begin_synchronized_op(sc, NULL, HOLD_LOCK | SLEEP_OK | INTR_OK,
 	    "t4getf");
 	if (rc)
 		return (rc);
 
 	if (sc->tids.ftids_in_use == 0 || sc->tids.ftid_tab == NULL ||
 	    t->idx >= nfilters) {
 		t->idx = 0xffffffff;
 		goto done;
 	}
 
 	f = &sc->tids.ftid_tab[t->idx];
 	for (i = t->idx; i < nfilters; i++, f++) {
 		if (f->valid) {
 			t->idx = i;
 			t->l2tidx = f->l2t ? f->l2t->idx : 0;
 			t->smtidx = f->smtidx;
 			if (f->fs.hitcnts)
 				t->hits = get_filter_hits(sc, t->idx);
 			else
 				t->hits = UINT64_MAX;
 			t->fs = f->fs;
 
 			goto done;
 		}
 	}
 
 	t->idx = 0xffffffff;
 done:
 	end_synchronized_op(sc, LOCK_HELD);
 	return (0);
 }
 
 static int
 set_filter(struct adapter *sc, struct t4_filter *t)
 {
 	unsigned int nfilters, nports;
 	struct filter_entry *f;
 	int i, rc;
 
 	rc = begin_synchronized_op(sc, NULL, SLEEP_OK | INTR_OK, "t4setf");
 	if (rc)
 		return (rc);
 
 	nfilters = sc->tids.nftids;
 	nports = sc->params.nports;
 
 	if (nfilters == 0) {
 		rc = ENOTSUP;
 		goto done;
 	}
 
 	if (!(sc->flags & FULL_INIT_DONE)) {
 		rc = EAGAIN;
 		goto done;
 	}
 
 	if (t->idx >= nfilters) {
 		rc = EINVAL;
 		goto done;
 	}
 
 	/* Validate against the global filter mode */
 	if ((sc->params.tp.vlan_pri_map | fspec_to_fconf(&t->fs)) !=
 	    sc->params.tp.vlan_pri_map) {
 		rc = E2BIG;
 		goto done;
 	}
 
 	if (t->fs.action == FILTER_SWITCH && t->fs.eport >= nports) {
 		rc = EINVAL;
 		goto done;
 	}
 
 	if (t->fs.val.iport >= nports) {
 		rc = EINVAL;
 		goto done;
 	}
 
 	/* Can't specify an iq if not steering to it */
 	if (!t->fs.dirsteer && t->fs.iq) {
 		rc = EINVAL;
 		goto done;
 	}
 
 	/* IPv6 filter idx must be 4 aligned */
 	if (t->fs.type == 1 &&
 	    ((t->idx & 0x3) || t->idx + 4 >= nfilters)) {
 		rc = EINVAL;
 		goto done;
 	}
 
 	if (sc->tids.ftid_tab == NULL) {
 		KASSERT(sc->tids.ftids_in_use == 0,
 		    ("%s: no memory allocated but filters_in_use > 0",
 		    __func__));
 
 		sc->tids.ftid_tab = malloc(sizeof (struct filter_entry) *
 		    nfilters, M_CXGBE, M_NOWAIT | M_ZERO);
 		if (sc->tids.ftid_tab == NULL) {
 			rc = ENOMEM;
 			goto done;
 		}
 		mtx_init(&sc->tids.ftid_lock, "T4 filters", 0, MTX_DEF);
 	}
 
 	for (i = 0; i < 4; i++) {
 		f = &sc->tids.ftid_tab[t->idx + i];
 
 		if (f->pending || f->valid) {
 			rc = EBUSY;
 			goto done;
 		}
 		if (f->locked) {
 			rc = EPERM;
 			goto done;
 		}
 
 		if (t->fs.type == 0)
 			break;
 	}
 
 	f = &sc->tids.ftid_tab[t->idx];
 	f->fs = t->fs;
 
 	rc = set_filter_wr(sc, t->idx);
 done:
 	end_synchronized_op(sc, 0);
 
 	if (rc == 0) {
 		mtx_lock(&sc->tids.ftid_lock);
 		for (;;) {
 			if (f->pending == 0) {
 				rc = f->valid ? 0 : EIO;
 				break;
 			}
 
 			if (mtx_sleep(&sc->tids.ftid_tab, &sc->tids.ftid_lock,
 			    PCATCH, "t4setfw", 0)) {
 				rc = EINPROGRESS;
 				break;
 			}
 		}
 		mtx_unlock(&sc->tids.ftid_lock);
 	}
 	return (rc);
 }
 
 static int
 del_filter(struct adapter *sc, struct t4_filter *t)
 {
 	unsigned int nfilters;
 	struct filter_entry *f;
 	int rc;
 
 	rc = begin_synchronized_op(sc, NULL, SLEEP_OK | INTR_OK, "t4delf");
 	if (rc)
 		return (rc);
 
 	nfilters = sc->tids.nftids;
 
 	if (nfilters == 0) {
 		rc = ENOTSUP;
 		goto done;
 	}
 
 	if (sc->tids.ftid_tab == NULL || sc->tids.ftids_in_use == 0 ||
 	    t->idx >= nfilters) {
 		rc = EINVAL;
 		goto done;
 	}
 
 	if (!(sc->flags & FULL_INIT_DONE)) {
 		rc = EAGAIN;
 		goto done;
 	}
 
 	f = &sc->tids.ftid_tab[t->idx];
 
 	if (f->pending) {
 		rc = EBUSY;
 		goto done;
 	}
 	if (f->locked) {
 		rc = EPERM;
 		goto done;
 	}
 
 	if (f->valid) {
 		t->fs = f->fs;	/* extra info for the caller */
 		rc = del_filter_wr(sc, t->idx);
 	}
 
 done:
 	end_synchronized_op(sc, 0);
 
 	if (rc == 0) {
 		mtx_lock(&sc->tids.ftid_lock);
 		for (;;) {
 			if (f->pending == 0) {
 				rc = f->valid ? EIO : 0;
 				break;
 			}
 
 			if (mtx_sleep(&sc->tids.ftid_tab, &sc->tids.ftid_lock,
 			    PCATCH, "t4delfw", 0)) {
 				rc = EINPROGRESS;
 				break;
 			}
 		}
 		mtx_unlock(&sc->tids.ftid_lock);
 	}
 
 	return (rc);
 }
 
 static void
 clear_filter(struct filter_entry *f)
 {
 	if (f->l2t)
 		t4_l2t_release(f->l2t);
 
 	bzero(f, sizeof (*f));
 }
 
 static int
 set_filter_wr(struct adapter *sc, int fidx)
 {
 	struct filter_entry *f = &sc->tids.ftid_tab[fidx];
 	struct fw_filter_wr *fwr;
 	unsigned int ftid;
 	struct wrq_cookie cookie;
 
 	ASSERT_SYNCHRONIZED_OP(sc);
 
 	if (f->fs.newdmac || f->fs.newvlan) {
 		/* This filter needs an L2T entry; allocate one. */
 		f->l2t = t4_l2t_alloc_switching(sc->l2t);
 		if (f->l2t == NULL)
 			return (EAGAIN);
 		if (t4_l2t_set_switching(sc, f->l2t, f->fs.vlan, f->fs.eport,
 		    f->fs.dmac)) {
 			t4_l2t_release(f->l2t);
 			f->l2t = NULL;
 			return (ENOMEM);
 		}
 	}
 
 	ftid = sc->tids.ftid_base + fidx;
 
 	fwr = start_wrq_wr(&sc->sge.mgmtq, howmany(sizeof(*fwr), 16), &cookie);
 	if (fwr == NULL)
 		return (ENOMEM);
 	bzero(fwr, sizeof(*fwr));
 
 	fwr->op_pkd = htobe32(V_FW_WR_OP(FW_FILTER_WR));
 	fwr->len16_pkd = htobe32(FW_LEN16(*fwr));
 	fwr->tid_to_iq =
 	    htobe32(V_FW_FILTER_WR_TID(ftid) |
 		V_FW_FILTER_WR_RQTYPE(f->fs.type) |
 		V_FW_FILTER_WR_NOREPLY(0) |
 		V_FW_FILTER_WR_IQ(f->fs.iq));
 	fwr->del_filter_to_l2tix =
 	    htobe32(V_FW_FILTER_WR_RPTTID(f->fs.rpttid) |
 		V_FW_FILTER_WR_DROP(f->fs.action == FILTER_DROP) |
 		V_FW_FILTER_WR_DIRSTEER(f->fs.dirsteer) |
 		V_FW_FILTER_WR_MASKHASH(f->fs.maskhash) |
 		V_FW_FILTER_WR_DIRSTEERHASH(f->fs.dirsteerhash) |
 		V_FW_FILTER_WR_LPBK(f->fs.action == FILTER_SWITCH) |
 		V_FW_FILTER_WR_DMAC(f->fs.newdmac) |
 		V_FW_FILTER_WR_SMAC(f->fs.newsmac) |
 		V_FW_FILTER_WR_INSVLAN(f->fs.newvlan == VLAN_INSERT ||
 		    f->fs.newvlan == VLAN_REWRITE) |
 		V_FW_FILTER_WR_RMVLAN(f->fs.newvlan == VLAN_REMOVE ||
 		    f->fs.newvlan == VLAN_REWRITE) |
 		V_FW_FILTER_WR_HITCNTS(f->fs.hitcnts) |
 		V_FW_FILTER_WR_TXCHAN(f->fs.eport) |
 		V_FW_FILTER_WR_PRIO(f->fs.prio) |
 		V_FW_FILTER_WR_L2TIX(f->l2t ? f->l2t->idx : 0));
 	fwr->ethtype = htobe16(f->fs.val.ethtype);
 	fwr->ethtypem = htobe16(f->fs.mask.ethtype);
 	fwr->frag_to_ovlan_vldm =
 	    (V_FW_FILTER_WR_FRAG(f->fs.val.frag) |
 		V_FW_FILTER_WR_FRAGM(f->fs.mask.frag) |
 		V_FW_FILTER_WR_IVLAN_VLD(f->fs.val.vlan_vld) |
 		V_FW_FILTER_WR_OVLAN_VLD(f->fs.val.vnic_vld) |
 		V_FW_FILTER_WR_IVLAN_VLDM(f->fs.mask.vlan_vld) |
 		V_FW_FILTER_WR_OVLAN_VLDM(f->fs.mask.vnic_vld));
 	fwr->smac_sel = 0;
 	fwr->rx_chan_rx_rpl_iq = htobe16(V_FW_FILTER_WR_RX_CHAN(0) |
 	    V_FW_FILTER_WR_RX_RPL_IQ(sc->sge.fwq.abs_id));
 	fwr->maci_to_matchtypem =
 	    htobe32(V_FW_FILTER_WR_MACI(f->fs.val.macidx) |
 		V_FW_FILTER_WR_MACIM(f->fs.mask.macidx) |
 		V_FW_FILTER_WR_FCOE(f->fs.val.fcoe) |
 		V_FW_FILTER_WR_FCOEM(f->fs.mask.fcoe) |
 		V_FW_FILTER_WR_PORT(f->fs.val.iport) |
 		V_FW_FILTER_WR_PORTM(f->fs.mask.iport) |
 		V_FW_FILTER_WR_MATCHTYPE(f->fs.val.matchtype) |
 		V_FW_FILTER_WR_MATCHTYPEM(f->fs.mask.matchtype));
 	fwr->ptcl = f->fs.val.proto;
 	fwr->ptclm = f->fs.mask.proto;
 	fwr->ttyp = f->fs.val.tos;
 	fwr->ttypm = f->fs.mask.tos;
 	fwr->ivlan = htobe16(f->fs.val.vlan);
 	fwr->ivlanm = htobe16(f->fs.mask.vlan);
 	fwr->ovlan = htobe16(f->fs.val.vnic);
 	fwr->ovlanm = htobe16(f->fs.mask.vnic);
 	bcopy(f->fs.val.dip, fwr->lip, sizeof (fwr->lip));
 	bcopy(f->fs.mask.dip, fwr->lipm, sizeof (fwr->lipm));
 	bcopy(f->fs.val.sip, fwr->fip, sizeof (fwr->fip));
 	bcopy(f->fs.mask.sip, fwr->fipm, sizeof (fwr->fipm));
 	fwr->lp = htobe16(f->fs.val.dport);
 	fwr->lpm = htobe16(f->fs.mask.dport);
 	fwr->fp = htobe16(f->fs.val.sport);
 	fwr->fpm = htobe16(f->fs.mask.sport);
 	if (f->fs.newsmac)
 		bcopy(f->fs.smac, fwr->sma, sizeof (fwr->sma));
 
 	f->pending = 1;
 	sc->tids.ftids_in_use++;
 
 	commit_wrq_wr(&sc->sge.mgmtq, fwr, &cookie);
 	return (0);
 }
 
 static int
 del_filter_wr(struct adapter *sc, int fidx)
 {
 	struct filter_entry *f = &sc->tids.ftid_tab[fidx];
 	struct fw_filter_wr *fwr;
 	unsigned int ftid;
 	struct wrq_cookie cookie;
 
 	ftid = sc->tids.ftid_base + fidx;
 
 	fwr = start_wrq_wr(&sc->sge.mgmtq, howmany(sizeof(*fwr), 16), &cookie);
 	if (fwr == NULL)
 		return (ENOMEM);
 	bzero(fwr, sizeof (*fwr));
 
 	t4_mk_filtdelwr(ftid, fwr, sc->sge.fwq.abs_id);
 
 	f->pending = 1;
 	commit_wrq_wr(&sc->sge.mgmtq, fwr, &cookie);
 	return (0);
 }
 
 int
 t4_filter_rpl(struct sge_iq *iq, const struct rss_header *rss, struct mbuf *m)
 {
 	struct adapter *sc = iq->adapter;
 	const struct cpl_set_tcb_rpl *rpl = (const void *)(rss + 1);
 	unsigned int idx = GET_TID(rpl);
 	unsigned int rc;
 	struct filter_entry *f;
 
 	KASSERT(m == NULL, ("%s: payload with opcode %02x", __func__,
 	    rss->opcode));
 
 	if (is_ftid(sc, idx)) {
 
 		idx -= sc->tids.ftid_base;
 		f = &sc->tids.ftid_tab[idx];
 		rc = G_COOKIE(rpl->cookie);
 
 		mtx_lock(&sc->tids.ftid_lock);
 		if (rc == FW_FILTER_WR_FLT_ADDED) {
 			KASSERT(f->pending, ("%s: filter[%u] isn't pending.",
 			    __func__, idx));
 			f->smtidx = (be64toh(rpl->oldval) >> 24) & 0xff;
 			f->pending = 0;  /* asynchronous setup completed */
 			f->valid = 1;
 		} else {
 			if (rc != FW_FILTER_WR_FLT_DELETED) {
 				/* Add or delete failed, display an error */
 				log(LOG_ERR,
 				    "filter %u setup failed with error %u\n",
 				    idx, rc);
 			}
 
 			clear_filter(f);
 			sc->tids.ftids_in_use--;
 		}
 		wakeup(&sc->tids.ftid_tab);
 		mtx_unlock(&sc->tids.ftid_lock);
 	}
 
 	return (0);
 }
 
 static int
 get_sge_context(struct adapter *sc, struct t4_sge_context *cntxt)
 {
 	int rc;
 
 	if (cntxt->cid > M_CTXTQID)
 		return (EINVAL);
 
 	if (cntxt->mem_id != CTXT_EGRESS && cntxt->mem_id != CTXT_INGRESS &&
 	    cntxt->mem_id != CTXT_FLM && cntxt->mem_id != CTXT_CNM)
 		return (EINVAL);
 
 	rc = begin_synchronized_op(sc, NULL, SLEEP_OK | INTR_OK, "t4ctxt");
 	if (rc)
 		return (rc);
 
 	if (sc->flags & FW_OK) {
 		rc = -t4_sge_ctxt_rd(sc, sc->mbox, cntxt->cid, cntxt->mem_id,
 		    &cntxt->data[0]);
 		if (rc == 0)
 			goto done;
 	}
 
 	/*
 	 * Read via firmware failed or wasn't even attempted.  Read directly via
 	 * the backdoor.
 	 */
 	rc = -t4_sge_ctxt_rd_bd(sc, cntxt->cid, cntxt->mem_id, &cntxt->data[0]);
 done:
 	end_synchronized_op(sc, 0);
 	return (rc);
 }
 
 static int
 load_fw(struct adapter *sc, struct t4_data *fw)
 {
 	int rc;
 	uint8_t *fw_data;
 
 	rc = begin_synchronized_op(sc, NULL, SLEEP_OK | INTR_OK, "t4ldfw");
 	if (rc)
 		return (rc);
 
 	if (sc->flags & FULL_INIT_DONE) {
 		rc = EBUSY;
 		goto done;
 	}
 
 	fw_data = malloc(fw->len, M_CXGBE, M_WAITOK);
 	if (fw_data == NULL) {
 		rc = ENOMEM;
 		goto done;
 	}
 
 	rc = copyin(fw->data, fw_data, fw->len);
 	if (rc == 0)
 		rc = -t4_load_fw(sc, fw_data, fw->len);
 
 	free(fw_data, M_CXGBE);
 done:
 	end_synchronized_op(sc, 0);
 	return (rc);
 }
 
 static int
 read_card_mem(struct adapter *sc, int win, struct t4_mem_range *mr)
 {
 	uint32_t addr, off, remaining, i, n;
 	uint32_t *buf, *b;
 	uint32_t mw_base, mw_aperture;
 	int rc;
 	uint8_t *dst;
 
 	rc = validate_mem_range(sc, mr->addr, mr->len);
 	if (rc != 0)
 		return (rc);
 
 	memwin_info(sc, win, &mw_base, &mw_aperture);
 	buf = b = malloc(min(mr->len, mw_aperture), M_CXGBE, M_WAITOK);
 	addr = mr->addr;
 	remaining = mr->len;
 	dst = (void *)mr->data;
 
 	while (remaining) {
 		off = position_memwin(sc, win, addr);
 
 		/* number of bytes that we'll copy in the inner loop */
 		n = min(remaining, mw_aperture - off);
 		for (i = 0; i < n; i += 4)
 			*b++ = t4_read_reg(sc, mw_base + off + i);
 
 		rc = copyout(buf, dst, n);
 		if (rc != 0)
 			break;
 
 		b = buf;
 		dst += n;
 		remaining -= n;
 		addr += n;
 	}
 
 	free(buf, M_CXGBE);
 	return (rc);
 }
 
 static int
 read_i2c(struct adapter *sc, struct t4_i2c_data *i2cd)
 {
 	int rc;
 
 	if (i2cd->len == 0 || i2cd->port_id >= sc->params.nports)
 		return (EINVAL);
 
 	if (i2cd->len > sizeof(i2cd->data))
 		return (EFBIG);
 
 	rc = begin_synchronized_op(sc, NULL, SLEEP_OK | INTR_OK, "t4i2crd");
 	if (rc)
 		return (rc);
 	rc = -t4_i2c_rd(sc, sc->mbox, i2cd->port_id, i2cd->dev_addr,
 	    i2cd->offset, i2cd->len, &i2cd->data[0]);
 	end_synchronized_op(sc, 0);
 
 	return (rc);
 }
 
 static int
 in_range(int val, int lo, int hi)
 {
 
 	return (val < 0 || (val <= hi && val >= lo));
 }
 
 static int
 set_sched_class(struct adapter *sc, struct t4_sched_params *p)
 {
 	int fw_subcmd, fw_type, rc;
 
 	rc = begin_synchronized_op(sc, NULL, SLEEP_OK | INTR_OK, "t4setsc");
 	if (rc)
 		return (rc);
 
 	if (!(sc->flags & FULL_INIT_DONE)) {
 		rc = EAGAIN;
 		goto done;
 	}
 
 	/*
 	 * Translate the cxgbetool parameters into T4 firmware parameters.  (The
 	 * sub-command and type are in common locations.)
 	 */
 	if (p->subcmd == SCHED_CLASS_SUBCMD_CONFIG)
 		fw_subcmd = FW_SCHED_SC_CONFIG;
 	else if (p->subcmd == SCHED_CLASS_SUBCMD_PARAMS)
 		fw_subcmd = FW_SCHED_SC_PARAMS;
 	else {
 		rc = EINVAL;
 		goto done;
 	}
 	if (p->type == SCHED_CLASS_TYPE_PACKET)
 		fw_type = FW_SCHED_TYPE_PKTSCHED;
 	else {
 		rc = EINVAL;
 		goto done;
 	}
 
 	if (fw_subcmd == FW_SCHED_SC_CONFIG) {
 		/* Vet our parameters ..*/
 		if (p->u.config.minmax < 0) {
 			rc = EINVAL;
 			goto done;
 		}
 
 		/* And pass the request to the firmware ...*/
 		rc = -t4_sched_config(sc, fw_type, p->u.config.minmax, 1);
 		goto done;
 	}
 
 	if (fw_subcmd == FW_SCHED_SC_PARAMS) {
 		int fw_level;
 		int fw_mode;
 		int fw_rateunit;
 		int fw_ratemode;
 
 		if (p->u.params.level == SCHED_CLASS_LEVEL_CL_RL)
 			fw_level = FW_SCHED_PARAMS_LEVEL_CL_RL;
 		else if (p->u.params.level == SCHED_CLASS_LEVEL_CL_WRR)
 			fw_level = FW_SCHED_PARAMS_LEVEL_CL_WRR;
 		else if (p->u.params.level == SCHED_CLASS_LEVEL_CH_RL)
 			fw_level = FW_SCHED_PARAMS_LEVEL_CH_RL;
 		else {
 			rc = EINVAL;
 			goto done;
 		}
 
 		if (p->u.params.mode == SCHED_CLASS_MODE_CLASS)
 			fw_mode = FW_SCHED_PARAMS_MODE_CLASS;
 		else if (p->u.params.mode == SCHED_CLASS_MODE_FLOW)
 			fw_mode = FW_SCHED_PARAMS_MODE_FLOW;
 		else {
 			rc = EINVAL;
 			goto done;
 		}
 
 		if (p->u.params.rateunit == SCHED_CLASS_RATEUNIT_BITS)
 			fw_rateunit = FW_SCHED_PARAMS_UNIT_BITRATE;
 		else if (p->u.params.rateunit == SCHED_CLASS_RATEUNIT_PKTS)
 			fw_rateunit = FW_SCHED_PARAMS_UNIT_PKTRATE;
 		else {
 			rc = EINVAL;
 			goto done;
 		}
 
 		if (p->u.params.ratemode == SCHED_CLASS_RATEMODE_REL)
 			fw_ratemode = FW_SCHED_PARAMS_RATE_REL;
 		else if (p->u.params.ratemode == SCHED_CLASS_RATEMODE_ABS)
 			fw_ratemode = FW_SCHED_PARAMS_RATE_ABS;
 		else {
 			rc = EINVAL;
 			goto done;
 		}
 
 		/* Vet our parameters ... */
 		if (!in_range(p->u.params.channel, 0, 3) ||
 		    !in_range(p->u.params.cl, 0, is_t4(sc) ? 15 : 16) ||
 		    !in_range(p->u.params.minrate, 0, 10000000) ||
 		    !in_range(p->u.params.maxrate, 0, 10000000) ||
 		    !in_range(p->u.params.weight, 0, 100)) {
 			rc = ERANGE;
 			goto done;
 		}
 
 		/*
 		 * Translate any unset parameters into the firmware's
 		 * nomenclature and/or fail the call if the parameters
 		 * are required ...
 		 */
 		if (p->u.params.rateunit < 0 || p->u.params.ratemode < 0 ||
 		    p->u.params.channel < 0 || p->u.params.cl < 0) {
 			rc = EINVAL;
 			goto done;
 		}
 		if (p->u.params.minrate < 0)
 			p->u.params.minrate = 0;
 		if (p->u.params.maxrate < 0) {
 			if (p->u.params.level == SCHED_CLASS_LEVEL_CL_RL ||
 			    p->u.params.level == SCHED_CLASS_LEVEL_CH_RL) {
 				rc = EINVAL;
 				goto done;
 			} else
 				p->u.params.maxrate = 0;
 		}
 		if (p->u.params.weight < 0) {
 			if (p->u.params.level == SCHED_CLASS_LEVEL_CL_WRR) {
 				rc = EINVAL;
 				goto done;
 			} else
 				p->u.params.weight = 0;
 		}
 		if (p->u.params.pktsize < 0) {
 			if (p->u.params.level == SCHED_CLASS_LEVEL_CL_RL ||
 			    p->u.params.level == SCHED_CLASS_LEVEL_CH_RL) {
 				rc = EINVAL;
 				goto done;
 			} else
 				p->u.params.pktsize = 0;
 		}
 
 		/* See what the firmware thinks of the request ... */
 		rc = -t4_sched_params(sc, fw_type, fw_level, fw_mode,
 		    fw_rateunit, fw_ratemode, p->u.params.channel,
 		    p->u.params.cl, p->u.params.minrate, p->u.params.maxrate,
 		    p->u.params.weight, p->u.params.pktsize, 1);
 		goto done;
 	}
 
 	rc = EINVAL;
 done:
 	end_synchronized_op(sc, 0);
 	return (rc);
 }
 
 static int
 set_sched_queue(struct adapter *sc, struct t4_sched_queue *p)
 {
 	struct port_info *pi = NULL;
 	struct sge_txq *txq;
 	uint32_t fw_mnem, fw_queue, fw_class;
 	int i, rc;
 
 	rc = begin_synchronized_op(sc, NULL, SLEEP_OK | INTR_OK, "t4setsq");
 	if (rc)
 		return (rc);
 
 	if (!(sc->flags & FULL_INIT_DONE)) {
 		rc = EAGAIN;
 		goto done;
 	}
 
 	if (p->port >= sc->params.nports) {
 		rc = EINVAL;
 		goto done;
 	}
 
 	pi = sc->port[p->port];
 	if (!in_range(p->queue, 0, pi->ntxq - 1) || !in_range(p->cl, 0, 7)) {
 		rc = EINVAL;
 		goto done;
 	}
 
 	/*
 	 * Create a template for the FW_PARAMS_CMD mnemonic and value (TX
 	 * Scheduling Class in this case).
 	 */
 	fw_mnem = (V_FW_PARAMS_MNEM(FW_PARAMS_MNEM_DMAQ) |
 	    V_FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_DMAQ_EQ_SCHEDCLASS_ETH));
 	fw_class = p->cl < 0 ? 0xffffffff : p->cl;
 
 	/*
 	 * If op.queue is non-negative, then we're only changing the scheduling
 	 * on a single specified TX queue.
 	 */
 	if (p->queue >= 0) {
 		txq = &sc->sge.txq[pi->first_txq + p->queue];
 		fw_queue = (fw_mnem | V_FW_PARAMS_PARAM_YZ(txq->eq.cntxt_id));
 		rc = -t4_set_params(sc, sc->mbox, sc->pf, 0, 1, &fw_queue,
 		    &fw_class);
 		goto done;
 	}
 
 	/*
 	 * Change the scheduling on all the TX queues for the
 	 * interface.
 	 */
 	for_each_txq(pi, i, txq) {
 		fw_queue = (fw_mnem | V_FW_PARAMS_PARAM_YZ(txq->eq.cntxt_id));
 		rc = -t4_set_params(sc, sc->mbox, sc->pf, 0, 1, &fw_queue,
 		    &fw_class);
 		if (rc)
 			goto done;
 	}
 
 	rc = 0;
 done:
 	end_synchronized_op(sc, 0);
 	return (rc);
 }
 
 int
 t4_os_find_pci_capability(struct adapter *sc, int cap)
 {
 	int i;
 
 	return (pci_find_cap(sc->dev, cap, &i) == 0 ? i : 0);
 }
 
 int
 t4_os_pci_save_state(struct adapter *sc)
 {
 	device_t dev;
 	struct pci_devinfo *dinfo;
 
 	dev = sc->dev;
 	dinfo = device_get_ivars(dev);
 
 	pci_cfg_save(dev, dinfo, 0);
 	return (0);
 }
 
 int
 t4_os_pci_restore_state(struct adapter *sc)
 {
 	device_t dev;
 	struct pci_devinfo *dinfo;
 
 	dev = sc->dev;
 	dinfo = device_get_ivars(dev);
 
 	pci_cfg_restore(dev, dinfo);
 	return (0);
 }
 
 void
 t4_os_portmod_changed(const struct adapter *sc, int idx)
 {
 	struct port_info *pi = sc->port[idx];
 	static const char *mod_str[] = {
 		NULL, "LR", "SR", "ER", "TWINAX", "active TWINAX", "LRM"
 	};
 
 	build_medialist(pi, &pi->media);
 #ifdef DEV_NETMAP
 	build_medialist(pi, &pi->nm_media);
 #endif
 
 	if (pi->mod_type == FW_PORT_MOD_TYPE_NONE)
 		if_printf(pi->ifp, "transceiver unplugged.\n");
 	else if (pi->mod_type == FW_PORT_MOD_TYPE_UNKNOWN)
 		if_printf(pi->ifp, "unknown transceiver inserted.\n");
 	else if (pi->mod_type == FW_PORT_MOD_TYPE_NOTSUPPORTED)
 		if_printf(pi->ifp, "unsupported transceiver inserted.\n");
 	else if (pi->mod_type > 0 && pi->mod_type < nitems(mod_str)) {
 		if_printf(pi->ifp, "%s transceiver inserted.\n",
 		    mod_str[pi->mod_type]);
 	} else {
 		if_printf(pi->ifp, "transceiver (type %d) inserted.\n",
 		    pi->mod_type);
 	}
 }
 
 void
 t4_os_link_changed(struct adapter *sc, int idx, int link_stat, int reason)
 {
 	struct port_info *pi = sc->port[idx];
 	struct ifnet *ifp = pi->ifp;
 
 	if (link_stat) {
 		pi->linkdnrc = -1;
 		ifp->if_baudrate = IF_Mbps(pi->link_cfg.speed);
 		if_link_state_change(ifp, LINK_STATE_UP);
 	} else {
 		if (reason >= 0)
 			pi->linkdnrc = reason;
 		if_link_state_change(ifp, LINK_STATE_DOWN);
 	}
 }
 
 void
 t4_iterate(void (*func)(struct adapter *, void *), void *arg)
 {
 	struct adapter *sc;
 
 	sx_slock(&t4_list_lock);
 	SLIST_FOREACH(sc, &t4_list, link) {
 		/*
 		 * func should not make any assumptions about what state sc is
 		 * in - the only guarantee is that sc->sc_lock is a valid lock.
 		 */
 		func(sc, arg);
 	}
 	sx_sunlock(&t4_list_lock);
 }
 
 static int
 t4_open(struct cdev *dev, int flags, int type, struct thread *td)
 {
        return (0);
 }
 
 static int
 t4_close(struct cdev *dev, int flags, int type, struct thread *td)
 {
        return (0);
 }
 
 static int
 t4_ioctl(struct cdev *dev, unsigned long cmd, caddr_t data, int fflag,
     struct thread *td)
 {
 	int rc;
 	struct adapter *sc = dev->si_drv1;
 
 	rc = priv_check(td, PRIV_DRIVER);
 	if (rc != 0)
 		return (rc);
 
 	switch (cmd) {
 	case CHELSIO_T4_GETREG: {
 		struct t4_reg *edata = (struct t4_reg *)data;
 
 		if ((edata->addr & 0x3) != 0 || edata->addr >= sc->mmio_len)
 			return (EFAULT);
 
 		if (edata->size == 4)
 			edata->val = t4_read_reg(sc, edata->addr);
 		else if (edata->size == 8)
 			edata->val = t4_read_reg64(sc, edata->addr);
 		else
 			return (EINVAL);
 
 		break;
 	}
 	case CHELSIO_T4_SETREG: {
 		struct t4_reg *edata = (struct t4_reg *)data;
 
 		if ((edata->addr & 0x3) != 0 || edata->addr >= sc->mmio_len)
 			return (EFAULT);
 
 		if (edata->size == 4) {
 			if (edata->val & 0xffffffff00000000)
 				return (EINVAL);
 			t4_write_reg(sc, edata->addr, (uint32_t) edata->val);
 		} else if (edata->size == 8)
 			t4_write_reg64(sc, edata->addr, edata->val);
 		else
 			return (EINVAL);
 		break;
 	}
 	case CHELSIO_T4_REGDUMP: {
 		struct t4_regdump *regs = (struct t4_regdump *)data;
 		int reglen = is_t4(sc) ? T4_REGDUMP_SIZE : T5_REGDUMP_SIZE;
 		uint8_t *buf;
 
 		if (regs->len < reglen) {
 			regs->len = reglen; /* hint to the caller */
 			return (ENOBUFS);
 		}
 
 		regs->len = reglen;
 		buf = malloc(reglen, M_CXGBE, M_WAITOK | M_ZERO);
 		t4_get_regs(sc, regs, buf);
 		rc = copyout(buf, regs->data, reglen);
 		free(buf, M_CXGBE);
 		break;
 	}
 	case CHELSIO_T4_GET_FILTER_MODE:
 		rc = get_filter_mode(sc, (uint32_t *)data);
 		break;
 	case CHELSIO_T4_SET_FILTER_MODE:
 		rc = set_filter_mode(sc, *(uint32_t *)data);
 		break;
 	case CHELSIO_T4_GET_FILTER:
 		rc = get_filter(sc, (struct t4_filter *)data);
 		break;
 	case CHELSIO_T4_SET_FILTER:
 		rc = set_filter(sc, (struct t4_filter *)data);
 		break;
 	case CHELSIO_T4_DEL_FILTER:
 		rc = del_filter(sc, (struct t4_filter *)data);
 		break;
 	case CHELSIO_T4_GET_SGE_CONTEXT:
 		rc = get_sge_context(sc, (struct t4_sge_context *)data);
 		break;
 	case CHELSIO_T4_LOAD_FW:
 		rc = load_fw(sc, (struct t4_data *)data);
 		break;
 	case CHELSIO_T4_GET_MEM:
 		rc = read_card_mem(sc, 2, (struct t4_mem_range *)data);
 		break;
 	case CHELSIO_T4_GET_I2C:
 		rc = read_i2c(sc, (struct t4_i2c_data *)data);
 		break;
 	case CHELSIO_T4_CLEAR_STATS: {
 		int i;
 		u_int port_id = *(uint32_t *)data;
 		struct port_info *pi;
 
 		if (port_id >= sc->params.nports)
 			return (EINVAL);
 		pi = sc->port[port_id];
 
 		/* MAC stats */
 		t4_clr_port_stats(sc, pi->tx_chan);
 		pi->tx_parse_error = 0;
 
 		if (pi->flags & PORT_INIT_DONE) {
 			struct sge_rxq *rxq;
 			struct sge_txq *txq;
 			struct sge_wrq *wrq;
 
 			for_each_rxq(pi, i, rxq) {
 #if defined(INET) || defined(INET6)
 				rxq->lro.lro_queued = 0;
 				rxq->lro.lro_flushed = 0;
 #endif
 				rxq->rxcsum = 0;
 				rxq->vlan_extraction = 0;
 			}
 
 			for_each_txq(pi, i, txq) {
 				txq->txcsum = 0;
 				txq->tso_wrs = 0;
 				txq->vlan_insertion = 0;
 				txq->imm_wrs = 0;
 				txq->sgl_wrs = 0;
 				txq->txpkt_wrs = 0;
 				txq->txpkts0_wrs = 0;
 				txq->txpkts1_wrs = 0;
 				txq->txpkts0_pkts = 0;
 				txq->txpkts1_pkts = 0;
 				mp_ring_reset_stats(txq->r);
 			}
 
 #ifdef TCP_OFFLOAD
 			/* nothing to clear for each ofld_rxq */
 
 			for_each_ofld_txq(pi, i, wrq) {
 				wrq->tx_wrs_direct = 0;
 				wrq->tx_wrs_copied = 0;
 			}
 #endif
 			wrq = &sc->sge.ctrlq[pi->port_id];
 			wrq->tx_wrs_direct = 0;
 			wrq->tx_wrs_copied = 0;
 		}
 		break;
 	}
 	case CHELSIO_T4_SCHED_CLASS:
 		rc = set_sched_class(sc, (struct t4_sched_params *)data);
 		break;
 	case CHELSIO_T4_SCHED_QUEUE:
 		rc = set_sched_queue(sc, (struct t4_sched_queue *)data);
 		break;
 	case CHELSIO_T4_GET_TRACER:
 		rc = t4_get_tracer(sc, (struct t4_tracer *)data);
 		break;
 	case CHELSIO_T4_SET_TRACER:
 		rc = t4_set_tracer(sc, (struct t4_tracer *)data);
 		break;
 	default:
 		rc = EINVAL;
 	}
 
 	return (rc);
 }
 
 #ifdef TCP_OFFLOAD
 void
 t4_iscsi_init(struct ifnet *ifp, unsigned int tag_mask,
     const unsigned int *pgsz_order)
 {
 	struct port_info *pi = ifp->if_softc;
 	struct adapter *sc = pi->adapter;
 
 	t4_write_reg(sc, A_ULP_RX_ISCSI_TAGMASK, tag_mask);
 	t4_write_reg(sc, A_ULP_RX_ISCSI_PSZ, V_HPZ0(pgsz_order[0]) |
 		V_HPZ1(pgsz_order[1]) | V_HPZ2(pgsz_order[2]) |
 		V_HPZ3(pgsz_order[3]));
 }
 
 static int
 toe_capability(struct port_info *pi, int enable)
 {
 	int rc;
 	struct adapter *sc = pi->adapter;
 
 	ASSERT_SYNCHRONIZED_OP(sc);
 
 	if (!is_offload(sc))
 		return (ENODEV);
 
 	if (enable) {
 		if (!(sc->flags & FULL_INIT_DONE)) {
 			rc = cxgbe_init_synchronized(pi);
 			if (rc)
 				return (rc);
 		}
 
 		if (isset(&sc->offload_map, pi->port_id))
 			return (0);
 
 		if (!(sc->flags & TOM_INIT_DONE)) {
 			rc = t4_activate_uld(sc, ULD_TOM);
 			if (rc == EAGAIN) {
 				log(LOG_WARNING,
 				    "You must kldload t4_tom.ko before trying "
 				    "to enable TOE on a cxgbe interface.\n");
 			}
 			if (rc != 0)
 				return (rc);
 			KASSERT(sc->tom_softc != NULL,
 			    ("%s: TOM activated but softc NULL", __func__));
 			KASSERT(sc->flags & TOM_INIT_DONE,
 			    ("%s: TOM activated but flag not set", __func__));
 		}
 
 		setbit(&sc->offload_map, pi->port_id);
 	} else {
 		if (!isset(&sc->offload_map, pi->port_id))
 			return (0);
 
 		KASSERT(sc->flags & TOM_INIT_DONE,
 		    ("%s: TOM never initialized?", __func__));
 		clrbit(&sc->offload_map, pi->port_id);
 	}
 
 	return (0);
 }
 
 /*
  * Add an upper layer driver to the global list.
  */
 int
 t4_register_uld(struct uld_info *ui)
 {
 	int rc = 0;
 	struct uld_info *u;
 
 	sx_xlock(&t4_uld_list_lock);
 	SLIST_FOREACH(u, &t4_uld_list, link) {
 	    if (u->uld_id == ui->uld_id) {
 		    rc = EEXIST;
 		    goto done;
 	    }
 	}
 
 	SLIST_INSERT_HEAD(&t4_uld_list, ui, link);
 	ui->refcount = 0;
 done:
 	sx_xunlock(&t4_uld_list_lock);
 	return (rc);
 }
 
 int
 t4_unregister_uld(struct uld_info *ui)
 {
 	int rc = EINVAL;
 	struct uld_info *u;
 
 	sx_xlock(&t4_uld_list_lock);
 
 	SLIST_FOREACH(u, &t4_uld_list, link) {
 	    if (u == ui) {
 		    if (ui->refcount > 0) {
 			    rc = EBUSY;
 			    goto done;
 		    }
 
 		    SLIST_REMOVE(&t4_uld_list, ui, uld_info, link);
 		    rc = 0;
 		    goto done;
 	    }
 	}
 done:
 	sx_xunlock(&t4_uld_list_lock);
 	return (rc);
 }
 
 int
 t4_activate_uld(struct adapter *sc, int id)
 {
 	int rc = EAGAIN;
 	struct uld_info *ui;
 
 	ASSERT_SYNCHRONIZED_OP(sc);
 
 	sx_slock(&t4_uld_list_lock);
 
 	SLIST_FOREACH(ui, &t4_uld_list, link) {
 		if (ui->uld_id == id) {
 			if (!(sc->flags & FULL_INIT_DONE)) {
 				rc = adapter_full_init(sc);
 				if (rc != 0)
 					goto done;
 			}
 
 			rc = ui->activate(sc);
 			if (rc == 0)
 				ui->refcount++;
 			goto done;
 		}
 	}
 done:
 	sx_sunlock(&t4_uld_list_lock);
 
 	return (rc);
 }
 
 int
 t4_deactivate_uld(struct adapter *sc, int id)
 {
 	int rc = EINVAL;
 	struct uld_info *ui;
 
 	ASSERT_SYNCHRONIZED_OP(sc);
 
 	sx_slock(&t4_uld_list_lock);
 
 	SLIST_FOREACH(ui, &t4_uld_list, link) {
 		if (ui->uld_id == id) {
 			rc = ui->deactivate(sc);
 			if (rc == 0)
 				ui->refcount--;
 			goto done;
 		}
 	}
 done:
 	sx_sunlock(&t4_uld_list_lock);
 
 	return (rc);
 }
 #endif
 
 /*
  * Come up with reasonable defaults for some of the tunables, provided they're
  * not set by the user (in which case we'll use the values as is).
  */
 static void
 tweak_tunables(void)
 {
 	int nc = mp_ncpus;	/* our snapshot of the number of CPUs */
 
 	if (t4_ntxq10g < 1)
 		t4_ntxq10g = min(nc, NTXQ_10G);
 
 	if (t4_ntxq1g < 1)
 		t4_ntxq1g = min(nc, NTXQ_1G);
 
 	if (t4_nrxq10g < 1)
 		t4_nrxq10g = min(nc, NRXQ_10G);
 
 	if (t4_nrxq1g < 1)
 		t4_nrxq1g = min(nc, NRXQ_1G);
 
 #ifdef TCP_OFFLOAD
 	if (t4_nofldtxq10g < 1)
 		t4_nofldtxq10g = min(nc, NOFLDTXQ_10G);
 
 	if (t4_nofldtxq1g < 1)
 		t4_nofldtxq1g = min(nc, NOFLDTXQ_1G);
 
 	if (t4_nofldrxq10g < 1)
 		t4_nofldrxq10g = min(nc, NOFLDRXQ_10G);
 
 	if (t4_nofldrxq1g < 1)
 		t4_nofldrxq1g = min(nc, NOFLDRXQ_1G);
 
 	if (t4_toecaps_allowed == -1)
 		t4_toecaps_allowed = FW_CAPS_CONFIG_TOE;
 #else
 	if (t4_toecaps_allowed == -1)
 		t4_toecaps_allowed = 0;
 #endif
 
 #ifdef DEV_NETMAP
 	if (t4_nnmtxq10g < 1)
 		t4_nnmtxq10g = min(nc, NNMTXQ_10G);
 
 	if (t4_nnmtxq1g < 1)
 		t4_nnmtxq1g = min(nc, NNMTXQ_1G);
 
 	if (t4_nnmrxq10g < 1)
 		t4_nnmrxq10g = min(nc, NNMRXQ_10G);
 
 	if (t4_nnmrxq1g < 1)
 		t4_nnmrxq1g = min(nc, NNMRXQ_1G);
 #endif
 
 	if (t4_tmr_idx_10g < 0 || t4_tmr_idx_10g >= SGE_NTIMERS)
 		t4_tmr_idx_10g = TMR_IDX_10G;
 
 	if (t4_pktc_idx_10g < -1 || t4_pktc_idx_10g >= SGE_NCOUNTERS)
 		t4_pktc_idx_10g = PKTC_IDX_10G;
 
 	if (t4_tmr_idx_1g < 0 || t4_tmr_idx_1g >= SGE_NTIMERS)
 		t4_tmr_idx_1g = TMR_IDX_1G;
 
 	if (t4_pktc_idx_1g < -1 || t4_pktc_idx_1g >= SGE_NCOUNTERS)
 		t4_pktc_idx_1g = PKTC_IDX_1G;
 
 	if (t4_qsize_txq < 128)
 		t4_qsize_txq = 128;
 
 	if (t4_qsize_rxq < 128)
 		t4_qsize_rxq = 128;
 	while (t4_qsize_rxq & 7)
 		t4_qsize_rxq++;
 
 	t4_intr_types &= INTR_MSIX | INTR_MSI | INTR_INTX;
 }
 
 static struct sx mlu;	/* mod load unload */
 SX_SYSINIT(cxgbe_mlu, &mlu, "cxgbe mod load/unload");
 
 static int
 mod_event(module_t mod, int cmd, void *arg)
 {
 	int rc = 0;
 	static int loaded = 0;
 
 	switch (cmd) {
 	case MOD_LOAD:
 		sx_xlock(&mlu);
 		if (loaded++ == 0) {
 			t4_sge_modload();
 			sx_init(&t4_list_lock, "T4/T5 adapters");
 			SLIST_INIT(&t4_list);
 #ifdef TCP_OFFLOAD
 			sx_init(&t4_uld_list_lock, "T4/T5 ULDs");
 			SLIST_INIT(&t4_uld_list);
 #endif
 			t4_tracer_modload();
 			tweak_tunables();
 		}
 		sx_xunlock(&mlu);
 		break;
 
 	case MOD_UNLOAD:
 		sx_xlock(&mlu);
 		if (--loaded == 0) {
 			int tries;
 
 			sx_slock(&t4_list_lock);
 			if (!SLIST_EMPTY(&t4_list)) {
 				rc = EBUSY;
 				sx_sunlock(&t4_list_lock);
 				goto done_unload;
 			}
 #ifdef TCP_OFFLOAD
 			sx_slock(&t4_uld_list_lock);
 			if (!SLIST_EMPTY(&t4_uld_list)) {
 				rc = EBUSY;
 				sx_sunlock(&t4_uld_list_lock);
 				sx_sunlock(&t4_list_lock);
 				goto done_unload;
 			}
 #endif
 			tries = 0;
 			while (tries++ < 5 && t4_sge_extfree_refs() != 0) {
 				uprintf("%ju clusters with custom free routine "
 				    "still is use.\n", t4_sge_extfree_refs());
 				pause("t4unload", 2 * hz);
 			}
 #ifdef TCP_OFFLOAD
 			sx_sunlock(&t4_uld_list_lock);
 #endif
 			sx_sunlock(&t4_list_lock);
 
 			if (t4_sge_extfree_refs() == 0) {
 				t4_tracer_modunload();
 #ifdef TCP_OFFLOAD
 				sx_destroy(&t4_uld_list_lock);
 #endif
 				sx_destroy(&t4_list_lock);
 				t4_sge_modunload();
 				loaded = 0;
 			} else {
 				rc = EBUSY;
 				loaded++;	/* undo earlier decrement */
 			}
 		}
 done_unload:
 		sx_xunlock(&mlu);
 		break;
 	}
 
 	return (rc);
 }
 
 static devclass_t t4_devclass, t5_devclass;
 static devclass_t cxgbe_devclass, cxl_devclass;
 
 DRIVER_MODULE(t4nex, pci, t4_driver, t4_devclass, mod_event, 0);
 MODULE_VERSION(t4nex, 1);
 MODULE_DEPEND(t4nex, firmware, 1, 1, 1);
 
 DRIVER_MODULE(t5nex, pci, t5_driver, t5_devclass, mod_event, 0);
 MODULE_VERSION(t5nex, 1);
 MODULE_DEPEND(t5nex, firmware, 1, 1, 1);
 
 DRIVER_MODULE(cxgbe, t4nex, cxgbe_driver, cxgbe_devclass, 0, 0);
 MODULE_VERSION(cxgbe, 1);
 
 DRIVER_MODULE(cxl, t5nex, cxl_driver, cxl_devclass, 0, 0);
 MODULE_VERSION(cxl, 1);
Index: projects/clang360-import/sys/dev/cxgbe/tom/t4_ddp.c
===================================================================
--- projects/clang360-import/sys/dev/cxgbe/tom/t4_ddp.c	(revision 277777)
+++ projects/clang360-import/sys/dev/cxgbe/tom/t4_ddp.c	(revision 277778)
@@ -1,1243 +1,1243 @@
 /*-
  * Copyright (c) 2012 Chelsio Communications, Inc.
  * All rights reserved.
  * Written by: Navdeep Parhar <np@FreeBSD.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include "opt_inet.h"
 
 #include <sys/param.h>
 #include <sys/types.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/ktr.h>
 #include <sys/module.h>
 #include <sys/protosw.h>
 #include <sys/proc.h>
 #include <sys/domain.h>
 #include <sys/socket.h>
 #include <sys/socketvar.h>
 #include <sys/uio.h>
 #include <netinet/in.h>
 #include <netinet/in_pcb.h>
 #include <netinet/ip.h>
 #include <netinet/tcp_var.h>
 #define TCPSTATES
 #include <netinet/tcp_fsm.h>
 #include <netinet/toecore.h>
 
 #include <vm/vm.h>
 #include <vm/vm_extern.h>
 #include <vm/vm_param.h>
 #include <vm/pmap.h>
 #include <vm/vm_map.h>
 #include <vm/vm_page.h>
 #include <vm/vm_object.h>
 
 #ifdef TCP_OFFLOAD
 #include "common/common.h"
 #include "common/t4_msg.h"
 #include "common/t4_regs.h"
 #include "common/t4_tcb.h"
 #include "tom/t4_tom.h"
 
 #define PPOD_SZ(n)	((n) * sizeof(struct pagepod))
 #define PPOD_SIZE	(PPOD_SZ(1))
 
 /* XXX: must match A_ULP_RX_TDDP_PSZ */
 static int t4_ddp_pgsz[] = {4096, 4096 << 2, 4096 << 4, 4096 << 6};
 
 #if 0
 static void
 t4_dump_tcb(struct adapter *sc, int tid)
 {
 	uint32_t tcb_base, off, i, j;
 
 	/* Dump TCB for the tid */
 	tcb_base = t4_read_reg(sc, A_TP_CMM_TCB_BASE);
 	t4_write_reg(sc, PCIE_MEM_ACCESS_REG(A_PCIE_MEM_ACCESS_OFFSET, 2),
 	    tcb_base + tid * TCB_SIZE);
 	t4_read_reg(sc, PCIE_MEM_ACCESS_REG(A_PCIE_MEM_ACCESS_OFFSET, 2));
 	off = 0;
 	printf("\n");
 	for (i = 0; i < 4; i++) {
 		uint32_t buf[8];
 		for (j = 0; j < 8; j++, off += 4)
 			buf[j] = htonl(t4_read_reg(sc, MEMWIN2_BASE + off));
 
 		printf("%08x %08x %08x %08x %08x %08x %08x %08x\n",
 		    buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6],
 		    buf[7]);
 	}
 }
 #endif
 
 #define MAX_DDP_BUFFER_SIZE		(M_TCB_RX_DDP_BUF0_LEN)
 static int
 alloc_ppods(struct tom_data *td, int n, u_int *ppod_addr)
 {
 	vmem_addr_t v;
 	int rc;
 
 	MPASS(n > 0);
 
 	rc = vmem_alloc(td->ppod_arena, PPOD_SZ(n), M_NOWAIT | M_FIRSTFIT, &v);
 	*ppod_addr = (u_int)v;
 
 	return (rc);
 }
 
 static void
 free_ppods(struct tom_data *td, u_int ppod_addr, int n)
 {
 
 	MPASS(n > 0);
 
 	vmem_free(td->ppod_arena, (vmem_addr_t)ppod_addr, PPOD_SZ(n));
 }
 
 static inline int
 pages_to_nppods(int npages, int ddp_pgsz)
 {
 	int nsegs = npages * PAGE_SIZE / ddp_pgsz;
 
 	return (howmany(nsegs, PPOD_PAGES));
 }
 
 static void
 free_ddp_buffer(struct tom_data *td, struct ddp_buffer *db)
 {
 
 	if (db == NULL)
 		return;
 
 	if (db->pages)
 		free(db->pages, M_CXGBE);
 
 	if (db->nppods > 0)
 		free_ppods(td, db->ppod_addr, db->nppods);
 
 	free(db, M_CXGBE);
 }
 
 void
 release_ddp_resources(struct toepcb *toep)
 {
 	int i;
 
 	for (i = 0; i < nitems(toep->db); i++) {
 		if (toep->db[i] != NULL) {
 			free_ddp_buffer(toep->td, toep->db[i]);
 			toep->db[i] = NULL;
 		}
 	}
 }
 
 /* XXX: handle_ddp_data code duplication */
 void
 insert_ddp_data(struct toepcb *toep, uint32_t n)
 {
 	struct inpcb *inp = toep->inp;
 	struct tcpcb *tp = intotcpcb(inp);
 	struct sockbuf *sb = &inp->inp_socket->so_rcv;
 	struct mbuf *m;
 
 	INP_WLOCK_ASSERT(inp);
 	SOCKBUF_LOCK_ASSERT(sb);
 
 	m = get_ddp_mbuf(n);
 	tp->rcv_nxt += n;
 #ifndef USE_DDP_RX_FLOW_CONTROL
 	KASSERT(tp->rcv_wnd >= n, ("%s: negative window size", __func__));
 	tp->rcv_wnd -= n;
 #endif
 
 	KASSERT(toep->sb_cc >= sbused(sb),
 	    ("%s: sb %p has more data (%d) than last time (%d).",
 	    __func__, sb, sbused(sb), toep->sb_cc));
 	toep->rx_credits += toep->sb_cc - sbused(sb);
 #ifdef USE_DDP_RX_FLOW_CONTROL
 	toep->rx_credits -= n;	/* adjust for F_RX_FC_DDP */
 #endif
 	sbappendstream_locked(sb, m, 0);
 	toep->sb_cc = sbused(sb);
 }
 
 /* SET_TCB_FIELD sent as a ULP command looks like this */
 #define LEN__SET_TCB_FIELD_ULP (sizeof(struct ulp_txpkt) + \
     sizeof(struct ulptx_idata) + sizeof(struct cpl_set_tcb_field_core))
 
 /* RX_DATA_ACK sent as a ULP command looks like this */
 #define LEN__RX_DATA_ACK_ULP (sizeof(struct ulp_txpkt) + \
     sizeof(struct ulptx_idata) + sizeof(struct cpl_rx_data_ack_core))
 
 static inline void *
 mk_set_tcb_field_ulp(struct ulp_txpkt *ulpmc, struct toepcb *toep,
     uint64_t word, uint64_t mask, uint64_t val)
 {
 	struct ulptx_idata *ulpsc;
 	struct cpl_set_tcb_field_core *req;
 
 	ulpmc->cmd_dest = htonl(V_ULPTX_CMD(ULP_TX_PKT) | V_ULP_TXPKT_DEST(0));
 	ulpmc->len = htobe32(howmany(LEN__SET_TCB_FIELD_ULP, 16));
 
 	ulpsc = (struct ulptx_idata *)(ulpmc + 1);
 	ulpsc->cmd_more = htobe32(V_ULPTX_CMD(ULP_TX_SC_IMM));
 	ulpsc->len = htobe32(sizeof(*req));
 
 	req = (struct cpl_set_tcb_field_core *)(ulpsc + 1);
 	OPCODE_TID(req) = htobe32(MK_OPCODE_TID(CPL_SET_TCB_FIELD, toep->tid));
 	req->reply_ctrl = htobe16(V_NO_REPLY(1) |
 	    V_QUEUENO(toep->ofld_rxq->iq.abs_id));
 	req->word_cookie = htobe16(V_WORD(word) | V_COOKIE(0));
         req->mask = htobe64(mask);
         req->val = htobe64(val);
 
 	ulpsc = (struct ulptx_idata *)(req + 1);
 	if (LEN__SET_TCB_FIELD_ULP % 16) {
 		ulpsc->cmd_more = htobe32(V_ULPTX_CMD(ULP_TX_SC_NOOP));
 		ulpsc->len = htobe32(0);
 		return (ulpsc + 1);
 	}
 	return (ulpsc);
 }
 
 static inline void *
 mk_rx_data_ack_ulp(struct ulp_txpkt *ulpmc, struct toepcb *toep)
 {
 	struct ulptx_idata *ulpsc;
 	struct cpl_rx_data_ack_core *req;
 
 	ulpmc->cmd_dest = htonl(V_ULPTX_CMD(ULP_TX_PKT) | V_ULP_TXPKT_DEST(0));
 	ulpmc->len = htobe32(howmany(LEN__RX_DATA_ACK_ULP, 16));
 
 	ulpsc = (struct ulptx_idata *)(ulpmc + 1);
 	ulpsc->cmd_more = htobe32(V_ULPTX_CMD(ULP_TX_SC_IMM));
 	ulpsc->len = htobe32(sizeof(*req));
 
 	req = (struct cpl_rx_data_ack_core *)(ulpsc + 1);
 	OPCODE_TID(req) = htobe32(MK_OPCODE_TID(CPL_RX_DATA_ACK, toep->tid));
 	req->credit_dack = htobe32(F_RX_MODULATE_RX);
 
 	ulpsc = (struct ulptx_idata *)(req + 1);
 	if (LEN__RX_DATA_ACK_ULP % 16) {
 		ulpsc->cmd_more = htobe32(V_ULPTX_CMD(ULP_TX_SC_NOOP));
 		ulpsc->len = htobe32(0);
 		return (ulpsc + 1);
 	}
 	return (ulpsc);
 }
 
 static inline uint64_t
 select_ddp_flags(struct socket *so, int flags, int db_idx)
 {
 	uint64_t ddp_flags = V_TF_DDP_INDICATE_OUT(0);
 	int waitall = flags & MSG_WAITALL;
 	int nb = so->so_state & SS_NBIO || flags & (MSG_DONTWAIT | MSG_NBIO);
 
 	KASSERT(db_idx == 0 || db_idx == 1,
 	    ("%s: bad DDP buffer index %d", __func__, db_idx));
 
 	if (db_idx == 0) {
 		ddp_flags |= V_TF_DDP_BUF0_VALID(1) | V_TF_DDP_ACTIVE_BUF(0);
 		if (waitall)
 			ddp_flags |= V_TF_DDP_PUSH_DISABLE_0(1);
 		else if (nb)
 			ddp_flags |= V_TF_DDP_BUF0_FLUSH(1);
 		else
 			ddp_flags |= V_TF_DDP_BUF0_FLUSH(0);
 	} else {
 		ddp_flags |= V_TF_DDP_BUF1_VALID(1) | V_TF_DDP_ACTIVE_BUF(1);
 		if (waitall)
 			ddp_flags |= V_TF_DDP_PUSH_DISABLE_1(1);
 		else if (nb)
 			ddp_flags |= V_TF_DDP_BUF1_FLUSH(1);
 		else
 			ddp_flags |= V_TF_DDP_BUF1_FLUSH(0);
 	}
 
 	return (ddp_flags);
 }
 
 static struct wrqe *
 mk_update_tcb_for_ddp(struct adapter *sc, struct toepcb *toep, int db_idx,
     int offset, uint64_t ddp_flags)
 {
 	struct ddp_buffer *db = toep->db[db_idx];
 	struct wrqe *wr;
 	struct work_request_hdr *wrh;
 	struct ulp_txpkt *ulpmc;
 	int len;
 
 	KASSERT(db_idx == 0 || db_idx == 1,
 	    ("%s: bad DDP buffer index %d", __func__, db_idx));
 
 	/*
 	 * We'll send a compound work request that has 3 SET_TCB_FIELDs and an
 	 * RX_DATA_ACK (with RX_MODULATE to speed up delivery).
 	 *
 	 * The work request header is 16B and always ends at a 16B boundary.
 	 * The ULPTX master commands that follow must all end at 16B boundaries
 	 * too so we round up the size to 16.
 	 */
 	len = sizeof(*wrh) + 3 * roundup2(LEN__SET_TCB_FIELD_ULP, 16) +
 	    roundup2(LEN__RX_DATA_ACK_ULP, 16);
 
 	wr = alloc_wrqe(len, toep->ctrlq);
 	if (wr == NULL)
 		return (NULL);
 	wrh = wrtod(wr);
 	INIT_ULPTX_WRH(wrh, len, 1, 0);	/* atomic */
 	ulpmc = (struct ulp_txpkt *)(wrh + 1);
 
 	/* Write the buffer's tag */
 	ulpmc = mk_set_tcb_field_ulp(ulpmc, toep,
 	    W_TCB_RX_DDP_BUF0_TAG + db_idx,
 	    V_TCB_RX_DDP_BUF0_TAG(M_TCB_RX_DDP_BUF0_TAG),
 	    V_TCB_RX_DDP_BUF0_TAG(db->tag));
 
 	/* Update the current offset in the DDP buffer and its total length */
 	if (db_idx == 0)
 		ulpmc = mk_set_tcb_field_ulp(ulpmc, toep,
 		    W_TCB_RX_DDP_BUF0_OFFSET,
 		    V_TCB_RX_DDP_BUF0_OFFSET(M_TCB_RX_DDP_BUF0_OFFSET) |
 		    V_TCB_RX_DDP_BUF0_LEN(M_TCB_RX_DDP_BUF0_LEN),
 		    V_TCB_RX_DDP_BUF0_OFFSET(offset) |
 		    V_TCB_RX_DDP_BUF0_LEN(db->len));
 	else
 		ulpmc = mk_set_tcb_field_ulp(ulpmc, toep,
 		    W_TCB_RX_DDP_BUF1_OFFSET,
 		    V_TCB_RX_DDP_BUF1_OFFSET(M_TCB_RX_DDP_BUF1_OFFSET) |
 		    V_TCB_RX_DDP_BUF1_LEN((u64)M_TCB_RX_DDP_BUF1_LEN << 32),
 		    V_TCB_RX_DDP_BUF1_OFFSET(offset) |
 		    V_TCB_RX_DDP_BUF1_LEN((u64)db->len << 32));
 
 	/* Update DDP flags */
 	ulpmc = mk_set_tcb_field_ulp(ulpmc, toep, W_TCB_RX_DDP_FLAGS,
 	    V_TF_DDP_BUF0_FLUSH(1) | V_TF_DDP_BUF1_FLUSH(1) |
 	    V_TF_DDP_PUSH_DISABLE_0(1) | V_TF_DDP_PUSH_DISABLE_1(1) |
 	    V_TF_DDP_BUF0_VALID(1) | V_TF_DDP_BUF1_VALID(1) |
 	    V_TF_DDP_ACTIVE_BUF(1) | V_TF_DDP_INDICATE_OUT(1), ddp_flags);
 
 	/* Gratuitous RX_DATA_ACK with RX_MODULATE set to speed up delivery. */
 	ulpmc = mk_rx_data_ack_ulp(ulpmc, toep);
 
 	return (wr);
 }
 
 static void
 discourage_ddp(struct toepcb *toep)
 {
 
 	if (toep->ddp_score && --toep->ddp_score == 0) {
 		toep->ddp_flags &= ~DDP_OK;
 		toep->ddp_disabled = time_uptime;
 		CTR3(KTR_CXGBE, "%s: tid %u !DDP_OK @ %u",
 		    __func__, toep->tid, time_uptime);
 	}
 }
 
 static int
 handle_ddp_data(struct toepcb *toep, __be32 ddp_report, __be32 rcv_nxt, int len)
 {
 	uint32_t report = be32toh(ddp_report);
 	unsigned int db_flag;
 	struct inpcb *inp = toep->inp;
 	struct tcpcb *tp;
 	struct socket *so;
 	struct sockbuf *sb;
 	struct mbuf *m;
 
 	db_flag = report & F_DDP_BUF_IDX ? DDP_BUF1_ACTIVE : DDP_BUF0_ACTIVE;
 
 	if (__predict_false(!(report & F_DDP_INV)))
 		CXGBE_UNIMPLEMENTED("DDP buffer still valid");
 
 	INP_WLOCK(inp);
 	so = inp_inpcbtosocket(inp);
 	sb = &so->so_rcv;
 	if (__predict_false(inp->inp_flags & (INP_DROPPED | INP_TIMEWAIT))) {
 
 		/*
 		 * XXX: think a bit more.
 		 * tcpcb probably gone, but socket should still be around
 		 * because we always wait for DDP completion in soreceive no
 		 * matter what.  Just wake it up and let it clean up.
 		 */
 
 		CTR5(KTR_CXGBE, "%s: tid %u, seq 0x%x, len %d, inp_flags 0x%x",
 		    __func__, toep->tid, be32toh(rcv_nxt), len, inp->inp_flags);
 		SOCKBUF_LOCK(sb);
 		goto wakeup;
 	}
 
 	tp = intotcpcb(inp);
 	len += be32toh(rcv_nxt) - tp->rcv_nxt;
 	tp->rcv_nxt += len;
 	tp->t_rcvtime = ticks;
 #ifndef USE_DDP_RX_FLOW_CONTROL
 	KASSERT(tp->rcv_wnd >= len, ("%s: negative window size", __func__));
 	tp->rcv_wnd -= len;
 #endif
 	m = get_ddp_mbuf(len);
 
 	SOCKBUF_LOCK(sb);
 	if (report & F_DDP_BUF_COMPLETE)
 		toep->ddp_score = DDP_HIGH_SCORE;
 	else
 		discourage_ddp(toep);
 
 	KASSERT(toep->sb_cc >= sbused(sb),
 	    ("%s: sb %p has more data (%d) than last time (%d).",
 	    __func__, sb, sbused(sb), toep->sb_cc));
 	toep->rx_credits += toep->sb_cc - sbused(sb);
 #ifdef USE_DDP_RX_FLOW_CONTROL
 	toep->rx_credits -= len;	/* adjust for F_RX_FC_DDP */
 #endif
 	sbappendstream_locked(sb, m, 0);
 	toep->sb_cc = sbused(sb);
 wakeup:
 	KASSERT(toep->ddp_flags & db_flag,
 	    ("%s: DDP buffer not active. toep %p, ddp_flags 0x%x, report 0x%x",
 	    __func__, toep, toep->ddp_flags, report));
 	toep->ddp_flags &= ~db_flag;
 	sorwakeup_locked(so);
 	SOCKBUF_UNLOCK_ASSERT(sb);
 
 	INP_WUNLOCK(inp);
 	return (0);
 }
 
 #define DDP_ERR (F_DDP_PPOD_MISMATCH | F_DDP_LLIMIT_ERR | F_DDP_ULIMIT_ERR |\
 	 F_DDP_PPOD_PARITY_ERR | F_DDP_PADDING_ERR | F_DDP_OFFSET_ERR |\
 	 F_DDP_INVALID_TAG | F_DDP_COLOR_ERR | F_DDP_TID_MISMATCH |\
 	 F_DDP_INVALID_PPOD | F_DDP_HDRCRC_ERR | F_DDP_DATACRC_ERR)
 
 static int
 do_rx_data_ddp(struct sge_iq *iq, const struct rss_header *rss, struct mbuf *m)
 {
 	struct adapter *sc = iq->adapter;
 	const struct cpl_rx_data_ddp *cpl = (const void *)(rss + 1);
 	unsigned int tid = GET_TID(cpl);
 	uint32_t vld;
 	struct toepcb *toep = lookup_tid(sc, tid);
 	struct tom_data *td = toep->td;
 
 	KASSERT(m == NULL, ("%s: wasn't expecting payload", __func__));
 	KASSERT(toep->tid == tid, ("%s: toep tid/atid mismatch", __func__));
 	KASSERT(!(toep->flags & TPF_SYNQE),
 	    ("%s: toep %p claims to be a synq entry", __func__, toep));
 
 	vld = be32toh(cpl->ddpvld);
 	if (__predict_false(vld & DDP_ERR)) {
 		panic("%s: DDP error 0x%x (tid %d, toep %p)",
 		    __func__, vld, tid, toep);
 	}
 	if (toep->ulp_mode == ULP_MODE_ISCSI) {
 		m = m_get(M_NOWAIT, MT_DATA);
 		if (m == NULL)
 			CXGBE_UNIMPLEMENTED("mbuf alloc failure");
 		memcpy(mtod(m, unsigned char *), cpl,
 		    sizeof(struct cpl_rx_data_ddp));
         	if (!t4_cpl_iscsi_callback(td, toep, m, CPL_RX_DATA_DDP))
 			return (0);
 		m_freem(m);
         }
 
 	handle_ddp_data(toep, cpl->u.ddp_report, cpl->seq, be16toh(cpl->len));
 
 	return (0);
 }
 
 static int
 do_rx_ddp_complete(struct sge_iq *iq, const struct rss_header *rss,
     struct mbuf *m)
 {
 	struct adapter *sc = iq->adapter;
 	const struct cpl_rx_ddp_complete *cpl = (const void *)(rss + 1);
 	unsigned int tid = GET_TID(cpl);
 	struct toepcb *toep = lookup_tid(sc, tid);
 
 	KASSERT(m == NULL, ("%s: wasn't expecting payload", __func__));
 	KASSERT(toep->tid == tid, ("%s: toep tid/atid mismatch", __func__));
 	KASSERT(!(toep->flags & TPF_SYNQE),
 	    ("%s: toep %p claims to be a synq entry", __func__, toep));
 
 	handle_ddp_data(toep, cpl->ddp_report, cpl->rcv_nxt, 0);
 
 	return (0);
 }
 
 void
 enable_ddp(struct adapter *sc, struct toepcb *toep)
 {
 
 	KASSERT((toep->ddp_flags & (DDP_ON | DDP_OK | DDP_SC_REQ)) == DDP_OK,
 	    ("%s: toep %p has bad ddp_flags 0x%x",
 	    __func__, toep, toep->ddp_flags));
 
 	CTR3(KTR_CXGBE, "%s: tid %u (time %u)",
 	    __func__, toep->tid, time_uptime);
 
 	toep->ddp_flags |= DDP_SC_REQ;
 	t4_set_tcb_field(sc, toep, 1, W_TCB_RX_DDP_FLAGS,
 	    V_TF_DDP_OFF(1) | V_TF_DDP_INDICATE_OUT(1) |
 	    V_TF_DDP_BUF0_INDICATE(1) | V_TF_DDP_BUF1_INDICATE(1) |
 	    V_TF_DDP_BUF0_VALID(1) | V_TF_DDP_BUF1_VALID(1),
 	    V_TF_DDP_BUF0_INDICATE(1) | V_TF_DDP_BUF1_INDICATE(1));
 	t4_set_tcb_field(sc, toep, 1, W_TCB_T_FLAGS,
 	    V_TF_RCV_COALESCE_ENABLE(1), 0);
 }
 
 static inline void
 disable_ddp(struct adapter *sc, struct toepcb *toep)
 {
 
 	KASSERT((toep->ddp_flags & (DDP_ON | DDP_SC_REQ)) == DDP_ON,
 	    ("%s: toep %p has bad ddp_flags 0x%x",
 	    __func__, toep, toep->ddp_flags));
 
 	CTR3(KTR_CXGBE, "%s: tid %u (time %u)",
 	    __func__, toep->tid, time_uptime);
 
 	toep->ddp_flags |= DDP_SC_REQ;
 	t4_set_tcb_field(sc, toep, 1, W_TCB_T_FLAGS,
 	    V_TF_RCV_COALESCE_ENABLE(1), V_TF_RCV_COALESCE_ENABLE(1));
 	t4_set_tcb_field(sc, toep, 1, W_TCB_RX_DDP_FLAGS, V_TF_DDP_OFF(1),
 	    V_TF_DDP_OFF(1));
 }
 
 static int
 hold_uio(struct uio *uio, vm_page_t **ppages, int *pnpages)
 {
 	struct vm_map *map;
 	struct iovec *iov;
 	vm_offset_t start, end;
 	vm_page_t *pp;
 	int n;
 
 	KASSERT(uio->uio_iovcnt == 1,
 	    ("%s: uio_iovcnt %d", __func__, uio->uio_iovcnt));
 	KASSERT(uio->uio_td->td_proc == curproc,
 	    ("%s: uio proc (%p) is not curproc (%p)",
 	    __func__, uio->uio_td->td_proc, curproc));
 
 	map = &curproc->p_vmspace->vm_map;
 	iov = &uio->uio_iov[0];
 	start = trunc_page((uintptr_t)iov->iov_base);
 	end = round_page((vm_offset_t)iov->iov_base + iov->iov_len);
 	n = howmany(end - start, PAGE_SIZE);
 
 	if (end - start > MAX_DDP_BUFFER_SIZE)
 		return (E2BIG);
 
 	pp = malloc(n * sizeof(vm_page_t), M_CXGBE, M_NOWAIT);
 	if (pp == NULL)
 		return (ENOMEM);
 
 	if (vm_fault_quick_hold_pages(map, (vm_offset_t)iov->iov_base,
 	    iov->iov_len, VM_PROT_WRITE, pp, n) < 0) {
 		free(pp, M_CXGBE);
 		return (EFAULT);
 	}
 
 	*ppages = pp;
 	*pnpages = n;
 
 	return (0);
 }
 
 static int
 bufcmp(struct ddp_buffer *db, vm_page_t *pages, int npages, int offset, int len)
 {
 	int i;
 
 	if (db == NULL || db->npages != npages || db->offset != offset ||
 	    db->len != len)
 		return (1);
 
 	for (i = 0; i < npages; i++) {
 		if (pages[i]->phys_addr != db->pages[i]->phys_addr)
 			return (1);
 	}
 
 	return (0);
 }
 
 static int
 calculate_hcf(int n1, int n2)
 {
 	int a, b, t;
 
 	if (n1 <= n2) {
 		a = n1;
 		b = n2;
 	} else {
 		a = n2;
 		b = n1;
 	}
 
 	while (a != 0) {
 		t = a;
 		a = b % a;
 		b = t;
 	}
 
 	return (b);
 }
 
 static struct ddp_buffer *
 alloc_ddp_buffer(struct tom_data *td, vm_page_t *pages, int npages, int offset,
     int len)
 {
 	int i, hcf, seglen, idx, ppod, nppods;
 	struct ddp_buffer *db;
 
 	/*
 	 * The DDP page size is unrelated to the VM page size.  We combine
 	 * contiguous physical pages into larger segments to get the best DDP
 	 * page size possible.  This is the largest of the four sizes in
 	 * A_ULP_RX_TDDP_PSZ that evenly divides the HCF of the segment sizes in
 	 * the page list.
 	 */
 	hcf = 0;
 	for (i = 0; i < npages; i++) {
 		seglen = PAGE_SIZE;
 		while (i < npages - 1 &&
 		    pages[i]->phys_addr + PAGE_SIZE == pages[i + 1]->phys_addr) {
 			seglen += PAGE_SIZE;
 			i++;
 		}
 
 		hcf = calculate_hcf(hcf, seglen);
 		if (hcf < t4_ddp_pgsz[1]) {
 			idx = 0;
 			goto have_pgsz;	/* give up, short circuit */
 		}
 	}
 
 	if (hcf % t4_ddp_pgsz[0] != 0) {
 		/* hmmm.  This could only happen when PAGE_SIZE < 4K */
 		KASSERT(PAGE_SIZE < 4096,
 		    ("%s: PAGE_SIZE %d, hcf %d", __func__, PAGE_SIZE, hcf));
 		CTR3(KTR_CXGBE, "%s: PAGE_SIZE %d, hcf %d",
 		    __func__, PAGE_SIZE, hcf);
 		return (NULL);
 	}
 
 	for (idx = nitems(t4_ddp_pgsz) - 1; idx > 0; idx--) {
 		if (hcf % t4_ddp_pgsz[idx] == 0)
 			break;
 	}
 have_pgsz:
 	MPASS(idx <= M_PPOD_PGSZ);
 
 	db = malloc(sizeof(*db), M_CXGBE, M_NOWAIT);
 	if (db == NULL) {
 		CTR1(KTR_CXGBE, "%s: malloc failed.", __func__);
 		return (NULL);
 	}
 
 	nppods = pages_to_nppods(npages, t4_ddp_pgsz[idx]);
 	if (alloc_ppods(td, nppods, &db->ppod_addr) != 0) {
 		free(db, M_CXGBE);
 		CTR4(KTR_CXGBE, "%s: no pods, nppods %d, resid %d, pgsz %d",
 		    __func__, nppods, len, t4_ddp_pgsz[idx]);
 		return (NULL);
 	}
 	ppod = (db->ppod_addr - td->ppod_start) / PPOD_SIZE;
 
 	db->tag = V_PPOD_PGSZ(idx) | V_PPOD_TAG(ppod);
 	db->nppods = nppods;
 	db->npages = npages;
 	db->pages = pages;
 	db->offset = offset;
 	db->len = len;
 
 	CTR6(KTR_CXGBE, "New DDP buffer.  "
 	    "ddp_pgsz %d, ppod 0x%x, npages %d, nppods %d, offset %d, len %d",
 	    t4_ddp_pgsz[idx], ppod, db->npages, db->nppods, db->offset,
 	    db->len);
 
 	return (db);
 }
 
 #define NUM_ULP_TX_SC_IMM_PPODS (256 / PPOD_SIZE)
 
 static int
 write_page_pods(struct adapter *sc, struct toepcb *toep, struct ddp_buffer *db)
 {
 	struct wrqe *wr;
 	struct ulp_mem_io *ulpmc;
 	struct ulptx_idata *ulpsc;
 	struct pagepod *ppod;
 	int i, j, k, n, chunk, len, ddp_pgsz, idx;
 	u_int ppod_addr;
 	uint32_t cmd;
 
 	cmd = htobe32(V_ULPTX_CMD(ULP_TX_MEM_WRITE));
 	if (is_t4(sc))
 		cmd |= htobe32(F_ULP_MEMIO_ORDER);
 	else
 		cmd |= htobe32(F_T5_ULP_MEMIO_IMM);
 	ddp_pgsz = t4_ddp_pgsz[G_PPOD_PGSZ(db->tag)];
 	ppod_addr = db->ppod_addr;
 	for (i = 0; i < db->nppods; ppod_addr += chunk) {
 
 		/* How many page pods are we writing in this cycle */
 		n = min(db->nppods - i, NUM_ULP_TX_SC_IMM_PPODS);
 		chunk = PPOD_SZ(n);
 		len = roundup2(sizeof(*ulpmc) + sizeof(*ulpsc) + chunk, 16);
 
 		wr = alloc_wrqe(len, toep->ctrlq);
 		if (wr == NULL)
 			return (ENOMEM);	/* ok to just bail out */
 		ulpmc = wrtod(wr);
 
 		INIT_ULPTX_WR(ulpmc, len, 0, 0);
 		ulpmc->cmd = cmd;
 		ulpmc->dlen = htobe32(V_ULP_MEMIO_DATA_LEN(chunk / 32));
 		ulpmc->len16 = htobe32(howmany(len - sizeof(ulpmc->wr), 16));
 		ulpmc->lock_addr = htobe32(V_ULP_MEMIO_ADDR(ppod_addr >> 5));
 
 		ulpsc = (struct ulptx_idata *)(ulpmc + 1);
 		ulpsc->cmd_more = htobe32(V_ULPTX_CMD(ULP_TX_SC_IMM));
 		ulpsc->len = htobe32(chunk);
 
 		ppod = (struct pagepod *)(ulpsc + 1);
 		for (j = 0; j < n; i++, j++, ppod++) {
 			ppod->vld_tid_pgsz_tag_color = htobe64(F_PPOD_VALID |
 			    V_PPOD_TID(toep->tid) | db->tag);
 			ppod->len_offset = htobe64(V_PPOD_LEN(db->len) |
 			    V_PPOD_OFST(db->offset));
 			ppod->rsvd = 0;
 			idx = i * PPOD_PAGES * (ddp_pgsz / PAGE_SIZE);
 			for (k = 0; k < nitems(ppod->addr); k++) {
 				if (idx < db->npages) {
 					ppod->addr[k] =
 					    htobe64(db->pages[idx]->phys_addr);
 					idx += ddp_pgsz / PAGE_SIZE;
 				} else
 					ppod->addr[k] = 0;
 #if 0
 				CTR5(KTR_CXGBE,
 				    "%s: tid %d ppod[%d]->addr[%d] = %p",
 				    __func__, toep->tid, i, k,
 				    htobe64(ppod->addr[k]));
 #endif
 			}
 
 		}
 
 		t4_wrq_tx(sc, wr);
 	}
 
 	return (0);
 }
 
 /*
  * Reuse, or allocate (and program the page pods for) a new DDP buffer.  The
  * "pages" array is handed over to this function and should not be used in any
  * way by the caller after that.
  */
 static int
 select_ddp_buffer(struct adapter *sc, struct toepcb *toep, vm_page_t *pages,
     int npages, int db_off, int db_len)
 {
 	struct ddp_buffer *db;
 	struct tom_data *td = sc->tom_softc;
 	int i, empty_slot = -1;
 
 	/* Try to reuse */
 	for (i = 0; i < nitems(toep->db); i++) {
 		if (bufcmp(toep->db[i], pages, npages, db_off, db_len) == 0) {
 			free(pages, M_CXGBE);
 			return (i);	/* pages still held */
 		} else if (toep->db[i] == NULL && empty_slot < 0)
 			empty_slot = i;
 	}
 
 	/* Allocate new buffer, write its page pods. */
 	db = alloc_ddp_buffer(td, pages, npages, db_off, db_len);
 	if (db == NULL) {
 		vm_page_unhold_pages(pages, npages);
 		free(pages, M_CXGBE);
 		return (-1);
 	}
 	if (write_page_pods(sc, toep, db) != 0) {
 		vm_page_unhold_pages(pages, npages);
 		free_ddp_buffer(td, db);
 		return (-1);
 	}
 
 	i = empty_slot;
 	if (i < 0) {
 		i = arc4random() % nitems(toep->db);
 		free_ddp_buffer(td, toep->db[i]);
 	}
 	toep->db[i] = db;
 
 	CTR5(KTR_CXGBE, "%s: tid %d, DDP buffer[%d] = %p (tag 0x%x)",
 	    __func__, toep->tid, i, db, db->tag);
 
 	return (i);
 }
 
 static void
 wire_ddp_buffer(struct ddp_buffer *db)
 {
 	int i;
 	vm_page_t p;
 
 	for (i = 0; i < db->npages; i++) {
 		p = db->pages[i];
 		vm_page_lock(p);
 		vm_page_wire(p);
 		vm_page_unhold(p);
 		vm_page_unlock(p);
 	}
 }
 
 static void
 unwire_ddp_buffer(struct ddp_buffer *db)
 {
 	int i;
 	vm_page_t p;
 
 	for (i = 0; i < db->npages; i++) {
 		p = db->pages[i];
 		vm_page_lock(p);
 		vm_page_unwire(p, PQ_INACTIVE);
 		vm_page_unlock(p);
 	}
 }
 
 static int
 handle_ddp(struct socket *so, struct uio *uio, int flags, int error)
 {
 	struct sockbuf *sb = &so->so_rcv;
 	struct tcpcb *tp = so_sototcpcb(so);
 	struct toepcb *toep = tp->t_toe;
 	struct adapter *sc = td_adapter(toep->td);
 	vm_page_t *pages;
 	int npages, db_idx, rc, buf_flag;
 	struct ddp_buffer *db;
 	struct wrqe *wr;
 	uint64_t ddp_flags;
 
 	SOCKBUF_LOCK_ASSERT(sb);
 
 #if 0
-	if (sb->sb_cc + sc->tt.ddp_thres > uio->uio_resid) {
+	if (sbused(sb) + sc->tt.ddp_thres > uio->uio_resid) {
 		CTR4(KTR_CXGBE, "%s: sb_cc %d, threshold %d, resid %d",
-		    __func__, sb->sb_cc, sc->tt.ddp_thres, uio->uio_resid);
+		    __func__, sbused(sb), sc->tt.ddp_thres, uio->uio_resid);
 	}
 #endif
 
 	/* XXX: too eager to disable DDP, could handle NBIO better than this. */
 	if (sbused(sb) >= uio->uio_resid || uio->uio_resid < sc->tt.ddp_thres ||
 	    uio->uio_resid > MAX_DDP_BUFFER_SIZE || uio->uio_iovcnt > 1 ||
 	    so->so_state & SS_NBIO || flags & (MSG_DONTWAIT | MSG_NBIO) ||
 	    error || so->so_error || sb->sb_state & SBS_CANTRCVMORE)
 		goto no_ddp;
 
 	/*
 	 * Fault in and then hold the pages of the uio buffers.  We'll wire them
 	 * a bit later if everything else works out.
 	 */
 	SOCKBUF_UNLOCK(sb);
 	if (hold_uio(uio, &pages, &npages) != 0) {
 		SOCKBUF_LOCK(sb);
 		goto no_ddp;
 	}
 	SOCKBUF_LOCK(sb);
 	if (__predict_false(so->so_error || sb->sb_state & SBS_CANTRCVMORE)) {
 		vm_page_unhold_pages(pages, npages);
 		free(pages, M_CXGBE);
 		goto no_ddp;
 	}
 
 	/*
 	 * Figure out which one of the two DDP buffers to use this time.
 	 */
 	db_idx = select_ddp_buffer(sc, toep, pages, npages,
 	    (uintptr_t)uio->uio_iov->iov_base & PAGE_MASK, uio->uio_resid);
 	pages = NULL;	/* handed off to select_ddp_buffer */
 	if (db_idx < 0)
 		goto no_ddp;
 	db = toep->db[db_idx];
 	buf_flag = db_idx == 0 ? DDP_BUF0_ACTIVE : DDP_BUF1_ACTIVE;
 
 	/*
 	 * Build the compound work request that tells the chip where to DMA the
 	 * payload.
 	 */
 	ddp_flags = select_ddp_flags(so, flags, db_idx);
 	wr = mk_update_tcb_for_ddp(sc, toep, db_idx, sbused(sb), ddp_flags);
 	if (wr == NULL) {
 		/*
 		 * Just unhold the pages.  The DDP buffer's software state is
 		 * left as-is in the toep.  The page pods were written
 		 * successfully and we may have an opportunity to use it in the
 		 * future.
 		 */
 		vm_page_unhold_pages(db->pages, db->npages);
 		goto no_ddp;
 	}
 
 	/* Wire (and then unhold) the pages, and give the chip the go-ahead. */
 	wire_ddp_buffer(db);
 	t4_wrq_tx(sc, wr);
 	sb->sb_flags &= ~SB_DDP_INDICATE;
 	toep->ddp_flags |= buf_flag;
 
 	/*
 	 * Wait for the DDP operation to complete and then unwire the pages.
 	 * The return code from the sbwait will be the final return code of this
 	 * function.  But we do need to wait for DDP no matter what.
 	 */
 	rc = sbwait(sb);
 	while (toep->ddp_flags & buf_flag) {
 		/* XXXGL: shouldn't here be sbwait() call? */
 		sb->sb_flags |= SB_WAIT;
 		msleep(&sb->sb_acc, &sb->sb_mtx, PSOCK , "sbwait", 0);
 	}
 	unwire_ddp_buffer(db);
 	return (rc);
 no_ddp:
 	disable_ddp(sc, toep);
 	discourage_ddp(toep);
 	sb->sb_flags &= ~SB_DDP_INDICATE;
 	return (0);
 }
 
 void
 t4_init_ddp(struct adapter *sc, struct tom_data *td)
 {
 
 	td->ppod_start = sc->vres.ddp.start;
 	td->ppod_arena = vmem_create("DDP page pods", sc->vres.ddp.start,
 	    sc->vres.ddp.size, 1, 32, M_FIRSTFIT | M_NOWAIT);
 
 	t4_register_cpl_handler(sc, CPL_RX_DATA_DDP, do_rx_data_ddp);
 	t4_register_cpl_handler(sc, CPL_RX_DDP_COMPLETE, do_rx_ddp_complete);
 }
 
 void
 t4_uninit_ddp(struct adapter *sc __unused, struct tom_data *td)
 {
 
 	if (td->ppod_arena != NULL) {
 		vmem_destroy(td->ppod_arena);
 		td->ppod_arena = NULL;
 	}
 }
 
 #define	VNET_SO_ASSERT(so)						\
 	VNET_ASSERT(curvnet != NULL,					\
 	    ("%s:%d curvnet is NULL, so=%p", __func__, __LINE__, (so)));
 #define	SBLOCKWAIT(f)	(((f) & MSG_DONTWAIT) ? 0 : SBL_WAIT)
 static int
 soreceive_rcvoob(struct socket *so, struct uio *uio, int flags)
 {
 
 	CXGBE_UNIMPLEMENTED(__func__);
 }
 
 static char ddp_magic_str[] = "nothing to see here";
 
 struct mbuf *
 get_ddp_mbuf(int len)
 {
 	struct mbuf *m;
 
 	m = m_get(M_NOWAIT, MT_DATA);
 	if (m == NULL)
 		CXGBE_UNIMPLEMENTED("mbuf alloc failure");
 	m->m_len = len;
 	m->m_data = &ddp_magic_str[0];
 
 	return (m);
 }
 
 static inline int
 is_ddp_mbuf(struct mbuf *m)
 {
 
 	return (m->m_data == &ddp_magic_str[0]);
 }
 
 /*
  * Copy an mbuf chain into a uio limited by len if set.
  */
 static int
 m_mbuftouio_ddp(struct uio *uio, struct mbuf *m, int len)
 {
 	int error, length, total;
 	int progress = 0;
 
 	if (len > 0)
 		total = min(uio->uio_resid, len);
 	else
 		total = uio->uio_resid;
 
 	/* Fill the uio with data from the mbufs. */
 	for (; m != NULL; m = m->m_next) {
 		length = min(m->m_len, total - progress);
 
 		if (is_ddp_mbuf(m)) {
 			enum uio_seg segflag = uio->uio_segflg;
 
 			uio->uio_segflg	= UIO_NOCOPY;
 			error = uiomove(mtod(m, void *), length, uio);
 			uio->uio_segflg	= segflag;
 		} else
 			error = uiomove(mtod(m, void *), length, uio);
 		if (error)
 			return (error);
 
 		progress += length;
 	}
 
 	return (0);
 }
 
 /*
  * Based on soreceive_stream() in uipc_socket.c
  */
 int
 t4_soreceive_ddp(struct socket *so, struct sockaddr **psa, struct uio *uio,
     struct mbuf **mp0, struct mbuf **controlp, int *flagsp)
 {
 	int len = 0, error = 0, flags, oresid, ddp_handled = 0;
 	struct sockbuf *sb;
 	struct mbuf *m, *n = NULL;
 
 	/* We only do stream sockets. */
 	if (so->so_type != SOCK_STREAM)
 		return (EINVAL);
 	if (psa != NULL)
 		*psa = NULL;
 	if (controlp != NULL)
 		return (EINVAL);
 	if (flagsp != NULL)
 		flags = *flagsp &~ MSG_EOR;
 	else
 		flags = 0;
 	if (flags & MSG_OOB)
 		return (soreceive_rcvoob(so, uio, flags));
 	if (mp0 != NULL)
 		*mp0 = NULL;
 
 	sb = &so->so_rcv;
 
 	/* Prevent other readers from entering the socket. */
 	error = sblock(sb, SBLOCKWAIT(flags));
+	SOCKBUF_LOCK(sb);
 	if (error)
 		goto out;
-	SOCKBUF_LOCK(sb);
 
 	/* Easy one, no space to copyout anything. */
 	if (uio->uio_resid == 0) {
 		error = EINVAL;
 		goto out;
 	}
 	oresid = uio->uio_resid;
 
 	/* We will never ever get anything unless we are or were connected. */
 	if (!(so->so_state & (SS_ISCONNECTED|SS_ISDISCONNECTED))) {
 		error = ENOTCONN;
 		goto out;
 	}
 
 restart:
 	SOCKBUF_LOCK_ASSERT(&so->so_rcv);
 
 	if (sb->sb_flags & SB_DDP_INDICATE && !ddp_handled) {
 
 		/* uio should be just as it was at entry */
 		KASSERT(oresid == uio->uio_resid,
-		    ("%s: oresid = %d, uio_resid = %zd, sbused = %d",
-		    __func__, oresid, uio->uio_resid, sbused(sb)));
+		    ("%s: oresid = %d, uio_resid = %zd, sbavail = %d",
+		    __func__, oresid, uio->uio_resid, sbavail(sb)));
 
 		error = handle_ddp(so, uio, flags, 0);
 		ddp_handled = 1;
 		if (error)
 			goto out;
 	}
 
 	/* Abort if socket has reported problems. */
 	if (so->so_error) {
-		if (sbused(sb))
+		if (sbavail(sb))
 			goto deliver;
 		if (oresid > uio->uio_resid)
 			goto out;
 		error = so->so_error;
 		if (!(flags & MSG_PEEK))
 			so->so_error = 0;
 		goto out;
 	}
 
 	/* Door is closed.  Deliver what is left, if any. */
 	if (sb->sb_state & SBS_CANTRCVMORE) {
-		if (sbused(sb))
+		if (sbavail(sb))
 			goto deliver;
 		else
 			goto out;
 	}
 
 	/* Socket buffer is empty and we shall not block. */
-	if (sbused(sb) == 0 &&
+	if (sbavail(sb) == 0 &&
 	    ((so->so_state & SS_NBIO) || (flags & (MSG_DONTWAIT|MSG_NBIO)))) {
 		error = EAGAIN;
 		goto out;
 	}
 
 	/* Socket buffer got some data that we shall deliver now. */
-	if (sbused(sb) && !(flags & MSG_WAITALL) &&
+	if (sbavail(sb) > 0 && !(flags & MSG_WAITALL) &&
 	    ((so->so_state & SS_NBIO) ||
 	     (flags & (MSG_DONTWAIT|MSG_NBIO)) ||
-	     sbused(sb) >= sb->sb_lowat ||
-	     sbused(sb) >= uio->uio_resid ||
-	     sbused(sb) >= sb->sb_hiwat) ) {
+	     sbavail(sb) >= sb->sb_lowat ||
+	     sbavail(sb) >= uio->uio_resid ||
+	     sbavail(sb) >= sb->sb_hiwat) ) {
 		goto deliver;
 	}
 
 	/* On MSG_WAITALL we must wait until all data or error arrives. */
 	if ((flags & MSG_WAITALL) &&
-	    (sbused(sb) >= uio->uio_resid || sbused(sb) >= sb->sb_lowat))
+	    (sbavail(sb) >= uio->uio_resid || sbavail(sb) >= sb->sb_lowat))
 		goto deliver;
 
 	/*
 	 * Wait and block until (more) data comes in.
 	 * NB: Drops the sockbuf lock during wait.
 	 */
 	error = sbwait(sb);
 	if (error) {
 		if (sb->sb_flags & SB_DDP_INDICATE && !ddp_handled) {
 			(void) handle_ddp(so, uio, flags, 1);
 			ddp_handled = 1;
 		}
 		goto out;
 	}
 	goto restart;
 
 deliver:
 	SOCKBUF_LOCK_ASSERT(&so->so_rcv);
-	KASSERT(sbused(sb) > 0, ("%s: sockbuf empty", __func__));
+	KASSERT(sbavail(sb) > 0, ("%s: sockbuf empty", __func__));
 	KASSERT(sb->sb_mb != NULL, ("%s: sb_mb == NULL", __func__));
 
 	if (sb->sb_flags & SB_DDP_INDICATE && !ddp_handled)
 		goto restart;
 
 	/* Statistics. */
 	if (uio->uio_td)
 		uio->uio_td->td_ru.ru_msgrcv++;
 
 	/* Fill uio until full or current end of socket buffer is reached. */
-	len = min(uio->uio_resid, sbused(sb));
+	len = min(uio->uio_resid, sbavail(sb));
 	if (mp0 != NULL) {
 		/* Dequeue as many mbufs as possible. */
 		if (!(flags & MSG_PEEK) && len >= sb->sb_mb->m_len) {
 			for (*mp0 = m = sb->sb_mb;
 			     m != NULL && m->m_len <= len;
 			     m = m->m_next) {
 				len -= m->m_len;
 				uio->uio_resid -= m->m_len;
 				sbfree(sb, m);
 				n = m;
 			}
 			sb->sb_mb = m;
 			if (sb->sb_mb == NULL)
 				SB_EMPTY_FIXUP(sb);
 			n->m_next = NULL;
 		}
 		/* Copy the remainder. */
 		if (len > 0) {
 			KASSERT(sb->sb_mb != NULL,
 			    ("%s: len > 0 && sb->sb_mb empty", __func__));
 
 			m = m_copym(sb->sb_mb, 0, len, M_NOWAIT);
 			if (m == NULL)
 				len = 0;	/* Don't flush data from sockbuf. */
 			else
 				uio->uio_resid -= m->m_len;
 			if (*mp0 != NULL)
 				n->m_next = m;
 			else
 				*mp0 = m;
 			if (*mp0 == NULL) {
 				error = ENOBUFS;
 				goto out;
 			}
 		}
 	} else {
 		/* NB: Must unlock socket buffer as uiomove may sleep. */
 		SOCKBUF_UNLOCK(sb);
 		error = m_mbuftouio_ddp(uio, sb->sb_mb, len);
 		SOCKBUF_LOCK(sb);
 		if (error)
 			goto out;
 	}
 	SBLASTRECORDCHK(sb);
 	SBLASTMBUFCHK(sb);
 
 	/*
 	 * Remove the delivered data from the socket buffer unless we
 	 * were only peeking.
 	 */
 	if (!(flags & MSG_PEEK)) {
 		if (len > 0)
 			sbdrop_locked(sb, len);
 
 		/* Notify protocol that we drained some data. */
 		if ((so->so_proto->pr_flags & PR_WANTRCVD) &&
 		    (((flags & MSG_WAITALL) && uio->uio_resid > 0) ||
 		     !(flags & MSG_SOCALLBCK))) {
 			SOCKBUF_UNLOCK(sb);
 			VNET_SO_ASSERT(so);
 			(*so->so_proto->pr_usrreqs->pru_rcvd)(so, flags);
 			SOCKBUF_LOCK(sb);
 		}
 	}
 
 	/*
 	 * For MSG_WAITALL we may have to loop again and wait for
 	 * more data to come in.
 	 */
 	if ((flags & MSG_WAITALL) && uio->uio_resid > 0)
 		goto restart;
 out:
 	SOCKBUF_LOCK_ASSERT(sb);
 	SBLASTRECORDCHK(sb);
 	SBLASTMBUFCHK(sb);
 	SOCKBUF_UNLOCK(sb);
 	sbunlock(sb);
 	return (error);
 }
 
 #endif
Index: projects/clang360-import/sys/kern/kern_timeout.c
===================================================================
--- projects/clang360-import/sys/kern/kern_timeout.c	(revision 277777)
+++ projects/clang360-import/sys/kern/kern_timeout.c	(revision 277778)
@@ -1,1475 +1,1479 @@
 /*-
  * Copyright (c) 1982, 1986, 1991, 1993
  *	The Regents of the University of California.  All rights reserved.
  * (c) UNIX System Laboratories, Inc.
  * All or some portions of this file are derived from material licensed
  * to the University of California by American Telephone and Telegraph
  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  * the permission of UNIX System Laboratories, Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
  *	From: @(#)kern_clock.c	8.5 (Berkeley) 1/21/94
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include "opt_callout_profiling.h"
 #if defined(__arm__)
 #include "opt_timer.h"
 #endif
 #include "opt_rss.h"
 
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/bus.h>
 #include <sys/callout.h>
 #include <sys/file.h>
 #include <sys/interrupt.h>
 #include <sys/kernel.h>
 #include <sys/ktr.h>
 #include <sys/lock.h>
 #include <sys/malloc.h>
 #include <sys/mutex.h>
 #include <sys/proc.h>
 #include <sys/sdt.h>
 #include <sys/sleepqueue.h>
 #include <sys/sysctl.h>
 #include <sys/smp.h>
 
 #ifdef SMP
 #include <machine/cpu.h>
 #endif
 
 #ifndef NO_EVENTTIMERS
 DPCPU_DECLARE(sbintime_t, hardclocktime);
 #endif
 
 SDT_PROVIDER_DEFINE(callout_execute);
 SDT_PROBE_DEFINE1(callout_execute, kernel, , callout__start,
     "struct callout *");
 SDT_PROBE_DEFINE1(callout_execute, kernel, , callout__end,
     "struct callout *");
 
 #ifdef CALLOUT_PROFILING
 static int avg_depth;
 SYSCTL_INT(_debug, OID_AUTO, to_avg_depth, CTLFLAG_RD, &avg_depth, 0,
     "Average number of items examined per softclock call. Units = 1/1000");
 static int avg_gcalls;
 SYSCTL_INT(_debug, OID_AUTO, to_avg_gcalls, CTLFLAG_RD, &avg_gcalls, 0,
     "Average number of Giant callouts made per softclock call. Units = 1/1000");
 static int avg_lockcalls;
 SYSCTL_INT(_debug, OID_AUTO, to_avg_lockcalls, CTLFLAG_RD, &avg_lockcalls, 0,
     "Average number of lock callouts made per softclock call. Units = 1/1000");
 static int avg_mpcalls;
 SYSCTL_INT(_debug, OID_AUTO, to_avg_mpcalls, CTLFLAG_RD, &avg_mpcalls, 0,
     "Average number of MP callouts made per softclock call. Units = 1/1000");
 static int avg_depth_dir;
 SYSCTL_INT(_debug, OID_AUTO, to_avg_depth_dir, CTLFLAG_RD, &avg_depth_dir, 0,
     "Average number of direct callouts examined per callout_process call. "
     "Units = 1/1000");
 static int avg_lockcalls_dir;
 SYSCTL_INT(_debug, OID_AUTO, to_avg_lockcalls_dir, CTLFLAG_RD,
     &avg_lockcalls_dir, 0, "Average number of lock direct callouts made per "
     "callout_process call. Units = 1/1000");
 static int avg_mpcalls_dir;
 SYSCTL_INT(_debug, OID_AUTO, to_avg_mpcalls_dir, CTLFLAG_RD, &avg_mpcalls_dir,
     0, "Average number of MP direct callouts made per callout_process call. "
     "Units = 1/1000");
 #endif
 
 static int ncallout;
 SYSCTL_INT(_kern, OID_AUTO, ncallout, CTLFLAG_RDTUN | CTLFLAG_NOFETCH, &ncallout, 0,
     "Number of entries in callwheel and size of timeout() preallocation");
 
 #ifdef	RSS
 static int pin_default_swi = 1;
 static int pin_pcpu_swi = 1;
 #else
 static int pin_default_swi = 0;
 static int pin_pcpu_swi = 0;
 #endif
 
 SYSCTL_INT(_kern, OID_AUTO, pin_default_swi, CTLFLAG_RDTUN | CTLFLAG_NOFETCH, &pin_default_swi,
     0, "Pin the default (non-per-cpu) swi (shared with PCPU 0 swi)");
 SYSCTL_INT(_kern, OID_AUTO, pin_pcpu_swi, CTLFLAG_RDTUN | CTLFLAG_NOFETCH, &pin_pcpu_swi,
     0, "Pin the per-CPU swis (except PCPU 0, which is also default");
 
 /*
  * TODO:
  *	allocate more timeout table slots when table overflows.
  */
 u_int callwheelsize, callwheelmask;
 
 /*
  * The callout cpu exec entities represent informations necessary for
  * describing the state of callouts currently running on the CPU and the ones
  * necessary for migrating callouts to the new callout cpu. In particular,
  * the first entry of the array cc_exec_entity holds informations for callout
  * running in SWI thread context, while the second one holds informations
  * for callout running directly from hardware interrupt context.
  * The cached informations are very important for deferring migration when
  * the migrating callout is already running.
  */
 struct cc_exec {
 	struct callout		*cc_next;
 	struct callout		*cc_curr;
 #ifdef SMP
 	void			(*ce_migration_func)(void *);
 	void			*ce_migration_arg;
 	int			ce_migration_cpu;
 	sbintime_t		ce_migration_time;
 	sbintime_t		ce_migration_prec;
 #endif
 	bool			cc_cancel;
 	bool			cc_waiting;
 };
 
 /*
  * There is one struct callout_cpu per cpu, holding all relevant
  * state for the callout processing thread on the individual CPU.
  */
 struct callout_cpu {
 	struct mtx_padalign	cc_lock;
 	struct cc_exec 		cc_exec_entity[2];
 	struct callout		*cc_callout;
 	struct callout_list	*cc_callwheel;
 	struct callout_tailq	cc_expireq;
 	struct callout_slist	cc_callfree;
 	sbintime_t		cc_firstevent;
 	sbintime_t		cc_lastscan;
 	void			*cc_cookie;
 	u_int			cc_bucket;
 	char			cc_ktr_event_name[20];
 };
 
 #define	cc_exec_curr		cc_exec_entity[0].cc_curr
 #define	cc_exec_next		cc_exec_entity[0].cc_next
 #define	cc_exec_cancel		cc_exec_entity[0].cc_cancel
 #define	cc_exec_waiting		cc_exec_entity[0].cc_waiting
 #define	cc_exec_curr_dir	cc_exec_entity[1].cc_curr
 #define	cc_exec_next_dir	cc_exec_entity[1].cc_next
 #define	cc_exec_cancel_dir	cc_exec_entity[1].cc_cancel
 #define	cc_exec_waiting_dir	cc_exec_entity[1].cc_waiting
 
 #ifdef SMP
 #define	cc_migration_func	cc_exec_entity[0].ce_migration_func
 #define	cc_migration_arg	cc_exec_entity[0].ce_migration_arg
 #define	cc_migration_cpu	cc_exec_entity[0].ce_migration_cpu
 #define	cc_migration_time	cc_exec_entity[0].ce_migration_time
 #define	cc_migration_prec	cc_exec_entity[0].ce_migration_prec
 #define	cc_migration_func_dir	cc_exec_entity[1].ce_migration_func
 #define	cc_migration_arg_dir	cc_exec_entity[1].ce_migration_arg
 #define	cc_migration_cpu_dir	cc_exec_entity[1].ce_migration_cpu
 #define	cc_migration_time_dir	cc_exec_entity[1].ce_migration_time
 #define	cc_migration_prec_dir	cc_exec_entity[1].ce_migration_prec
 
 struct callout_cpu cc_cpu[MAXCPU];
 #define	CPUBLOCK	MAXCPU
 #define	CC_CPU(cpu)	(&cc_cpu[(cpu)])
 #define	CC_SELF()	CC_CPU(PCPU_GET(cpuid))
 #else
 struct callout_cpu cc_cpu;
 #define	CC_CPU(cpu)	&cc_cpu
 #define	CC_SELF()	&cc_cpu
 #endif
 #define	CC_LOCK(cc)	mtx_lock_spin(&(cc)->cc_lock)
 #define	CC_UNLOCK(cc)	mtx_unlock_spin(&(cc)->cc_lock)
 #define	CC_LOCK_ASSERT(cc)	mtx_assert(&(cc)->cc_lock, MA_OWNED)
 
 static int timeout_cpu;
 
 static void	callout_cpu_init(struct callout_cpu *cc, int cpu);
 static void	softclock_call_cc(struct callout *c, struct callout_cpu *cc,
 #ifdef CALLOUT_PROFILING
 		    int *mpcalls, int *lockcalls, int *gcalls,
 #endif
 		    int direct);
 
 static MALLOC_DEFINE(M_CALLOUT, "callout", "Callout datastructures");
 
 /**
  * Locked by cc_lock:
  *   cc_curr         - If a callout is in progress, it is cc_curr.
  *                     If cc_curr is non-NULL, threads waiting in
  *                     callout_drain() will be woken up as soon as the
  *                     relevant callout completes.
  *   cc_cancel       - Changing to 1 with both callout_lock and cc_lock held
  *                     guarantees that the current callout will not run.
  *                     The softclock() function sets this to 0 before it
  *                     drops callout_lock to acquire c_lock, and it calls
  *                     the handler only if curr_cancelled is still 0 after
  *                     cc_lock is successfully acquired.
  *   cc_waiting      - If a thread is waiting in callout_drain(), then
  *                     callout_wait is nonzero.  Set only when
  *                     cc_curr is non-NULL.
  */
 
 /*
  * Resets the execution entity tied to a specific callout cpu.
  */
 static void
 cc_cce_cleanup(struct callout_cpu *cc, int direct)
 {
 
 	cc->cc_exec_entity[direct].cc_curr = NULL;
 	cc->cc_exec_entity[direct].cc_next = NULL;
 	cc->cc_exec_entity[direct].cc_cancel = false;
 	cc->cc_exec_entity[direct].cc_waiting = false;
 #ifdef SMP
 	cc->cc_exec_entity[direct].ce_migration_cpu = CPUBLOCK;
 	cc->cc_exec_entity[direct].ce_migration_time = 0;
 	cc->cc_exec_entity[direct].ce_migration_prec = 0;
 	cc->cc_exec_entity[direct].ce_migration_func = NULL;
 	cc->cc_exec_entity[direct].ce_migration_arg = NULL;
 #endif
 }
 
 /*
  * Checks if migration is requested by a specific callout cpu.
  */
 static int
 cc_cce_migrating(struct callout_cpu *cc, int direct)
 {
 
 #ifdef SMP
 	return (cc->cc_exec_entity[direct].ce_migration_cpu != CPUBLOCK);
 #else
 	return (0);
 #endif
 }
 
 /*
  * Kernel low level callwheel initialization
  * called on cpu0 during kernel startup.
  */
 static void
 callout_callwheel_init(void *dummy)
 {
 	struct callout_cpu *cc;
 
 	/*
 	 * Calculate the size of the callout wheel and the preallocated
 	 * timeout() structures.
 	 * XXX: Clip callout to result of previous function of maxusers
 	 * maximum 384.  This is still huge, but acceptable.
 	 */
 	ncallout = imin(16 + maxproc + maxfiles, 18508);
 	TUNABLE_INT_FETCH("kern.ncallout", &ncallout);
 
 	/*
 	 * Calculate callout wheel size, should be next power of two higher
 	 * than 'ncallout'.
 	 */
 	callwheelsize = 1 << fls(ncallout);
 	callwheelmask = callwheelsize - 1;
 
 	/*
 	 * Fetch whether we're pinning the swi's or not.
 	 */
 	TUNABLE_INT_FETCH("kern.pin_default_swi", &pin_default_swi);
 	TUNABLE_INT_FETCH("kern.pin_pcpu_swi", &pin_pcpu_swi);
 
 	/*
 	 * Only cpu0 handles timeout(9) and receives a preallocation.
 	 *
 	 * XXX: Once all timeout(9) consumers are converted this can
 	 * be removed.
 	 */
 	timeout_cpu = PCPU_GET(cpuid);
 	cc = CC_CPU(timeout_cpu);
 	cc->cc_callout = malloc(ncallout * sizeof(struct callout),
 	    M_CALLOUT, M_WAITOK);
 	callout_cpu_init(cc, timeout_cpu);
 }
 SYSINIT(callwheel_init, SI_SUB_CPU, SI_ORDER_ANY, callout_callwheel_init, NULL);
 
 /*
  * Initialize the per-cpu callout structures.
  */
 static void
 callout_cpu_init(struct callout_cpu *cc, int cpu)
 {
 	struct callout *c;
 	int i;
 
 	mtx_init(&cc->cc_lock, "callout", NULL, MTX_SPIN | MTX_RECURSE);
 	SLIST_INIT(&cc->cc_callfree);
 	cc->cc_callwheel = malloc(sizeof(struct callout_list) * callwheelsize,
 	    M_CALLOUT, M_WAITOK);
 	for (i = 0; i < callwheelsize; i++)
 		LIST_INIT(&cc->cc_callwheel[i]);
 	TAILQ_INIT(&cc->cc_expireq);
 	cc->cc_firstevent = SBT_MAX;
 	for (i = 0; i < 2; i++)
 		cc_cce_cleanup(cc, i);
 	snprintf(cc->cc_ktr_event_name, sizeof(cc->cc_ktr_event_name),
 	    "callwheel cpu %d", cpu);
 	if (cc->cc_callout == NULL)	/* Only cpu0 handles timeout(9) */
 		return;
 	for (i = 0; i < ncallout; i++) {
 		c = &cc->cc_callout[i];
 		callout_init(c, 0);
 		c->c_flags = CALLOUT_LOCAL_ALLOC;
 		SLIST_INSERT_HEAD(&cc->cc_callfree, c, c_links.sle);
 	}
 }
 
 #ifdef SMP
 /*
  * Switches the cpu tied to a specific callout.
  * The function expects a locked incoming callout cpu and returns with
  * locked outcoming callout cpu.
  */
 static struct callout_cpu *
 callout_cpu_switch(struct callout *c, struct callout_cpu *cc, int new_cpu)
 {
 	struct callout_cpu *new_cc;
 
 	MPASS(c != NULL && cc != NULL);
 	CC_LOCK_ASSERT(cc);
 
 	/*
 	 * Avoid interrupts and preemption firing after the callout cpu
 	 * is blocked in order to avoid deadlocks as the new thread
 	 * may be willing to acquire the callout cpu lock.
 	 */
 	c->c_cpu = CPUBLOCK;
 	spinlock_enter();
 	CC_UNLOCK(cc);
 	new_cc = CC_CPU(new_cpu);
 	CC_LOCK(new_cc);
 	spinlock_exit();
 	c->c_cpu = new_cpu;
 	return (new_cc);
 }
 #endif
 
 /*
  * Start standard softclock thread.
  */
 static void
 start_softclock(void *dummy)
 {
 	struct callout_cpu *cc;
 	char name[MAXCOMLEN];
 #ifdef SMP
 	int cpu;
 	struct intr_event *ie;
 #endif
 
 	cc = CC_CPU(timeout_cpu);
 	snprintf(name, sizeof(name), "clock (%d)", timeout_cpu);
 	if (swi_add(&clk_intr_event, name, softclock, cc, SWI_CLOCK,
 	    INTR_MPSAFE, &cc->cc_cookie))
 		panic("died while creating standard software ithreads");
 	if (pin_default_swi &&
 	    (intr_event_bind(clk_intr_event, timeout_cpu) != 0)) {
 		printf("%s: timeout clock couldn't be pinned to cpu %d\n",
 		    __func__,
 		    timeout_cpu);
 	}
 
 #ifdef SMP
 	CPU_FOREACH(cpu) {
 		if (cpu == timeout_cpu)
 			continue;
 		cc = CC_CPU(cpu);
 		cc->cc_callout = NULL;	/* Only cpu0 handles timeout(9). */
 		callout_cpu_init(cc, cpu);
 		snprintf(name, sizeof(name), "clock (%d)", cpu);
 		ie = NULL;
 		if (swi_add(&ie, name, softclock, cc, SWI_CLOCK,
 		    INTR_MPSAFE, &cc->cc_cookie))
 			panic("died while creating standard software ithreads");
 		if (pin_pcpu_swi && (intr_event_bind(ie, cpu) != 0)) {
 			printf("%s: per-cpu clock couldn't be pinned to "
 			    "cpu %d\n",
 			    __func__,
 			    cpu);
 		}
 	}
 #endif
 }
 SYSINIT(start_softclock, SI_SUB_SOFTINTR, SI_ORDER_FIRST, start_softclock, NULL);
 
 #define	CC_HASH_SHIFT	8
 
 static inline u_int
 callout_hash(sbintime_t sbt)
 {
 
 	return (sbt >> (32 - CC_HASH_SHIFT));
 }
 
 static inline u_int
 callout_get_bucket(sbintime_t sbt)
 {
 
 	return (callout_hash(sbt) & callwheelmask);
 }
 
 void
 callout_process(sbintime_t now)
 {
 	struct callout *tmp, *tmpn;
 	struct callout_cpu *cc;
 	struct callout_list *sc;
 	sbintime_t first, last, max, tmp_max;
 	uint32_t lookahead;
 	u_int firstb, lastb, nowb;
 #ifdef CALLOUT_PROFILING
 	int depth_dir = 0, mpcalls_dir = 0, lockcalls_dir = 0;
 #endif
 
 	cc = CC_SELF();
 	mtx_lock_spin_flags(&cc->cc_lock, MTX_QUIET);
 
 	/* Compute the buckets of the last scan and present times. */
 	firstb = callout_hash(cc->cc_lastscan);
 	cc->cc_lastscan = now;
 	nowb = callout_hash(now);
 
 	/* Compute the last bucket and minimum time of the bucket after it. */
 	if (nowb == firstb)
 		lookahead = (SBT_1S / 16);
 	else if (nowb - firstb == 1)
 		lookahead = (SBT_1S / 8);
 	else
 		lookahead = (SBT_1S / 2);
 	first = last = now;
 	first += (lookahead / 2);
 	last += lookahead;
 	last &= (0xffffffffffffffffLLU << (32 - CC_HASH_SHIFT));
 	lastb = callout_hash(last) - 1;
 	max = last;
 
 	/*
 	 * Check if we wrapped around the entire wheel from the last scan.
 	 * In case, we need to scan entirely the wheel for pending callouts.
 	 */
 	if (lastb - firstb >= callwheelsize) {
 		lastb = firstb + callwheelsize - 1;
 		if (nowb - firstb >= callwheelsize)
 			nowb = lastb;
 	}
 
 	/* Iterate callwheel from firstb to nowb and then up to lastb. */
 	do {
 		sc = &cc->cc_callwheel[firstb & callwheelmask];
 		tmp = LIST_FIRST(sc);
 		while (tmp != NULL) {
 			/* Run the callout if present time within allowed. */
 			if (tmp->c_time <= now) {
 				/*
 				 * Consumer told us the callout may be run
 				 * directly from hardware interrupt context.
 				 */
 				if (tmp->c_flags & CALLOUT_DIRECT) {
 #ifdef CALLOUT_PROFILING
 					++depth_dir;
 #endif
 					cc->cc_exec_next_dir =
 					    LIST_NEXT(tmp, c_links.le);
 					cc->cc_bucket = firstb & callwheelmask;
 					LIST_REMOVE(tmp, c_links.le);
 					softclock_call_cc(tmp, cc,
 #ifdef CALLOUT_PROFILING
 					    &mpcalls_dir, &lockcalls_dir, NULL,
 #endif
 					    1);
 					tmp = cc->cc_exec_next_dir;
 				} else {
 					tmpn = LIST_NEXT(tmp, c_links.le);
 					LIST_REMOVE(tmp, c_links.le);
 					TAILQ_INSERT_TAIL(&cc->cc_expireq,
 					    tmp, c_links.tqe);
 					tmp->c_flags |= CALLOUT_PROCESSED;
 					tmp = tmpn;
 				}
 				continue;
 			}
 			/* Skip events from distant future. */
 			if (tmp->c_time >= max)
 				goto next;
 			/*
 			 * Event minimal time is bigger than present maximal
 			 * time, so it cannot be aggregated.
 			 */
 			if (tmp->c_time > last) {
 				lastb = nowb;
 				goto next;
 			}
 			/* Update first and last time, respecting this event. */
 			if (tmp->c_time < first)
 				first = tmp->c_time;
 			tmp_max = tmp->c_time + tmp->c_precision;
 			if (tmp_max < last)
 				last = tmp_max;
 next:
 			tmp = LIST_NEXT(tmp, c_links.le);
 		}
 		/* Proceed with the next bucket. */
 		firstb++;
 		/*
 		 * Stop if we looked after present time and found
 		 * some event we can't execute at now.
 		 * Stop if we looked far enough into the future.
 		 */
 	} while (((int)(firstb - lastb)) <= 0);
 	cc->cc_firstevent = last;
 #ifndef NO_EVENTTIMERS
 	cpu_new_callout(curcpu, last, first);
 #endif
 #ifdef CALLOUT_PROFILING
 	avg_depth_dir += (depth_dir * 1000 - avg_depth_dir) >> 8;
 	avg_mpcalls_dir += (mpcalls_dir * 1000 - avg_mpcalls_dir) >> 8;
 	avg_lockcalls_dir += (lockcalls_dir * 1000 - avg_lockcalls_dir) >> 8;
 #endif
 	mtx_unlock_spin_flags(&cc->cc_lock, MTX_QUIET);
 	/*
 	 * swi_sched acquires the thread lock, so we don't want to call it
 	 * with cc_lock held; incorrect locking order.
 	 */
 	if (!TAILQ_EMPTY(&cc->cc_expireq))
 		swi_sched(cc->cc_cookie, 0);
 }
 
 static struct callout_cpu *
 callout_lock(struct callout *c)
 {
 	struct callout_cpu *cc;
 	int cpu;
 
 	for (;;) {
 		cpu = c->c_cpu;
 #ifdef SMP
 		if (cpu == CPUBLOCK) {
 			while (c->c_cpu == CPUBLOCK)
 				cpu_spinwait();
 			continue;
 		}
 #endif
 		cc = CC_CPU(cpu);
 		CC_LOCK(cc);
 		if (cpu == c->c_cpu)
 			break;
 		CC_UNLOCK(cc);
 	}
 	return (cc);
 }
 
 static void
 callout_cc_add(struct callout *c, struct callout_cpu *cc,
     sbintime_t sbt, sbintime_t precision, void (*func)(void *),
     void *arg, int cpu, int flags)
 {
 	int bucket;
 
 	CC_LOCK_ASSERT(cc);
 	if (sbt < cc->cc_lastscan)
 		sbt = cc->cc_lastscan;
 	c->c_arg = arg;
 	c->c_flags |= (CALLOUT_ACTIVE | CALLOUT_PENDING);
 	if (flags & C_DIRECT_EXEC)
 		c->c_flags |= CALLOUT_DIRECT;
 	c->c_flags &= ~CALLOUT_PROCESSED;
 	c->c_func = func;
 	c->c_time = sbt;
 	c->c_precision = precision;
 	bucket = callout_get_bucket(c->c_time);
 	CTR3(KTR_CALLOUT, "precision set for %p: %d.%08x",
 	    c, (int)(c->c_precision >> 32),
 	    (u_int)(c->c_precision & 0xffffffff));
 	LIST_INSERT_HEAD(&cc->cc_callwheel[bucket], c, c_links.le);
 	if (cc->cc_bucket == bucket)
 		cc->cc_exec_next_dir = c;
 #ifndef NO_EVENTTIMERS
 	/*
 	 * Inform the eventtimers(4) subsystem there's a new callout
 	 * that has been inserted, but only if really required.
 	 */
 	if (SBT_MAX - c->c_time < c->c_precision)
 		c->c_precision = SBT_MAX - c->c_time;
 	sbt = c->c_time + c->c_precision;
 	if (sbt < cc->cc_firstevent) {
 		cc->cc_firstevent = sbt;
 		cpu_new_callout(cpu, sbt, c->c_time);
 	}
 #endif
 }
 
 static void
 callout_cc_del(struct callout *c, struct callout_cpu *cc)
 {
 
 	if ((c->c_flags & CALLOUT_LOCAL_ALLOC) == 0)
 		return;
 	c->c_func = NULL;
 	SLIST_INSERT_HEAD(&cc->cc_callfree, c, c_links.sle);
 }
 
 static void
 softclock_call_cc(struct callout *c, struct callout_cpu *cc,
 #ifdef CALLOUT_PROFILING
     int *mpcalls, int *lockcalls, int *gcalls,
 #endif
     int direct)
 {
 	struct rm_priotracker tracker;
 	void (*c_func)(void *);
 	void *c_arg;
 	struct lock_class *class;
 	struct lock_object *c_lock;
 	uintptr_t lock_status;
 	int c_flags;
 #ifdef SMP
 	struct callout_cpu *new_cc;
 	void (*new_func)(void *);
 	void *new_arg;
 	int flags, new_cpu;
 	sbintime_t new_prec, new_time;
 #endif
 #if defined(DIAGNOSTIC) || defined(CALLOUT_PROFILING) 
 	sbintime_t sbt1, sbt2;
 	struct timespec ts2;
 	static sbintime_t maxdt = 2 * SBT_1MS;	/* 2 msec */
 	static timeout_t *lastfunc;
 #endif
 
 	KASSERT((c->c_flags & (CALLOUT_PENDING | CALLOUT_ACTIVE)) ==
 	    (CALLOUT_PENDING | CALLOUT_ACTIVE),
 	    ("softclock_call_cc: pend|act %p %x", c, c->c_flags));
 	class = (c->c_lock != NULL) ? LOCK_CLASS(c->c_lock) : NULL;
 	lock_status = 0;
 	if (c->c_flags & CALLOUT_SHAREDLOCK) {
 		if (class == &lock_class_rm)
 			lock_status = (uintptr_t)&tracker;
 		else
 			lock_status = 1;
 	}
 	c_lock = c->c_lock;
 	c_func = c->c_func;
 	c_arg = c->c_arg;
 	c_flags = c->c_flags;
 	if (c->c_flags & CALLOUT_LOCAL_ALLOC)
 		c->c_flags = CALLOUT_LOCAL_ALLOC;
 	else
 		c->c_flags &= ~CALLOUT_PENDING;
 	cc->cc_exec_entity[direct].cc_curr = c;
 	cc->cc_exec_entity[direct].cc_cancel = false;
 	CC_UNLOCK(cc);
 	if (c_lock != NULL) {
 		class->lc_lock(c_lock, lock_status);
 		/*
 		 * The callout may have been cancelled
 		 * while we switched locks.
 		 */
 		if (cc->cc_exec_entity[direct].cc_cancel) {
 			class->lc_unlock(c_lock);
 			goto skip;
 		}
 		/* The callout cannot be stopped now. */
 		cc->cc_exec_entity[direct].cc_cancel = true;
 		if (c_lock == &Giant.lock_object) {
 #ifdef CALLOUT_PROFILING
 			(*gcalls)++;
 #endif
 			CTR3(KTR_CALLOUT, "callout giant %p func %p arg %p",
 			    c, c_func, c_arg);
 		} else {
 #ifdef CALLOUT_PROFILING
 			(*lockcalls)++;
 #endif
 			CTR3(KTR_CALLOUT, "callout lock %p func %p arg %p",
 			    c, c_func, c_arg);
 		}
 	} else {
 #ifdef CALLOUT_PROFILING
 		(*mpcalls)++;
 #endif
 		CTR3(KTR_CALLOUT, "callout %p func %p arg %p",
 		    c, c_func, c_arg);
 	}
 	KTR_STATE3(KTR_SCHED, "callout", cc->cc_ktr_event_name, "running",
 	    "func:%p", c_func, "arg:%p", c_arg, "direct:%d", direct);
 #if defined(DIAGNOSTIC) || defined(CALLOUT_PROFILING)
 	sbt1 = sbinuptime();
 #endif
 	THREAD_NO_SLEEPING();
 	SDT_PROBE(callout_execute, kernel, , callout__start, c, 0, 0, 0, 0);
 	c_func(c_arg);
 	SDT_PROBE(callout_execute, kernel, , callout__end, c, 0, 0, 0, 0);
 	THREAD_SLEEPING_OK();
 #if defined(DIAGNOSTIC) || defined(CALLOUT_PROFILING)
 	sbt2 = sbinuptime();
 	sbt2 -= sbt1;
 	if (sbt2 > maxdt) {
 		if (lastfunc != c_func || sbt2 > maxdt * 2) {
 			ts2 = sbttots(sbt2);
 			printf(
 		"Expensive timeout(9) function: %p(%p) %jd.%09ld s\n",
 			    c_func, c_arg, (intmax_t)ts2.tv_sec, ts2.tv_nsec);
 		}
 		maxdt = sbt2;
 		lastfunc = c_func;
 	}
 #endif
 	KTR_STATE0(KTR_SCHED, "callout", cc->cc_ktr_event_name, "idle");
 	CTR1(KTR_CALLOUT, "callout %p finished", c);
 	if ((c_flags & CALLOUT_RETURNUNLOCKED) == 0)
 		class->lc_unlock(c_lock);
 skip:
 	CC_LOCK(cc);
 	KASSERT(cc->cc_exec_entity[direct].cc_curr == c, ("mishandled cc_curr"));
 	cc->cc_exec_entity[direct].cc_curr = NULL;
 	if (cc->cc_exec_entity[direct].cc_waiting) {
 		/*
 		 * There is someone waiting for the
 		 * callout to complete.
 		 * If the callout was scheduled for
 		 * migration just cancel it.
 		 */
 		if (cc_cce_migrating(cc, direct)) {
 			cc_cce_cleanup(cc, direct);
 
 			/*
 			 * It should be assert here that the callout is not
 			 * destroyed but that is not easy.
 			 */
 			c->c_flags &= ~CALLOUT_DFRMIGRATION;
 		}
 		cc->cc_exec_entity[direct].cc_waiting = false;
 		CC_UNLOCK(cc);
 		wakeup(&cc->cc_exec_entity[direct].cc_waiting);
 		CC_LOCK(cc);
 	} else if (cc_cce_migrating(cc, direct)) {
 		KASSERT((c_flags & CALLOUT_LOCAL_ALLOC) == 0,
 		    ("Migrating legacy callout %p", c));
 #ifdef SMP
 		/*
 		 * If the callout was scheduled for
 		 * migration just perform it now.
 		 */
 		new_cpu = cc->cc_exec_entity[direct].ce_migration_cpu;
 		new_time = cc->cc_exec_entity[direct].ce_migration_time;
 		new_prec = cc->cc_exec_entity[direct].ce_migration_prec;
 		new_func = cc->cc_exec_entity[direct].ce_migration_func;
 		new_arg = cc->cc_exec_entity[direct].ce_migration_arg;
 		cc_cce_cleanup(cc, direct);
 
 		/*
 		 * It should be assert here that the callout is not destroyed
 		 * but that is not easy.
 		 *
 		 * As first thing, handle deferred callout stops.
 		 */
 		if ((c->c_flags & CALLOUT_DFRMIGRATION) == 0) {
 			CTR3(KTR_CALLOUT,
 			     "deferred cancelled %p func %p arg %p",
 			     c, new_func, new_arg);
 			callout_cc_del(c, cc);
 			return;
 		}
 		c->c_flags &= ~CALLOUT_DFRMIGRATION;
 
 		new_cc = callout_cpu_switch(c, cc, new_cpu);
 		flags = (direct) ? C_DIRECT_EXEC : 0;
 		callout_cc_add(c, new_cc, new_time, new_prec, new_func,
 		    new_arg, new_cpu, flags);
 		CC_UNLOCK(new_cc);
 		CC_LOCK(cc);
 #else
 		panic("migration should not happen");
 #endif
 	}
 	/*
 	 * If the current callout is locally allocated (from
 	 * timeout(9)) then put it on the freelist.
 	 *
 	 * Note: we need to check the cached copy of c_flags because
 	 * if it was not local, then it's not safe to deref the
 	 * callout pointer.
 	 */
 	KASSERT((c_flags & CALLOUT_LOCAL_ALLOC) == 0 ||
 	    c->c_flags == CALLOUT_LOCAL_ALLOC,
 	    ("corrupted callout"));
 	if (c_flags & CALLOUT_LOCAL_ALLOC)
 		callout_cc_del(c, cc);
 }
 
 /*
  * The callout mechanism is based on the work of Adam M. Costello and
  * George Varghese, published in a technical report entitled "Redesigning
  * the BSD Callout and Timer Facilities" and modified slightly for inclusion
  * in FreeBSD by Justin T. Gibbs.  The original work on the data structures
  * used in this implementation was published by G. Varghese and T. Lauck in
  * the paper "Hashed and Hierarchical Timing Wheels: Data Structures for
  * the Efficient Implementation of a Timer Facility" in the Proceedings of
  * the 11th ACM Annual Symposium on Operating Systems Principles,
  * Austin, Texas Nov 1987.
  */
 
 /*
  * Software (low priority) clock interrupt.
  * Run periodic events from timeout queue.
  */
 void
 softclock(void *arg)
 {
 	struct callout_cpu *cc;
 	struct callout *c;
 #ifdef CALLOUT_PROFILING
 	int depth = 0, gcalls = 0, lockcalls = 0, mpcalls = 0;
 #endif
 
 	cc = (struct callout_cpu *)arg;
 	CC_LOCK(cc);
 	while ((c = TAILQ_FIRST(&cc->cc_expireq)) != NULL) {
 		TAILQ_REMOVE(&cc->cc_expireq, c, c_links.tqe);
 		softclock_call_cc(c, cc,
 #ifdef CALLOUT_PROFILING
 		    &mpcalls, &lockcalls, &gcalls,
 #endif
 		    0);
 #ifdef CALLOUT_PROFILING
 		++depth;
 #endif
 	}
 #ifdef CALLOUT_PROFILING
 	avg_depth += (depth * 1000 - avg_depth) >> 8;
 	avg_mpcalls += (mpcalls * 1000 - avg_mpcalls) >> 8;
 	avg_lockcalls += (lockcalls * 1000 - avg_lockcalls) >> 8;
 	avg_gcalls += (gcalls * 1000 - avg_gcalls) >> 8;
 #endif
 	CC_UNLOCK(cc);
 }
 
 /*
  * timeout --
  *	Execute a function after a specified length of time.
  *
  * untimeout --
  *	Cancel previous timeout function call.
  *
  * callout_handle_init --
  *	Initialize a handle so that using it with untimeout is benign.
  *
  *	See AT&T BCI Driver Reference Manual for specification.  This
  *	implementation differs from that one in that although an
  *	identification value is returned from timeout, the original
  *	arguments to timeout as well as the identifier are used to
  *	identify entries for untimeout.
  */
 struct callout_handle
 timeout(timeout_t *ftn, void *arg, int to_ticks)
 {
 	struct callout_cpu *cc;
 	struct callout *new;
 	struct callout_handle handle;
 
 	cc = CC_CPU(timeout_cpu);
 	CC_LOCK(cc);
 	/* Fill in the next free callout structure. */
 	new = SLIST_FIRST(&cc->cc_callfree);
 	if (new == NULL)
 		/* XXX Attempt to malloc first */
 		panic("timeout table full");
 	SLIST_REMOVE_HEAD(&cc->cc_callfree, c_links.sle);
 	callout_reset(new, to_ticks, ftn, arg);
 	handle.callout = new;
 	CC_UNLOCK(cc);
 
 	return (handle);
 }
 
 void
 untimeout(timeout_t *ftn, void *arg, struct callout_handle handle)
 {
 	struct callout_cpu *cc;
 
 	/*
 	 * Check for a handle that was initialized
 	 * by callout_handle_init, but never used
 	 * for a real timeout.
 	 */
 	if (handle.callout == NULL)
 		return;
 
 	cc = callout_lock(handle.callout);
 	if (handle.callout->c_func == ftn && handle.callout->c_arg == arg)
 		callout_stop(handle.callout);
 	CC_UNLOCK(cc);
 }
 
 void
 callout_handle_init(struct callout_handle *handle)
 {
 	handle->callout = NULL;
 }
 
 /*
  * New interface; clients allocate their own callout structures.
  *
  * callout_reset() - establish or change a timeout
  * callout_stop() - disestablish a timeout
  * callout_init() - initialize a callout structure so that it can
  *	safely be passed to callout_reset() and callout_stop()
  *
  * <sys/callout.h> defines three convenience macros:
  *
  * callout_active() - returns truth if callout has not been stopped,
  *	drained, or deactivated since the last time the callout was
  *	reset.
  * callout_pending() - returns truth if callout is still waiting for timeout
  * callout_deactivate() - marks the callout as having been serviced
  */
 int
 callout_reset_sbt_on(struct callout *c, sbintime_t sbt, sbintime_t precision,
     void (*ftn)(void *), void *arg, int cpu, int flags)
 {
 	sbintime_t to_sbt, pr;
 	struct callout_cpu *cc;
 	int cancelled, direct;
 
 	cancelled = 0;
 	if (flags & C_ABSOLUTE) {
 		to_sbt = sbt;
 	} else {
 		if ((flags & C_HARDCLOCK) && (sbt < tick_sbt))
 			sbt = tick_sbt;
 		if ((flags & C_HARDCLOCK) ||
 #ifdef NO_EVENTTIMERS
 		    sbt >= sbt_timethreshold) {
 			to_sbt = getsbinuptime();
 
 			/* Add safety belt for the case of hz > 1000. */
 			to_sbt += tc_tick_sbt - tick_sbt;
 #else
 		    sbt >= sbt_tickthreshold) {
 			/*
 			 * Obtain the time of the last hardclock() call on
 			 * this CPU directly from the kern_clocksource.c.
 			 * This value is per-CPU, but it is equal for all
 			 * active ones.
 			 */
 #ifdef __LP64__
 			to_sbt = DPCPU_GET(hardclocktime);
 #else
 			spinlock_enter();
 			to_sbt = DPCPU_GET(hardclocktime);
 			spinlock_exit();
 #endif
 #endif
 			if ((flags & C_HARDCLOCK) == 0)
 				to_sbt += tick_sbt;
 		} else
 			to_sbt = sbinuptime();
 		if (SBT_MAX - to_sbt < sbt)
 			to_sbt = SBT_MAX;
 		else
 			to_sbt += sbt;
 		pr = ((C_PRELGET(flags) < 0) ? sbt >> tc_precexp :
 		    sbt >> C_PRELGET(flags));
 		if (pr > precision)
 			precision = pr;
 	}
 	/*
 	 * Don't allow migration of pre-allocated callouts lest they
 	 * become unbalanced.
 	 */
 	if (c->c_flags & CALLOUT_LOCAL_ALLOC)
 		cpu = c->c_cpu;
 	direct = (c->c_flags & CALLOUT_DIRECT) != 0;
 	KASSERT(!direct || c->c_lock == NULL,
 	    ("%s: direct callout %p has lock", __func__, c));
 	cc = callout_lock(c);
 	if (cc->cc_exec_entity[direct].cc_curr == c) {
 		/*
 		 * We're being asked to reschedule a callout which is
 		 * currently in progress.  If there is a lock then we
 		 * can cancel the callout if it has not really started.
 		 */
 		if (c->c_lock != NULL && !cc->cc_exec_entity[direct].cc_cancel)
 			cancelled = cc->cc_exec_entity[direct].cc_cancel = true;
 		if (cc->cc_exec_entity[direct].cc_waiting) {
 			/*
 			 * Someone has called callout_drain to kill this
 			 * callout.  Don't reschedule.
 			 */
 			CTR4(KTR_CALLOUT, "%s %p func %p arg %p",
 			    cancelled ? "cancelled" : "failed to cancel",
 			    c, c->c_func, c->c_arg);
 			CC_UNLOCK(cc);
 			return (cancelled);
 		}
 	}
 	if (c->c_flags & CALLOUT_PENDING) {
 		if ((c->c_flags & CALLOUT_PROCESSED) == 0) {
 			if (cc->cc_exec_next_dir == c)
 				cc->cc_exec_next_dir = LIST_NEXT(c, c_links.le);
 			LIST_REMOVE(c, c_links.le);
 		} else
 			TAILQ_REMOVE(&cc->cc_expireq, c, c_links.tqe);
 		cancelled = 1;
 		c->c_flags &= ~(CALLOUT_ACTIVE | CALLOUT_PENDING);
 	}
 
 #ifdef SMP
 	/*
 	 * If the callout must migrate try to perform it immediately.
 	 * If the callout is currently running, just defer the migration
 	 * to a more appropriate moment.
 	 */
 	if (c->c_cpu != cpu) {
 		if (cc->cc_exec_entity[direct].cc_curr == c) {
 			cc->cc_exec_entity[direct].ce_migration_cpu = cpu;
 			cc->cc_exec_entity[direct].ce_migration_time
 			    = to_sbt;
 			cc->cc_exec_entity[direct].ce_migration_prec 
 			    = precision;
 			cc->cc_exec_entity[direct].ce_migration_func = ftn;
 			cc->cc_exec_entity[direct].ce_migration_arg = arg;
 			c->c_flags |= CALLOUT_DFRMIGRATION;
 			CTR6(KTR_CALLOUT,
 		    "migration of %p func %p arg %p in %d.%08x to %u deferred",
 			    c, c->c_func, c->c_arg, (int)(to_sbt >> 32),
 			    (u_int)(to_sbt & 0xffffffff), cpu);
 			CC_UNLOCK(cc);
 			return (cancelled);
 		}
 		cc = callout_cpu_switch(c, cc, cpu);
 	}
 #endif
 
 	callout_cc_add(c, cc, to_sbt, precision, ftn, arg, cpu, flags);
 	CTR6(KTR_CALLOUT, "%sscheduled %p func %p arg %p in %d.%08x",
 	    cancelled ? "re" : "", c, c->c_func, c->c_arg, (int)(to_sbt >> 32),
 	    (u_int)(to_sbt & 0xffffffff));
 	CC_UNLOCK(cc);
 
 	return (cancelled);
 }
 
 /*
  * Common idioms that can be optimized in the future.
  */
 int
 callout_schedule_on(struct callout *c, int to_ticks, int cpu)
 {
 	return callout_reset_on(c, to_ticks, c->c_func, c->c_arg, cpu);
 }
 
 int
 callout_schedule(struct callout *c, int to_ticks)
 {
 	return callout_reset_on(c, to_ticks, c->c_func, c->c_arg, c->c_cpu);
 }
 
 int
 _callout_stop_safe(struct callout *c, int safe)
 {
 	struct callout_cpu *cc, *old_cc;
 	struct lock_class *class;
 	int direct, sq_locked, use_lock;
 
+	if (safe)
+		WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, c->c_lock,
+		    "calling %s", __func__);
+
 	/*
 	 * Some old subsystems don't hold Giant while running a callout_stop(),
 	 * so just discard this check for the moment.
 	 */
 	if (!safe && c->c_lock != NULL) {
 		if (c->c_lock == &Giant.lock_object)
 			use_lock = mtx_owned(&Giant);
 		else {
 			use_lock = 1;
 			class = LOCK_CLASS(c->c_lock);
 			class->lc_assert(c->c_lock, LA_XLOCKED);
 		}
 	} else
 		use_lock = 0;
 	direct = (c->c_flags & CALLOUT_DIRECT) != 0;
 	sq_locked = 0;
 	old_cc = NULL;
 again:
 	cc = callout_lock(c);
 
 	/*
 	 * If the callout was migrating while the callout cpu lock was
 	 * dropped,  just drop the sleepqueue lock and check the states
 	 * again.
 	 */
 	if (sq_locked != 0 && cc != old_cc) {
 #ifdef SMP
 		CC_UNLOCK(cc);
 		sleepq_release(&old_cc->cc_exec_entity[direct].cc_waiting);
 		sq_locked = 0;
 		old_cc = NULL;
 		goto again;
 #else
 		panic("migration should not happen");
 #endif
 	}
 
 	/*
 	 * If the callout isn't pending, it's not on the queue, so
 	 * don't attempt to remove it from the queue.  We can try to
 	 * stop it by other means however.
 	 */
 	if (!(c->c_flags & CALLOUT_PENDING)) {
 		c->c_flags &= ~CALLOUT_ACTIVE;
 
 		/*
 		 * If it wasn't on the queue and it isn't the current
 		 * callout, then we can't stop it, so just bail.
 		 */
 		if (cc->cc_exec_entity[direct].cc_curr != c) {
 			CTR3(KTR_CALLOUT, "failed to stop %p func %p arg %p",
 			    c, c->c_func, c->c_arg);
 			CC_UNLOCK(cc);
 			if (sq_locked)
 				sleepq_release(
 				    &cc->cc_exec_entity[direct].cc_waiting);
 			return (0);
 		}
 
 		if (safe) {
 			/*
 			 * The current callout is running (or just
 			 * about to run) and blocking is allowed, so
 			 * just wait for the current invocation to
 			 * finish.
 			 */
 			while (cc->cc_exec_entity[direct].cc_curr == c) {
 				/*
 				 * Use direct calls to sleepqueue interface
 				 * instead of cv/msleep in order to avoid
 				 * a LOR between cc_lock and sleepqueue
 				 * chain spinlocks.  This piece of code
 				 * emulates a msleep_spin() call actually.
 				 *
 				 * If we already have the sleepqueue chain
 				 * locked, then we can safely block.  If we
 				 * don't already have it locked, however,
 				 * we have to drop the cc_lock to lock
 				 * it.  This opens several races, so we
 				 * restart at the beginning once we have
 				 * both locks.  If nothing has changed, then
 				 * we will end up back here with sq_locked
 				 * set.
 				 */
 				if (!sq_locked) {
 					CC_UNLOCK(cc);
 					sleepq_lock(
 					&cc->cc_exec_entity[direct].cc_waiting);
 					sq_locked = 1;
 					old_cc = cc;
 					goto again;
 				}
 
 				/*
 				 * Migration could be cancelled here, but
 				 * as long as it is still not sure when it
 				 * will be packed up, just let softclock()
 				 * take care of it.
 				 */
 				cc->cc_exec_entity[direct].cc_waiting = true;
 				DROP_GIANT();
 				CC_UNLOCK(cc);
 				sleepq_add(
 				    &cc->cc_exec_entity[direct].cc_waiting,
 				    &cc->cc_lock.lock_object, "codrain",
 				    SLEEPQ_SLEEP, 0);
 				sleepq_wait(
 				    &cc->cc_exec_entity[direct].cc_waiting,
 					     0);
 				sq_locked = 0;
 				old_cc = NULL;
 
 				/* Reacquire locks previously released. */
 				PICKUP_GIANT();
 				CC_LOCK(cc);
 			}
 		} else if (use_lock &&
 			    !cc->cc_exec_entity[direct].cc_cancel) {
 			/*
 			 * The current callout is waiting for its
 			 * lock which we hold.  Cancel the callout
 			 * and return.  After our caller drops the
 			 * lock, the callout will be skipped in
 			 * softclock().
 			 */
 			cc->cc_exec_entity[direct].cc_cancel = true;
 			CTR3(KTR_CALLOUT, "cancelled %p func %p arg %p",
 			    c, c->c_func, c->c_arg);
 			KASSERT(!cc_cce_migrating(cc, direct),
 			    ("callout wrongly scheduled for migration"));
 			CC_UNLOCK(cc);
 			KASSERT(!sq_locked, ("sleepqueue chain locked"));
 			return (1);
 		} else if ((c->c_flags & CALLOUT_DFRMIGRATION) != 0) {
 			c->c_flags &= ~CALLOUT_DFRMIGRATION;
 			CTR3(KTR_CALLOUT, "postponing stop %p func %p arg %p",
 			    c, c->c_func, c->c_arg);
 			CC_UNLOCK(cc);
 			return (1);
 		}
 		CTR3(KTR_CALLOUT, "failed to stop %p func %p arg %p",
 		    c, c->c_func, c->c_arg);
 		CC_UNLOCK(cc);
 		KASSERT(!sq_locked, ("sleepqueue chain still locked"));
 		return (0);
 	}
 	if (sq_locked)
 		sleepq_release(&cc->cc_exec_entity[direct].cc_waiting);
 
 	c->c_flags &= ~(CALLOUT_ACTIVE | CALLOUT_PENDING);
 
 	CTR3(KTR_CALLOUT, "cancelled %p func %p arg %p",
 	    c, c->c_func, c->c_arg);
 	if ((c->c_flags & CALLOUT_PROCESSED) == 0) {
 		if (cc->cc_exec_next_dir == c)
 			cc->cc_exec_next_dir = LIST_NEXT(c, c_links.le);
 		LIST_REMOVE(c, c_links.le);
 	} else
 		TAILQ_REMOVE(&cc->cc_expireq, c, c_links.tqe);
 	callout_cc_del(c, cc);
 
 	CC_UNLOCK(cc);
 	return (1);
 }
 
 void
 callout_init(struct callout *c, int mpsafe)
 {
 	bzero(c, sizeof *c);
 	if (mpsafe) {
 		c->c_lock = NULL;
 		c->c_flags = CALLOUT_RETURNUNLOCKED;
 	} else {
 		c->c_lock = &Giant.lock_object;
 		c->c_flags = 0;
 	}
 	c->c_cpu = timeout_cpu;
 }
 
 void
 _callout_init_lock(struct callout *c, struct lock_object *lock, int flags)
 {
 	bzero(c, sizeof *c);
 	c->c_lock = lock;
 	KASSERT((flags & ~(CALLOUT_RETURNUNLOCKED | CALLOUT_SHAREDLOCK)) == 0,
 	    ("callout_init_lock: bad flags %d", flags));
 	KASSERT(lock != NULL || (flags & CALLOUT_RETURNUNLOCKED) == 0,
 	    ("callout_init_lock: CALLOUT_RETURNUNLOCKED with no lock"));
 	KASSERT(lock == NULL || !(LOCK_CLASS(lock)->lc_flags &
 	    (LC_SPINLOCK | LC_SLEEPABLE)), ("%s: invalid lock class",
 	    __func__));
 	c->c_flags = flags & (CALLOUT_RETURNUNLOCKED | CALLOUT_SHAREDLOCK);
 	c->c_cpu = timeout_cpu;
 }
 
 #ifdef APM_FIXUP_CALLTODO
 /* 
  * Adjust the kernel calltodo timeout list.  This routine is used after 
  * an APM resume to recalculate the calltodo timer list values with the 
  * number of hz's we have been sleeping.  The next hardclock() will detect 
  * that there are fired timers and run softclock() to execute them.
  *
  * Please note, I have not done an exhaustive analysis of what code this
  * might break.  I am motivated to have my select()'s and alarm()'s that
  * have expired during suspend firing upon resume so that the applications
  * which set the timer can do the maintanence the timer was for as close
  * as possible to the originally intended time.  Testing this code for a 
  * week showed that resuming from a suspend resulted in 22 to 25 timers 
  * firing, which seemed independant on whether the suspend was 2 hours or
  * 2 days.  Your milage may vary.   - Ken Key <key@cs.utk.edu>
  */
 void
 adjust_timeout_calltodo(struct timeval *time_change)
 {
 	register struct callout *p;
 	unsigned long delta_ticks;
 
 	/* 
 	 * How many ticks were we asleep?
 	 * (stolen from tvtohz()).
 	 */
 
 	/* Don't do anything */
 	if (time_change->tv_sec < 0)
 		return;
 	else if (time_change->tv_sec <= LONG_MAX / 1000000)
 		delta_ticks = (time_change->tv_sec * 1000000 +
 			       time_change->tv_usec + (tick - 1)) / tick + 1;
 	else if (time_change->tv_sec <= LONG_MAX / hz)
 		delta_ticks = time_change->tv_sec * hz +
 			      (time_change->tv_usec + (tick - 1)) / tick + 1;
 	else
 		delta_ticks = LONG_MAX;
 
 	if (delta_ticks > INT_MAX)
 		delta_ticks = INT_MAX;
 
 	/* 
 	 * Now rip through the timer calltodo list looking for timers
 	 * to expire.
 	 */
 
 	/* don't collide with softclock() */
 	CC_LOCK(cc);
 	for (p = calltodo.c_next; p != NULL; p = p->c_next) {
 		p->c_time -= delta_ticks;
 
 		/* Break if the timer had more time on it than delta_ticks */
 		if (p->c_time > 0)
 			break;
 
 		/* take back the ticks the timer didn't use (p->c_time <= 0) */
 		delta_ticks = -p->c_time;
 	}
 	CC_UNLOCK(cc);
 
 	return;
 }
 #endif /* APM_FIXUP_CALLTODO */
 
 static int
 flssbt(sbintime_t sbt)
 {
 
 	sbt += (uint64_t)sbt >> 1;
 	if (sizeof(long) >= sizeof(sbintime_t))
 		return (flsl(sbt));
 	if (sbt >= SBT_1S)
 		return (flsl(((uint64_t)sbt) >> 32) + 32);
 	return (flsl(sbt));
 }
 
 /*
  * Dump immediate statistic snapshot of the scheduled callouts.
  */
 static int
 sysctl_kern_callout_stat(SYSCTL_HANDLER_ARGS)
 {
 	struct callout *tmp;
 	struct callout_cpu *cc;
 	struct callout_list *sc;
 	sbintime_t maxpr, maxt, medpr, medt, now, spr, st, t;
 	int ct[64], cpr[64], ccpbk[32];
 	int error, val, i, count, tcum, pcum, maxc, c, medc;
 #ifdef SMP
 	int cpu;
 #endif
 
 	val = 0;
 	error = sysctl_handle_int(oidp, &val, 0, req);
 	if (error != 0 || req->newptr == NULL)
 		return (error);
 	count = maxc = 0;
 	st = spr = maxt = maxpr = 0;
 	bzero(ccpbk, sizeof(ccpbk));
 	bzero(ct, sizeof(ct));
 	bzero(cpr, sizeof(cpr));
 	now = sbinuptime();
 #ifdef SMP
 	CPU_FOREACH(cpu) {
 		cc = CC_CPU(cpu);
 #else
 		cc = CC_CPU(timeout_cpu);
 #endif
 		CC_LOCK(cc);
 		for (i = 0; i < callwheelsize; i++) {
 			sc = &cc->cc_callwheel[i];
 			c = 0;
 			LIST_FOREACH(tmp, sc, c_links.le) {
 				c++;
 				t = tmp->c_time - now;
 				if (t < 0)
 					t = 0;
 				st += t / SBT_1US;
 				spr += tmp->c_precision / SBT_1US;
 				if (t > maxt)
 					maxt = t;
 				if (tmp->c_precision > maxpr)
 					maxpr = tmp->c_precision;
 				ct[flssbt(t)]++;
 				cpr[flssbt(tmp->c_precision)]++;
 			}
 			if (c > maxc)
 				maxc = c;
 			ccpbk[fls(c + c / 2)]++;
 			count += c;
 		}
 		CC_UNLOCK(cc);
 #ifdef SMP
 	}
 #endif
 
 	for (i = 0, tcum = 0; i < 64 && tcum < count / 2; i++)
 		tcum += ct[i];
 	medt = (i >= 2) ? (((sbintime_t)1) << (i - 2)) : 0;
 	for (i = 0, pcum = 0; i < 64 && pcum < count / 2; i++)
 		pcum += cpr[i];
 	medpr = (i >= 2) ? (((sbintime_t)1) << (i - 2)) : 0;
 	for (i = 0, c = 0; i < 32 && c < count / 2; i++)
 		c += ccpbk[i];
 	medc = (i >= 2) ? (1 << (i - 2)) : 0;
 
 	printf("Scheduled callouts statistic snapshot:\n");
 	printf("  Callouts: %6d  Buckets: %6d*%-3d  Bucket size: 0.%06ds\n",
 	    count, callwheelsize, mp_ncpus, 1000000 >> CC_HASH_SHIFT);
 	printf("  C/Bk: med %5d         avg %6d.%06jd  max %6d\n",
 	    medc,
 	    count / callwheelsize / mp_ncpus,
 	    (uint64_t)count * 1000000 / callwheelsize / mp_ncpus % 1000000,
 	    maxc);
 	printf("  Time: med %5jd.%06jds avg %6jd.%06jds max %6jd.%06jds\n",
 	    medt / SBT_1S, (medt & 0xffffffff) * 1000000 >> 32,
 	    (st / count) / 1000000, (st / count) % 1000000,
 	    maxt / SBT_1S, (maxt & 0xffffffff) * 1000000 >> 32);
 	printf("  Prec: med %5jd.%06jds avg %6jd.%06jds max %6jd.%06jds\n",
 	    medpr / SBT_1S, (medpr & 0xffffffff) * 1000000 >> 32,
 	    (spr / count) / 1000000, (spr / count) % 1000000,
 	    maxpr / SBT_1S, (maxpr & 0xffffffff) * 1000000 >> 32);
 	printf("  Distribution:       \tbuckets\t   time\t   tcum\t"
 	    "   prec\t   pcum\n");
 	for (i = 0, tcum = pcum = 0; i < 64; i++) {
 		if (ct[i] == 0 && cpr[i] == 0)
 			continue;
 		t = (i != 0) ? (((sbintime_t)1) << (i - 1)) : 0;
 		tcum += ct[i];
 		pcum += cpr[i];
 		printf("  %10jd.%06jds\t 2**%d\t%7d\t%7d\t%7d\t%7d\n",
 		    t / SBT_1S, (t & 0xffffffff) * 1000000 >> 32,
 		    i - 1 - (32 - CC_HASH_SHIFT),
 		    ct[i], tcum, cpr[i], pcum);
 	}
 	return (error);
 }
 SYSCTL_PROC(_kern, OID_AUTO, callout_stat,
     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
     0, 0, sysctl_kern_callout_stat, "I",
     "Dump immediate statistic snapshot of the scheduled callouts");
Index: projects/clang360-import/sys/kern/subr_sglist.c
===================================================================
--- projects/clang360-import/sys/kern/subr_sglist.c	(revision 277777)
+++ projects/clang360-import/sys/kern/subr_sglist.c	(revision 277778)
@@ -1,754 +1,757 @@
 /*-
  * Copyright (c) 2008 Yahoo!, Inc.
  * All rights reserved.
  * Written by: John Baldwin <jhb@FreeBSD.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the author nor the names of any co-contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/bio.h>
 #include <sys/malloc.h>
 #include <sys/mbuf.h>
 #include <sys/proc.h>
 #include <sys/sglist.h>
 #include <sys/uio.h>
 
 #include <vm/vm.h>
 #include <vm/vm_page.h>
 #include <vm/pmap.h>
 #include <vm/vm_map.h>
 
 #include <sys/ktr.h>
 
 static MALLOC_DEFINE(M_SGLIST, "sglist", "scatter/gather lists");
 
 /*
  * Convenience macros to save the state of an sglist so it can be restored
  * if an append attempt fails.  Since sglist's only grow we only need to
  * save the current count of segments and the length of the ending segment.
  * Earlier segments will not be changed by an append, and the only change
  * that can occur to the ending segment is that it can be extended.
  */
 struct sgsave {
 	u_short sg_nseg;
 	size_t ss_len;
 };
 
 #define	SGLIST_SAVE(sg, sgsave) do {					\
 	(sgsave).sg_nseg = (sg)->sg_nseg;				\
 	if ((sgsave).sg_nseg > 0)					\
 		(sgsave).ss_len = (sg)->sg_segs[(sgsave).sg_nseg - 1].ss_len; \
 	else								\
 		(sgsave).ss_len = 0;					\
 } while (0)
 
 #define	SGLIST_RESTORE(sg, sgsave) do {					\
 	(sg)->sg_nseg = (sgsave).sg_nseg;				\
 	if ((sgsave).sg_nseg > 0)					\
 		(sg)->sg_segs[(sgsave).sg_nseg - 1].ss_len = (sgsave).ss_len; \
 } while (0)
 
 /*
  * Append a single (paddr, len) to a sglist.  sg is the list and ss is
  * the current segment in the list.  If we run out of segments then
  * EFBIG will be returned.
  */
 static __inline int
 _sglist_append_range(struct sglist *sg, struct sglist_seg **ssp,
     vm_paddr_t paddr, size_t len)
 {
 	struct sglist_seg *ss;
 
 	ss = *ssp;
 	if (ss->ss_paddr + ss->ss_len == paddr)
 		ss->ss_len += len;
 	else {
 		if (sg->sg_nseg == sg->sg_maxseg)
 			return (EFBIG);
 		ss++;
 		ss->ss_paddr = paddr;
 		ss->ss_len = len;
 		sg->sg_nseg++;
 		*ssp = ss;
 	}
 	return (0);
 }
 
 /*
  * Worker routine to append a virtual address range (either kernel or
  * user) to a scatter/gather list.
  */
 static __inline int
 _sglist_append_buf(struct sglist *sg, void *buf, size_t len, pmap_t pmap,
     size_t *donep)
 {
 	struct sglist_seg *ss;
 	vm_offset_t vaddr, offset;
 	vm_paddr_t paddr;
 	size_t seglen;
 	int error;
 
 	if (donep)
 		*donep = 0;
 	if (len == 0)
 		return (0);
 
 	/* Do the first page.  It may have an offset. */
 	vaddr = (vm_offset_t)buf;
 	offset = vaddr & PAGE_MASK;
 	if (pmap != NULL)
 		paddr = pmap_extract(pmap, vaddr);
 	else
 		paddr = pmap_kextract(vaddr);
 	seglen = MIN(len, PAGE_SIZE - offset);
 	if (sg->sg_nseg == 0) {
 		ss = sg->sg_segs;
 		ss->ss_paddr = paddr;
 		ss->ss_len = seglen;
 		sg->sg_nseg = 1;
 	} else {
 		ss = &sg->sg_segs[sg->sg_nseg - 1];
 		error = _sglist_append_range(sg, &ss, paddr, seglen);
 		if (error)
 			return (error);
 	}
 	vaddr += seglen;
 	len -= seglen;
 	if (donep)
 		*donep += seglen;
 
 	while (len > 0) {
 		seglen = MIN(len, PAGE_SIZE);
 		if (pmap != NULL)
 			paddr = pmap_extract(pmap, vaddr);
 		else
 			paddr = pmap_kextract(vaddr);
 		error = _sglist_append_range(sg, &ss, paddr, seglen);
 		if (error)
 			return (error);
 		vaddr += seglen;
 		len -= seglen;
 		if (donep)
 			*donep += seglen;
 	}
 
 	return (0);
 }
 
 /*
  * Determine the number of scatter/gather list elements needed to
  * describe a kernel virtual address range.
  */
 int
 sglist_count(void *buf, size_t len)
 {
 	vm_offset_t vaddr, vendaddr;
 	vm_paddr_t lastaddr, paddr;
 	int nsegs;
 
 	if (len == 0)
 		return (0);
 
 	vaddr = trunc_page((vm_offset_t)buf);
 	vendaddr = (vm_offset_t)buf + len;
 	nsegs = 1;
 	lastaddr = pmap_kextract(vaddr);
 	vaddr += PAGE_SIZE;
 	while (vaddr < vendaddr) {
 		paddr = pmap_kextract(vaddr);
 		if (lastaddr + PAGE_SIZE != paddr)
 			nsegs++;
 		lastaddr = paddr;
 		vaddr += PAGE_SIZE;
 	}
 	return (nsegs);
 }
 
 /*
  * Allocate a scatter/gather list along with 'nsegs' segments.  The
  * 'mflags' parameters are the same as passed to malloc(9).  The caller
  * should use sglist_free() to free this list.
  */
 struct sglist *
 sglist_alloc(int nsegs, int mflags)
 {
 	struct sglist *sg;
 
 	sg = malloc(sizeof(struct sglist) + nsegs * sizeof(struct sglist_seg),
 	    M_SGLIST, mflags);
 	if (sg == NULL)
 		return (NULL);
 	sglist_init(sg, nsegs, (struct sglist_seg *)(sg + 1));
 	return (sg);
 }
 
 /*
  * Free a scatter/gather list allocated via sglist_allc().
  */
 void
 sglist_free(struct sglist *sg)
 {
 
+	if (sg == NULL)
+		return;
+
 	if (refcount_release(&sg->sg_refs))
 		free(sg, M_SGLIST);
 }
 
 /*
  * Append the segments to describe a single kernel virtual address
  * range to a scatter/gather list.  If there are insufficient
  * segments, then this fails with EFBIG.
  */
 int
 sglist_append(struct sglist *sg, void *buf, size_t len)
 {
 	struct sgsave save;
 	int error;
 
 	if (sg->sg_maxseg == 0)
 		return (EINVAL);
 	SGLIST_SAVE(sg, save);
 	error = _sglist_append_buf(sg, buf, len, NULL, NULL);
 	if (error)
 		SGLIST_RESTORE(sg, save);
 	return (error);
 }
 
 /*
  * Append the segments to describe a bio's data to a scatter/gather list.
  * If there are insufficient segments, then this fails with EFBIG.
  *
  * NOTE: This function expects bio_bcount to be initialized.
  */
 int
 sglist_append_bio(struct sglist *sg, struct bio *bp)
 {
 	struct sgsave save;
 	vm_paddr_t paddr;
 	size_t len, tlen;
 	int error, i, ma_offs;
 
 	if ((bp->bio_flags & BIO_UNMAPPED) == 0) {
 		error = sglist_append(sg, bp->bio_data, bp->bio_bcount);
 		return (error);
 	}
 
 	if (sg->sg_maxseg == 0)
 		return (EINVAL);
 
 	SGLIST_SAVE(sg, save);
 	tlen = bp->bio_bcount;
 	ma_offs = bp->bio_ma_offset;
 	for (i = 0; tlen > 0; i++, tlen -= len) {
 		len = min(PAGE_SIZE - ma_offs, tlen);
 		paddr = VM_PAGE_TO_PHYS(bp->bio_ma[i]) + ma_offs;
 		error = sglist_append_phys(sg, paddr, len);
 		if (error) {
 			SGLIST_RESTORE(sg, save);
 			return (error);
 		}
 		ma_offs = 0;
 	}
 	return (0);
 }
 
 /*
  * Append a single physical address range to a scatter/gather list.
  * If there are insufficient segments, then this fails with EFBIG.
  */
 int
 sglist_append_phys(struct sglist *sg, vm_paddr_t paddr, size_t len)
 {
 	struct sglist_seg *ss;
 	struct sgsave save;
 	int error;
 
 	if (sg->sg_maxseg == 0)
 		return (EINVAL);
 	if (len == 0)
 		return (0);
 
 	if (sg->sg_nseg == 0) {
 		sg->sg_segs[0].ss_paddr = paddr;
 		sg->sg_segs[0].ss_len = len;
 		sg->sg_nseg = 1;
 		return (0);
 	}
 	ss = &sg->sg_segs[sg->sg_nseg - 1];
 	SGLIST_SAVE(sg, save);
 	error = _sglist_append_range(sg, &ss, paddr, len);
 	if (error)
 		SGLIST_RESTORE(sg, save);
 	return (error);
 }
 
 /*
  * Append the segments that describe a single mbuf chain to a
  * scatter/gather list.  If there are insufficient segments, then this
  * fails with EFBIG.
  */
 int
 sglist_append_mbuf(struct sglist *sg, struct mbuf *m0)
 {
 	struct sgsave save;
 	struct mbuf *m;
 	int error;
 
 	if (sg->sg_maxseg == 0)
 		return (EINVAL);
 
 	error = 0;
 	SGLIST_SAVE(sg, save);
 	for (m = m0; m != NULL; m = m->m_next) {
 		if (m->m_len > 0) {
 			error = sglist_append(sg, m->m_data, m->m_len);
 			if (error) {
 				SGLIST_RESTORE(sg, save);
 				return (error);
 			}
 		}
 	}
 	return (0);
 }
 
 /*
  * Append the segments that describe a single user address range to a
  * scatter/gather list.  If there are insufficient segments, then this
  * fails with EFBIG.
  */
 int
 sglist_append_user(struct sglist *sg, void *buf, size_t len, struct thread *td)
 {
 	struct sgsave save;
 	int error;
 
 	if (sg->sg_maxseg == 0)
 		return (EINVAL);
 	SGLIST_SAVE(sg, save);
 	error = _sglist_append_buf(sg, buf, len,
 	    vmspace_pmap(td->td_proc->p_vmspace), NULL);
 	if (error)
 		SGLIST_RESTORE(sg, save);
 	return (error);
 }
 
 /*
  * Append the segments that describe a single uio to a scatter/gather
  * list.  If there are insufficient segments, then this fails with
  * EFBIG.
  */
 int
 sglist_append_uio(struct sglist *sg, struct uio *uio)
 {
 	struct iovec *iov;
 	struct sgsave save;
 	size_t resid, minlen;
 	pmap_t pmap;
 	int error, i;
 
 	if (sg->sg_maxseg == 0)
 		return (EINVAL);
 
 	resid = uio->uio_resid;
 	iov = uio->uio_iov;
 
 	if (uio->uio_segflg == UIO_USERSPACE) {
 		KASSERT(uio->uio_td != NULL,
 		    ("sglist_append_uio: USERSPACE but no thread"));
 		pmap = vmspace_pmap(uio->uio_td->td_proc->p_vmspace);
 	} else
 		pmap = NULL;
 
 	error = 0;
 	SGLIST_SAVE(sg, save);
 	for (i = 0; i < uio->uio_iovcnt && resid != 0; i++) {
 		/*
 		 * Now at the first iovec to load.  Load each iovec
 		 * until we have exhausted the residual count.
 		 */
 		minlen = MIN(resid, iov[i].iov_len);
 		if (minlen > 0) {
 			error = _sglist_append_buf(sg, iov[i].iov_base, minlen,
 			    pmap, NULL);
 			if (error) {
 				SGLIST_RESTORE(sg, save);
 				return (error);
 			}
 			resid -= minlen;
 		}
 	}
 	return (0);
 }
 
 /*
  * Append the segments that describe at most 'resid' bytes from a
  * single uio to a scatter/gather list.  If there are insufficient
  * segments, then only the amount that fits is appended.
  */
 int
 sglist_consume_uio(struct sglist *sg, struct uio *uio, size_t resid)
 {
 	struct iovec *iov;
 	size_t done;
 	pmap_t pmap;
 	int error, len;
 
 	if (sg->sg_maxseg == 0)
 		return (EINVAL);
 
 	if (uio->uio_segflg == UIO_USERSPACE) {
 		KASSERT(uio->uio_td != NULL,
 		    ("sglist_consume_uio: USERSPACE but no thread"));
 		pmap = vmspace_pmap(uio->uio_td->td_proc->p_vmspace);
 	} else
 		pmap = NULL;
 
 	error = 0;
 	while (resid > 0 && uio->uio_resid) {
 		iov = uio->uio_iov;
 		len = iov->iov_len;
 		if (len == 0) {
 			uio->uio_iov++;
 			uio->uio_iovcnt--;
 			continue;
 		}
 		if (len > resid)
 			len = resid;
 
 		/*
 		 * Try to append this iovec.  If we run out of room,
 		 * then break out of the loop.
 		 */
 		error = _sglist_append_buf(sg, iov->iov_base, len, pmap, &done);
 		iov->iov_base = (char *)iov->iov_base + done;
 		iov->iov_len -= done;
 		uio->uio_resid -= done;
 		uio->uio_offset += done;
 		resid -= done;
 		if (error)
 			break;
 	}
 	return (0);
 }
 
 /*
  * Allocate and populate a scatter/gather list to describe a single
  * kernel virtual address range.
  */
 struct sglist *
 sglist_build(void *buf, size_t len, int mflags)
 {
 	struct sglist *sg;
 	int nsegs;
 
 	if (len == 0)
 		return (NULL);
 
 	nsegs = sglist_count(buf, len);
 	sg = sglist_alloc(nsegs, mflags);
 	if (sg == NULL)
 		return (NULL);
 	if (sglist_append(sg, buf, len) != 0) {
 		sglist_free(sg);
 		return (NULL);
 	}
 	return (sg);
 }
 
 /*
  * Clone a new copy of a scatter/gather list.
  */
 struct sglist *
 sglist_clone(struct sglist *sg, int mflags)
 {
 	struct sglist *new;
 
 	if (sg == NULL)
 		return (NULL);
 	new = sglist_alloc(sg->sg_maxseg, mflags);
 	if (new == NULL)
 		return (NULL);
 	new->sg_nseg = sg->sg_nseg;
 	bcopy(sg->sg_segs, new->sg_segs, sizeof(struct sglist_seg) *
 	    sg->sg_nseg);
 	return (new);
 }
 
 /*
  * Calculate the total length of the segments described in a
  * scatter/gather list.
  */
 size_t
 sglist_length(struct sglist *sg)
 {
 	size_t space;
 	int i;
 
 	space = 0;
 	for (i = 0; i < sg->sg_nseg; i++)
 		space += sg->sg_segs[i].ss_len;
 	return (space);
 }
 
 /*
  * Split a scatter/gather list into two lists.  The scatter/gather
  * entries for the first 'length' bytes of the 'original' list are
  * stored in the '*head' list and are removed from 'original'.
  *
  * If '*head' is NULL, then a new list will be allocated using
  * 'mflags'.  If M_NOWAIT is specified and the allocation fails,
  * ENOMEM will be returned.
  *
  * If '*head' is not NULL, it should point to an empty sglist.  If it
  * does not have enough room for the remaining space, then EFBIG will
  * be returned.  If '*head' is not empty, then EINVAL will be
  * returned.
  *
  * If 'original' is shared (refcount > 1), then EDOOFUS will be
  * returned.
  */
 int
 sglist_split(struct sglist *original, struct sglist **head, size_t length,
     int mflags)
 {
 	struct sglist *sg;
 	size_t space, split;
 	int count, i;
 
 	if (original->sg_refs > 1)
 		return (EDOOFUS);
 
 	/* Figure out how big of a sglist '*head' has to hold. */
 	count = 0;
 	space = 0;
 	split = 0;
 	for (i = 0; i < original->sg_nseg; i++) {
 		space += original->sg_segs[i].ss_len;
 		count++;
 		if (space >= length) {
 			/*
 			 * If 'length' falls in the middle of a
 			 * scatter/gather list entry, then 'split'
 			 * holds how much of that entry will remain in
 			 * 'original'.
 			 */
 			split = space - length;
 			break;
 		}
 	}
 
 	/* Nothing to do, so leave head empty. */
 	if (count == 0)
 		return (0);
 
 	if (*head == NULL) {
 		sg = sglist_alloc(count, mflags);
 		if (sg == NULL)
 			return (ENOMEM);
 		*head = sg;
 	} else {
 		sg = *head;
 		if (sg->sg_maxseg < count)
 			return (EFBIG);
 		if (sg->sg_nseg != 0)
 			return (EINVAL);
 	}
 
 	/* Copy 'count' entries to 'sg' from 'original'. */
 	bcopy(original->sg_segs, sg->sg_segs, count *
 	    sizeof(struct sglist_seg));
 	sg->sg_nseg = count;
 
 	/*
 	 * If we had to split a list entry, fixup the last entry in
 	 * 'sg' and the new first entry in 'original'.  We also
 	 * decrement 'count' by 1 since we will only be removing
 	 * 'count - 1' segments from 'original' now.
 	 */
 	if (split != 0) {
 		count--;
 		sg->sg_segs[count].ss_len -= split;
 		original->sg_segs[count].ss_paddr =
 		    sg->sg_segs[count].ss_paddr + split;
 		original->sg_segs[count].ss_len = split;
 	}
 
 	/* Trim 'count' entries from the front of 'original'. */
 	original->sg_nseg -= count;
 	bcopy(original->sg_segs + count, original->sg_segs, count *
 	    sizeof(struct sglist_seg));
 	return (0);
 }
 
 /*
  * Append the scatter/gather list elements in 'second' to the
  * scatter/gather list 'first'.  If there is not enough space in
  * 'first', EFBIG is returned.
  */
 int
 sglist_join(struct sglist *first, struct sglist *second)
 {
 	struct sglist_seg *flast, *sfirst;
 	int append;
 
 	/* If 'second' is empty, there is nothing to do. */
 	if (second->sg_nseg == 0)
 		return (0);
 
 	/*
 	 * If the first entry in 'second' can be appended to the last entry
 	 * in 'first' then set append to '1'.
 	 */
 	append = 0;
 	flast = &first->sg_segs[first->sg_nseg - 1];
 	sfirst = &second->sg_segs[0];
 	if (first->sg_nseg != 0 &&
 	    flast->ss_paddr + flast->ss_len == sfirst->ss_paddr)
 		append = 1;
 
 	/* Make sure 'first' has enough room. */
 	if (first->sg_nseg + second->sg_nseg - append > first->sg_maxseg)
 		return (EFBIG);
 
 	/* Merge last in 'first' and first in 'second' if needed. */
 	if (append)
 		flast->ss_len += sfirst->ss_len;
 
 	/* Append new segments from 'second' to 'first'. */
 	bcopy(first->sg_segs + first->sg_nseg, second->sg_segs + append,
 	    (second->sg_nseg - append) * sizeof(struct sglist_seg));
 	first->sg_nseg += second->sg_nseg - append;
 	sglist_reset(second);
 	return (0);
 }
 
 /*
  * Generate a new scatter/gather list from a range of an existing
  * scatter/gather list.  The 'offset' and 'length' parameters specify
  * the logical range of the 'original' list to extract.  If that range
  * is not a subset of the length of 'original', then EINVAL is
  * returned.  The new scatter/gather list is stored in '*slice'.
  *
  * If '*slice' is NULL, then a new list will be allocated using
  * 'mflags'.  If M_NOWAIT is specified and the allocation fails,
  * ENOMEM will be returned.
  *
  * If '*slice' is not NULL, it should point to an empty sglist.  If it
  * does not have enough room for the remaining space, then EFBIG will
  * be returned.  If '*slice' is not empty, then EINVAL will be
  * returned.
  */
 int
 sglist_slice(struct sglist *original, struct sglist **slice, size_t offset,
     size_t length, int mflags)
 {
 	struct sglist *sg;
 	size_t space, end, foffs, loffs;
 	int count, i, fseg;
 
 	/* Nothing to do. */
 	if (length == 0)
 		return (0);
 
 	/* Figure out how many segments '*slice' needs to have. */
 	end = offset + length;
 	space = 0;
 	count = 0;
 	fseg = 0;
 	foffs = loffs = 0;
 	for (i = 0; i < original->sg_nseg; i++) {
 		space += original->sg_segs[i].ss_len;
 		if (space > offset) {
 			/*
 			 * When we hit the first segment, store its index
 			 * in 'fseg' and the offset into the first segment
 			 * of 'offset' in 'foffs'.
 			 */
 			if (count == 0) {
 				fseg = i;
 				foffs = offset - (space -
 				    original->sg_segs[i].ss_len);
 				CTR1(KTR_DEV, "sglist_slice: foffs = %08lx",
 				    foffs);
 			}
 			count++;
 
 			/*
 			 * When we hit the last segment, break out of
 			 * the loop.  Store the amount of extra space
 			 * at the end of this segment in 'loffs'.
 			 */
 			if (space >= end) {
 				loffs = space - end;
 				CTR1(KTR_DEV, "sglist_slice: loffs = %08lx",
 				    loffs);
 				break;
 			}
 		}
 	}
 
 	/* If we never hit 'end', then 'length' ran off the end, so fail. */
 	if (space < end)
 		return (EINVAL);
 
 	if (*slice == NULL) {
 		sg = sglist_alloc(count, mflags);
 		if (sg == NULL)
 			return (ENOMEM);
 		*slice = sg;
 	} else {
 		sg = *slice;
 		if (sg->sg_maxseg < count)
 			return (EFBIG);
 		if (sg->sg_nseg != 0)
 			return (EINVAL);
 	}
 
 	/*
 	 * Copy over 'count' segments from 'original' starting at
 	 * 'fseg' to 'sg'.
 	 */
 	bcopy(original->sg_segs + fseg, sg->sg_segs,
 	    count * sizeof(struct sglist_seg));
 	sg->sg_nseg = count;
 
 	/* Fixup first and last segments if needed. */
 	if (foffs != 0) {
 		sg->sg_segs[0].ss_paddr += foffs;
 		sg->sg_segs[0].ss_len -= foffs;
 		CTR2(KTR_DEV, "sglist_slice seg[0]: %08lx:%08lx",
 		    (long)sg->sg_segs[0].ss_paddr, sg->sg_segs[0].ss_len);
 	}
 	if (loffs != 0) {
 		sg->sg_segs[count - 1].ss_len -= loffs;
 		CTR2(KTR_DEV, "sglist_slice seg[%d]: len %08x", count - 1,
 		    sg->sg_segs[count - 1].ss_len);
 	}
 	return (0);
 }
Index: projects/clang360-import/sys/modules/Makefile
===================================================================
--- projects/clang360-import/sys/modules/Makefile	(revision 277777)
+++ projects/clang360-import/sys/modules/Makefile	(revision 277778)
@@ -1,745 +1,752 @@
 # $FreeBSD$
 
 SYSDIR?=${.CURDIR}/..
 .include "${SYSDIR}/conf/kern.opts.mk"
 
 SUBDIR_PARALLEL=
 
 # Modules that include binary-only blobs of microcode should be selectable by
 # MK_SOURCELESS_UCODE option (see below).
 
 .if defined(MODULES_OVERRIDE) && !defined(ALL_MODULES)
 SUBDIR=${MODULES_OVERRIDE}
 .else
 SUBDIR=	\
 	${_3dfx} \
 	${_3dfx_linux} \
 	${_aac} \
 	${_aacraid} \
 	accf_data \
 	accf_dns \
 	accf_http \
 	acl_nfs4 \
 	acl_posix1e \
 	${_acpi} \
 	ae \
 	${_aesni} \
 	age \
 	${_agp} \
 	aha \
 	${_ahb} \
 	ahci \
 	${_aic} \
 	aic7xxx \
 	aio \
 	alc \
 	ale \
 	alq \
 	${_amdsbwd} \
 	${_amdtemp} \
 	amr \
 	${_an} \
 	${_aout} \
 	${_apm} \
 	${_arcmsr} \
 	${_arcnet} \
 	${_asmc} \
 	ata \
 	ath \
 	ath_pci \
-	autofs \
+	${_autofs} \
 	${_auxio} \
 	${_bce} \
 	bfe \
 	bge \
 	${_bxe} \
 	${_bios} \
 	${_bktr} \
 	${_bm} \
 	bridgestp \
 	bwi \
 	bwn \
 	cam \
 	${_canbepm} \
 	${_canbus} \
 	${_cardbus} \
 	${_carp} \
 	cas \
 	${_cbb} \
 	cc \
 	cd9660 \
 	cd9660_iconv \
 	${_ce} \
 	${_cfi} \
 	${_ciss} \
 	${_cm} \
 	${_cmx} \
 	${_coff} \
 	${_coretemp} \
 	${_cp} \
 	${_cpsw} \
 	${_cpuctl} \
 	${_cpufreq} \
 	${_crypto} \
 	${_cryptodev} \
 	${_cs} \
 	${_ct} \
 	${_ctau} \
 	ctl \
 	${_cxgb} \
 	${_cxgbe} \
 	dc \
 	dcons \
 	dcons_crom \
 	de \
 	${_dpms} \
 	${_dpt} \
 	${_drm} \
 	${_drm2} \
 	${_dtrace} \
 	dummynet \
 	${_ed} \
 	${_elink} \
 	${_em} \
 	en \
 	${_ep} \
 	${_epic} \
 	esp \
 	${_et} \
 	${_ex} \
 	${_exca} \
 	${_ext2fs} \
 	${_fatm} \
 	fdc \
 	fdescfs \
 	${_fe} \
 	${_filemon} \
 	firewire \
 	firmware \
 	fuse \
 	${_fxp} \
 	gem \
 	geom \
 	${_glxiic} \
 	${_glxsb} \
 	hatm \
 	hifn \
 	hme \
 	${_hpt27xx} \
 	${_hptiop} \
 	${_hptmv} \
 	${_hptnr} \
 	${_hptrr} \
 	hwpmc \
 	${_hyperv} \
 	${_i2c} \
         ${_ibcore} \
 	${_ibcs2} \
 	${_ichwd} \
 	${_ida} \
 	${_ie} \
 	if_bridge \
 	if_disc \
 	if_edsc \
 	if_epair \
 	${_if_gif} \
 	${_if_gre} \
 	${_if_me} \
 	if_lagg \
 	${_if_ndis} \
 	if_stf \
 	if_tap \
 	if_tun \
 	if_vlan \
 	if_vxlan \
 	${_igb} \
 	${_iir} \
 	imgact_binmisc \
 	${_io} \
         ${_ipoib} \
 	${_ipdivert} \
 	${_ipfilter} \
 	${_ipfw} \
 	ipfw_nat \
 	${_ipmi} \
 	ip6_mroute_mod \
 	ip_mroute_mod \
 	${_ips} \
 	${_ipw} \
 	${_ipwfw} \
 	${_isci} \
 	isp \
 	${_ispfw} \
 	${_iwi} \
 	${_iwifw} \
 	${_iwn} \
 	${_iwnfw} \
 	${_ixgb} \
 	${_ixgbe} \
 	${_ixl} \
 	${_ixlv} \
 	jme \
 	joy \
 	kbdmux \
 	kgssapi \
 	kgssapi_krb5 \
 	khelp \
 	krpc \
 	ksyms \
 	le \
 	lge \
 	libalias \
 	libiconv \
 	libmbpool \
 	libmchain \
 	${_linprocfs} \
 	${_linsysfs} \
 	${_linux} \
 	${_linuxapi} \
 	lmc \
 	lpt \
 	mac_biba \
 	mac_bsdextended \
 	mac_ifoff \
 	mac_lomac \
 	mac_mls \
 	mac_none \
 	mac_partition \
 	mac_portacl \
 	mac_seeotheruids \
 	mac_stub \
 	mac_test \
 	malo \
 	mcd \
 	md \
 	mem \
 	mfi \
 	mii \
 	mlx \
 	${_mlx4} \
 	${_mlx4ib} \
 	${_mlxen} \
 	${_mly} \
 	mmc \
 	mmcsd \
 	mpr \
 	mps \
 	mpt \
 	mqueue \
 	mrsas \
 	msdosfs \
 	msdosfs_iconv \
 	${_mse} \
 	msk \
 	${_mthca} \
 	mvs \
 	mwl \
 	${_mwlfw} \
 	mxge \
 	my \
 	${_nandfs} \
 	${_nandsim} \
 	${_ncr} \
 	${_ncv} \
 	${_ndis} \
 	netfpga10g \
 	${_netgraph} \
 	${_nfe} \
 	nfscl \
 	nfscommon \
 	nfsd \
 	nfslock \
 	nfslockd \
 	nfssvc \
 	nge \
 	nmdm \
 	${_nsp} \
 	nullfs \
 	${_ntb} \
 	${_nvd} \
 	${_nvme} \
 	${_nvram} \
 	${_nxge} \
 	${_opensolaris} \
 	oce \
 	${_padlock} \
 	${_padlock_rng} \
 	patm \
 	${_pccard} \
 	${_pcfclock} \
 	pcn \
 	${_pf} \
 	${_pflog} \
 	${_pfsync} \
 	plip \
 	${_pmc} \
 	ppbus \
 	ppc \
 	ppi \
 	pps \
 	procfs \
 	proto \
 	pseudofs \
 	${_pst} \
 	pty  \
 	puc \
 	${_qlxge} \
 	${_qlxgb} \
 	${_qlxgbe} \
 	ral \
 	${_ralfw} \
 	${_random} \
 	rc4 \
 	${_rdma} \
 	${_rdrand_rng} \
 	re \
 	reiserfs \
 	rl \
 	${_s3} \
 	${_safe} \
 	${_sbni} \
 	scc \
 	scd \
 	${_scsi_low} \
 	sdhci \
 	sdhci_pci \
 	sem \
 	send \
 	${_sf} \
 	${_sfxge} \
 	sge \
 	${_si} \
 	siba_bwn \
 	siftr \
 	siis \
 	sis \
 	sk \
 	${_smbfs} \
 	sn \
 	${_snc} \
 	snp \
 	${_sound} \
 	${_speaker} \
 	${_splash} \
 	${_sppp} \
 	ste \
 	${_stg} \
 	stge \
 	${_streams} \
 	${_svr4} \
 	${_sym} \
 	${_syscons} \
 	sysvipc \
 	${_ti} \
 	tl \
 	tmpfs \
 	${_toecore} \
 	${_tpm} \
 	trm \
 	${_twa} \
 	twe \
 	tws \
 	tx \
 	${_txp} \
 	uart \
 	ubsec \
 	udf \
 	udf_iconv \
 	ufs \
 	unionfs \
 	usb \
 	utopia \
 	${_vesa} \
 	${_virtio} \
 	vge \
 	${_viawd} \
 	vkbd \
 	${_vmm} \
 	${_vmware} \
 	${_vpo} \
 	vr \
 	vte \
 	vx \
 	${_vxge} \
 	wb \
 	${_wbwd} \
 	${_wds} \
 	${_wi} \
 	${_wl} \
 	wlan \
 	wlan_acl \
 	wlan_amrr \
 	wlan_ccmp \
 	wlan_rssadapt \
 	wlan_tkip \
 	wlan_wep \
 	wlan_xauth \
 	${_wpi} \
 	${_wpifw} \
 	${_x86bios} \
 	${_xe} \
 	xl \
 	${_zfs} \
 	zlib
 
+.if ${MK_AUTOFS} != "no" || defined(ALL_MODULES)
+_autofs=	autofs
+.endif
+
 .if ${MK_CRYPT} != "no" || defined(ALL_MODULES)
 .if exists(${.CURDIR}/../opencrypto)
 _crypto=	crypto
 _cryptodev=	cryptodev
 .endif
 .if exists(${.CURDIR}/../crypto)
 _random=	random
 .endif
 .endif
 
 .if ${MK_CUSE} != "no" || defined(ALL_MODULES)
 SUBDIR+=	cuse
 .endif
 
 .if (${MK_INET_SUPPORT} != "no" || ${MK_INET6_SUPPORT} != "no") || \
 	defined(ALL_MODULES)
 _carp=		carp
 _toecore=	toecore
 _if_gif=	if_gif
 _if_gre=	if_gre
 .endif
 
 .if ${MK_INET_SUPPORT} != "no" || defined(ALL_MODULES)
 _if_me=		if_me
 _ipdivert=	ipdivert
 _ipfw=		ipfw
 .endif
 
 .if ${MK_IPFILTER} != "no" || defined(ALL_MODULES)
 _ipfilter=	ipfilter
 .endif
 
 .if ${MK_ISCSI} != "no" || defined(ALL_MODULES)
 SUBDIR+=	iscsi
 SUBDIR+=	iscsi_initiator
 .endif
 
 .if ${MK_NAND} != "no" || defined(ALL_MODULES)
 _nandfs=	nandfs
 _nandsim=	nandsim
 .endif
 
 .if ${MK_NETGRAPH} != "no" || defined(ALL_MODULES)
 _netgraph=	netgraph
 .endif
 
 .if (${MK_PF} != "no" && (${MK_INET_SUPPORT} != "no" || \
 	${MK_INET6_SUPPORT} != "no")) || defined(ALL_MODULES)
 _pf=		pf
 _pflog=		pflog
 .if ${MK_INET_SUPPORT} != "no"
 _pfsync=	pfsync
 .endif
 .endif
 
 .if ${MK_SOURCELESS_UCODE} != "no"
 _bce=		bce
 _fatm=		fatm
 _fxp=		fxp
 _ispfw=		ispfw
 _mwlfw=		mwlfw
 _ralfw=		ralfw
 _sf=		sf
 _ti=		ti
 _txp=		txp
 .endif
 
 .if ${MK_SOURCELESS_UCODE} != "no" && ${MACHINE_CPUARCH} != "arm" && \
 	${MACHINE_ARCH} != "powerpc"
 _cxgbe=		cxgbe
 .endif
 
 .if ${MACHINE_CPUARCH} != "arm" && ${MACHINE_CPUARCH} != "mips" && \
 	${MACHINE_CPUARCH} != "powerpc"
 _syscons=	syscons
 _vpo=		vpo
 .endif
 
 .if ${MACHINE_CPUARCH} != "arm" && ${MACHINE_CPUARCH} != "mips"
 # no BUS_SPACE_UNSPECIFIED
 # No barrier instruction support (specific to this driver)
 _sym=		sym
 # intr_disable() is a macro, causes problems
 .if ${MK_SOURCELESS_UCODE} != "no"
 _cxgb=		cxgb
 .endif
 .endif
 
 .if ${MACHINE_CPUARCH} == "i386" || ${MACHINE_CPUARCH} == "amd64"
 _agp=		agp
 _an=		an
 _aout=		aout
 _bktr=		bktr
 _bxe=		bxe
 _cardbus=	cardbus
 _cbb=		cbb
 _cpuctl=	cpuctl
 _cpufreq=	cpufreq
 _cs=		cs
 _dpms=		dpms
 _drm=		drm
 _drm2=		drm2
 .if ${MK_CDDL} != "no" || defined(ALL_MODULES)
 _dtrace=	dtrace
 .endif
 _ed=		ed
 _em=		em
 _ep=		ep
 _et=		et
 _exca=		exca
 _ext2fs=	ext2fs
 _fe=		fe
 _filemon=	filemon
 _i2c=		i2c
 .if ${MK_OFED} != "no" || defined(ALL_MODULES)
 _ibcore=        ibcore
 .endif
 _if_ndis=	if_ndis
 _igb=		igb
 _io=		io
 .if ${MK_OFED} != "no" || defined(ALL_MODULES)
 _ipoib=         ipoib
 .endif
 _linprocfs=	linprocfs
 _linsysfs=	linsysfs
 _linux=		linux
 .if ${MK_OFED} != "no"
 _linuxapi=	linuxapi
 .endif
 _ndis=		ndis
 .if ${MK_CDDL} != "no" || defined(ALL_MODULES)
 _opensolaris=	opensolaris
 .endif
 _pccard=	pccard
 .if ${MK_OFED} != "no" || defined(ALL_MODULES)
 _rdma=		rdma
 .endif
 _safe=		safe
 _scsi_low=	scsi_low
 _si=		si
 _smbfs=		smbfs
 _sound=		sound
 _speaker=	speaker
 _splash=	splash
 _sppp=		sppp
 _vmware=	vmware
 _vxge=  	vxge
 _wbwd=		wbwd
 _wi=		wi
 _xe=		xe
 .if ${MK_ZFS} != "no" || defined(ALL_MODULES)
 _zfs=		zfs
 .endif
 .if ${MACHINE} != "pc98"
 _aac=		aac
 _aacraid=	aacraid
 _acpi=		acpi
 .if ${MK_CRYPT} != "no" || defined(ALL_MODULES)
 _aesni=		aesni
 .endif
 _amdsbwd=	amdsbwd
 _amdtemp=	amdtemp
 _arcmsr=	arcmsr
 _asmc=		asmc
 _ciss=		ciss
 _cmx=		cmx
 _coretemp=	coretemp
 .if ${MK_SOURCELESS_HOST} != "no"
 _hpt27xx=	hpt27xx
 .endif
 _hptiop=	hptiop
 .if ${MK_SOURCELESS_HOST} != "no"
 _hptmv=		hptmv
 _hptnr=		hptnr
 _hptrr=		hptrr
 .endif
 _hyperv=	hyperv
 _ichwd=		ichwd
 _ida=		ida
 _iir=		iir
 _ipmi=		ipmi
 _ips=		ips
 _ipw=		ipw
 .if ${MK_SOURCELESS_UCODE} != "no"
 _ipwfw=		ipwfw
 .endif
 _isci=		isci
 _iwi=		iwi
 .if ${MK_SOURCELESS_UCODE} != "no"
 _iwifw=		iwifw
 .endif
 _iwn=		iwn
 .if ${MK_SOURCELESS_UCODE} != "no"
 _iwnfw=		iwnfw
 .endif
 _ixgb=		ixgb
 _ixgbe=		ixgbe
 .if ${MK_OFED} != "no" || defined(ALL_MODULES)
 _mlx4=		mlx4
 _mlx4ib=	mlx4ib
 _mlxen=		mlxen
 .endif
 _mly=		mly
 .if ${MK_OFED} != "no" || defined(ALL_MODULES)
 _mthca=		mthca
 .endif
 _nfe=		nfe
 _nvd=		nvd
 _nvme=		nvme
 _nvram=		nvram
 _nxge=		nxge
 .if ${MK_CRYPT} != "no" || defined(ALL_MODULES)
 _padlock=	padlock
 _padlock_rng=	padlock_rng
 _rdrand_rng=	rdrand_rng
 .endif
 _s3=		s3
 _tpm=		tpm
 _twa=		twa
 _vesa=		vesa
 _viawd=		viawd
 _virtio=	virtio
 _wpi=		wpi
 .if ${MK_SOURCELESS_UCODE} != "no"
 _wpifw=		wpifw
 .endif
 _x86bios=	x86bios
 .endif
 .endif
 
 .if ${MACHINE_CPUARCH} == "amd64"
 _ixl=		ixl
 _ixlv=		ixlv
 _ntb=		ntb
 _qlxge=		qlxge
 _qlxgb=		qlxgb
 _qlxgbe=	qlxgbe
 _sfxge=		sfxge
+
+.if ${MK_BHYVE} != "no" || defined(ALL_MODULES)
 _vmm=		vmm
+.endif
 .endif
 
 .if ${MACHINE_CPUARCH} == "i386"
 # XXX some of these can move to the general case when de-i386'ed
 # XXX some of these can move now, but are untested on other architectures.
 _3dfx=		3dfx
 _3dfx_linux=	3dfx_linux
 _aic=		aic
 _apm=		apm
 _arcnet=	arcnet
 .if ${MK_SOURCELESS_UCODE} != "no"
 _ce=		ce
 .endif
 _coff=		coff
 .if ${MK_SOURCELESS_UCODE} != "no"
 _cp=		cp
 .endif
 _elink=		elink
 _glxiic=	glxiic
 _glxsb=		glxsb
 _ibcs2=		ibcs2
 _ie=		ie
 _mse=		mse
 _ncr=		ncr
 _ncv=		ncv
 _nsp=		nsp
 _pcfclock=	pcfclock
 _pst=		pst
 _sbni=		sbni
 _streams=	streams
 _stg=		stg
 _svr4=		svr4
 _wds=		wds
 .if ${MACHINE} == "i386"
 .if ${MK_EISA} != "no"
 _ahb=		ahb
 .endif
 _bios=		bios
 _cm=		cm
 .if ${MK_SOURCELESS_UCODE} != "no"
 _ctau=		ctau
 .endif
 _dpt=		dpt
 _ex=		ex
 _wl=		wl
 .elif ${MACHINE} == "pc98"
 _canbepm=	canbepm
 _canbus=	canbus
 _ct=		ct
 _pmc=		pmc
 _snc=		snc
 .endif
 .endif
 
 .if ${MACHINE_CPUARCH} == "arm"
 _cfi=		cfi
 _cpsw=		cpsw
 _sound=		sound
 .endif
 
 .if ${MACHINE_CPUARCH} == "powerpc"
 _agp=		agp
 _an=		an
 _bm=		bm
 _cardbus=	cardbus
 _cbb=		cbb
 _cfi=		cfi
 _cpufreq=	cpufreq
 _drm=		drm
 .if ${MK_CDDL} != "no" || defined(ALL_MODULES)
 _dtrace=	dtrace
 .endif
 _exca=		exca
 _nvram=		powermac_nvram
 .if ${MK_CDDL} != "no" || defined(ALL_MODULES)
 _opensolaris=	opensolaris
 .endif
 _pccard=	pccard
 _smbfs=		smbfs
 _sound=		sound
 _wi=		wi
 .endif
 
 .if ${MACHINE_ARCH} == "powerpc64"
 .if ${MK_ZFS} != "no" || defined(ALL_MODULES)
 _zfs=		zfs
 .endif
 .endif
 
 .if ${MACHINE_CPUARCH} == "sparc64"
 _auxio=		auxio
 _em=		em
 _epic=		epic
 _i2c=		i2c
 _igb=		igb
 .if ${MK_CDDL} != "no" || defined(ALL_MODULES)
 _opensolaris=	opensolaris
 .endif
 _smbfs=		smbfs
 _sound=		sound
 .if ${MK_ZFS} != "no" || defined(ALL_MODULES)
 _zfs=		zfs
 .endif
 .endif
 
 .endif
 
 .for reject in ${WITHOUT_MODULES}
 SUBDIR:= ${SUBDIR:N${reject}}
 .endfor
 
 # Calling kldxref(8) for each module is expensive.
 .if !defined(NO_XREF)
 .MAKEFLAGS+=	-DNO_XREF
 afterinstall:
 	@if type kldxref >/dev/null 2>&1; then \
 		${ECHO} kldxref ${DESTDIR}${KMODDIR}; \
 		kldxref ${DESTDIR}${KMODDIR}; \
 	fi
 .endif
 
 .include <bsd.subdir.mk>
Index: projects/clang360-import/sys/modules/iscsi/Makefile
===================================================================
--- projects/clang360-import/sys/modules/iscsi/Makefile	(revision 277777)
+++ projects/clang360-import/sys/modules/iscsi/Makefile	(revision 277778)
@@ -1,25 +1,15 @@
 # $FreeBSD$
 
 .PATH:	${.CURDIR}/../../dev/iscsi/
 KMOD=	iscsi
 
 SRCS=	iscsi.c
-.if defined(ICL_RDMA)
-SRCS+=	icl_rdma.c
-.else
 SRCS+=	icl.c
-.endif
 SRCS+=	icl_proxy.c
 SRCS+=	opt_cam.h
 SRCS+=	bus_if.h
 SRCS+=	device_if.h
 
-# Those below are required for RDMA.
-SRCS+=	vnode_if.h
-SRCS+=	opt_inet.h
-SRCS+=	opt_inet6.h
-
-CFLAGS+= -I${.CURDIR}/../../ofed/include
 #CFLAGS+=-DICL_KERNEL_PROXY
 
 .include <bsd.kmod.mk>
Index: projects/clang360-import/sys
===================================================================
--- projects/clang360-import/sys	(revision 277777)
+++ projects/clang360-import/sys	(revision 277778)

Property changes on: projects/clang360-import/sys
___________________________________________________________________
Modified: svn:mergeinfo
## -0,0 +0,1 ##
   Merged /head/sys:r277719-277776
Index: projects/clang360-import/tools/build/mk/OptionalObsoleteFiles.inc
===================================================================
--- projects/clang360-import/tools/build/mk/OptionalObsoleteFiles.inc	(revision 277777)
+++ projects/clang360-import/tools/build/mk/OptionalObsoleteFiles.inc	(revision 277778)
@@ -1,5007 +1,5065 @@
 #
 # $FreeBSD$
 #
 # This file add support for the WITHOUT_* and WITH_* knobs in src.conf(5) to
 # the check-old and delete-old* targets.
 #
 
 .if ${MK_ACCT} == no
+OLD_FILES+=etc/rc.d/accounting
 OLD_FILES+=etc/periodic/daily/310.accounting
 OLD_FILES+=usr/sbin/accton
 OLD_FILES+=usr/sbin/sa
 OLD_FILES+=usr/share/man/man8/accton.8.gz
 OLD_FILES+=usr/share/man/man8/sa.8.gz
 .endif
 
 .if ${MK_ACPI} == no
+OLD_FILES+=etc/devd/asus.conf
+OLD_FILES+=etc/rc.d/power_profile
 OLD_FILES+=usr/sbin/acpiconf
 OLD_FILES+=usr/sbin/acpidb
 OLD_FILES+=usr/sbin/acpidump
 OLD_FILES+=usr/sbin/iasl
 OLD_FILES+=usr/share/man/man8/acpiconf.8.gz
 OLD_FILES+=usr/share/man/man8/acpidb.8.gz
 OLD_FILES+=usr/share/man/man8/acpidump.8.gz
 OLD_FILES+=usr/share/man/man8/iasl.8.gz
 .endif
 
 .if ${MK_AMD} == no
 OLD_FILES+=etc/amd.map
+OLD_FILES+=etc/rc.d/amd
 OLD_FILES+=usr/bin/pawd
 OLD_FILES+=usr/sbin/amd
 OLD_FILES+=usr/sbin/amq
 OLD_FILES+=usr/sbin/fixmount
 OLD_FILES+=usr/sbin/fsinfo
 OLD_FILES+=usr/sbin/hlfsd
 OLD_FILES+=usr/sbin/mk-amd-map
 OLD_FILES+=usr/sbin/wire-test
 OLD_FILES+=usr/share/examples/etc/amd.map
 OLD_FILES+=usr/share/info/am-utils.info.gz
 OLD_FILES+=usr/share/man/man1/pawd.1.gz
 OLD_FILES+=usr/share/man/man5/amd.conf.5.gz
 OLD_FILES+=usr/share/man/man8/amd.8.gz
 OLD_FILES+=usr/share/man/man8/amq.8.gz
 OLD_FILES+=usr/share/man/man8/fixmount.8.gz
 OLD_FILES+=usr/share/man/man8/fsinfo.8.gz
 OLD_FILES+=usr/share/man/man8/hlfsd.8.gz
 OLD_FILES+=usr/share/man/man8/mk-amd-map.8.gz
 OLD_FILES+=usr/share/man/man8/wire-test.8.gz
 .endif
 
 .if ${MK_APM} == no
+OLD_FILES+=etc/rc.d/apm
+OLD_FILES+=etc/rc.d/apmd
 OLD_FILES+=etc/apmd.conf
 OLD_FILES+=usr/sbin/apm
 OLD_FILES+=usr/share/examples/etc/apmd.conf
 OLD_FILES+=usr/share/man/man8/amd64/apm.8.gz
 OLD_FILES+=usr/share/man/man8/amd64/apmconf.8.gz
 .endif
 
 .if ${MK_AT} == no
+OLD_FILES+=etc/pam.d/atrun
 OLD_FILES+=usr/bin/at
 OLD_FILES+=usr/bin/atq
 OLD_FILES+=usr/bin/atrm
 OLD_FILES+=usr/bin/batch
 OLD_FILES+=usr/libexec/atrun
 OLD_FILES+=usr/share/man/man1/at.1.gz
 OLD_FILES+=usr/share/man/man1/atq.1.gz
 OLD_FILES+=usr/share/man/man1/atrm.1.gz
 OLD_FILES+=usr/share/man/man1/batch.1.gz
 OLD_FILES+=usr/share/man/man8/atrun.8.gz
 .endif
 
 .if ${MK_ATM} == no
 OLD_FILES+=rescue/atmconfig
 OLD_FILES+=sbin/atmconfig
 OLD_FILES+=usr/bin/sscop
 OLD_FILES+=usr/include/bsnmp/snmp_atm.h
 OLD_FILES+=usr/include/netnatm/addr.h
 OLD_FILES+=usr/include/netnatm/api/atmapi.h
 OLD_FILES+=usr/include/netnatm/api/ccatm.h
 OLD_FILES+=usr/include/netnatm/api/unisap.h
 OLD_DIRS+=usr/include/netnatm/api
 OLD_FILES+=usr/include/netnatm/msg/uni_config.h
 OLD_FILES+=usr/include/netnatm/msg/uni_hdr.h
 OLD_FILES+=usr/include/netnatm/msg/uni_ie.h
 OLD_FILES+=usr/include/netnatm/msg/uni_msg.h
 OLD_FILES+=usr/include/netnatm/msg/unimsglib.h
 OLD_FILES+=usr/include/netnatm/msg/uniprint.h
 OLD_FILES+=usr/include/netnatm/msg/unistruct.h
 OLD_DIRS+=usr/include/netnatm/msg
 OLD_FILES+=usr/include/netnatm/saal/sscfu.h
 OLD_FILES+=usr/include/netnatm/saal/sscfudef.h
 OLD_FILES+=usr/include/netnatm/saal/sscop.h
 OLD_FILES+=usr/include/netnatm/saal/sscopdef.h
 OLD_DIRS+=usr/include/netnatm/saal
 OLD_FILES+=usr/include/netnatm/sig/uni.h
 OLD_FILES+=usr/include/netnatm/sig/unidef.h
 OLD_FILES+=usr/include/netnatm/sig/unisig.h
 OLD_DIRS+=usr/include/netnatm/sig
 OLD_FILES+=usr/include/netnatm/unimsg.h
 OLD_FILES+=usr/lib/libngatm.a
 OLD_FILES+=usr/lib/libngatm.so
 OLD_LIBS+=usr/lib/libngatm.so.4
 OLD_FILES+=usr/lib/libngatm_p.a
 OLD_FILES+=usr/lib/snmp_atm.so
 OLD_LIBS+=usr/lib/snmp_atm.so.6
 .if ${TARGET_ARCH} == "amd64" || ${TARGET_ARCH} == "powerpc64"
 OLD_FILES+=usr/lib32/libngatm.a
 OLD_FILES+=usr/lib32/libngatm.so
 OLD_LIBS+=usr/lib32/libngatm.so.4
 OLD_FILES+=usr/lib32/libngatm_p.a
 .endif
 OLD_FILES+=usr/share/doc/atm/atmconfig.help
 OLD_FILES+=usr/share/doc/atm/atmconfig_device.help
 OLD_DIRS+=usr/share/doc/atm
 OLD_FILES+=usr/share/man/man1/sscop.1.gz
 OLD_FILES+=usr/share/man/man3/libngatm.3.gz
 OLD_FILES+=usr/share/man/man3/snmp_atm.3.gz
 OLD_FILES+=usr/share/man/man3/uniaddr.3.gz
 OLD_FILES+=usr/share/man/man3/unifunc.3.gz
 OLD_FILES+=usr/share/man/man3/unimsg.3.gz
 OLD_FILES+=usr/share/man/man3/unisap.3.gz
 OLD_FILES+=usr/share/man/man3/unistruct.3.gz
 OLD_FILES+=usr/share/man/man8/atmconfig.8.gz
 OLD_FILES+=usr/share/snmp/defs/atm_freebsd.def
 OLD_FILES+=usr/share/snmp/defs/atm_tree.def
 OLD_FILES+=usr/share/snmp/mibs/BEGEMOT-ATM-FREEBSD-MIB.txt
 OLD_FILES+=usr/share/snmp/mibs/BEGEMOT-ATM.txt
 .endif
 
 .if ${MK_AUDIT} == no
 OLD_FILES+=usr/sbin/audit
 OLD_FILES+=usr/sbin/auditd
 OLD_FILES+=usr/sbin/auditreduce
 OLD_FILES+=usr/sbin/praudit
 OLD_FILES+=usr/share/man/man1/auditreduce.1.gz
 OLD_FILES+=usr/share/man/man1/praudit.1.gz
 OLD_FILES+=usr/share/man/man8/audit.8.gz
 OLD_FILES+=usr/share/man/man8/auditd.8.gz
 .endif
 
 .if ${MK_AUTHPF} == no
 OLD_FILES+=usr/sbin/authpf
 OLD_FILES+=usr/sbin/authpf-noip
 OLD_FILES+=usr/share/man/man8/authpf.8.gz
 OLD_FILES+=usr/share/man/man8/authpf-noip.8.gz
 .endif
 
+.if ${MK_AUTOFS} == no
+OLD_FILES+=etc/autofs/include_ldap
+OLD_FILES+=etc/autofs/special_hosts
+OLD_FILES+=etc/autofs/special_media
+OLD_FILES+=etc/autofs/special_null
+OLD_FILES+=etc/auto_master
+OLD_FILES+=etc/rc.d/automount
+OLD_FILES+=etc/rc.d/automountd
+OLD_FILES+=etc/rc.d/autounmountd
+OLD_FILES+=usr/sbin/automount
+OLD_FILES+=usr/sbin/automountd
+OLD_FILES+=usr/sbin/autounmountd
+OLD_FILES+=usr/share/man/man5/autofs.5.gz
+OLD_FILES+=usr/share/man/man5/auto_master.5.gz
+OLD_FILES+=usr/share/man/man8/automount.8.gz
+OLD_FILES+=usr/share/man/man8/automountd.8.gz
+OLD_FILES+=usr/share/man/man8/autounmountd.8.gz
+OLD_DIRS+=etc/autofs
+.endif
+
+.if ${MK_BHYVE} == no
+OLD_FILES+=usr/sbin/bhyve
+OLD_FILES+=usr/sbin/bhyvectl
+OLD_FILES+=usr/sbin/bhyveload
+OLD_FILES+=usr/share/examples/bhyve/vmrun.sh
+OLD_FILES+=usr/share/man/man8/bhyve.8.gz
+OLD_FILES+=usr/share/man/man8/bhyveload.8.gz
+OLD_DIRS+=usr/share/examples/bhyve
+.endif
+
 .if ${MK_BLUETOOTH} == no
 OLD_FILES+=etc/bluetooth/hcsecd.conf
 OLD_FILES+=etc/bluetooth/hosts
 OLD_FILES+=etc/bluetooth/protocols
+OLD_FILES+=etc/defaults/bluetooth.device.conf
 OLD_DIRS+=etc/bluetooth
 OLD_FILES+=usr/bin/bthost
 OLD_FILES+=usr/bin/btsockstat
 OLD_FILES+=usr/bin/rfcomm_sppd
 OLD_FILES+=usr/include/bluetooth.h
 OLD_FILES+=usr/include/netgraph/bluetooth/include/ng_bluetooth.h
 OLD_FILES+=usr/include/netgraph/bluetooth/include/ng_bt3c.h
 OLD_FILES+=usr/include/netgraph/bluetooth/include/ng_btsocket.h
 OLD_FILES+=usr/include/netgraph/bluetooth/include/ng_btsocket_hci_raw.h
 OLD_FILES+=usr/include/netgraph/bluetooth/include/ng_btsocket_l2cap.h
 OLD_FILES+=usr/include/netgraph/bluetooth/include/ng_btsocket_rfcomm.h
 OLD_FILES+=usr/include/netgraph/bluetooth/include/ng_btsocket_sco.h
 OLD_FILES+=usr/include/netgraph/bluetooth/include/ng_h4.h
 OLD_FILES+=usr/include/netgraph/bluetooth/include/ng_hci.h
 OLD_FILES+=usr/include/netgraph/bluetooth/include/ng_l2cap.h
 OLD_FILES+=usr/include/netgraph/bluetooth/include/ng_ubt.h
 OLD_DIRS+=usr/include/netgraph/bluetooth/include
 OLD_DIRS+=usr/include/netgraph/bluetooth
 OLD_FILES+=usr/include/sdp.h
 OLD_FILES+=usr/lib/libbluetooth.a
 OLD_FILES+=usr/lib/libbluetooth.so
 OLD_LIBS+=usr/lib/libbluetooth.so.4
 OLD_FILES+=usr/lib/libbluetooth_p.a
 OLD_FILES+=usr/lib/libsdp.a
 OLD_FILES+=usr/lib/libsdp.so
 OLD_LIBS+=usr/lib/libsdp.so.4
 OLD_FILES+=usr/lib/libsdp_p.a
 .if ${TARGET_ARCH} == "amd64" || ${TARGET_ARCH} == "powerpc64"
 OLD_FILES+=usr/lib32/libbluetooth.a
 OLD_FILES+=usr/lib32/libbluetooth.so
 OLD_LIBS+=usr/lib32/libbluetooth.so.4
 OLD_FILES+=usr/lib32/libbluetooth_p.a
 OLD_FILES+=usr/lib32/libsdp.a
 OLD_FILES+=usr/lib32/libsdp.so
 OLD_LIBS+=usr/lib32/libsdp.so.4
 OLD_FILES+=usr/lib32/libsdp_p.a
 .endif
 OLD_FILES+=usr/sbin/bcmfw
 OLD_FILES+=usr/sbin/bt3cfw
 OLD_FILES+=usr/sbin/bthidcontrol
 OLD_FILES+=usr/sbin/bthidd
 OLD_FILES+=usr/sbin/btpand
 OLD_FILES+=usr/sbin/hccontrol
 OLD_FILES+=usr/sbin/hcsecd
 OLD_FILES+=usr/sbin/hcseriald
 OLD_FILES+=usr/sbin/l2control
 OLD_FILES+=usr/sbin/l2ping
 OLD_FILES+=usr/sbin/rfcomm_pppd
 OLD_FILES+=usr/sbin/sdpcontrol
 OLD_FILES+=usr/sbin/sdpd
 OLD_FILES+=usr/share/man/man1/bthost.1.gz
 OLD_FILES+=usr/share/man/man1/btsockstat.1.gz
 OLD_FILES+=usr/share/man/man1/rfcomm_sppd.1.gz
 OLD_FILES+=usr/share/man/man3/SDP_GET128.3.gz
 OLD_FILES+=usr/share/man/man3/SDP_GET16.3.gz
 OLD_FILES+=usr/share/man/man3/SDP_GET32.3.gz
 OLD_FILES+=usr/share/man/man3/SDP_GET64.3.gz
 OLD_FILES+=usr/share/man/man3/SDP_GET8.3.gz
 OLD_FILES+=usr/share/man/man3/SDP_PUT128.3.gz
 OLD_FILES+=usr/share/man/man3/SDP_PUT16.3.gz
 OLD_FILES+=usr/share/man/man3/SDP_PUT32.3.gz
 OLD_FILES+=usr/share/man/man3/SDP_PUT64.3.gz
 OLD_FILES+=usr/share/man/man3/SDP_PUT8.3.gz
 OLD_FILES+=usr/share/man/man3/bdaddr_any.3.gz
 OLD_FILES+=usr/share/man/man3/bdaddr_copy.3.gz
 OLD_FILES+=usr/share/man/man3/bdaddr_same.3.gz
 OLD_FILES+=usr/share/man/man3/bluetooth.3.gz
 OLD_FILES+=usr/share/man/man3/bt_aton.3.gz
 OLD_FILES+=usr/share/man/man3/bt_devaddr.3.gz
 OLD_FILES+=usr/share/man/man3/bt_devclose.3.gz
 OLD_FILES+=usr/share/man/man3/bt_devenum.3.gz
 OLD_FILES+=usr/share/man/man3/bt_devfilter.3.gz
 OLD_FILES+=usr/share/man/man3/bt_devfilter_evt_clr.3.gz
 OLD_FILES+=usr/share/man/man3/bt_devfilter_evt_set.3.gz
 OLD_FILES+=usr/share/man/man3/bt_devfilter_evt_tst.3.gz
 OLD_FILES+=usr/share/man/man3/bt_devfilter_pkt_clr.3.gz
 OLD_FILES+=usr/share/man/man3/bt_devfilter_pkt_set.3.gz
 OLD_FILES+=usr/share/man/man3/bt_devfilter_pkt_tst.3.gz
 OLD_FILES+=usr/share/man/man3/bt_devinfo.3.gz
 OLD_FILES+=usr/share/man/man3/bt_devinquiry.3.gz
 OLD_FILES+=usr/share/man/man3/bt_devname.3.gz
 OLD_FILES+=usr/share/man/man3/bt_devopen.3.gz
 OLD_FILES+=usr/share/man/man3/bt_devreq.3.gz
 OLD_FILES+=usr/share/man/man3/bt_devsend.3.gz
 OLD_FILES+=usr/share/man/man3/bt_endhostent.3.gz
 OLD_FILES+=usr/share/man/man3/bt_endprotoent.3.gz
 OLD_FILES+=usr/share/man/man3/bt_gethostbyaddr.3.gz
 OLD_FILES+=usr/share/man/man3/bt_gethostbyname.3.gz
 OLD_FILES+=usr/share/man/man3/bt_gethostent.3.gz
 OLD_FILES+=usr/share/man/man3/bt_getprotobyname.3.gz
 OLD_FILES+=usr/share/man/man3/bt_getprotobynumber.3.gz
 OLD_FILES+=usr/share/man/man3/bt_getprotoent.3.gz
 OLD_FILES+=usr/share/man/man3/bt_ntoa.3.gz
 OLD_FILES+=usr/share/man/man3/bt_sethostent.3.gz
 OLD_FILES+=usr/share/man/man3/bt_setprotoent.3.gz
 OLD_FILES+=usr/share/man/man3/sdp.3.gz
 OLD_FILES+=usr/share/man/man3/sdp_attr2desc.3.gz
 OLD_FILES+=usr/share/man/man3/sdp_change_service.3.gz
 OLD_FILES+=usr/share/man/man3/sdp_close.3.gz
 OLD_FILES+=usr/share/man/man3/sdp_error.3.gz
 OLD_FILES+=usr/share/man/man3/sdp_open.3.gz
 OLD_FILES+=usr/share/man/man3/sdp_open_local.3.gz
 OLD_FILES+=usr/share/man/man3/sdp_register_service.3.gz
 OLD_FILES+=usr/share/man/man3/sdp_search.3.gz
 OLD_FILES+=usr/share/man/man3/sdp_unregister_service.3.gz
 OLD_FILES+=usr/share/man/man3/sdp_uuid2desc.3.gz
 OLD_FILES+=usr/share/man/man5/hcsecd.conf.5.gz
 OLD_FILES+=usr/share/man/man8/bcmfw.8.gz
 OLD_FILES+=usr/share/man/man8/bt3cfw.8.gz
 OLD_FILES+=usr/share/man/man8/bthidcontrol.8.gz
 OLD_FILES+=usr/share/man/man8/bthidd.8.gz
 OLD_FILES+=usr/share/man/man8/btpand.8.gz
 OLD_FILES+=usr/share/man/man8/hccontrol.8.gz
 OLD_FILES+=usr/share/man/man8/hcsecd.8.gz
 OLD_FILES+=usr/share/man/man8/hcseriald.8.gz
 OLD_FILES+=usr/share/man/man8/l2control.8.gz
 OLD_FILES+=usr/share/man/man8/l2ping.8.gz
 OLD_FILES+=usr/share/man/man8/rfcomm_pppd.8.gz
 OLD_FILES+=usr/share/man/man8/sdpcontrol.8.gz
 OLD_FILES+=usr/share/man/man8/sdpd.8.gz
 .endif
 
 #.if ${MK_BOOT} == no
 # to be filled in
 #.endif
 
 .if ${MK_BSDINSTALL} == no
 OLD_FILES+=usr/libexec/bsdinstall/adduser
 OLD_FILES+=usr/libexec/bsdinstall/auto
 OLD_FILES+=usr/libexec/bsdinstall/autopart
 OLD_FILES+=usr/libexec/bsdinstall/checksum
 OLD_FILES+=usr/libexec/bsdinstall/config
 OLD_FILES+=usr/libexec/bsdinstall/distextract
 OLD_FILES+=usr/libexec/bsdinstall/distfetch
 OLD_FILES+=usr/libexec/bsdinstall/docsinstall
 OLD_FILES+=usr/libexec/bsdinstall/entropy
 OLD_FILES+=usr/libexec/bsdinstall/hostname
 OLD_FILES+=usr/libexec/bsdinstall/jail
 OLD_FILES+=usr/libexec/bsdinstall/keymap
 OLD_FILES+=usr/libexec/bsdinstall/mirrorselect
 OLD_FILES+=usr/libexec/bsdinstall/mount
 OLD_FILES+=usr/libexec/bsdinstall/netconfig
 OLD_FILES+=usr/libexec/bsdinstall/netconfig_ipv4
 OLD_FILES+=usr/libexec/bsdinstall/netconfig_ipv6
 OLD_FILES+=usr/libexec/bsdinstall/partedit
 OLD_FILES+=usr/libexec/bsdinstall/rootpass
 OLD_FILES+=usr/libexec/bsdinstall/script
 OLD_FILES+=usr/libexec/bsdinstall/scriptedpart
 OLD_FILES+=usr/libexec/bsdinstall/services
 OLD_FILES+=usr/libexec/bsdinstall/time
 OLD_FILES+=usr/libexec/bsdinstall/umount
 OLD_FILES+=usr/libexec/bsdinstall/wlanconfig
 OLD_FILES+=usr/libexec/bsdinstall/zfsboot
 OLD_FILES+=usr/sbin/bsdinstall
 OLD_FILES+=usr/share/man/man8/bsdinstall.8.gz
 OLD_FILES+=usr/share/man/man8/sade.8.gz
 OLD_DIRS+=usr/libexec/bsdinstall
 .endif
 
 .if ${MK_BSNMP} == no
 OLD_FILES+=etc/snmpd.config
 OLD_FILES+=etc/rc.d/bsnmpd
 OLD_FILES+=usr/bin/bsnmpget
 OLD_FILES+=usr/bin/bsnmpset
 OLD_FILES+=usr/bin/bsnmpwalk
 OLD_FILES+=usr/include/bsnmp/asn1.h
 OLD_FILES+=usr/include/bsnmp/bridge_snmp.h
 OLD_FILES+=usr/include/bsnmp/snmp.h
 OLD_FILES+=usr/include/bsnmp/snmp_atm.h
 OLD_FILES+=usr/include/bsnmp/snmp_mibII.h
 OLD_FILES+=usr/include/bsnmp/snmp_netgraph.h
 OLD_FILES+=usr/include/bsnmp/snmpagent.h
 OLD_FILES+=usr/include/bsnmp/snmpclient.h
 OLD_FILES+=usr/include/bsnmp/snmpmod.h
 OLD_FILES+=usr/lib/libbsnmp.a
 OLD_LIBS+=usr/lib/libbsnmp.so.6
 OLD_FILES+=usr/lib/libbsnmp_p.a
 OLD_FILES+=usr/lib/libbsnmptools.a
 OLD_LIBS+=usr/lib/libbsnmptools.so.0
 OLD_FILES+=usr/lib/libbsnmptools_p.a
 OLD_LIBS+=usr/lib/snmp_atm.so.6
 OLD_LIBS+=usr/lib/snmp_bridge.so.6
 OLD_LIBS+=usr/lib/snmp_hast.so.6
 OLD_LIBS+=usr/lib/snmp_hostres.so.6
 OLD_LIBS+=usr/lib/snmp_lm75.so.6
 OLD_LIBS+=usr/lib/snmp_mibII.so.6
 OLD_LIBS+=usr/lib/snmp_netgraph.so.6
 OLD_LIBS+=usr/lib/snmp_pf.so.6
 OLD_LIBS+=usr/lib/snmp_target.so.6
 OLD_LIBS+=usr/lib/snmp_usm.so.6
 OLD_LIBS+=usr/lib/snmp_vacm.so.6
 OLD_LIBS+=usr/lib/snmp_wlan.so.6
 OLD_FILES+=usr/sbin/bsnmpd
 OLD_FILES+=usr/sbin/gensnmptree
 OLD_FILES+=usr/share/man/man1/bsnmpd.1.gz
 OLD_FILES+=usr/share/man/man1/bsnmpget.1.gz
 OLD_FILES+=usr/share/man/man1/bsnmpset.1.gz
 OLD_FILES+=usr/share/man/man1/bsnmpwalk.1.gz
 OLD_FILES+=usr/share/man/man1/gensnmptree.1.gz
 OLD_FILES+=usr/share/man/man3/asn1.3.gz
 OLD_FILES+=usr/share/man/man3/bsnmpagent.3.gz
 OLD_FILES+=usr/share/man/man3/bsnmpclient.3.gz
 OLD_FILES+=usr/share/man/man3/bsnmplib.3.gz
 OLD_FILES+=usr/share/man/man3/snmp_atm.3.gz
 OLD_FILES+=usr/share/man/man3/snmp_bridge.3.gz
 OLD_FILES+=usr/share/man/man3/snmp_hast.3.gz
 OLD_FILES+=usr/share/man/man3/snmp_hostres.3.gz
 OLD_FILES+=usr/share/man/man3/snmp_lm75.3.gz
 OLD_FILES+=usr/share/man/man3/snmp_mibII.3.gz
 OLD_FILES+=usr/share/man/man3/snmp_netgraph.3.gz
 OLD_FILES+=usr/share/man/man3/snmp_target.3.gz
 OLD_FILES+=usr/share/man/man3/snmp_usm.3.gz
 OLD_FILES+=usr/share/man/man3/snmp_vacm.3.gz
 OLD_FILES+=usr/share/man/man3/snmp_wlan.3.gz
 OLD_FILES+=usr/share/man/man3/snmpmod.3.gz
 OLD_FILES+=usr/share/snmp/defs/atm_freebsd.def
 OLD_FILES+=usr/share/snmp/defs/atm_tree.def
 OLD_FILES+=usr/share/snmp/defs/bridge_tree.def
 OLD_FILES+=usr/share/snmp/defs/hast_tree.def
 OLD_FILES+=usr/share/snmp/defs/hostres_tree.def
 OLD_FILES+=usr/share/snmp/defs/lm75_tree.def
 OLD_FILES+=usr/share/snmp/defs/mibII_tree.def
 OLD_FILES+=usr/share/snmp/defs/netgraph_tree.def
 OLD_FILES+=usr/share/snmp/defs/pf_tree.def
 OLD_FILES+=usr/share/snmp/defs/target_tree.def
 OLD_FILES+=usr/share/snmp/defs/tree.def
 OLD_FILES+=usr/share/snmp/defs/usm_tree.def
 OLD_FILES+=usr/share/snmp/defs/vacm_tree.def
 OLD_FILES+=usr/share/snmp/defs/wlan_tree.def
 OLD_FILES+=usr/share/snmp/mibs/BEGEMOT-ATM-FREEBSD-MIB.txt
 OLD_FILES+=usr/share/snmp/mibs/BEGEMOT-ATM.txt
 OLD_FILES+=usr/share/snmp/mibs/BEGEMOT-BRIDGE-MIB.txt
 OLD_FILES+=usr/share/snmp/mibs/BEGEMOT-HAST-MIB.txt
 OLD_FILES+=usr/share/snmp/mibs/BEGEMOT-HOSTRES-MIB.txt
 OLD_FILES+=usr/share/snmp/mibs/BEGEMOT-IP-MIB.txt
 OLD_FILES+=usr/share/snmp/mibs/BEGEMOT-LM75-MIB.txt
 OLD_FILES+=usr/share/snmp/mibs/BEGEMOT-MIB.txt
 OLD_FILES+=usr/share/snmp/mibs/BEGEMOT-MIB2-MIB.txt
 OLD_FILES+=usr/share/snmp/mibs/BEGEMOT-NETGRAPH.txt
 OLD_FILES+=usr/share/snmp/mibs/BEGEMOT-PF-MIB.txt
 OLD_FILES+=usr/share/snmp/mibs/BEGEMOT-SNMPD.txt
 OLD_FILES+=usr/share/snmp/mibs/BEGEMOT-WIRELESS-MIB.txt
 OLD_FILES+=usr/share/snmp/mibs/BRIDGE-MIB.txt
 OLD_FILES+=usr/share/snmp/mibs/FOKUS-MIB.txt
 OLD_FILES+=usr/share/snmp/mibs/FREEBSD-MIB.txt
 OLD_FILES+=usr/share/snmp/mibs/RSTP-MIB.txt
 OLD_DIRS+=usr/include/bsnmp
 OLD_DIRS+=usr/share/snmp
 OLD_DIRS+=usr/share/snmp/defs
 OLD_DIRS+=usr/share/snmp/mibs
 .endif
 
 .if ${MK_CALENDAR} == no
 OLD_FILES+=etc/periodic/daily/300.calendar
 OLD_FILES+=usr/bin/calendar
 OLD_FILES+=usr/share/calendar/calendar.all
 OLD_FILES+=usr/share/calendar/calendar.australia
 OLD_FILES+=usr/share/calendar/calendar.birthday
 OLD_FILES+=usr/share/calendar/calendar.brazilian
 OLD_FILES+=usr/share/calendar/calendar.christian
 OLD_FILES+=usr/share/calendar/calendar.computer
 OLD_FILES+=usr/share/calendar/calendar.croatian
 OLD_FILES+=usr/share/calendar/calendar.dutch
 OLD_FILES+=usr/share/calendar/calendar.freebsd
 OLD_FILES+=usr/share/calendar/calendar.french
 OLD_FILES+=usr/share/calendar/calendar.german
 OLD_FILES+=usr/share/calendar/calendar.history
 OLD_FILES+=usr/share/calendar/calendar.holiday
 OLD_FILES+=usr/share/calendar/calendar.hungarian
 OLD_FILES+=usr/share/calendar/calendar.judaic
 OLD_FILES+=usr/share/calendar/calendar.lotr
 OLD_FILES+=usr/share/calendar/calendar.music
 OLD_FILES+=usr/share/calendar/calendar.newzealand
 OLD_FILES+=usr/share/calendar/calendar.russian
 OLD_FILES+=usr/share/calendar/calendar.southafrica
 OLD_FILES+=usr/share/calendar/calendar.ukrainian
 OLD_FILES+=usr/share/calendar/calendar.usholiday
 OLD_FILES+=usr/share/calendar/calendar.world
 OLD_FILES+=usr/share/calendar/de_AT.ISO_8859-15/calendar.feiertag
 OLD_DIRS+=usr/share/calendar/de_AT.ISO_8859-15
 OLD_FILES+=usr/share/calendar/de_DE.ISO8859-1/calendar.all
 OLD_FILES+=usr/share/calendar/de_DE.ISO8859-1/calendar.feiertag
 OLD_FILES+=usr/share/calendar/de_DE.ISO8859-1/calendar.geschichte
 OLD_FILES+=usr/share/calendar/de_DE.ISO8859-1/calendar.kirche
 OLD_FILES+=usr/share/calendar/de_DE.ISO8859-1/calendar.literatur
 OLD_FILES+=usr/share/calendar/de_DE.ISO8859-1/calendar.musik
 OLD_FILES+=usr/share/calendar/de_DE.ISO8859-1/calendar.wissenschaft
 OLD_DIRS+=usr/share/calendar/de_DE.ISO8859-1
 OLD_FILES+=usr/share/calendar/de_DE.ISO8859-15
 OLD_FILES+=usr/share/calendar/fr_FR.ISO8859-1/calendar.all
 OLD_FILES+=usr/share/calendar/fr_FR.ISO8859-1/calendar.fetes
 OLD_FILES+=usr/share/calendar/fr_FR.ISO8859-1/calendar.french
 OLD_FILES+=usr/share/calendar/fr_FR.ISO8859-1/calendar.jferies
 OLD_FILES+=usr/share/calendar/fr_FR.ISO8859-1/calendar.proverbes
 OLD_DIRS+=usr/share/calendar/fr_FR.ISO8859-1
 OLD_FILES+=usr/share/calendar/fr_FR.ISO8859-15
 OLD_FILES+=usr/share/calendar/hr_HR.ISO8859-2/calendar.all
 OLD_FILES+=usr/share/calendar/hr_HR.ISO8859-2/calendar.praznici
 OLD_DIRS+=usr/share/calendar/hr_HR.ISO8859-2
 OLD_FILES+=usr/share/calendar/hu_HU.ISO8859-2/calendar.all
 OLD_FILES+=usr/share/calendar/hu_HU.ISO8859-2/calendar.nevnapok
 OLD_FILES+=usr/share/calendar/hu_HU.ISO8859-2/calendar.unnepek
 OLD_DIRS+=usr/share/calendar/hu_HU.ISO8859-2
 OLD_FILES+=usr/share/calendar/pt_BR.ISO8859-1/calendar.all
 OLD_FILES+=usr/share/calendar/pt_BR.ISO8859-1/calendar.commemorative
 OLD_FILES+=usr/share/calendar/pt_BR.ISO8859-1/calendar.holidays
 OLD_FILES+=usr/share/calendar/pt_BR.ISO8859-1/calendar.mcommemorative
 OLD_DIRS+=usr/share/calendar/pt_BR.ISO8859-1
 OLD_FILES+=usr/share/calendar/pt_BR.UTF-8/calendar.all
 OLD_FILES+=usr/share/calendar/pt_BR.UTF-8/calendar.commemorative
 OLD_FILES+=usr/share/calendar/pt_BR.UTF-8/calendar.holidays
 OLD_FILES+=usr/share/calendar/pt_BR.UTF-8/calendar.mcommemorative
 OLD_DIRS+=usr/share/calendar/pt_BR.UTF-8
 OLD_FILES+=usr/share/calendar/ru_RU.KOI8-R/calendar.all
 OLD_FILES+=usr/share/calendar/ru_RU.KOI8-R/calendar.common
 OLD_FILES+=usr/share/calendar/ru_RU.KOI8-R/calendar.holiday
 OLD_FILES+=usr/share/calendar/ru_RU.KOI8-R/calendar.military
 OLD_FILES+=usr/share/calendar/ru_RU.KOI8-R/calendar.orthodox
 OLD_FILES+=usr/share/calendar/ru_RU.KOI8-R/calendar.pagan
 OLD_DIRS+=usr/share/calendar/ru_RU.KOI8-R
 OLD_FILES+=usr/share/calendar/ru_RU.UTF-8/calendar.all
 OLD_FILES+=usr/share/calendar/ru_RU.UTF-8/calendar.common
 OLD_FILES+=usr/share/calendar/ru_RU.UTF-8/calendar.holiday
 OLD_FILES+=usr/share/calendar/ru_RU.UTF-8/calendar.military
 OLD_FILES+=usr/share/calendar/ru_RU.UTF-8/calendar.orthodox
 OLD_FILES+=usr/share/calendar/ru_RU.UTF-8/calendar.pagan
 OLD_DIRS+=usr/share/calendar/ru_RU.UTF-8
 OLD_FILES+=usr/share/calendar/uk_UA.KOI8-U/calendar.all
 OLD_FILES+=usr/share/calendar/uk_UA.KOI8-U/calendar.holiday
 OLD_FILES+=usr/share/calendar/uk_UA.KOI8-U/calendar.misc
 OLD_FILES+=usr/share/calendar/uk_UA.KOI8-U/calendar.orthodox
 OLD_DIRS+=usr/share/calendar/uk_UA.KOI8-U
 OLD_DIRS+=usr/share/calendar
 OLD_FILES+=usr/share/man/man1/calendar.1.gz
 .endif
 
 .if ${MK_CASPER} == no
 OLD_FILES+=etc/rc.d/casperd
 OLD_LIBS+=lib/libcasper.so.0
 OLD_FILES+=sbin/casper
 OLD_FILES+=usr/lib/libcasper.a
 .endif
 
 .if ${MK_CCD} == no
 OLD_FILES+=etc/rc.d/ccd
 OLD_FILES+=sbin/ccdconfig
 OLD_FILES+=usr/share/man/man4/ccd.4.gz
 OLD_FILES+=usr/share/man/man8/ccdconfig.8.gz
 .endif
 
 .if ${MK_CDDL} == no
 OLD_LIBS+=lib/libavl.so.2
 OLD_LIBS+=lib/libctf.so.2
 OLD_LIBS+=lib/libdtrace.so.2
 OLD_LIBS+=lib/libnvpair.so.2
 OLD_LIBS+=lib/libumem.so.2
 OLD_LIBS+=lib/libuutil.so.2
 OLD_FILES+=usr/bin/ctfconvert
 OLD_FILES+=usr/bin/ctfdump
 OLD_FILES+=usr/bin/ctfmerge
 OLD_FILES+=usr/bin/sgsmsg
 OLD_FILES+=usr/lib/dtrace/drti.o
 OLD_FILES+=usr/lib/dtrace/errno.d
 OLD_FILES+=usr/lib/dtrace/io.d
 OLD_FILES+=usr/lib/dtrace/ip.d
 OLD_FILES+=usr/lib/dtrace/psinfo.d
 .if ${TARGET_ARCH} == "amd64" || ${TARGET_ARCH} == "i386"
 OLD_FILES+=usr/lib/dtrace/regs_x86.d
 .endif
 OLD_FILES+=usr/lib/dtrace/signal.d
 OLD_FILES+=usr/lib/dtrace/tcp.d
 OLD_FILES+=usr/lib/dtrace/udp.d
 OLD_FILES+=usr/lib/dtrace/unistd.d
 OLD_FILES+=usr/lib/libavl.a
 OLD_FILES+=usr/lib/libavl.so
 OLD_FILES+=usr/lib/libavl_p.a
 OLD_FILES+=usr/lib/libctf.a
 OLD_FILES+=usr/lib/libctf.so
 OLD_FILES+=usr/lib/libctf_p.a
 OLD_FILES+=usr/lib/libdtrace.a
 OLD_FILES+=usr/lib/libdtrace.so
 OLD_FILES+=usr/lib/libdtrace_p.a
 OLD_FILES+=usr/lib/libnvpair.a
 OLD_FILES+=usr/lib/libnvpair.so
 OLD_FILES+=usr/lib/libnvpair_p.a
 OLD_FILES+=usr/lib/libumem.a
 OLD_FILES+=usr/lib/libumem.so
 OLD_FILES+=usr/lib/libumem_p.a
 OLD_FILES+=usr/lib/libuutil.a
 OLD_FILES+=usr/lib/libuutil.so
 OLD_FILES+=usr/lib/libuutil_p.a
 .if ${TARGET_ARCH} == "amd64" || ${TARGET_ARCH} == "powerpc64"
 OLD_FILES+=usr/lib32/dtrace/drti.o
 OLD_FILES+=usr/lib32/libavl.a
 OLD_FILES+=usr/lib32/libavl.so
 OLD_LIBS+=usr/lib32/libavl.so.2
 OLD_FILES+=usr/lib32/libavl_p.a
 OLD_FILES+=usr/lib32/libctf.a
 OLD_FILES+=usr/lib32/libctf.so
 OLD_LIBS+=usr/lib32/libctf.so.2
 OLD_FILES+=usr/lib32/libctf_p.a
 OLD_FILES+=usr/lib32/libdtrace.a
 OLD_FILES+=usr/lib32/libdtrace.so
 OLD_LIBS+=usr/lib32/libdtrace.so.2
 OLD_FILES+=usr/lib32/libdtrace_p.a
 OLD_FILES+=usr/lib32/libnvpair.a
 OLD_FILES+=usr/lib32/libnvpair.so
 OLD_LIBS+=usr/lib32/libnvpair.so.2
 OLD_FILES+=usr/lib32/libnvpair_p.a
 OLD_FILES+=usr/lib32/libumem.a
 OLD_FILES+=usr/lib32/libumem.so
 OLD_LIBS+=usr/lib32/libumem.so.2
 OLD_FILES+=usr/lib32/libumem_p.a
 OLD_FILES+=usr/lib32/libuutil.a
 OLD_FILES+=usr/lib32/libuutil.so
 OLD_LIBS+=usr/lib32/libuutil.so.2
 OLD_FILES+=usr/lib32/libuutil_p.a
 .endif
 OLD_LIBS+=lib/libdtrace.so.2
 OLD_FILES+=usr/sbin/dtrace
 OLD_FILES+=usr/sbin/lockstat
 OLD_FILES+=usr/share/man/man1/dtrace.1.gz
 OLD_FILES+=usr/share/dtrace/disklatency
 OLD_FILES+=usr/share/dtrace/disklatencycmd
 OLD_FILES+=usr/share/dtrace/hotopen
 OLD_FILES+=usr/share/dtrace/nfsclienttime
 OLD_FILES+=usr/share/dtrace/toolkit/execsnoop
 OLD_FILES+=usr/share/dtrace/toolkit/hotkernel
 OLD_FILES+=usr/share/dtrace/toolkit/hotuser
 OLD_FILES+=usr/share/dtrace/toolkit/opensnoop
 OLD_FILES+=usr/share/dtrace/toolkit/procsystime
 OLD_FILES+=usr/share/man/man1/dtrace.1.gz
 OLD_DIRS+=usr/lib/dtrace
 OLD_DIRS+=usr/lib32/dtrace
 OLD_DIRS+=usr/share/dtrace/toolkit
 OLD_DIRS+=usr/share/dtrace
 .endif
 
 .if ${MK_ZFS} == no
 OLD_FILES+=boot/gptzfsboot
 OLD_FILES+=boot/zfsboot
 OLD_FILES+=boot/zfsloader
 OLD_FILES+=etc/devd/zfs.conf
 OLD_FILES+=etc/periodic/daily/404.status-zfs
 OLD_FILES+=etc/periodic/daily/800.scrub-zfs
 OLD_LIBS+=lib/libzfs.so.2
 OLD_LIBS+=lib/libzfs_core.so.2
 OLD_LIBS+=lib/libzpool.so.2
 OLD_FILES+=rescue/zfs
 OLD_FILES+=rescue/zpool
 OLD_FILES+=sbin/zfs
 OLD_FILES+=sbin/zpool
 OLD_FILES+=usr/bin/zinject
 OLD_FILES+=usr/bin/ztest
 OLD_FILES+=usr/lib/libzfs.a
 OLD_FILES+=usr/lib/libzfs.so
 OLD_FILES+=usr/lib/libzfs_core.a
 OLD_FILES+=usr/lib/libzfs_core.so
 OLD_FILES+=usr/lib/libzfs_core_p.a
 OLD_FILES+=usr/lib/libzfs_p.a
 OLD_FILES+=usr/lib/libzpool.a
 OLD_FILES+=usr/lib/libzpool.so
 .if ${TARGET_ARCH} == "amd64" || ${TARGET_ARCH} == "powerpc64"
 OLD_FILES+=usr/lib32/libzfs.a
 OLD_FILES+=usr/lib32/libzfs.so
 OLD_LIBS+=usr/lib32/libzfs.so.2
 OLD_FILES+=usr/lib32/libzfs_core.a
 OLD_FILES+=usr/lib32/libzfs_core.so
 OLD_LIBS+=usr/lib32/libzfs_core.so.2
 OLD_FILES+=usr/lib32/libzfs_core_p.a
 OLD_FILES+=usr/lib32/libzfs_p.a
 OLD_FILES+=usr/lib32/libzpool.a
 OLD_FILES+=usr/lib32/libzpool.so
 OLD_LIBS+=usr/lib32/libzpool.so.2
 .endif
 OLD_FILES+=usr/sbin/zdb
 OLD_FILES+=usr/share/man/man8/zdb.8.gz
 OLD_FILES+=usr/share/man/man8/zfs.8.gz
 OLD_FILES+=usr/share/man/man8/zpool.8.gz
 .endif
 
 .if ${MK_CLANG} == no
 OLD_FILES+=usr/bin/clang
 OLD_FILES+=usr/bin/clang++
 OLD_FILES+=usr/bin/clang-cpp
 OLD_FILES+=usr/bin/clang-tblgen
 OLD_FILES+=usr/bin/tblgen
 OLD_FILES+=usr/lib/clang/3.6.0/include/__stddef_max_align_t.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/__wmmintrin_aes.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/__wmmintrin_pclmul.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/adxintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/altivec.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/ammintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/arm_acle.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/arm_neon.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/avx2intrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/avx512bwintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/avx512erintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/avx512fintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/avx512vlbwintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/avx512vlintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/avxintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/bmi2intrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/bmiintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/cpuid.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/emmintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/f16cintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/fma4intrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/fmaintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/ia32intrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/immintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/lzcntintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/mm3dnow.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/mm_malloc.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/mmintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/module.modulemap
 OLD_FILES+=usr/lib/clang/3.6.0/include/nmmintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/pmmintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/popcntintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/prfchwintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/rdseedintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/rtmintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/shaintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/smmintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/tbmintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/tmmintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/wmmintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/x86intrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/xmmintrin.h
 OLD_FILES+=usr/lib/clang/3.6.0/include/xopintrin.h
 OLD_DIRS+=usr/lib/clang/3.6.0/include
 OLD_FILES+=usr/lib/clang/3.6.0/lib/freebsd/libclang_rt.asan-i386.a
 OLD_FILES+=usr/lib/clang/3.6.0/lib/freebsd/libclang_rt.asan-x86_64.a
 OLD_FILES+=usr/lib/clang/3.6.0/lib/freebsd/libclang_rt.asan_cxx-i386.a
 OLD_FILES+=usr/lib/clang/3.6.0/lib/freebsd/libclang_rt.asan_cxx-x86_64.a
 OLD_FILES+=usr/lib/clang/3.6.0/lib/freebsd/libclang_rt.profile-arm.a
 OLD_FILES+=usr/lib/clang/3.6.0/lib/freebsd/libclang_rt.profile-i386.a
 OLD_FILES+=usr/lib/clang/3.6.0/lib/freebsd/libclang_rt.profile-x86_64.a
 OLD_FILES+=usr/lib/clang/3.6.0/lib/freebsd/libclang_rt.san-i386.a
 OLD_FILES+=usr/lib/clang/3.6.0/lib/freebsd/libclang_rt.san-x86_64.a
 OLD_FILES+=usr/lib/clang/3.6.0/lib/freebsd/libclang_rt.ubsan-i386.a
 OLD_FILES+=usr/lib/clang/3.6.0/lib/freebsd/libclang_rt.ubsan-x86_64.a
 OLD_FILES+=usr/lib/clang/3.6.0/lib/freebsd/libclang_rt.ubsan_cxx-i386.a
 OLD_FILES+=usr/lib/clang/3.6.0/lib/freebsd/libclang_rt.ubsan_cxx-x86_64.a
 OLD_DIRS+=usr/lib/clang/3.6.0/lib/freebsd
 OLD_DIRS+=usr/lib/clang/3.6.0/lib
 OLD_DIRS+=usr/lib/clang/3.6.0
 OLD_DIRS+=usr/lib/clang
 OLD_FILES+=usr/share/doc/llvm/clang/LICENSE.TXT
 OLD_DIRS+=usr/share/doc/llvm/clang
 OLD_FILES+=usr/share/doc/llvm/COPYRIGHT.regex
 OLD_FILES+=usr/share/doc/llvm/LICENSE.TXT
 OLD_DIRS+=usr/share/doc/llvm
 OLD_FILES+=usr/share/man/man1/clang.1.gz
 OLD_FILES+=usr/share/man/man1/clang++.1.gz
 OLD_FILES+=usr/share/man/man1/clang-cpp.1.gz
 OLD_FILES+=usr/share/man/man1/tblgen.1.gz
 .endif
 
 .if ${MK_CLANG_EXTRAS} == no
 OLD_FILES+=usr/bin/bugpoint
 OLD_FILES+=usr/bin/llc
 OLD_FILES+=usr/bin/lli
 OLD_FILES+=usr/bin/llvm-ar
 OLD_FILES+=usr/bin/llvm-as
 OLD_FILES+=usr/bin/llvm-bcanalyzer
 OLD_FILES+=usr/bin/llvm-diff
 OLD_FILES+=usr/bin/llvm-dis
 OLD_FILES+=usr/bin/llvm-extract
 OLD_FILES+=usr/bin/llvm-link
 OLD_FILES+=usr/bin/llvm-mc
 OLD_FILES+=usr/bin/llvm-nm
 OLD_FILES+=usr/bin/llvm-objdump
 OLD_FILES+=usr/bin/llvm-rtdyld
 OLD_FILES+=usr/bin/llvm-symbolizer
 OLD_FILES+=usr/bin/macho-dump
 OLD_FILES+=usr/bin/opt
 OLD_FILES+=usr/share/man/man1/bugpoint.1.gz
 OLD_FILES+=usr/share/man/man1/llc.1.gz
 OLD_FILES+=usr/share/man/man1/lli.1.gz
 OLD_FILES+=usr/share/man/man1/llvm-ar.1.gz
 OLD_FILES+=usr/share/man/man1/llvm-as.1.gz
 OLD_FILES+=usr/share/man/man1/llvm-bcanalyzer.1.gz
 OLD_FILES+=usr/share/man/man1/llvm-diff.1.gz
 OLD_FILES+=usr/share/man/man1/llvm-dis.1.gz
 OLD_FILES+=usr/share/man/man1/llvm-extract.1.gz
 OLD_FILES+=usr/share/man/man1/llvm-link.1.gz
 OLD_FILES+=usr/share/man/man1/llvm-nm.1.gz
 OLD_FILES+=usr/share/man/man1/llvm-symbolizer.1.gz
 OLD_FILES+=usr/share/man/man1/opt.1.gz
 .endif
 
 .if ${MK_CPP} == no
 OLD_FILES+=usr/bin/cpp
 OLD_FILES+=usr/share/man/man1/cpp.1.gz
 .endif
 
 #.if ${MK_CRYPT} == no
 # to be filled in
 #.endif
 
 .if ${MK_CTM} == no
 OLD_FILES+=usr/sbin/ctm
 OLD_FILES+=usr/sbin/ctm_dequeue
 OLD_FILES+=usr/sbin/ctm_rmail
 OLD_FILES+=usr/sbin/ctm_smail
 OLD_FILES+=usr/share/man/man1/ctm.1.gz
 OLD_FILES+=usr/share/man/man1/ctm_dequeue.1.gz
 OLD_FILES+=usr/share/man/man1/ctm_rmail.1.gz
 OLD_FILES+=usr/share/man/man1/ctm_smail.1.gz
 OLD_FILES+=usr/share/man/man5/ctm.5.gz
 .endif
 
 .if ${MK_CUSE} == no
 OLD_FILES+=usr/include/fs/cuse/cuse_defs.h
 OLD_FILES+=usr/include/fs/cuse/cuse_ioctl.h
 OLD_FILES+=usr/include/cuse.h
 OLD_FILES+=usr/lib/libcuse.a
 OLD_LIBS+=usr/lib/libcuse.so.1
 OLD_FILES+=usr/lib/libcuse_p.a
 OLD_FILES+=usr/share/man/man3/cuse.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_alloc_unit_number.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_alloc_unit_number_by_id.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_copy_in.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_copy_out.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_dev_create.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_dev_destroy.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_dev_get_current.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_dev_get_per_file_handle.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_dev_get_priv0.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_dev_get_priv1.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_dev_set_per_file_handle.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_dev_set_priv0.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_dev_set_priv1.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_free_unit_number.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_free_unit_number_by_id.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_get_local.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_got_peer_signal.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_init.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_is_vmalloc_addr.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_poll_wakeup.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_set_local.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_uninit.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_vmalloc.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_vmfree.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_vmoffset.3.gz
 OLD_FILES+=usr/share/man/man3/cuse_wait_and_process.3.gz
 OLD_DIRS+=usr/include/fs/cuse
 .endif
 
 # devd(8) not listed here on purpose
 .if ${MK_CXX} == no
 OLD_FILES+=usr/bin/CC
 OLD_FILES+=usr/bin/c++
 OLD_FILES+=usr/bin/c++filt
 OLD_FILES+=usr/bin/g++
 OLD_FILES+=usr/libexec/cc1plus
 .if ${MK_GCC} == no
 OLD_FILES+=usr/bin/gperf
 OLD_FILES+=usr/share/info/gperf.info.gz
 OLD_FILES+=usr/share/man/man1/gperf.1.gz
 .endif
 .endif
 
 .if ${MK_FMTREE} == no
 OLD_FILES+=usr/sbin/fmtree
 OLD_FILES+=usr/share/man/man8/fmtree.8.gz
 .endif
 
 .if ${MK_GNUCXX} == no
 OLD_FILES+=usr/bin/g++
 OLD_FILES+=usr/include/c++/4.2/algorithm
 OLD_FILES+=usr/include/c++/4.2/backward/algo.h
 OLD_FILES+=usr/include/c++/4.2/backward/algobase.h
 OLD_FILES+=usr/include/c++/4.2/backward/alloc.h
 OLD_FILES+=usr/include/c++/4.2/backward/backward_warning.h
 OLD_FILES+=usr/include/c++/4.2/backward/bvector.h
 OLD_FILES+=usr/include/c++/4.2/backward/complex.h
 OLD_FILES+=usr/include/c++/4.2/backward/defalloc.h
 OLD_FILES+=usr/include/c++/4.2/backward/deque.h
 OLD_FILES+=usr/include/c++/4.2/backward/fstream.h
 OLD_FILES+=usr/include/c++/4.2/backward/function.h
 OLD_FILES+=usr/include/c++/4.2/backward/hash_map.h
 OLD_FILES+=usr/include/c++/4.2/backward/hash_set.h
 OLD_FILES+=usr/include/c++/4.2/backward/hashtable.h
 OLD_FILES+=usr/include/c++/4.2/backward/heap.h
 OLD_FILES+=usr/include/c++/4.2/backward/iomanip.h
 OLD_FILES+=usr/include/c++/4.2/backward/iostream.h
 OLD_FILES+=usr/include/c++/4.2/backward/istream.h
 OLD_FILES+=usr/include/c++/4.2/backward/iterator.h
 OLD_FILES+=usr/include/c++/4.2/backward/list.h
 OLD_FILES+=usr/include/c++/4.2/backward/map.h
 OLD_FILES+=usr/include/c++/4.2/backward/multimap.h
 OLD_FILES+=usr/include/c++/4.2/backward/multiset.h
 OLD_FILES+=usr/include/c++/4.2/backward/new.h
 OLD_FILES+=usr/include/c++/4.2/backward/ostream.h
 OLD_FILES+=usr/include/c++/4.2/backward/pair.h
 OLD_FILES+=usr/include/c++/4.2/backward/queue.h
 OLD_FILES+=usr/include/c++/4.2/backward/rope.h
 OLD_FILES+=usr/include/c++/4.2/backward/set.h
 OLD_FILES+=usr/include/c++/4.2/backward/slist.h
 OLD_FILES+=usr/include/c++/4.2/backward/stack.h
 OLD_FILES+=usr/include/c++/4.2/backward/stream.h
 OLD_FILES+=usr/include/c++/4.2/backward/streambuf.h
 OLD_FILES+=usr/include/c++/4.2/backward/strstream
 OLD_FILES+=usr/include/c++/4.2/backward/tempbuf.h
 OLD_FILES+=usr/include/c++/4.2/backward/tree.h
 OLD_FILES+=usr/include/c++/4.2/backward/vector.h
 OLD_FILES+=usr/include/c++/4.2/bits/allocator.h
 OLD_FILES+=usr/include/c++/4.2/bits/atomic_word.h
 OLD_FILES+=usr/include/c++/4.2/bits/basic_file.h
 OLD_FILES+=usr/include/c++/4.2/bits/basic_ios.h
 OLD_FILES+=usr/include/c++/4.2/bits/basic_ios.tcc
 OLD_FILES+=usr/include/c++/4.2/bits/basic_string.h
 OLD_FILES+=usr/include/c++/4.2/bits/basic_string.tcc
 OLD_FILES+=usr/include/c++/4.2/bits/boost_concept_check.h
 OLD_FILES+=usr/include/c++/4.2/bits/c++allocator.h
 OLD_FILES+=usr/include/c++/4.2/bits/c++config.h
 OLD_FILES+=usr/include/c++/4.2/bits/c++io.h
 OLD_FILES+=usr/include/c++/4.2/bits/c++locale.h
 OLD_FILES+=usr/include/c++/4.2/bits/c++locale_internal.h
 OLD_FILES+=usr/include/c++/4.2/bits/char_traits.h
 OLD_FILES+=usr/include/c++/4.2/bits/cmath.tcc
 OLD_FILES+=usr/include/c++/4.2/bits/codecvt.h
 OLD_FILES+=usr/include/c++/4.2/bits/compatibility.h
 OLD_FILES+=usr/include/c++/4.2/bits/concept_check.h
 OLD_FILES+=usr/include/c++/4.2/bits/cpp_type_traits.h
 OLD_FILES+=usr/include/c++/4.2/bits/cpu_defines.h
 OLD_FILES+=usr/include/c++/4.2/bits/ctype_base.h
 OLD_FILES+=usr/include/c++/4.2/bits/ctype_inline.h
 OLD_FILES+=usr/include/c++/4.2/bits/ctype_noninline.h
 OLD_FILES+=usr/include/c++/4.2/bits/cxxabi_tweaks.h
 OLD_FILES+=usr/include/c++/4.2/bits/deque.tcc
 OLD_FILES+=usr/include/c++/4.2/bits/fstream.tcc
 OLD_FILES+=usr/include/c++/4.2/bits/functexcept.h
 OLD_FILES+=usr/include/c++/4.2/bits/gslice.h
 OLD_FILES+=usr/include/c++/4.2/bits/gslice_array.h
 OLD_FILES+=usr/include/c++/4.2/bits/gthr-default.h
 OLD_FILES+=usr/include/c++/4.2/bits/gthr-posix.h
 OLD_FILES+=usr/include/c++/4.2/bits/gthr-single.h
 OLD_FILES+=usr/include/c++/4.2/bits/gthr-tpf.h
 OLD_FILES+=usr/include/c++/4.2/bits/gthr.h
 OLD_FILES+=usr/include/c++/4.2/bits/indirect_array.h
 OLD_FILES+=usr/include/c++/4.2/bits/ios_base.h
 OLD_FILES+=usr/include/c++/4.2/bits/istream.tcc
 OLD_FILES+=usr/include/c++/4.2/bits/list.tcc
 OLD_FILES+=usr/include/c++/4.2/bits/locale_classes.h
 OLD_FILES+=usr/include/c++/4.2/bits/locale_facets.h
 OLD_FILES+=usr/include/c++/4.2/bits/locale_facets.tcc
 OLD_FILES+=usr/include/c++/4.2/bits/localefwd.h
 OLD_FILES+=usr/include/c++/4.2/bits/mask_array.h
 OLD_FILES+=usr/include/c++/4.2/bits/messages_members.h
 OLD_FILES+=usr/include/c++/4.2/bits/os_defines.h
 OLD_FILES+=usr/include/c++/4.2/bits/ostream.tcc
 OLD_FILES+=usr/include/c++/4.2/bits/ostream_insert.h
 OLD_FILES+=usr/include/c++/4.2/bits/postypes.h
 OLD_FILES+=usr/include/c++/4.2/bits/slice_array.h
 OLD_FILES+=usr/include/c++/4.2/bits/sstream.tcc
 OLD_FILES+=usr/include/c++/4.2/bits/stl_algo.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_algobase.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_bvector.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_construct.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_deque.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_function.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_heap.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_iterator.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_iterator_base_funcs.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_iterator_base_types.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_list.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_map.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_multimap.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_multiset.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_numeric.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_pair.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_queue.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_raw_storage_iter.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_relops.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_set.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_stack.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_tempbuf.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_tree.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_uninitialized.h
 OLD_FILES+=usr/include/c++/4.2/bits/stl_vector.h
 OLD_FILES+=usr/include/c++/4.2/bits/stream_iterator.h
 OLD_FILES+=usr/include/c++/4.2/bits/streambuf.tcc
 OLD_FILES+=usr/include/c++/4.2/bits/streambuf_iterator.h
 OLD_FILES+=usr/include/c++/4.2/bits/stringfwd.h
 OLD_FILES+=usr/include/c++/4.2/bits/time_members.h
 OLD_FILES+=usr/include/c++/4.2/bits/valarray_after.h
 OLD_FILES+=usr/include/c++/4.2/bits/valarray_array.h
 OLD_FILES+=usr/include/c++/4.2/bits/valarray_array.tcc
 OLD_FILES+=usr/include/c++/4.2/bits/valarray_before.h
 OLD_FILES+=usr/include/c++/4.2/bits/vector.tcc
 OLD_FILES+=usr/include/c++/4.2/bitset
 OLD_FILES+=usr/include/c++/4.2/cassert
 OLD_FILES+=usr/include/c++/4.2/cctype
 OLD_FILES+=usr/include/c++/4.2/cerrno
 OLD_FILES+=usr/include/c++/4.2/cfloat
 OLD_FILES+=usr/include/c++/4.2/ciso646
 OLD_FILES+=usr/include/c++/4.2/climits
 OLD_FILES+=usr/include/c++/4.2/clocale
 OLD_FILES+=usr/include/c++/4.2/cmath
 OLD_FILES+=usr/include/c++/4.2/complex
 OLD_FILES+=usr/include/c++/4.2/csetjmp
 OLD_FILES+=usr/include/c++/4.2/csignal
 OLD_FILES+=usr/include/c++/4.2/cstdarg
 OLD_FILES+=usr/include/c++/4.2/cstddef
 OLD_FILES+=usr/include/c++/4.2/cstdio
 OLD_FILES+=usr/include/c++/4.2/cstdlib
 OLD_FILES+=usr/include/c++/4.2/cstring
 OLD_FILES+=usr/include/c++/4.2/ctime
 OLD_FILES+=usr/include/c++/4.2/cwchar
 OLD_FILES+=usr/include/c++/4.2/cwctype
 OLD_FILES+=usr/include/c++/4.2/cxxabi.h
 OLD_FILES+=usr/include/c++/4.2/debug/bitset
 OLD_FILES+=usr/include/c++/4.2/debug/debug.h
 OLD_FILES+=usr/include/c++/4.2/debug/deque
 OLD_FILES+=usr/include/c++/4.2/debug/formatter.h
 OLD_FILES+=usr/include/c++/4.2/debug/functions.h
 OLD_FILES+=usr/include/c++/4.2/debug/hash_map
 OLD_FILES+=usr/include/c++/4.2/debug/hash_map.h
 OLD_FILES+=usr/include/c++/4.2/debug/hash_multimap.h
 OLD_FILES+=usr/include/c++/4.2/debug/hash_multiset.h
 OLD_FILES+=usr/include/c++/4.2/debug/hash_set
 OLD_FILES+=usr/include/c++/4.2/debug/hash_set.h
 OLD_FILES+=usr/include/c++/4.2/debug/list
 OLD_FILES+=usr/include/c++/4.2/debug/macros.h
 OLD_FILES+=usr/include/c++/4.2/debug/map
 OLD_FILES+=usr/include/c++/4.2/debug/map.h
 OLD_FILES+=usr/include/c++/4.2/debug/multimap.h
 OLD_FILES+=usr/include/c++/4.2/debug/multiset.h
 OLD_FILES+=usr/include/c++/4.2/debug/safe_base.h
 OLD_FILES+=usr/include/c++/4.2/debug/safe_iterator.h
 OLD_FILES+=usr/include/c++/4.2/debug/safe_iterator.tcc
 OLD_FILES+=usr/include/c++/4.2/debug/safe_sequence.h
 OLD_FILES+=usr/include/c++/4.2/debug/set
 OLD_FILES+=usr/include/c++/4.2/debug/set.h
 OLD_FILES+=usr/include/c++/4.2/debug/string
 OLD_FILES+=usr/include/c++/4.2/debug/vector
 OLD_FILES+=usr/include/c++/4.2/deque
 OLD_FILES+=usr/include/c++/4.2/exception
 OLD_FILES+=usr/include/c++/4.2/exception_defines.h
 OLD_FILES+=usr/include/c++/4.2/ext/algorithm
 OLD_FILES+=usr/include/c++/4.2/ext/array_allocator.h
 OLD_FILES+=usr/include/c++/4.2/ext/atomicity.h
 OLD_FILES+=usr/include/c++/4.2/ext/bitmap_allocator.h
 OLD_FILES+=usr/include/c++/4.2/ext/codecvt_specializations.h
 OLD_FILES+=usr/include/c++/4.2/ext/concurrence.h
 OLD_FILES+=usr/include/c++/4.2/ext/debug_allocator.h
 OLD_FILES+=usr/include/c++/4.2/ext/functional
 OLD_FILES+=usr/include/c++/4.2/ext/hash_fun.h
 OLD_FILES+=usr/include/c++/4.2/ext/hash_map
 OLD_FILES+=usr/include/c++/4.2/ext/hash_set
 OLD_FILES+=usr/include/c++/4.2/ext/hashtable.h
 OLD_FILES+=usr/include/c++/4.2/ext/iterator
 OLD_FILES+=usr/include/c++/4.2/ext/malloc_allocator.h
 OLD_FILES+=usr/include/c++/4.2/ext/memory
 OLD_FILES+=usr/include/c++/4.2/ext/mt_allocator.h
 OLD_FILES+=usr/include/c++/4.2/ext/new_allocator.h
 OLD_FILES+=usr/include/c++/4.2/ext/numeric
 OLD_FILES+=usr/include/c++/4.2/ext/numeric_traits.h
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/assoc_container.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/basic_tree_policy/basic_tree_policy_base.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/basic_tree_policy/null_node_metadata.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/basic_tree_policy/traits.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/basic_types.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/bin_search_tree_/bin_search_tree_.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/bin_search_tree_/cond_dtor_entry_dealtor.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/bin_search_tree_/cond_key_dtor_entry_dealtor.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/bin_search_tree_/constructors_destructor_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/bin_search_tree_/debug_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/bin_search_tree_/erase_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/bin_search_tree_/find_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/bin_search_tree_/info_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/bin_search_tree_/insert_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/bin_search_tree_/iterators_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/bin_search_tree_/node_iterators.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/bin_search_tree_/point_iterators.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/bin_search_tree_/policy_access_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/bin_search_tree_/r_erase_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/bin_search_tree_/rotate_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/bin_search_tree_/split_join_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/bin_search_tree_/traits.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binary_heap_/binary_heap_.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binary_heap_/const_iterator.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binary_heap_/const_point_iterator.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binary_heap_/constructors_destructor_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binary_heap_/debug_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binary_heap_/entry_cmp.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binary_heap_/entry_pred.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binary_heap_/erase_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binary_heap_/find_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binary_heap_/info_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binary_heap_/insert_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binary_heap_/iterators_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binary_heap_/policy_access_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binary_heap_/resize_policy.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binary_heap_/split_join_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binary_heap_/trace_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binomial_heap_/binomial_heap_.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binomial_heap_/constructors_destructor_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binomial_heap_/debug_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binomial_heap_base_/binomial_heap_base_.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binomial_heap_base_/constructors_destructor_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binomial_heap_base_/debug_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binomial_heap_base_/erase_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binomial_heap_base_/find_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binomial_heap_base_/insert_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/binomial_heap_base_/split_join_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/cmp_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/cond_key_dtor_entry_dealtor.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/debug_no_store_hash_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/debug_store_hash_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/entry_list_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/find_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/find_store_hash_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/info_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/insert_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/iterators_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/policy_access_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/resize_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/resize_no_store_hash_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/resize_store_hash_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/size_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/standard_policies.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cc_hash_table_map_/trace_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/cond_dealtor.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/constructors_destructor_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/container_base_dispatch.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/eq_fn/eq_by_less.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/eq_fn/hash_eq_fn.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/debug_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/debug_no_store_hash_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/debug_store_hash_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/erase_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/erase_no_store_hash_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/erase_store_hash_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/find_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/find_no_store_hash_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/find_store_hash_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/info_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/insert_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/insert_no_store_hash_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/insert_store_hash_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/iterator_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/policy_access_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/resize_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/resize_no_store_hash_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/resize_store_hash_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/standard_policies.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/gp_hash_table_map_/trace_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/hash_fn/direct_mask_range_hashing_imp.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/hash_fn/direct_mod_range_hashing_imp.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/hash_fn/linear_probe_fn_imp.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/hash_fn/mask_based_range_hashing.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/hash_fn/mod_based_range_hashing.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/hash_fn/probe_fn_base.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/hash_fn/quadratic_probe_fn_imp.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/hash_fn/ranged_hash_fn.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/hash_fn/ranged_probe_fn.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/hash_fn/sample_probe_fn.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/hash_fn/sample_range_hashing.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/hash_fn/sample_ranged_hash_fn.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/hash_fn/sample_ranged_probe_fn.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/left_child_next_sibling_heap_/const_iterator.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/left_child_next_sibling_heap_/const_point_iterator.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/left_child_next_sibling_heap_/constructors_destructor_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/left_child_next_sibling_heap_/debug_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/left_child_next_sibling_heap_/erase_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/left_child_next_sibling_heap_/info_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/left_child_next_sibling_heap_/insert_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/left_child_next_sibling_heap_/iterators_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/left_child_next_sibling_heap_/left_child_next_sibling_heap_.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/left_child_next_sibling_heap_/node.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/left_child_next_sibling_heap_/null_metadata.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/left_child_next_sibling_heap_/policy_access_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/left_child_next_sibling_heap_/trace_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/list_update_map_/constructor_destructor_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/list_update_map_/debug_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/list_update_map_/entry_metadata_base.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/list_update_map_/erase_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/list_update_map_/find_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/list_update_map_/info_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/list_update_map_/insert_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/list_update_map_/iterators_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/list_update_map_/lu_map_.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/list_update_map_/trace_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/list_update_policy/counter_lu_metadata.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/list_update_policy/counter_lu_policy_imp.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/list_update_policy/mtf_lu_policy_imp.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/list_update_policy/sample_update_policy.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/map_debug_base.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/ov_tree_map_/cond_dtor.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/ov_tree_map_/constructors_destructor_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/ov_tree_map_/debug_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/ov_tree_map_/erase_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/ov_tree_map_/info_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/ov_tree_map_/insert_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/ov_tree_map_/iterators_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/ov_tree_map_/node_iterators.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/ov_tree_map_/ov_tree_map_.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/ov_tree_map_/policy_access_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/ov_tree_map_/split_join_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/ov_tree_map_/traits.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pairing_heap_/constructors_destructor_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pairing_heap_/debug_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pairing_heap_/erase_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pairing_heap_/find_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pairing_heap_/insert_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pairing_heap_/pairing_heap_.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pairing_heap_/split_join_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/child_iterator.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/cond_dtor_entry_dealtor.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/const_child_iterator.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/constructors_destructor_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/debug_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/erase_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/find_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/head.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/info_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/insert_join_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/internal_node.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/iterators_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/leaf.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/node_base.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/node_iterators.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/node_metadata_base.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/pat_trie_.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/point_iterators.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/policy_access_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/r_erase_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/rotate_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/split_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/split_join_branch_bag.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/synth_e_access_traits.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/trace_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/traits.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/pat_trie_/update_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/priority_queue_base_dispatch.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/rb_tree_map_/constructors_destructor_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/rb_tree_map_/debug_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/rb_tree_map_/erase_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/rb_tree_map_/find_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/rb_tree_map_/info_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/rb_tree_map_/insert_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/rb_tree_map_/node.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/rb_tree_map_/rb_tree_.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/rb_tree_map_/split_join_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/rb_tree_map_/traits.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/rc_binomial_heap_/constructors_destructor_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/rc_binomial_heap_/debug_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/rc_binomial_heap_/erase_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/rc_binomial_heap_/insert_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/rc_binomial_heap_/rc.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/rc_binomial_heap_/rc_binomial_heap_.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/rc_binomial_heap_/split_join_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/rc_binomial_heap_/trace_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/resize_policy/cc_hash_max_collision_check_resize_trigger_imp.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/resize_policy/hash_exponential_size_policy_imp.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/resize_policy/hash_load_check_resize_trigger_imp.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/resize_policy/hash_load_check_resize_trigger_size_base.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/resize_policy/hash_prime_size_policy_imp.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/resize_policy/hash_standard_resize_policy_imp.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/resize_policy/sample_resize_policy.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/resize_policy/sample_resize_trigger.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/resize_policy/sample_size_policy.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/splay_tree_/constructors_destructor_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/splay_tree_/debug_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/splay_tree_/erase_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/splay_tree_/find_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/splay_tree_/info_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/splay_tree_/insert_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/splay_tree_/node.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/splay_tree_/splay_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/splay_tree_/splay_tree_.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/splay_tree_/split_join_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/splay_tree_/traits.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/standard_policies.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/thin_heap_/constructors_destructor_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/thin_heap_/debug_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/thin_heap_/erase_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/thin_heap_/find_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/thin_heap_/insert_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/thin_heap_/split_join_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/thin_heap_/thin_heap_.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/thin_heap_/trace_fn_imps.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/tree_policy/node_metadata_selector.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/tree_policy/null_node_update_imp.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/tree_policy/order_statistics_imp.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/tree_policy/sample_tree_node_update.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/tree_trace_base.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/trie_policy/node_metadata_selector.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/trie_policy/null_node_update_imp.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/trie_policy/order_statistics_imp.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/trie_policy/prefix_search_node_update_imp.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/trie_policy/sample_trie_e_access_traits.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/trie_policy/sample_trie_node_update.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/trie_policy/string_trie_e_access_traits_imp.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/trie_policy/trie_policy_base.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/type_utils.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/types_traits.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/unordered_iterator/const_iterator.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/unordered_iterator/const_point_iterator.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/unordered_iterator/iterator.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/detail/unordered_iterator/point_iterator.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/exception.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/hash_policy.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/list_update_policy.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/priority_queue.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/tag_and_trait.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/tree_policy.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pb_ds/trie_policy.hpp
 OLD_FILES+=usr/include/c++/4.2/ext/pod_char_traits.h
 OLD_FILES+=usr/include/c++/4.2/ext/pool_allocator.h
 OLD_FILES+=usr/include/c++/4.2/ext/rb_tree
 OLD_FILES+=usr/include/c++/4.2/ext/rc_string_base.h
 OLD_FILES+=usr/include/c++/4.2/ext/rope
 OLD_FILES+=usr/include/c++/4.2/ext/ropeimpl.h
 OLD_FILES+=usr/include/c++/4.2/ext/slist
 OLD_FILES+=usr/include/c++/4.2/ext/sso_string_base.h
 OLD_FILES+=usr/include/c++/4.2/ext/stdio_filebuf.h
 OLD_FILES+=usr/include/c++/4.2/ext/stdio_sync_filebuf.h
 OLD_FILES+=usr/include/c++/4.2/ext/throw_allocator.h
 OLD_FILES+=usr/include/c++/4.2/ext/type_traits.h
 OLD_FILES+=usr/include/c++/4.2/ext/typelist.h
 OLD_FILES+=usr/include/c++/4.2/ext/vstring.h
 OLD_FILES+=usr/include/c++/4.2/ext/vstring.tcc
 OLD_FILES+=usr/include/c++/4.2/ext/vstring_fwd.h
 OLD_FILES+=usr/include/c++/4.2/ext/vstring_util.h
 OLD_FILES+=usr/include/c++/4.2/fstream
 OLD_FILES+=usr/include/c++/4.2/functional
 OLD_FILES+=usr/include/c++/4.2/iomanip
 OLD_FILES+=usr/include/c++/4.2/ios
 OLD_FILES+=usr/include/c++/4.2/iosfwd
 OLD_FILES+=usr/include/c++/4.2/iostream
 OLD_FILES+=usr/include/c++/4.2/istream
 OLD_FILES+=usr/include/c++/4.2/iterator
 OLD_FILES+=usr/include/c++/4.2/limits
 OLD_FILES+=usr/include/c++/4.2/list
 OLD_FILES+=usr/include/c++/4.2/locale
 OLD_FILES+=usr/include/c++/4.2/map
 OLD_FILES+=usr/include/c++/4.2/memory
 OLD_FILES+=usr/include/c++/4.2/new
 OLD_FILES+=usr/include/c++/4.2/numeric
 OLD_FILES+=usr/include/c++/4.2/ostream
 OLD_FILES+=usr/include/c++/4.2/queue
 OLD_FILES+=usr/include/c++/4.2/set
 OLD_FILES+=usr/include/c++/4.2/sstream
 OLD_FILES+=usr/include/c++/4.2/stack
 OLD_FILES+=usr/include/c++/4.2/stdexcept
 OLD_FILES+=usr/include/c++/4.2/streambuf
 OLD_FILES+=usr/include/c++/4.2/string
 OLD_FILES+=usr/include/c++/4.2/tr1/array
 OLD_FILES+=usr/include/c++/4.2/tr1/bind_iterate.h
 OLD_FILES+=usr/include/c++/4.2/tr1/bind_repeat.h
 OLD_FILES+=usr/include/c++/4.2/tr1/boost_shared_ptr.h
 OLD_FILES+=usr/include/c++/4.2/tr1/cctype
 OLD_FILES+=usr/include/c++/4.2/tr1/cfenv
 OLD_FILES+=usr/include/c++/4.2/tr1/cfloat
 OLD_FILES+=usr/include/c++/4.2/tr1/cinttypes
 OLD_FILES+=usr/include/c++/4.2/tr1/climits
 OLD_FILES+=usr/include/c++/4.2/tr1/cmath
 OLD_FILES+=usr/include/c++/4.2/tr1/common.h
 OLD_FILES+=usr/include/c++/4.2/tr1/complex
 OLD_FILES+=usr/include/c++/4.2/tr1/cstdarg
 OLD_FILES+=usr/include/c++/4.2/tr1/cstdbool
 OLD_FILES+=usr/include/c++/4.2/tr1/cstdint
 OLD_FILES+=usr/include/c++/4.2/tr1/cstdio
 OLD_FILES+=usr/include/c++/4.2/tr1/cstdlib
 OLD_FILES+=usr/include/c++/4.2/tr1/ctgmath
 OLD_FILES+=usr/include/c++/4.2/tr1/ctime
 OLD_FILES+=usr/include/c++/4.2/tr1/ctype.h
 OLD_FILES+=usr/include/c++/4.2/tr1/cwchar
 OLD_FILES+=usr/include/c++/4.2/tr1/cwctype
 OLD_FILES+=usr/include/c++/4.2/tr1/fenv.h
 OLD_FILES+=usr/include/c++/4.2/tr1/float.h
 OLD_FILES+=usr/include/c++/4.2/tr1/functional
 OLD_FILES+=usr/include/c++/4.2/tr1/functional_hash.h
 OLD_FILES+=usr/include/c++/4.2/tr1/functional_iterate.h
 OLD_FILES+=usr/include/c++/4.2/tr1/hashtable
 OLD_FILES+=usr/include/c++/4.2/tr1/hashtable_policy.h
 OLD_FILES+=usr/include/c++/4.2/tr1/inttypes.h
 OLD_FILES+=usr/include/c++/4.2/tr1/limits.h
 OLD_FILES+=usr/include/c++/4.2/tr1/math.h
 OLD_FILES+=usr/include/c++/4.2/tr1/memory
 OLD_FILES+=usr/include/c++/4.2/tr1/mu_iterate.h
 OLD_FILES+=usr/include/c++/4.2/tr1/random
 OLD_FILES+=usr/include/c++/4.2/tr1/random.tcc
 OLD_FILES+=usr/include/c++/4.2/tr1/ref_fwd.h
 OLD_FILES+=usr/include/c++/4.2/tr1/ref_wrap_iterate.h
 OLD_FILES+=usr/include/c++/4.2/tr1/repeat.h
 OLD_FILES+=usr/include/c++/4.2/tr1/stdarg.h
 OLD_FILES+=usr/include/c++/4.2/tr1/stdbool.h
 OLD_FILES+=usr/include/c++/4.2/tr1/stdint.h
 OLD_FILES+=usr/include/c++/4.2/tr1/stdio.h
 OLD_FILES+=usr/include/c++/4.2/tr1/stdlib.h
 OLD_FILES+=usr/include/c++/4.2/tr1/tgmath.h
 OLD_FILES+=usr/include/c++/4.2/tr1/tuple
 OLD_FILES+=usr/include/c++/4.2/tr1/tuple_defs.h
 OLD_FILES+=usr/include/c++/4.2/tr1/tuple_iterate.h
 OLD_FILES+=usr/include/c++/4.2/tr1/type_traits
 OLD_FILES+=usr/include/c++/4.2/tr1/type_traits_fwd.h
 OLD_FILES+=usr/include/c++/4.2/tr1/unordered_map
 OLD_FILES+=usr/include/c++/4.2/tr1/unordered_set
 OLD_FILES+=usr/include/c++/4.2/tr1/utility
 OLD_FILES+=usr/include/c++/4.2/tr1/wchar.h
 OLD_FILES+=usr/include/c++/4.2/tr1/wctype.h
 OLD_FILES+=usr/include/c++/4.2/typeinfo
 OLD_FILES+=usr/include/c++/4.2/utility
 OLD_FILES+=usr/include/c++/4.2/valarray
 OLD_FILES+=usr/include/c++/4.2/vector
 OLD_FILES+=usr/lib/libstdc++.a
 OLD_FILES+=usr/lib/libstdc++.so
 OLD_LIBS+=usr/lib/libstdc++.so.6
 OLD_FILES+=usr/lib/libstdc++_p.a
 OLD_FILES+=usr/lib/libsupc++.a
 OLD_FILES+=usr/lib/libsupc++.so
 OLD_LIBS+=usr/lib/libsupc++.so.1
 OLD_FILES+=usr/lib/libsupc++_p.a
 .if ${TARGET_ARCH} == "amd64" || ${TARGET_ARCH} == "powerpc64"
 OLD_FILES+=usr/lib32/libstdc++.a
 OLD_FILES+=usr/lib32/libstdc++.so
 OLD_LIBS+=usr/lib32/libstdc++.so.6
 OLD_FILES+=usr/lib32/libstdc++_p.a
 OLD_FILES+=usr/lib32/libsupc++.a
 OLD_FILES+=usr/lib32/libsupc++.so
 OLD_LIBS+=usr/lib32/libsupc++.so.1
 OLD_FILES+=usr/lib32/libsupc++_p.a
 .endif
 OLD_FILES+=usr/libexec/cc1plus
 .endif
 
 .if ${MK_DICT} == no
 OLD_FILES+=usr/share/dict/README
 OLD_FILES+=usr/share/dict/eign
 OLD_FILES+=usr/share/dict/freebsd
 OLD_FILES+=usr/share/dict/propernames
 OLD_FILES+=usr/share/dict/web2
 OLD_FILES+=usr/share/dict/web2a
 OLD_FILES+=usr/share/dict/words
 OLD_DIRS+=usr/share/dict
 .endif
 
 .if ${MK_EE} == no
 OLD_FILES+=usr/bin/edit
 OLD_FILES+=usr/bin/ee
 OLD_FILES+=usr/bin/ree
 OLD_FILES+=usr/share/man/man1/edit.1.gz
 OLD_FILES+=usr/share/man/man1/ee.1.gz
 OLD_FILES+=usr/share/man/man1/ree.1.gz
 OLD_FILES+=usr/share/nls/C/ee.cat
 OLD_FILES+=usr/share/nls/de_DE.ISO8859-1/ee.cat
 OLD_FILES+=usr/share/nls/fr_FR.ISO8859-1/ee.cat
 OLD_FILES+=usr/share/nls/hu_HU.ISO8859-2/ee.cat
 OLD_FILES+=usr/share/nls/pl_PL.ISO8859-2/ee.cat
 OLD_FILES+=usr/share/nls/pt_BR.ISO8859-1/ee.cat
 OLD_FILES+=usr/share/nls/ru_RU.KOI8-R/ee.cat
 OLD_FILES+=usr/share/nls/uk_UA.KOI8-U/ee.cat
 .endif
 
 .if ${MK_ELFTOOLCHAIN_TOOLS} == no
 OLD_FILES+=usr/bin/elfcopy
 OLD_FILES+=usr/share/man/man1/elfcopy.1.gz
 .endif
 
 #.if ${MK_EXAMPLES} == no
 # to be filled in
 #.endif
 
 .if ${MK_FLOPPY} == no
 OLD_FILES+=usr/sbin/fdcontrol
 OLD_FILES+=usr/sbin/fdformat
 OLD_FILES+=usr/sbin/fdread
 OLD_FILES+=usr/sbin/fdwrite
 OLD_FILES+=usr/share/man/man1/fdformat.1.gz
 OLD_FILES+=usr/share/man/man1/fdread.1.gz
 OLD_FILES+=usr/share/man/man1/fdwrite.1.gz
 OLD_FILES+=usr/share/man/man8/fdcontrol.8.gz
 .endif
 
 .if ${MK_FREEBSD_UPDATE} == no
 OLD_FILES+=etc/freebsd-update.conf
 OLD_FILES+=usr/sbin/freebsd-update
 OLD_FILES+=usr/share/examples/etc/freebsd-update.conf
 OLD_FILES+=usr/share/man/man5/freebsd-update.conf.5.gz
 OLD_FILES+=usr/share/man/man8/freebsd-update.8.gz
 .endif
 
 .if ${MK_GAMES} == no
 OLD_FILES+=usr/games/bcd
 OLD_FILES+=usr/games/caesar
 OLD_FILES+=usr/games/factor
 OLD_FILES+=usr/games/fortune
 OLD_FILES+=usr/games/grdc
 OLD_FILES+=usr/games/morse
 OLD_FILES+=usr/games/number
 OLD_FILES+=usr/games/pom
 OLD_FILES+=usr/games/ppt
 OLD_FILES+=usr/games/primes
 OLD_FILES+=usr/games/random
 OLD_FILES+=usr/games/rot13
 OLD_FILES+=usr/games/strfile
 OLD_FILES+=usr/games/unstr
 OLD_DIRS+=usr/games
 OLD_FILES+=usr/share/games/fortune/fortunes
 OLD_FILES+=usr/share/games/fortune/fortunes.dat
 OLD_FILES+=usr/share/games/fortune/freebsd-tips
 OLD_FILES+=usr/share/games/fortune/freebsd-tips.dat
 OLD_FILES+=usr/share/games/fortune/gerrold.limerick
 OLD_FILES+=usr/share/games/fortune/gerrold.limerick.dat
 OLD_FILES+=usr/share/games/fortune/limerick
 OLD_FILES+=usr/share/games/fortune/limerick.dat
 OLD_FILES+=usr/share/games/fortune/murphy
 OLD_FILES+=usr/share/games/fortune/murphy-o
 OLD_FILES+=usr/share/games/fortune/murphy-o.dat
 OLD_FILES+=usr/share/games/fortune/murphy.dat
 OLD_FILES+=usr/share/games/fortune/startrek
 OLD_FILES+=usr/share/games/fortune/startrek.dat
 OLD_FILES+=usr/share/games/fortune/zippy
 OLD_FILES+=usr/share/games/fortune/zippy.dat
 OLD_DIRS+=usr/share/games/fortune
 OLD_DIRS+=usr/share/games
 OLD_FILES+=usr/share/man/man6/bcd.6.gz
 OLD_FILES+=usr/share/man/man6/caesar.6.gz
 OLD_FILES+=usr/share/man/man6/factor.6.gz
 OLD_FILES+=usr/share/man/man6/fortune.6.gz
 OLD_FILES+=usr/share/man/man6/grdc.6.gz
 OLD_FILES+=usr/share/man/man6/morse.6.gz
 OLD_FILES+=usr/share/man/man6/number.6.gz
 OLD_FILES+=usr/share/man/man6/pom.6.gz
 OLD_FILES+=usr/share/man/man6/ppt.6.gz
 OLD_FILES+=usr/share/man/man6/primes.6.gz
 OLD_FILES+=usr/share/man/man6/random.6.gz
 OLD_FILES+=usr/share/man/man6/rot13.6.gz
 OLD_FILES+=usr/share/man/man8/strfile.8.gz
 OLD_FILES+=usr/share/man/man8/unstr.8.gz
 .endif
 
 .if ${MK_GCC} == no
 OLD_FILES+=usr/bin/c++filt
 OLD_FILES+=usr/bin/g++
 OLD_FILES+=usr/bin/gcc
 OLD_FILES+=usr/bin/gcov
 OLD_FILES+=usr/bin/gcpp
 .if ${TARGET_ARCH} == "amd64" || ${TARGET_ARCH} == "i386"
 OLD_FILES+=usr/include/gcc/4.2/__wmmintrin_aes.h
 OLD_FILES+=usr/include/gcc/4.2/__wmmintrin_pclmul.h
 OLD_FILES+=usr/include/gcc/4.2/ammintrin.h
 OLD_FILES+=usr/include/gcc/4.2/emmintrin.h
 OLD_FILES+=usr/include/gcc/4.2/mm3dnow.h
 OLD_FILES+=usr/include/gcc/4.2/mm_malloc.h
 OLD_FILES+=usr/include/gcc/4.2/mmintrin.h
 OLD_FILES+=usr/include/gcc/4.2/pmmintrin.h
 OLD_FILES+=usr/include/gcc/4.2/tmmintrin.h
 OLD_FILES+=usr/include/gcc/4.2/wmmintrin.h
 OLD_FILES+=usr/include/gcc/4.2/xmmintrin.h
 .elif ${TARGET_ARCH} == "arm"
 OLD_FILES+=usr/include/gcc/4.2/mmintrin.h
 .elif ${TARGET_ARCH} == "powerpc" || ${TARGET_ARCH} == "powerpc64"
 OLD_FILES+=usr/include/gcc/4.2/altivec.h
 OLD_FILES+=usr/include/gcc/4.2/ppc-asm.h
 OLD_FILES+=usr/include/gcc/4.2/spe.h
 .endif
 OLD_FILES+=usr/libexec/cc1
 OLD_FILES+=usr/libexec/cc1plus
 OLD_FILES+=usr/share/info/cpp.info.gz
 OLD_FILES+=usr/share/info/cppinternals.info.gz
 OLD_FILES+=usr/share/info/gcc.info.gz
 OLD_FILES+=usr/share/info/gccint.info.gz
 OLD_FILES+=usr/share/man/man1/g++.1.gz
 OLD_FILES+=usr/share/man/man1/gcc.1.gz
 OLD_FILES+=usr/share/man/man1/gcov.1.gz
 OLD_FILES+=usr/share/man/man1/gcpp.1.gz
 .endif
 
 .if ${MK_GCOV} == no
 OLD_FILES+=usr/bin/gcov
 OLD_FILES+=usr/share/man/man1/gcov.1.gz
 .endif
 
 .if ${MK_GDB} == no
 OLD_FILES+=usr/bin/gdb
 OLD_FILES+=usr/bin/gdbserver
 OLD_FILES+=usr/bin/gdbtui
 OLD_FILES+=usr/bin/kgdb
 OLD_FILES+=usr/share/info/gdb.info.gz
 OLD_FILES+=usr/share/info/gdbint.info.gz
 OLD_FILES+=usr/share/info/stabs.info.gz
 OLD_FILES+=usr/share/man/man1/gdb.1.gz
 OLD_FILES+=usr/share/man/man1/gdbserver.1.gz
 OLD_FILES+=usr/share/man/man1/kgdb.1.gz
 .endif
 
 .if ${MK_GPIO} == no
 OLD_FILES+=usr/include/libgpio.h
 OLD_FILES+=usr/lib/libgpio.a
 OLD_LIBS+=usr/lib/libgpio.so.0
 OLD_FILES+=usr/lib/libgpio_p.a
 OLD_FILES+=usr/sbin/gpioctl
 OLD_FILES+=usr/share/man/man3/gpio.3.gz
 OLD_FILES+=usr/share/man/man3/gpio_close.3.gz
 OLD_FILES+=usr/share/man/man3/gpio_open.3.gz
 OLD_FILES+=usr/share/man/man3/gpio_open_device.3.gz
 OLD_FILES+=usr/share/man/man3/gpio_pin_config.3.gz
 OLD_FILES+=usr/share/man/man3/gpio_pin_get.3.gz
 OLD_FILES+=usr/share/man/man3/gpio_pin_high.3.gz
 OLD_FILES+=usr/share/man/man3/gpio_pin_input.3.gz
 OLD_FILES+=usr/share/man/man3/gpio_pin_invin.3.gz
 OLD_FILES+=usr/share/man/man3/gpio_pin_invout.3.gz
 OLD_FILES+=usr/share/man/man3/gpio_pin_list.3.gz
 OLD_FILES+=usr/share/man/man3/gpio_pin_low.3.gz
 OLD_FILES+=usr/share/man/man3/gpio_pin_opendrain.3.gz
 OLD_FILES+=usr/share/man/man3/gpio_pin_output.3.gz
 OLD_FILES+=usr/share/man/man3/gpio_pin_pulldown.3.gz
 OLD_FILES+=usr/share/man/man3/gpio_pin_pullup.3.gz
 OLD_FILES+=usr/share/man/man3/gpio_pin_pulsate.3.gz
 OLD_FILES+=usr/share/man/man3/gpio_pin_pushpull.3.gz
 OLD_FILES+=usr/share/man/man3/gpio_pin_set.3.gz
 OLD_FILES+=usr/share/man/man3/gpio_pin_set_flags.3.gz
 OLD_FILES+=usr/share/man/man3/gpio_pin_tristate.3.gz
 OLD_FILES+=usr/share/man/man8/gpioctl.8.gz
 .endif
 
 # Also includes vgrind(1)
 .if ${MK_GROFF} == no
 OLD_FILES+=usr/bin/addftinfo
 OLD_FILES+=usr/bin/afmtodit
 OLD_FILES+=usr/bin/eqn
 OLD_FILES+=usr/bin/grn
 OLD_FILES+=usr/bin/grodvi
 OLD_FILES+=usr/bin/groff
 OLD_FILES+=usr/bin/grog
 OLD_FILES+=usr/bin/grolbp
 OLD_FILES+=usr/bin/grolj4
 OLD_FILES+=usr/bin/grops
 OLD_FILES+=usr/bin/grotty
 OLD_FILES+=usr/bin/hpftodit
 OLD_FILES+=usr/bin/indxbib
 OLD_FILES+=usr/bin/lkbib
 OLD_FILES+=usr/bin/lookbib
 OLD_FILES+=usr/bin/mmroff
 OLD_FILES+=usr/bin/neqn
 OLD_FILES+=usr/bin/nroff
 OLD_FILES+=usr/bin/pfbtops
 OLD_FILES+=usr/bin/pic
 OLD_FILES+=usr/bin/post-grohtml
 OLD_FILES+=usr/bin/pre-grohtml
 OLD_FILES+=usr/bin/psroff
 OLD_FILES+=usr/bin/refer
 OLD_FILES+=usr/bin/soelim
 OLD_FILES+=usr/bin/tbl
 OLD_FILES+=usr/bin/tfmtodit
 OLD_FILES+=usr/bin/troff
 OLD_FILES+=usr/bin/vgrind
 OLD_FILES+=usr/libexec/vfontedpr
 OLD_FILES+=usr/share/groff_font/devX100-12/CB
 OLD_FILES+=usr/share/groff_font/devX100-12/CBI
 OLD_FILES+=usr/share/groff_font/devX100-12/CI
 OLD_FILES+=usr/share/groff_font/devX100-12/CR
 OLD_FILES+=usr/share/groff_font/devX100-12/DESC
 OLD_FILES+=usr/share/groff_font/devX100-12/HB
 OLD_FILES+=usr/share/groff_font/devX100-12/HBI
 OLD_FILES+=usr/share/groff_font/devX100-12/HI
 OLD_FILES+=usr/share/groff_font/devX100-12/HR
 OLD_FILES+=usr/share/groff_font/devX100-12/NB
 OLD_FILES+=usr/share/groff_font/devX100-12/NBI
 OLD_FILES+=usr/share/groff_font/devX100-12/NI
 OLD_FILES+=usr/share/groff_font/devX100-12/NR
 OLD_FILES+=usr/share/groff_font/devX100-12/S
 OLD_FILES+=usr/share/groff_font/devX100-12/TB
 OLD_FILES+=usr/share/groff_font/devX100-12/TBI
 OLD_FILES+=usr/share/groff_font/devX100-12/TI
 OLD_FILES+=usr/share/groff_font/devX100-12/TR
 OLD_DIRS+=usr/share/groff_font/devX100-12
 OLD_FILES+=usr/share/groff_font/devX100/CB
 OLD_FILES+=usr/share/groff_font/devX100/CBI
 OLD_FILES+=usr/share/groff_font/devX100/CI
 OLD_FILES+=usr/share/groff_font/devX100/CR
 OLD_FILES+=usr/share/groff_font/devX100/DESC
 OLD_FILES+=usr/share/groff_font/devX100/HB
 OLD_FILES+=usr/share/groff_font/devX100/HBI
 OLD_FILES+=usr/share/groff_font/devX100/HI
 OLD_FILES+=usr/share/groff_font/devX100/HR
 OLD_FILES+=usr/share/groff_font/devX100/NB
 OLD_FILES+=usr/share/groff_font/devX100/NBI
 OLD_FILES+=usr/share/groff_font/devX100/NI
 OLD_FILES+=usr/share/groff_font/devX100/NR
 OLD_FILES+=usr/share/groff_font/devX100/S
 OLD_FILES+=usr/share/groff_font/devX100/TB
 OLD_FILES+=usr/share/groff_font/devX100/TBI
 OLD_FILES+=usr/share/groff_font/devX100/TI
 OLD_FILES+=usr/share/groff_font/devX100/TR
 OLD_DIRS+=usr/share/groff_font/devX100
 OLD_FILES+=usr/share/groff_font/devX75-12/CB
 OLD_FILES+=usr/share/groff_font/devX75-12/CBI
 OLD_FILES+=usr/share/groff_font/devX75-12/CI
 OLD_FILES+=usr/share/groff_font/devX75-12/CR
 OLD_FILES+=usr/share/groff_font/devX75-12/DESC
 OLD_FILES+=usr/share/groff_font/devX75-12/HB
 OLD_FILES+=usr/share/groff_font/devX75-12/HBI
 OLD_FILES+=usr/share/groff_font/devX75-12/HI
 OLD_FILES+=usr/share/groff_font/devX75-12/HR
 OLD_FILES+=usr/share/groff_font/devX75-12/NB
 OLD_FILES+=usr/share/groff_font/devX75-12/NBI
 OLD_FILES+=usr/share/groff_font/devX75-12/NI
 OLD_FILES+=usr/share/groff_font/devX75-12/NR
 OLD_FILES+=usr/share/groff_font/devX75-12/S
 OLD_FILES+=usr/share/groff_font/devX75-12/TB
 OLD_FILES+=usr/share/groff_font/devX75-12/TBI
 OLD_FILES+=usr/share/groff_font/devX75-12/TI
 OLD_FILES+=usr/share/groff_font/devX75-12/TR
 OLD_DIRS+=usr/share/groff_font/devX75-12
 OLD_FILES+=usr/share/groff_font/devX75/CB
 OLD_FILES+=usr/share/groff_font/devX75/CBI
 OLD_FILES+=usr/share/groff_font/devX75/CI
 OLD_FILES+=usr/share/groff_font/devX75/CR
 OLD_FILES+=usr/share/groff_font/devX75/DESC
 OLD_FILES+=usr/share/groff_font/devX75/HB
 OLD_FILES+=usr/share/groff_font/devX75/HBI
 OLD_FILES+=usr/share/groff_font/devX75/HI
 OLD_FILES+=usr/share/groff_font/devX75/HR
 OLD_FILES+=usr/share/groff_font/devX75/NB
 OLD_FILES+=usr/share/groff_font/devX75/NBI
 OLD_FILES+=usr/share/groff_font/devX75/NI
 OLD_FILES+=usr/share/groff_font/devX75/NR
 OLD_FILES+=usr/share/groff_font/devX75/S
 OLD_FILES+=usr/share/groff_font/devX75/TB
 OLD_FILES+=usr/share/groff_font/devX75/TBI
 OLD_FILES+=usr/share/groff_font/devX75/TI
 OLD_FILES+=usr/share/groff_font/devX75/TR
 OLD_DIRS+=usr/share/groff_font/devX75
 OLD_FILES+=usr/share/groff_font/devascii/B
 OLD_FILES+=usr/share/groff_font/devascii/BI
 OLD_FILES+=usr/share/groff_font/devascii/CW
 OLD_FILES+=usr/share/groff_font/devascii/DESC
 OLD_FILES+=usr/share/groff_font/devascii/I
 OLD_FILES+=usr/share/groff_font/devascii/L
 OLD_FILES+=usr/share/groff_font/devascii/R
 OLD_FILES+=usr/share/groff_font/devascii/S
 OLD_DIRS+=usr/share/groff_font/devascii
 OLD_FILES+=usr/share/groff_font/devcp1047/B
 OLD_FILES+=usr/share/groff_font/devcp1047/BI
 OLD_FILES+=usr/share/groff_font/devcp1047/CW
 OLD_FILES+=usr/share/groff_font/devcp1047/DESC
 OLD_FILES+=usr/share/groff_font/devcp1047/I
 OLD_FILES+=usr/share/groff_font/devcp1047/L
 OLD_FILES+=usr/share/groff_font/devcp1047/R
 OLD_FILES+=usr/share/groff_font/devcp1047/S
 OLD_DIRS+=usr/share/groff_font/devcp1047
 OLD_FILES+=usr/share/groff_font/devdvi/CW
 OLD_FILES+=usr/share/groff_font/devdvi/CWEC
 OLD_FILES+=usr/share/groff_font/devdvi/CWI
 OLD_FILES+=usr/share/groff_font/devdvi/CWIEC
 OLD_FILES+=usr/share/groff_font/devdvi/CWITC
 OLD_FILES+=usr/share/groff_font/devdvi/CWTC
 OLD_FILES+=usr/share/groff_font/devdvi/CompileFonts
 OLD_FILES+=usr/share/groff_font/devdvi/DESC
 OLD_FILES+=usr/share/groff_font/devdvi/EX
 OLD_FILES+=usr/share/groff_font/devdvi/HB
 OLD_FILES+=usr/share/groff_font/devdvi/HBEC
 OLD_FILES+=usr/share/groff_font/devdvi/HBI
 OLD_FILES+=usr/share/groff_font/devdvi/HBIEC
 OLD_FILES+=usr/share/groff_font/devdvi/HBITC
 OLD_FILES+=usr/share/groff_font/devdvi/HBTC
 OLD_FILES+=usr/share/groff_font/devdvi/HI
 OLD_FILES+=usr/share/groff_font/devdvi/HIEC
 OLD_FILES+=usr/share/groff_font/devdvi/HITC
 OLD_FILES+=usr/share/groff_font/devdvi/HR
 OLD_FILES+=usr/share/groff_font/devdvi/HREC
 OLD_FILES+=usr/share/groff_font/devdvi/HRTC
 OLD_FILES+=usr/share/groff_font/devdvi/MI
 OLD_FILES+=usr/share/groff_font/devdvi/Makefile
 OLD_FILES+=usr/share/groff_font/devdvi/S
 OLD_FILES+=usr/share/groff_font/devdvi/SA
 OLD_FILES+=usr/share/groff_font/devdvi/SB
 OLD_FILES+=usr/share/groff_font/devdvi/SC
 OLD_FILES+=usr/share/groff_font/devdvi/TB
 OLD_FILES+=usr/share/groff_font/devdvi/TBEC
 OLD_FILES+=usr/share/groff_font/devdvi/TBI
 OLD_FILES+=usr/share/groff_font/devdvi/TBIEC
 OLD_FILES+=usr/share/groff_font/devdvi/TBITC
 OLD_FILES+=usr/share/groff_font/devdvi/TBTC
 OLD_FILES+=usr/share/groff_font/devdvi/TI
 OLD_FILES+=usr/share/groff_font/devdvi/TIEC
 OLD_FILES+=usr/share/groff_font/devdvi/TITC
 OLD_FILES+=usr/share/groff_font/devdvi/TR
 OLD_FILES+=usr/share/groff_font/devdvi/TREC
 OLD_FILES+=usr/share/groff_font/devdvi/TRTC
 OLD_FILES+=usr/share/groff_font/devdvi/ec.map
 OLD_FILES+=usr/share/groff_font/devdvi/msam.map
 OLD_FILES+=usr/share/groff_font/devdvi/msbm.map
 OLD_FILES+=usr/share/groff_font/devdvi/tc.map
 OLD_FILES+=usr/share/groff_font/devdvi/texb.map
 OLD_FILES+=usr/share/groff_font/devdvi/texex.map
 OLD_FILES+=usr/share/groff_font/devdvi/texi.map
 OLD_FILES+=usr/share/groff_font/devdvi/texmi.map
 OLD_FILES+=usr/share/groff_font/devdvi/texr.map
 OLD_FILES+=usr/share/groff_font/devdvi/texsy.map
 OLD_FILES+=usr/share/groff_font/devdvi/textex.map
 OLD_FILES+=usr/share/groff_font/devdvi/textt.map
 OLD_DIRS+=usr/share/groff_font/devdvi
 OLD_FILES+=usr/share/groff_font/devhtml/B
 OLD_FILES+=usr/share/groff_font/devhtml/BI
 OLD_FILES+=usr/share/groff_font/devhtml/CB
 OLD_FILES+=usr/share/groff_font/devhtml/CBI
 OLD_FILES+=usr/share/groff_font/devhtml/CI
 OLD_FILES+=usr/share/groff_font/devhtml/CR
 OLD_FILES+=usr/share/groff_font/devhtml/DESC
 OLD_FILES+=usr/share/groff_font/devhtml/I
 OLD_FILES+=usr/share/groff_font/devhtml/R
 OLD_FILES+=usr/share/groff_font/devhtml/S
 OLD_DIRS+=usr/share/groff_font/devhtml
 OLD_FILES+=usr/share/groff_font/devkoi8-r/B
 OLD_FILES+=usr/share/groff_font/devkoi8-r/BI
 OLD_FILES+=usr/share/groff_font/devkoi8-r/CW
 OLD_FILES+=usr/share/groff_font/devkoi8-r/DESC
 OLD_FILES+=usr/share/groff_font/devkoi8-r/I
 OLD_FILES+=usr/share/groff_font/devkoi8-r/L
 OLD_FILES+=usr/share/groff_font/devkoi8-r/R
 OLD_FILES+=usr/share/groff_font/devkoi8-r/S
 OLD_DIRS+=usr/share/groff_font/devkoi8-r
 OLD_FILES+=usr/share/groff_font/devlatin1/B
 OLD_FILES+=usr/share/groff_font/devlatin1/BI
 OLD_FILES+=usr/share/groff_font/devlatin1/CW
 OLD_FILES+=usr/share/groff_font/devlatin1/DESC
 OLD_FILES+=usr/share/groff_font/devlatin1/I
 OLD_FILES+=usr/share/groff_font/devlatin1/L
 OLD_FILES+=usr/share/groff_font/devlatin1/R
 OLD_FILES+=usr/share/groff_font/devlatin1/S
 OLD_DIRS+=usr/share/groff_font/devlatin1
 OLD_FILES+=usr/share/groff_font/devlbp/CB
 OLD_FILES+=usr/share/groff_font/devlbp/CI
 OLD_FILES+=usr/share/groff_font/devlbp/CR
 OLD_FILES+=usr/share/groff_font/devlbp/DESC
 OLD_FILES+=usr/share/groff_font/devlbp/EB
 OLD_FILES+=usr/share/groff_font/devlbp/EI
 OLD_FILES+=usr/share/groff_font/devlbp/ER
 OLD_FILES+=usr/share/groff_font/devlbp/HB
 OLD_FILES+=usr/share/groff_font/devlbp/HBI
 OLD_FILES+=usr/share/groff_font/devlbp/HI
 OLD_FILES+=usr/share/groff_font/devlbp/HNB
 OLD_FILES+=usr/share/groff_font/devlbp/HNBI
 OLD_FILES+=usr/share/groff_font/devlbp/HNI
 OLD_FILES+=usr/share/groff_font/devlbp/HNR
 OLD_FILES+=usr/share/groff_font/devlbp/HR
 OLD_FILES+=usr/share/groff_font/devlbp/TB
 OLD_FILES+=usr/share/groff_font/devlbp/TBI
 OLD_FILES+=usr/share/groff_font/devlbp/TI
 OLD_FILES+=usr/share/groff_font/devlbp/TR
 OLD_DIRS+=usr/share/groff_font/devlbp
 OLD_FILES+=usr/share/groff_font/devlj4/AB
 OLD_FILES+=usr/share/groff_font/devlj4/ABI
 OLD_FILES+=usr/share/groff_font/devlj4/AI
 OLD_FILES+=usr/share/groff_font/devlj4/ALBB
 OLD_FILES+=usr/share/groff_font/devlj4/ALBR
 OLD_FILES+=usr/share/groff_font/devlj4/AOB
 OLD_FILES+=usr/share/groff_font/devlj4/AOI
 OLD_FILES+=usr/share/groff_font/devlj4/AOR
 OLD_FILES+=usr/share/groff_font/devlj4/AR
 OLD_FILES+=usr/share/groff_font/devlj4/CB
 OLD_FILES+=usr/share/groff_font/devlj4/CBI
 OLD_FILES+=usr/share/groff_font/devlj4/CI
 OLD_FILES+=usr/share/groff_font/devlj4/CLARENDON
 OLD_FILES+=usr/share/groff_font/devlj4/CORONET
 OLD_FILES+=usr/share/groff_font/devlj4/CR
 OLD_FILES+=usr/share/groff_font/devlj4/DESC
 OLD_FILES+=usr/share/groff_font/devlj4/GB
 OLD_FILES+=usr/share/groff_font/devlj4/GBI
 OLD_FILES+=usr/share/groff_font/devlj4/GI
 OLD_FILES+=usr/share/groff_font/devlj4/GR
 OLD_FILES+=usr/share/groff_font/devlj4/LGB
 OLD_FILES+=usr/share/groff_font/devlj4/LGI
 OLD_FILES+=usr/share/groff_font/devlj4/LGR
 OLD_FILES+=usr/share/groff_font/devlj4/MARIGOLD
 OLD_FILES+=usr/share/groff_font/devlj4/OB
 OLD_FILES+=usr/share/groff_font/devlj4/OBI
 OLD_FILES+=usr/share/groff_font/devlj4/OI
 OLD_FILES+=usr/share/groff_font/devlj4/OR
 OLD_FILES+=usr/share/groff_font/devlj4/S
 OLD_FILES+=usr/share/groff_font/devlj4/SYMBOL
 OLD_FILES+=usr/share/groff_font/devlj4/TB
 OLD_FILES+=usr/share/groff_font/devlj4/TBI
 OLD_FILES+=usr/share/groff_font/devlj4/TI
 OLD_FILES+=usr/share/groff_font/devlj4/TNRB
 OLD_FILES+=usr/share/groff_font/devlj4/TNRBI
 OLD_FILES+=usr/share/groff_font/devlj4/TNRI
 OLD_FILES+=usr/share/groff_font/devlj4/TNRR
 OLD_FILES+=usr/share/groff_font/devlj4/TR
 OLD_FILES+=usr/share/groff_font/devlj4/UB
 OLD_FILES+=usr/share/groff_font/devlj4/UBI
 OLD_FILES+=usr/share/groff_font/devlj4/UCB
 OLD_FILES+=usr/share/groff_font/devlj4/UCBI
 OLD_FILES+=usr/share/groff_font/devlj4/UCI
 OLD_FILES+=usr/share/groff_font/devlj4/UCR
 OLD_FILES+=usr/share/groff_font/devlj4/UI
 OLD_FILES+=usr/share/groff_font/devlj4/UR
 OLD_FILES+=usr/share/groff_font/devlj4/WINGDINGS
 OLD_DIRS+=usr/share/groff_font/devlj4
 OLD_FILES+=usr/share/groff_font/devps/AB
 OLD_FILES+=usr/share/groff_font/devps/ABI
 OLD_FILES+=usr/share/groff_font/devps/AI
 OLD_FILES+=usr/share/groff_font/devps/AR
 OLD_FILES+=usr/share/groff_font/devps/BMB
 OLD_FILES+=usr/share/groff_font/devps/BMBI
 OLD_FILES+=usr/share/groff_font/devps/BMI
 OLD_FILES+=usr/share/groff_font/devps/BMR
 OLD_FILES+=usr/share/groff_font/devps/CB
 OLD_FILES+=usr/share/groff_font/devps/CBI
 OLD_FILES+=usr/share/groff_font/devps/CI
 OLD_FILES+=usr/share/groff_font/devps/CR
 OLD_FILES+=usr/share/groff_font/devps/DESC
 OLD_FILES+=usr/share/groff_font/devps/EURO
 OLD_FILES+=usr/share/groff_font/devps/HB
 OLD_FILES+=usr/share/groff_font/devps/HBI
 OLD_FILES+=usr/share/groff_font/devps/HI
 OLD_FILES+=usr/share/groff_font/devps/HNB
 OLD_FILES+=usr/share/groff_font/devps/HNBI
 OLD_FILES+=usr/share/groff_font/devps/HNI
 OLD_FILES+=usr/share/groff_font/devps/HNR
 OLD_FILES+=usr/share/groff_font/devps/HR
 OLD_FILES+=usr/share/groff_font/devps/Makefile
 OLD_FILES+=usr/share/groff_font/devps/NB
 OLD_FILES+=usr/share/groff_font/devps/NBI
 OLD_FILES+=usr/share/groff_font/devps/NI
 OLD_FILES+=usr/share/groff_font/devps/NR
 OLD_FILES+=usr/share/groff_font/devps/PB
 OLD_FILES+=usr/share/groff_font/devps/PBI
 OLD_FILES+=usr/share/groff_font/devps/PI
 OLD_FILES+=usr/share/groff_font/devps/PR
 OLD_FILES+=usr/share/groff_font/devps/S
 OLD_FILES+=usr/share/groff_font/devps/SS
 OLD_FILES+=usr/share/groff_font/devps/TB
 OLD_FILES+=usr/share/groff_font/devps/TBI
 OLD_FILES+=usr/share/groff_font/devps/TI
 OLD_FILES+=usr/share/groff_font/devps/TR
 OLD_FILES+=usr/share/groff_font/devps/ZCMI
 OLD_FILES+=usr/share/groff_font/devps/ZD
 OLD_FILES+=usr/share/groff_font/devps/ZDR
 OLD_FILES+=usr/share/groff_font/devps/afmname
 OLD_FILES+=usr/share/groff_font/devps/dingbats.map
 OLD_FILES+=usr/share/groff_font/devps/dingbats.rmap
 OLD_FILES+=usr/share/groff_font/devps/download
 OLD_FILES+=usr/share/groff_font/devps/freeeuro.pfa
 OLD_FILES+=usr/share/groff_font/devps/lgreekmap
 OLD_FILES+=usr/share/groff_font/devps/prologue
 OLD_FILES+=usr/share/groff_font/devps/symbol.sed
 OLD_FILES+=usr/share/groff_font/devps/symbolchars
 OLD_FILES+=usr/share/groff_font/devps/symbolsl.afm
 OLD_FILES+=usr/share/groff_font/devps/symbolsl.pfa
 OLD_FILES+=usr/share/groff_font/devps/text.enc
 OLD_FILES+=usr/share/groff_font/devps/textmap
 OLD_FILES+=usr/share/groff_font/devps/zapfdr.pfa
 OLD_DIRS+=usr/share/groff_font/devps
 OLD_FILES+=usr/share/groff_font/devutf8/B
 OLD_FILES+=usr/share/groff_font/devutf8/BI
 OLD_FILES+=usr/share/groff_font/devutf8/CW
 OLD_FILES+=usr/share/groff_font/devutf8/DESC
 OLD_FILES+=usr/share/groff_font/devutf8/I
 OLD_FILES+=usr/share/groff_font/devutf8/L
 OLD_FILES+=usr/share/groff_font/devutf8/R
 OLD_FILES+=usr/share/groff_font/devutf8/S
 OLD_DIRS+=usr/share/groff_font/devutf8
 OLD_DIRS+=usr/share/groff_font
 OLD_FILES+=usr/share/info/groff.info.gz
 OLD_FILES+=usr/share/man/man1/addftinfo.1.gz
 OLD_FILES+=usr/share/man/man1/afmtodit.1.gz
 OLD_FILES+=usr/share/man/man1/eqn.1.gz
 OLD_FILES+=usr/share/man/man1/grn.1.gz
 OLD_FILES+=usr/share/man/man1/grodvi.1.gz
 OLD_FILES+=usr/share/man/man1/groff.1.gz
 OLD_FILES+=usr/share/man/man1/grog.1.gz
 OLD_FILES+=usr/share/man/man1/grolbp.1.gz
 OLD_FILES+=usr/share/man/man1/grolj4.1.gz
 OLD_FILES+=usr/share/man/man1/grops.1.gz
 OLD_FILES+=usr/share/man/man1/grotty.1.gz
 OLD_FILES+=usr/share/man/man1/hpftodit.1.gz
 OLD_FILES+=usr/share/man/man1/indxbib.1.gz
 OLD_FILES+=usr/share/man/man1/lkbib.1.gz
 OLD_FILES+=usr/share/man/man1/lookbib.1.gz
 OLD_FILES+=usr/share/man/man1/mmroff.1.gz
 OLD_FILES+=usr/share/man/man1/neqn.1.gz
 OLD_FILES+=usr/share/man/man1/nroff.1.gz
 OLD_FILES+=usr/share/man/man1/pfbtops.1.gz
 OLD_FILES+=usr/share/man/man1/pic.1.gz
 OLD_FILES+=usr/share/man/man1/psroff.1.gz
 OLD_FILES+=usr/share/man/man1/refer.1.gz
 OLD_FILES+=usr/share/man/man1/soelim.1.gz
 OLD_FILES+=usr/share/man/man1/tbl.1.gz
 OLD_FILES+=usr/share/man/man1/tfmtodit.1.gz
 OLD_FILES+=usr/share/man/man1/troff.1.gz
 OLD_FILES+=usr/share/man/man1/vgrind.1.gz
 OLD_FILES+=usr/share/man/man5/groff_font.5.gz
 OLD_FILES+=usr/share/man/man5/groff_out.5.gz
 OLD_FILES+=usr/share/man/man5/groff_tmac.5.gz
 OLD_FILES+=usr/share/man/man5/lj4_font.5.gz
 OLD_FILES+=usr/share/man/man5/tmac.5.gz
 OLD_FILES+=usr/share/man/man5/vgrindefs.5.gz
 OLD_FILES+=usr/share/man/man7/ditroff.7.gz
 OLD_FILES+=usr/share/man/man7/groff.7.gz
 OLD_FILES+=usr/share/man/man7/groff_char.7.gz
 OLD_FILES+=usr/share/man/man7/groff_diff.7.gz
 OLD_FILES+=usr/share/man/man7/groff_man.7.gz
 OLD_FILES+=usr/share/man/man7/groff_mdoc.7.gz
 OLD_FILES+=usr/share/man/man7/groff_me.7.gz
 OLD_FILES+=usr/share/man/man7/groff_mm.7.gz
 OLD_FILES+=usr/share/man/man7/groff_mmse.7.gz
 OLD_FILES+=usr/share/man/man7/groff_ms.7.gz
 OLD_FILES+=usr/share/man/man7/groff_trace.7.gz
 OLD_FILES+=usr/share/man/man7/groff_www.7.gz
 OLD_FILES+=usr/share/man/man7/mdoc.samples.7.gz
 OLD_FILES+=usr/share/man/man7/me.7.gz
 OLD_FILES+=usr/share/man/man7/mm.7.gz
 OLD_FILES+=usr/share/man/man7/mmse.7.gz
 OLD_FILES+=usr/share/man/man7/ms.7.gz
 OLD_FILES+=usr/share/man/man7/orig_me.7.gz
 OLD_FILES+=usr/share/man/man7/roff.7.gz
 OLD_FILES+=usr/share/me/acm.me
 OLD_FILES+=usr/share/me/chars.me
 OLD_FILES+=usr/share/me/deltext.me
 OLD_FILES+=usr/share/me/eqn.me
 OLD_FILES+=usr/share/me/float.me
 OLD_FILES+=usr/share/me/footnote.me
 OLD_FILES+=usr/share/me/index.me
 OLD_FILES+=usr/share/me/letterhead.me
 OLD_FILES+=usr/share/me/local.me
 OLD_FILES+=usr/share/me/null.me
 OLD_FILES+=usr/share/me/refer.me
 OLD_FILES+=usr/share/me/revisions
 OLD_FILES+=usr/share/me/sh.me
 OLD_FILES+=usr/share/me/tbl.me
 OLD_FILES+=usr/share/me/thesis.me
 OLD_DIRS+=usr/share/me
 OLD_FILES+=usr/share/misc/vgrindefs
 OLD_FILES+=usr/share/misc/vgrindefs.db
 OLD_FILES+=usr/share/tmac/X.tmac
 OLD_FILES+=usr/share/tmac/Xps.tmac
 OLD_FILES+=usr/share/tmac/a4.tmac
 OLD_FILES+=usr/share/tmac/an-old.tmac
 OLD_FILES+=usr/share/tmac/an.tmac
 OLD_FILES+=usr/share/tmac/andoc.tmac
 OLD_FILES+=usr/share/tmac/composite.tmac
 OLD_FILES+=usr/share/tmac/cp1047.tmac
 OLD_FILES+=usr/share/tmac/devtag.tmac
 OLD_FILES+=usr/share/tmac/doc.tmac
 OLD_FILES+=usr/share/tmac/dvi.tmac
 OLD_FILES+=usr/share/tmac/e.tmac
 OLD_FILES+=usr/share/tmac/ec.tmac
 OLD_FILES+=usr/share/tmac/eqnrc
 OLD_FILES+=usr/share/tmac/europs.tmac
 OLD_FILES+=usr/share/tmac/html-end.tmac
 OLD_FILES+=usr/share/tmac/html.tmac
 OLD_FILES+=usr/share/tmac/hyphen.ru
 OLD_FILES+=usr/share/tmac/hyphen.us
 OLD_FILES+=usr/share/tmac/hyphenex.us
 OLD_FILES+=usr/share/tmac/koi8-r.tmac
 OLD_FILES+=usr/share/tmac/latin1.tmac
 OLD_FILES+=usr/share/tmac/latin2.tmac
 OLD_FILES+=usr/share/tmac/latin9.tmac
 OLD_FILES+=usr/share/tmac/lbp.tmac
 OLD_FILES+=usr/share/tmac/lj4.tmac
 OLD_FILES+=usr/share/tmac/m.tmac
 OLD_FILES+=usr/share/tmac/man.local
 OLD_FILES+=usr/share/tmac/man.tmac
 OLD_FILES+=usr/share/tmac/mandoc.tmac
 OLD_FILES+=usr/share/tmac/mdoc.local
 OLD_FILES+=usr/share/tmac/mdoc.tmac
 OLD_FILES+=usr/share/tmac/mdoc/doc-common
 OLD_FILES+=usr/share/tmac/mdoc/doc-ditroff
 OLD_FILES+=usr/share/tmac/mdoc/doc-nroff
 OLD_FILES+=usr/share/tmac/mdoc/doc-syms
 OLD_FILES+=usr/share/tmac/mdoc/fr.ISO8859-1
 OLD_FILES+=usr/share/tmac/mdoc/ru.KOI8-R
 OLD_DIRS+=usr/share/tmac/mdoc
 OLD_FILES+=usr/share/tmac/me.tmac
 OLD_FILES+=usr/share/tmac/mm/0.MT
 OLD_FILES+=usr/share/tmac/mm/4.MT
 OLD_FILES+=usr/share/tmac/mm/5.MT
 OLD_FILES+=usr/share/tmac/mm/locale
 OLD_FILES+=usr/share/tmac/mm/mm.tmac
 OLD_FILES+=usr/share/tmac/mm/mmse.tmac
 OLD_FILES+=usr/share/tmac/mm/ms.cov
 OLD_FILES+=usr/share/tmac/mm/se_locale
 OLD_FILES+=usr/share/tmac/mm/se_ms.cov
 OLD_DIRS+=usr/share/tmac/mm
 OLD_FILES+=usr/share/tmac/ms.tmac
 OLD_FILES+=usr/share/tmac/mse.tmac
 OLD_FILES+=usr/share/tmac/papersize.tmac
 OLD_FILES+=usr/share/tmac/pic.tmac
 OLD_FILES+=usr/share/tmac/ps.tmac
 OLD_FILES+=usr/share/tmac/psatk.tmac
 OLD_FILES+=usr/share/tmac/psold.tmac
 OLD_FILES+=usr/share/tmac/pspic.tmac
 OLD_FILES+=usr/share/tmac/s.tmac
 OLD_FILES+=usr/share/tmac/safer.tmac
 OLD_FILES+=usr/share/tmac/tmac.orig_me
 OLD_FILES+=usr/share/tmac/tmac.vgrind
 OLD_FILES+=usr/share/tmac/trace.tmac
 OLD_FILES+=usr/share/tmac/troffrc
 OLD_FILES+=usr/share/tmac/troffrc-end
 OLD_FILES+=usr/share/tmac/tty-char.tmac
 OLD_FILES+=usr/share/tmac/tty.tmac
 OLD_FILES+=usr/share/tmac/unicode.tmac
 OLD_FILES+=usr/share/tmac/www.tmac
 OLD_DIRS+=usr/share/tmac
 .endif
 
 .if ${MK_GSSAPI} == no
 OLD_FILES+=usr/include/gssapi/gssapi.h
 OLD_DIRS+=usr/include/gssapi
 OLD_FILES+=usr/include/gssapi.h
 OLD_FILES+=usr/lib/libgssapi.a
 OLD_FILES+=usr/lib/libgssapi.so
 OLD_LIBS+=usr/lib/libgssapi.so.10
 OLD_FILES+=usr/lib/libgssapi_p.a
 OLD_FILES+=usr/lib/librpcsec_gss.a
 OLD_FILES+=usr/lib/librpcsec_gss.so
 OLD_LIBS+=usr/lib/librpcsec_gss.so.1
 .if ${TARGET_ARCH} == "amd64" || ${TARGET_ARCH} == "powerpc64"
 OLD_FILES+=usr/lib32/libgssapi.a
 OLD_FILES+=usr/lib32/libgssapi.so
 OLD_LIBS+=usr/lib32/libgssapi.so.10
 OLD_FILES+=usr/lib32/libgssapi_p.a
 OLD_FILES+=usr/lib32/librpcsec_gss.a
 OLD_FILES+=usr/lib32/librpcsec_gss.so
 OLD_LIBS+=usr/lib32/librpcsec_gss.so.1
 .endif
 OLD_FILES+=usr/sbin/gssd
 OLD_FILES+=usr/share/man/man3/gss_accept_sec_context.3.gz
 OLD_FILES+=usr/share/man/man3/gss_acquire_cred.3.gz
 OLD_FILES+=usr/share/man/man3/gss_add_cred.3.gz
 OLD_FILES+=usr/share/man/man3/gss_add_oid_set_member.3.gz
 OLD_FILES+=usr/share/man/man3/gss_canonicalize_name.3.gz
 OLD_FILES+=usr/share/man/man3/gss_compare_name.3.gz
 OLD_FILES+=usr/share/man/man3/gss_context_time.3.gz
 OLD_FILES+=usr/share/man/man3/gss_create_empty_oid_set.3.gz
 OLD_FILES+=usr/share/man/man3/gss_delete_sec_context.3.gz
 OLD_FILES+=usr/share/man/man3/gss_display_name.3.gz
 OLD_FILES+=usr/share/man/man3/gss_display_status.3.gz
 OLD_FILES+=usr/share/man/man3/gss_duplicate_name.3.gz
 OLD_FILES+=usr/share/man/man3/gss_export_name.3.gz
 OLD_FILES+=usr/share/man/man3/gss_export_sec_context.3.gz
 OLD_FILES+=usr/share/man/man3/gss_get_mic.3.gz
 OLD_FILES+=usr/share/man/man3/gss_import_name.3.gz
 OLD_FILES+=usr/share/man/man3/gss_import_sec_context.3.gz
 OLD_FILES+=usr/share/man/man3/gss_indicate_mechs.3.gz
 OLD_FILES+=usr/share/man/man3/gss_init_sec_context.3.gz
 OLD_FILES+=usr/share/man/man3/gss_inquire_context.3.gz
 OLD_FILES+=usr/share/man/man3/gss_inquire_cred.3.gz
 OLD_FILES+=usr/share/man/man3/gss_inquire_cred_by_mech.3.gz
 OLD_FILES+=usr/share/man/man3/gss_inquire_mechs_for_name.3.gz
 OLD_FILES+=usr/share/man/man3/gss_inquire_names_for_mech.3.gz
 OLD_FILES+=usr/share/man/man3/gss_process_context_token.3.gz
 OLD_FILES+=usr/share/man/man3/gss_release_buffer.3.gz
 OLD_FILES+=usr/share/man/man3/gss_release_cred.3.gz
 OLD_FILES+=usr/share/man/man3/gss_release_name.3.gz
 OLD_FILES+=usr/share/man/man3/gss_release_oid_set.3.gz
 OLD_FILES+=usr/share/man/man3/gss_seal.3.gz
 OLD_FILES+=usr/share/man/man3/gss_sign.3.gz
 OLD_FILES+=usr/share/man/man3/gss_test_oid_set_member.3.gz
 OLD_FILES+=usr/share/man/man3/gss_unseal.3.gz
 OLD_FILES+=usr/share/man/man3/gss_unwrap.3.gz
 OLD_FILES+=usr/share/man/man3/gss_verify.3.gz
 OLD_FILES+=usr/share/man/man3/gss_verify_mic.3.gz
 OLD_FILES+=usr/share/man/man3/gss_wrap.3.gz
 OLD_FILES+=usr/share/man/man3/gss_wrap_size_limit.3.gz
 OLD_FILES+=usr/share/man/man3/gssapi.3.gz
 OLD_FILES+=usr/share/man/man3/rpc_gss_get_error.3.gz
 OLD_FILES+=usr/share/man/man3/rpc_gss_get_mech_info.3.gz
 OLD_FILES+=usr/share/man/man3/rpc_gss_get_mechanisms.3.gz
 OLD_FILES+=usr/share/man/man3/rpc_gss_get_principal_name.3.gz
 OLD_FILES+=usr/share/man/man3/rpc_gss_get_versions.3.gz
 OLD_FILES+=usr/share/man/man3/rpc_gss_getcred.3.gz
 OLD_FILES+=usr/share/man/man3/rpc_gss_is_installed.3.gz
 OLD_FILES+=usr/share/man/man3/rpc_gss_max_data_length.3.gz
 OLD_FILES+=usr/share/man/man3/rpc_gss_mech_to_oid.3.gz
 OLD_FILES+=usr/share/man/man3/rpc_gss_oid_to_mech.3.gz
 OLD_FILES+=usr/share/man/man3/rpc_gss_qop_to_num.3.gz
 OLD_FILES+=usr/share/man/man3/rpc_gss_seccreate.3.gz
 OLD_FILES+=usr/share/man/man3/rpc_gss_set_callback.3.gz
 OLD_FILES+=usr/share/man/man3/rpc_gss_set_defaults.3.gz
 OLD_FILES+=usr/share/man/man3/rpc_gss_set_svc_name.3.gz
 OLD_FILES+=usr/share/man/man3/rpc_gss_svc_max_data_length.3.gz
 OLD_FILES+=usr/share/man/man3/rpcsec_gss.3.gz
 OLD_FILES+=usr/share/man/man5/mech.5.gz
 OLD_FILES+=usr/share/man/man5/qop.5.gz
 OLD_FILES+=usr/share/man/man8/gssd.8.gz
 .endif
 
+.if ${MK_HAST} == no
+OLD_FILES+=sbin/hastctl
+OLD_FILES+=sbin/hastd
+OLD_FILES+=usr/share/examples/hast/ucarp.sh
+OLD_FILES+=usr/share/examples/hast/ucarp_down.sh
+OLD_FILES+=usr/share/examples/hast/ucarp_up.sh
+OLD_FILES+=usr/share/examples/hast/vip-down.sh
+OLD_FILES+=usr/share/examples/hast/vip-up.sh
+OLD_FILES+=usr/share/man/man5/hast.conf.5.gz
+OLD_FILES+=usr/share/man/man8/hastctl.8.gz
+OLD_FILES+=usr/share/man/man8/hastd.8.gz
+OLD_DIRS+=usr/share/examples/hast
+.endif
+
 .if ${MK_HESIOD} == no
 OLD_FILES+=usr/bin/hesinfo
 OLD_FILES+=usr/include/hesiod.h
 OLD_FILES+=usr/share/man/man1/hesinfo.1.gz
 OLD_FILES+=usr/share/man/man3/hesiod.3.gz
 OLD_FILES+=usr/share/man/man5/hesiod.conf.5.gz
 .endif
 
 #.if ${MK_HTML} == no
 # to be filled in
 #.endif
 
 .if ${MK_ICONV} == no
 OLD_FILES+=usr/bin/iconv
 OLD_FILES+=usr/bin/mkcsmapper
 OLD_FILES+=usr/bin/mkesdb
 OLD_FILES+=usr/include/_libiconv_compat.h
 OLD_FILES+=usr/include/iconv.h
 OLD_FILES+=usr/share/man/man1/iconv.1.gz
 OLD_FILES+=usr/share/man/man1/mkcsmapper.1.gz
 OLD_FILES+=usr/share/man/man1/mkesdb.1.gz
 OLD_FILES+=usr/share/man/man3/__iconv.3.gz
 OLD_FILES+=usr/share/man/man3/__iconv_free_list.3.gz	
 OLD_FILES+=usr/share/man/man3/__iconv_get_list.3.gz
 OLD_FILES+=usr/share/man/man3/iconv.3.gz
 OLD_FILES+=usr/share/man/man3/iconv_canonicalize.3.gz	
 OLD_FILES+=usr/share/man/man3/iconv_close.3.gz
 OLD_FILES+=usr/share/man/man3/iconv_open.3.gz
 OLD_FILES+=usr/share/man/man3/iconv_open_into.3.gz
 OLD_FILES+=usr/share/man/man3/iconvctl.3.gz
 OLD_FILES+=usr/share/man/man3/iconvlist.3.gz	
 .endif
 
 .if ${MK_INET6} == no
 OLD_FILES+=sbin/ping6
 OLD_FILES+=sbin/rtsol
 OLD_FILES+=usr/sbin/ip6addrctl
 OLD_FILES+=usr/sbin/mld6query
 OLD_FILES+=usr/sbin/ndp
 OLD_FILES+=usr/sbin/rip6query
 OLD_FILES+=usr/sbin/route6d
 OLD_FILES+=usr/sbin/rrenumd
 OLD_FILES+=usr/sbin/rtadvd
 OLD_FILES+=usr/sbin/rtsold
 OLD_FILES+=usr/sbin/traceroute6
 OLD_FILES+=usr/share/man/man5/rrenumd.conf.5.gz
 OLD_FILES+=usr/share/man/man5/rtadvd.conf.5.gz
 OLD_FILES+=usr/share/man/man8/ip6addrctl.8.gz
 OLD_FILES+=usr/share/man/man8/mld6query.8.gz
 OLD_FILES+=usr/share/man/man8/ndp.8.gz
 OLD_FILES+=usr/share/man/man8/ping6.8.gz
 OLD_FILES+=usr/share/man/man8/rip6query.8.gz
 OLD_FILES+=usr/share/man/man8/route6d.8.gz
 OLD_FILES+=usr/share/man/man8/rrenumd.8.gz
 OLD_FILES+=usr/share/man/man8/rtadvd.8.gz
 OLD_FILES+=usr/share/man/man8/rtsol.8.gz
 OLD_FILES+=usr/share/man/man8/rtsold.8.gz
 OLD_FILES+=usr/share/man/man8/traceroute6.8.gz
 .endif
 
 .if ${MK_INET6_SUPPORT} == no
 OLD_FILES+=rescue/ping6
 .endif
 
 .if ${MK_IPFILTER} == no
 OLD_FILES+=etc/periodic/security/510.ipfdenied
 OLD_FILES+=etc/periodic/security/610.ipf6denied
 OLD_FILES+=rescue/ipf
 OLD_FILES+=sbin/ipf
 OLD_FILES+=sbin/ipfs
 OLD_FILES+=sbin/ipfstat
 OLD_FILES+=sbin/ipftest
 OLD_FILES+=sbin/ipmon
 OLD_FILES+=sbin/ipnat
 OLD_FILES+=sbin/ippool
 OLD_FILES+=sbin/ipresend
 OLD_FILES+=usr/include/netinet/ip_auth.h
 OLD_FILES+=usr/include/netinet/ip_compat.h
 OLD_FILES+=usr/include/netinet/ip_fil.h
 OLD_FILES+=usr/include/netinet/ip_frag.h
 OLD_FILES+=usr/include/netinet/ip_htable.h
 OLD_FILES+=usr/include/netinet/ip_lookup.h
 OLD_FILES+=usr/include/netinet/ip_nat.h
 OLD_FILES+=usr/include/netinet/ip_pool.h
 OLD_FILES+=usr/include/netinet/ip_proxy.h
 OLD_FILES+=usr/include/netinet/ip_rules.h
 OLD_FILES+=usr/include/netinet/ip_scan.h
 OLD_FILES+=usr/include/netinet/ip_state.h
 OLD_FILES+=usr/include/netinet/ip_sync.h
 OLD_FILES+=usr/include/netinet/ipl.h
 OLD_FILES+=usr/share/examples/ipfilter/README
 OLD_FILES+=usr/share/examples/ipfilter/BASIC.NAT
 OLD_FILES+=usr/share/examples/ipfilter/BASIC_1.FW
 OLD_FILES+=usr/share/examples/ipfilter/BASIC_2.FW
 OLD_FILES+=usr/share/examples/ipfilter/example.1
 OLD_FILES+=usr/share/examples/ipfilter/example.2
 OLD_FILES+=usr/share/examples/ipfilter/example.3
 OLD_FILES+=usr/share/examples/ipfilter/example.4
 OLD_FILES+=usr/share/examples/ipfilter/example.5
 OLD_FILES+=usr/share/examples/ipfilter/example.6
 OLD_FILES+=usr/share/examples/ipfilter/example.7
 OLD_FILES+=usr/share/examples/ipfilter/example.8
 OLD_FILES+=usr/share/examples/ipfilter/example.9
 OLD_FILES+=usr/share/examples/ipfilter/example.10
 OLD_FILES+=usr/share/examples/ipfilter/example.11
 OLD_FILES+=usr/share/examples/ipfilter/example.12
 OLD_FILES+=usr/share/examples/ipfilter/example.13
 OLD_FILES+=usr/share/examples/ipfilter/example.sr
 OLD_FILES+=usr/share/examples/ipfilter/firewall
 OLD_FILES+=usr/share/examples/ipfilter/ftp-proxy
 OLD_FILES+=usr/share/examples/ipfilter/ftppxy
 OLD_FILES+=usr/share/examples/ipfilter/nat-setup
 OLD_FILES+=usr/share/examples/ipfilter/nat.eg
 OLD_FILES+=usr/share/examples/ipfilter/server
 OLD_FILES+=usr/share/examples/ipfilter/tcpstate
 OLD_FILES+=usr/share/examples/ipfilter/example.14
 OLD_FILES+=usr/share/examples/ipfilter/firewall.1
 OLD_FILES+=usr/share/examples/ipfilter/firewall.2
 OLD_FILES+=usr/share/examples/ipfilter/ipf.conf.permissive
 OLD_FILES+=usr/share/examples/ipfilter/ipf.conf.restrictive
 OLD_FILES+=usr/share/examples/ipfilter/ipf.conf.sample
 OLD_FILES+=usr/share/examples/ipfilter/ipnat.conf.sample
 OLD_FILES+=usr/share/examples/ipfilter/ipf-howto.txt
 OLD_FILES+=usr/share/examples/ipfilter/examples.txt
 OLD_FILES+=usr/share/examples/ipfilter/rules.txt
 OLD_FILES+=usr/share/examples/ipfilter/mkfilters
 OLD_DIRS+=usr/share/examples/ipfilter
 OLD_FILES+=usr/share/man/man1/ipftest.1.gz
 OLD_FILES+=usr/share/man/man1/ipresend.1.gz
 OLD_FILES+=usr/share/man/man4/ipf.4.gz
 OLD_FILES+=usr/share/man/man4/ipl.4.gz
 OLD_FILES+=usr/share/man/man4/ipfilter.4.gz
 OLD_FILES+=usr/share/man/man4/ipnat.4.gz
 OLD_FILES+=usr/share/man/man5/ipf.5.gz
 OLD_FILES+=usr/share/man/man5/ipf.conf.5.gz
 OLD_FILES+=usr/share/man/man5/ipf6.conf.5.gz
 OLD_FILES+=usr/share/man/man5/ipnat.5.gz
 OLD_FILES+=usr/share/man/man5/ipnat.conf.5.gz
 OLD_FILES+=usr/share/man/man5/ippool.5.gz
 OLD_FILES+=usr/share/man/man8/ipf.8.gz
 OLD_FILES+=usr/share/man/man8/ipfs.8.gz
 OLD_FILES+=usr/share/man/man8/ipfstat.8.gz
 OLD_FILES+=usr/share/man/man8/ipmon.8.gz
 OLD_FILES+=usr/share/man/man8/ipnat.8.gz
 OLD_FILES+=usr/share/man/man8/ippool.8.gz
 .endif
 
 .if ${MK_IPFW} == no
 OLD_FILES+=etc/periodic/security/500.ipfwdenied
 OLD_FILES+=etc/periodic/security/550.ipfwlimit
 OLD_FILES+=sbin/ipfw
 OLD_FILES+=sbin/natd
 OLD_FILES+=usr/sbin/ipfwpcap
 OLD_FILES+=usr/share/man/man8/ipfw.8.gz
 OLD_FILES+=usr/share/man/man8/ipfwpcap.8.gz
 OLD_FILES+=usr/share/man/man8/natd.8.gz
 .endif
 
 .if ${MK_ISCSI} == no
 OLD_FILES+=etc/rc.d/iscsictl
 OLD_FILES+=etc/rc.d/iscsid
 OLD_FILES+=sbin/iscontrol
 OLD_FILES+=usr/bin/iscsictl
 OLD_FILES+=usr/sbin/iscsid
 OLD_FILES+=usr/share/man/man4/iscsi.4.gz
 OLD_FILES+=usr/share/man/man4/iscsi_initiator.4.gz
 OLD_FILES+=usr/share/man/man5/iscsi.conf.5.gz
 OLD_FILES+=usr/share/man/man8/iscontrol.8.gz
 OLD_FILES+=usr/share/man/man8/iscsictl.8.gz
 OLD_FILES+=usr/share/man/man8/iscsid.8.gz
 .endif
 
 .if ${MK_JAIL} == no
+OLD_FILES+=etc/rc.d/jail
 OLD_FILES+=usr/sbin/jail
 OLD_FILES+=usr/sbin/jexec
 OLD_FILES+=usr/sbin/jls
 OLD_FILES+=usr/share/man/man8/jail.8.gz
 OLD_FILES+=usr/share/man/man8/jexec.8.gz
 OLD_FILES+=usr/share/man/man8/jls.8.gz
 .endif
 
 .if ${MK_KERBEROS} == no
+OLD_FILES+=etc/rc.d/ipropd_master
+OLD_FILES+=etc/rc.d/ipropd_slave
 OLD_FILES+=usr/bin/compile_et
 OLD_FILES+=usr/bin/hxtool
 OLD_FILES+=usr/bin/kadmin
 OLD_FILES+=usr/bin/kdestroy
 OLD_FILES+=usr/bin/kf
 OLD_FILES+=usr/bin/kgetcred
 OLD_FILES+=usr/bin/kinit
 OLD_FILES+=usr/bin/klist
 OLD_FILES+=usr/bin/kpasswd
 OLD_FILES+=usr/bin/krb5-config
 OLD_FILES+=usr/bin/ksu
 OLD_FILES+=usr/bin/kswitch
 OLD_FILES+=usr/bin/string2key
 OLD_FILES+=usr/bin/verify_krb5_conf
 OLD_FILES+=usr/include/asn1-common.h
 OLD_FILES+=usr/include/asn1_err.h
 OLD_FILES+=usr/include/base64.h
 OLD_FILES+=usr/include/cms_asn1.h
 OLD_FILES+=usr/include/crmf_asn1.h
 OLD_FILES+=usr/include/der-private.h
 OLD_FILES+=usr/include/der-protos.h
 OLD_FILES+=usr/include/der.h
 OLD_FILES+=usr/include/digest_asn1.h
 OLD_FILES+=usr/include/getarg.h
 OLD_FILES+=usr/include/gssapi/gssapi_krb5.h
 OLD_FILES+=usr/include/hdb-protos.h
 OLD_FILES+=usr/include/hdb.h
 OLD_FILES+=usr/include/hdb_asn1.h
 OLD_FILES+=usr/include/hdb_err.h
 OLD_FILES+=usr/include/heim_asn1.h
 OLD_FILES+=usr/include/heim_err.h
 OLD_FILES+=usr/include/heim_threads.h
 OLD_FILES+=usr/include/heimbase.h
 OLD_FILES+=usr/include/heimntlm-protos.h
 OLD_FILES+=usr/include/heimntlm.h
 OLD_FILES+=usr/include/hex.h
 OLD_FILES+=usr/include/hx509-private.h
 OLD_FILES+=usr/include/hx509-protos.h
 OLD_FILES+=usr/include/hx509.h
 OLD_FILES+=usr/include/hx509_err.h
 OLD_FILES+=usr/include/k524_err.h
 OLD_FILES+=usr/include/kadm5/admin.h
 OLD_FILES+=usr/include/kadm5/kadm5-private.h
 OLD_FILES+=usr/include/kadm5/kadm5-protos.h
 OLD_FILES+=usr/include/kadm5/kadm5-pwcheck.h
 OLD_FILES+=usr/include/kadm5/kadm5_err.h
 OLD_FILES+=usr/include/kadm5/private.h
 OLD_DIRS+=usr/include/kadm5
 OLD_FILES+=usr/include/kafs.h
 OLD_FILES+=usr/include/kdc-protos.h
 OLD_FILES+=usr/include/kdc.h
 OLD_FILES+=usr/include/krb5-private.h
 OLD_FILES+=usr/include/krb5-protos.h
 OLD_FILES+=usr/include/krb5-types.h
 OLD_FILES+=usr/include/krb5.h
 OLD_FILES+=usr/include/krb5/ccache_plugin.h
 OLD_FILES+=usr/include/krb5/locate_plugin.h
 OLD_FILES+=usr/include/krb5/send_to_kdc_plugin.h
 OLD_FILES+=usr/include/krb5/windc_plugin.h
 OLD_DIRS+=usr/include/krb5
 OLD_FILES+=usr/include/krb5_asn1.h
 OLD_FILES+=usr/include/krb5_ccapi.h
 OLD_FILES+=usr/include/krb5_err.h
 OLD_FILES+=usr/include/kx509_asn1.h
 OLD_FILES+=usr/include/ntlm_err.h
 OLD_FILES+=usr/include/ocsp_asn1.h
 OLD_FILES+=usr/include/parse_bytes.h
 OLD_FILES+=usr/include/parse_time.h
 OLD_FILES+=usr/include/parse_units.h
 OLD_FILES+=usr/include/pkcs10_asn1.h
 OLD_FILES+=usr/include/pkcs12_asn1.h
 OLD_FILES+=usr/include/pkcs8_asn1.h
 OLD_FILES+=usr/include/pkcs9_asn1.h
 OLD_FILES+=usr/include/pkinit_asn1.h
 OLD_FILES+=usr/include/resolve.h
 OLD_FILES+=usr/include/rfc2459_asn1.h
 OLD_FILES+=usr/include/roken-common.h
 OLD_FILES+=usr/include/rtbl.h
 OLD_FILES+=usr/include/wind.h
 OLD_FILES+=usr/include/wind_err.h
 OLD_FILES+=usr/include/xdbm.h
 OLD_FILES+=usr/lib/libasn1.a
 OLD_FILES+=usr/lib/libasn1.so
 OLD_LIBS+=usr/lib/libasn1.so.11
 OLD_FILES+=usr/lib/libasn1_p.a
 OLD_FILES+=usr/lib/libcom_err.a
 OLD_FILES+=usr/lib/libcom_err.so
 OLD_LIBS+=usr/lib/libcom_err.so.5
 OLD_FILES+=usr/lib/libcom_err_p.a
 OLD_FILES+=usr/lib/libgssapi_krb5.a
 OLD_FILES+=usr/lib/libgssapi_krb5.so
 OLD_LIBS+=usr/lib/libgssapi_krb5.so.10
 OLD_FILES+=usr/lib/libgssapi_krb5_p.a
 OLD_FILES+=usr/lib/libgssapi_ntlm.a
 OLD_FILES+=usr/lib/libgssapi_ntlm.so
 OLD_LIBS+=usr/lib/libgssapi_ntlm.so.10
 OLD_FILES+=usr/lib/libgssapi_ntlm_p.a
 OLD_FILES+=usr/lib/libgssapi_spnego.a
 OLD_FILES+=usr/lib/libgssapi_spnego.so
 OLD_LIBS+=usr/lib/libgssapi_spnego.so.10
 OLD_FILES+=usr/lib/libgssapi_spnego_p.a
 OLD_FILES+=usr/lib/libhdb.a
 OLD_FILES+=usr/lib/libhdb.so
 OLD_LIBS+=usr/lib/libhdb.so.11
 OLD_FILES+=usr/lib/libhdb_p.a
 OLD_FILES+=usr/lib/libheimbase.a
 OLD_FILES+=usr/lib/libheimbase.so
 OLD_LIBS+=usr/lib/libheimbase.so.11
 OLD_FILES+=usr/lib/libheimbase_p.a
 OLD_FILES+=usr/lib/libheimntlm.a
 OLD_FILES+=usr/lib/libheimntlm.so
 OLD_LIBS+=usr/lib/libheimntlm.so.11
 OLD_FILES+=usr/lib/libheimntlm_p.a
 OLD_FILES+=usr/lib/libheimsqlite.a
 OLD_FILES+=usr/lib/libheimsqlite.so
 OLD_LIBS+=usr/lib/libheimsqlite.so.11
 OLD_FILES+=usr/lib/libheimsqlite_p.a
 OLD_FILES+=usr/lib/libhx509.a
 OLD_FILES+=usr/lib/libhx509.so
 OLD_LIBS+=usr/lib/libhx509.so.11
 OLD_FILES+=usr/lib/libhx509_p.a
 OLD_FILES+=usr/lib/libkadm5clnt.a
 OLD_FILES+=usr/lib/libkadm5clnt.so
 OLD_LIBS+=usr/lib/libkadm5clnt.so.11
 OLD_FILES+=usr/lib/libkadm5clnt_p.a
 OLD_FILES+=usr/lib/libkadm5srv.a
 OLD_FILES+=usr/lib/libkadm5srv.so
 OLD_LIBS+=usr/lib/libkadm5srv.so.11
 OLD_FILES+=usr/lib/libkadm5srv_p.a
 OLD_FILES+=usr/lib/libkafs5.a
 OLD_FILES+=usr/lib/libkafs5.so
 OLD_LIBS+=usr/lib/libkafs5.so.11
 OLD_FILES+=usr/lib/libkafs5_p.a
 OLD_FILES+=usr/lib/libkdc.a
 OLD_FILES+=usr/lib/libkdc.so
 OLD_LIBS+=usr/lib/libkdc.so.11
 OLD_FILES+=usr/lib/libkdc_p.a
 OLD_FILES+=usr/lib/libkrb5.a
 OLD_FILES+=usr/lib/libkrb5.so
 OLD_LIBS+=usr/lib/libkrb5.so.11
 OLD_FILES+=usr/lib/libkrb5_p.a
 OLD_FILES+=usr/lib/libroken.a
 OLD_FILES+=usr/lib/libroken.so
 OLD_LIBS+=usr/lib/libroken.so.11
 OLD_FILES+=usr/lib/libroken_p.a
 OLD_FILES+=usr/lib/libwind.a
 OLD_FILES+=usr/lib/libwind.so
 OLD_LIBS+=usr/lib/libwind.so.11
 OLD_FILES+=usr/lib/libwind_p.a
 OLD_FILES+=usr/lib/pam_krb5.so
 OLD_LIBS+=usr/lib/pam_krb5.so.5
 OLD_FILES+=usr/lib/pam_ksu.so
 OLD_LIBS+=usr/lib/pam_ksu.so.5
 OLD_FILES+=usr/lib/private/libheimipcc.a
 OLD_FILES+=usr/lib/private/libheimipcc.so
 OLD_LIBS+=usr/lib/private/libheimipcc.so.11
 OLD_FILES+=usr/lib/private/libheimipcc_p.a
 OLD_FILES+=usr/lib/private/libheimipcs.a
 OLD_FILES+=usr/lib/private/libheimipcs.so
 OLD_LIBS+=usr/lib/private/libheimipcs.so.11
 OLD_FILES+=usr/lib/private/libheimipcs_p.a
 .if ${TARGET_ARCH} == "amd64" || ${TARGET_ARCH} == "powerpc64"
 OLD_FILES+=usr/lib32/libasn1.a
 OLD_FILES+=usr/lib32/libasn1.so
 OLD_LIBS+=usr/lib32/libasn1.so.11
 OLD_FILES+=usr/lib32/libasn1_p.a
 OLD_FILES+=usr/lib32/libgssapi_krb5.a
 OLD_FILES+=usr/lib32/libgssapi_krb5.so
 OLD_LIBS+=usr/lib32/libgssapi_krb5.so.10
 OLD_FILES+=usr/lib32/libgssapi_krb5_p.a
 OLD_FILES+=usr/lib32/libgssapi_ntlm.a
 OLD_FILES+=usr/lib32/libgssapi_ntlm.so
 OLD_LIBS+=usr/lib32/libgssapi_ntlm.so.10
 OLD_FILES+=usr/lib32/libgssapi_ntlm_p.a
 OLD_FILES+=usr/lib32/libgssapi_spnego.a
 OLD_FILES+=usr/lib32/libgssapi_spnego.so
 OLD_LIBS+=usr/lib32/libgssapi_spnego.so.10
 OLD_FILES+=usr/lib32/libgssapi_spnego_p.a
 OLD_FILES+=usr/lib32/libhdb.a
 OLD_FILES+=usr/lib32/libhdb.so
 OLD_LIBS+=usr/lib32/libhdb.so.11
 OLD_FILES+=usr/lib32/libhdb_p.a
 OLD_FILES+=usr/lib32/libheimbase.a
 OLD_FILES+=usr/lib32/libheimbase.so
 OLD_LIBS+=usr/lib32/libheimbase.so.11
 OLD_FILES+=usr/lib32/libheimbase_p.a
 OLD_FILES+=usr/lib32/libheimntlm.a
 OLD_FILES+=usr/lib32/libheimntlm.so
 OLD_LIBS+=usr/lib32/libheimntlm.so.11
 OLD_FILES+=usr/lib32/libheimntlm_p.a
 OLD_FILES+=usr/lib32/libheimsqlite.a
 OLD_FILES+=usr/lib32/libheimsqlite.so
 OLD_LIBS+=usr/lib32/libheimsqlite.so.11
 OLD_FILES+=usr/lib32/libheimsqlite_p.a
 OLD_FILES+=usr/lib32/libhx509.a
 OLD_FILES+=usr/lib32/libhx509.so
 OLD_LIBS+=usr/lib32/libhx509.so.11
 OLD_FILES+=usr/lib32/libhx509_p.a
 OLD_FILES+=usr/lib32/libkadm5clnt.a
 OLD_FILES+=usr/lib32/libkadm5clnt.so
 OLD_LIBS+=usr/lib32/libkadm5clnt.so.11
 OLD_FILES+=usr/lib32/libkadm5clnt_p.a
 OLD_FILES+=usr/lib32/libkadm5srv.a
 OLD_FILES+=usr/lib32/libkadm5srv.so
 OLD_LIBS+=usr/lib32/libkadm5srv.so.11
 OLD_FILES+=usr/lib32/libkadm5srv_p.a
 OLD_FILES+=usr/lib32/libkafs5.a
 OLD_FILES+=usr/lib32/libkafs5.so
 OLD_LIBS+=usr/lib32/libkafs5.so.11
 OLD_FILES+=usr/lib32/libkafs5_p.a
 OLD_FILES+=usr/lib32/libkdc.a
 OLD_FILES+=usr/lib32/libkdc.so
 OLD_LIBS+=usr/lib32/libkdc.so.11
 OLD_FILES+=usr/lib32/libkdc_p.a
 OLD_FILES+=usr/lib32/libkrb5.a
 OLD_FILES+=usr/lib32/libkrb5.so
 OLD_LIBS+=usr/lib32/libkrb5.so.11
 OLD_FILES+=usr/lib32/libkrb5_p.a
 OLD_FILES+=usr/lib32/libroken.a
 OLD_FILES+=usr/lib32/libroken.so
 OLD_LIBS+=usr/lib32/libroken.so.11
 OLD_FILES+=usr/lib32/libroken_p.a
 OLD_FILES+=usr/lib32/libwind.a
 OLD_FILES+=usr/lib32/libwind.so
 OLD_LIBS+=usr/lib32/libwind.so.11
 OLD_FILES+=usr/lib32/libwind_p.a
 OLD_FILES+=usr/lib32/pam_krb5.so
 OLD_LIBS+=usr/lib32/pam_krb5.so.5
 OLD_FILES+=usr/lib32/pam_ksu.so
 OLD_LIBS+=usr/lib32/pam_ksu.so.5
 OLD_FILES+=usr/lib32/private/libheimipcc.a
 OLD_FILES+=usr/lib32/private/libheimipcc.so
 OLD_LIBS+=usr/lib32/private/libheimipcc.so.11
 OLD_FILES+=usr/lib32/private/libheimipcc_p.a
 OLD_FILES+=usr/lib32/private/libheimipcs.a
 OLD_FILES+=usr/lib32/private/libheimipcs.so
 OLD_LIBS+=usr/lib32/private/libheimipcs.so.11
 OLD_FILES+=usr/lib32/private/libheimipcs_p.a
 .endif
 OLD_FILES+=usr/libexec/digest-service
 OLD_FILES+=usr/libexec/hprop
 OLD_FILES+=usr/libexec/hpropd
 OLD_FILES+=usr/libexec/ipropd-master
 OLD_FILES+=usr/libexec/ipropd-slave
 OLD_FILES+=usr/libexec/kadmind
 OLD_FILES+=usr/libexec/kcm
 OLD_FILES+=usr/libexec/kdc
 OLD_FILES+=usr/libexec/kdigest
 OLD_FILES+=usr/libexec/kfd
 OLD_FILES+=usr/libexec/kimpersonate
 OLD_FILES+=usr/libexec/kpasswdd
 OLD_FILES+=usr/sbin/kstash
 OLD_FILES+=usr/sbin/ktutil
 OLD_FILES+=usr/sbin/iprop-log
 OLD_FILES+=usr/share/info/heimdal.info.gz
 OLD_FILES+=usr/share/man/man1/kdestroy.1.gz
 OLD_FILES+=usr/share/man/man1/kf.1.gz
 OLD_FILES+=usr/share/man/man1/kinit.1.gz
 OLD_FILES+=usr/share/man/man1/klist.1.gz
 OLD_FILES+=usr/share/man/man1/kpasswd.1.gz
 OLD_FILES+=usr/share/man/man1/krb5-config.1.gz
 OLD_FILES+=usr/share/man/man1/kswitch.1.gz
 OLD_FILES+=usr/share/man/man3/HDB.3.gz
 OLD_FILES+=usr/share/man/man3/hdb__del.3.gz
 OLD_FILES+=usr/share/man/man3/hdb__get.3.gz
 OLD_FILES+=usr/share/man/man3/hdb__put.3.gz
 OLD_FILES+=usr/share/man/man3/hdb_auth_status.3.gz
 OLD_FILES+=usr/share/man/man3/hdb_check_constrained_delegation.3.gz
 OLD_FILES+=usr/share/man/man3/hdb_check_pkinit_ms_upn_match.3.gz
 OLD_FILES+=usr/share/man/man3/hdb_check_s4u2self.3.gz
 OLD_FILES+=usr/share/man/man3/hdb_close.3.gz
 OLD_FILES+=usr/share/man/man3/hdb_destroy.3.gz
 OLD_FILES+=usr/share/man/man3/hdb_entry_ex.3.gz
 OLD_FILES+=usr/share/man/man3/hdb_fetch_kvno.3.gz
 OLD_FILES+=usr/share/man/man3/hdb_firstkey.3.gz
 OLD_FILES+=usr/share/man/man3/hdb_free.3.gz
 OLD_FILES+=usr/share/man/man3/hdb_get_realms.3.gz
 OLD_FILES+=usr/share/man/man3/hdb_lock.3.gz
 OLD_FILES+=usr/share/man/man3/hdb_name.3.gz
 OLD_FILES+=usr/share/man/man3/hdb_nextkey.3.gz
 OLD_FILES+=usr/share/man/man3/hdb_open.3.gz
 OLD_FILES+=usr/share/man/man3/hdb_password.3.gz
 OLD_FILES+=usr/share/man/man3/hdb_remove.3.gz
 OLD_FILES+=usr/share/man/man3/hdb_rename.3.gz
 OLD_FILES+=usr/share/man/man3/hdb_store.3.gz
 OLD_FILES+=usr/share/man/man3/hdb_unlock.3.gz
 OLD_FILES+=usr/share/man/man3/heim_ntlm_build_ntlm1_master.3.gz
 OLD_FILES+=usr/share/man/man3/heim_ntlm_build_ntlm2_master.3.gz
 OLD_FILES+=usr/share/man/man3/heim_ntlm_calculate_lm2.3.gz
 OLD_FILES+=usr/share/man/man3/heim_ntlm_calculate_ntlm1.3.gz
 OLD_FILES+=usr/share/man/man3/heim_ntlm_calculate_ntlm2.3.gz
 OLD_FILES+=usr/share/man/man3/heim_ntlm_decode_targetinfo.3.gz
 OLD_FILES+=usr/share/man/man3/heim_ntlm_encode_targetinfo.3.gz
 OLD_FILES+=usr/share/man/man3/heim_ntlm_encode_type1.3.gz
 OLD_FILES+=usr/share/man/man3/heim_ntlm_encode_type2.3.gz
 OLD_FILES+=usr/share/man/man3/heim_ntlm_encode_type3.3.gz
 OLD_FILES+=usr/share/man/man3/heim_ntlm_free_buf.3.gz
 OLD_FILES+=usr/share/man/man3/heim_ntlm_free_targetinfo.3.gz
 OLD_FILES+=usr/share/man/man3/heim_ntlm_free_type1.3.gz
 OLD_FILES+=usr/share/man/man3/heim_ntlm_free_type2.3.gz
 OLD_FILES+=usr/share/man/man3/heim_ntlm_free_type3.3.gz
 OLD_FILES+=usr/share/man/man3/heim_ntlm_keyex_unwrap.3.gz
 OLD_FILES+=usr/share/man/man3/heim_ntlm_nt_key.3.gz
 OLD_FILES+=usr/share/man/man3/heim_ntlm_ntlmv2_key.3.gz
 OLD_FILES+=usr/share/man/man3/heim_ntlm_verify_ntlm2.3.gz
 OLD_FILES+=usr/share/man/man3/hx509.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_bitstring_print.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_sign.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_sign_self.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_tbs_add_crl_dp_uri.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_tbs_add_eku.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_tbs_add_san_hostname.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_tbs_add_san_jid.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_tbs_add_san_ms_upn.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_tbs_add_san_otherName.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_tbs_add_san_pkinit.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_tbs_add_san_rfc822name.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_tbs_free.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_tbs_init.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_tbs_set_ca.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_tbs_set_domaincontroller.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_tbs_set_notAfter.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_tbs_set_notAfter_lifetime.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_tbs_set_notBefore.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_tbs_set_proxy.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_tbs_set_serialnumber.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_tbs_set_spki.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_tbs_set_subject.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_tbs_set_template.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_tbs_set_unique.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_tbs_subject_expand.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ca_tbs_template_units.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cert.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cert_binary.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cert_check_eku.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cert_cmp.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cert_find_subjectAltName_otherName.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cert_free.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cert_get_SPKI.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cert_get_SPKI_AlgorithmIdentifier.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cert_get_attribute.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cert_get_base_subject.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cert_get_friendly_name.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cert_get_issuer.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cert_get_issuer_unique_id.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cert_get_notAfter.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cert_get_notBefore.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cert_get_serialnumber.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cert_get_subject.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cert_get_subject_unique_id.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cert_init.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cert_init_data.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cert_keyusage_print.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cert_ref.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cert_set_friendly_name.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_certs_add.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_certs_append.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_certs_end_seq.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_certs_filter.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_certs_find.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_certs_free.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_certs_info.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_certs_init.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_certs_iter_f.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_certs_merge.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_certs_next_cert.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_certs_start_seq.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_certs_store.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ci_print_names.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_clear_error_string.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cms.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cms_create_signed_1.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cms_envelope_1.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cms_unenvelope.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cms_unwrap_ContentInfo.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cms_verify_signed.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_cms_wrap_ContentInfo.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_context_free.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_context_init.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_context_set_missing_revoke.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_crl_add_revoked_certs.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_crl_alloc.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_crl_free.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_crl_lifetime.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_crl_sign.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_crypto.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_env.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_env_add.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_env_add_binding.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_env_find.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_env_find_binding.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_env_free.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_env_lfind.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_err.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_error.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_free_error_string.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_free_octet_string_list.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_general_name_unparse.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_get_error_string.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_get_one_cert.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_keyset.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_lock.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_misc.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_name.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_name_binary.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_name_cmp.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_name_copy.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_name_expand.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_name_free.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_name_is_null_p.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_name_to_Name.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_name_to_string.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ocsp_request.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_ocsp_verify.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_oid_print.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_oid_sprint.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_parse_name.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_peer.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_peer_info_add_cms_alg.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_peer_info_alloc.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_peer_info_free.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_peer_info_set_cert.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_peer_info_set_cms_algs.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_print.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_print_cert.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_print_stdout.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_query.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_query_alloc.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_query_free.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_query_match_cmp_func.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_query_match_eku.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_query_match_friendly_name.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_query_match_issuer_serial.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_query_match_option.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_query_statistic_file.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_query_unparse_stats.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_revoke.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_revoke_add_crl.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_revoke_add_ocsp.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_revoke_free.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_revoke_init.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_revoke_ocsp_print.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_revoke_verify.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_set_error_string.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_set_error_stringv.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_unparse_der_name.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_validate_cert.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_validate_ctx_add_flags.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_validate_ctx_free.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_validate_ctx_init.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_validate_ctx_set_print.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_verify.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_verify_attach_anchors.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_verify_attach_revoke.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_verify_ctx_f_allow_default_trustanchors.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_verify_destroy_ctx.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_verify_hostname.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_verify_init_ctx.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_verify_path.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_verify_set_max_depth.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_verify_set_proxy_certificate.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_verify_set_strict_rfc3280_verification.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_verify_set_time.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_verify_signature.3.gz
 OLD_FILES+=usr/share/man/man3/hx509_xfree.3.gz
 OLD_FILES+=usr/share/man/man3/k_afs_cell_of_file.3.gz
 OLD_FILES+=usr/share/man/man3/k_hasafs.3.gz
 OLD_FILES+=usr/share/man/man3/k_pioctl.3.gz
 OLD_FILES+=usr/share/man/man3/k_setpag.3.gz
 OLD_FILES+=usr/share/man/man3/k_unlog.3.gz
 OLD_FILES+=usr/share/man/man3/kadm5_pwcheck.3.gz
 OLD_FILES+=usr/share/man/man3/kafs.3.gz
 OLD_FILES+=usr/share/man/man3/kafs5.3.gz
 OLD_FILES+=usr/share/man/man3/kafs_set_verbose.3.gz
 OLD_FILES+=usr/share/man/man3/kafs_settoken.3.gz
 OLD_FILES+=usr/share/man/man3/kafs_settoken5.3.gz
 OLD_FILES+=usr/share/man/man3/kafs_settoken_rxkad.3.gz
 OLD_FILES+=usr/share/man/man3/krb5.3.gz
 OLD_FILES+=usr/share/man/man3/krb524_convert_creds_kdc.3.gz
 OLD_FILES+=usr/share/man/man3/krb524_convert_creds_kdc_ccache.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_425_conv_principal.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_425_conv_principal_ext.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_524_conv_principal.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_acc_ops.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_acl_match_file.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_acl_match_string.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_add_et_list.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_add_extra_addresses.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_add_ignore_addresses.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_addlog_dest.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_addlog_func.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_addr2sockaddr.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_address.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_address_compare.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_address_order.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_address_prefixlen_boundary.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_address_search.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_afslog.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_afslog_uid.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_allow_weak_crypto.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_aname_to_localname.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_anyaddr.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_appdefault.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_appdefault_boolean.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_appdefault_string.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_appdefault_time.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_append_addresses.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_con_free.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_con_genaddrs.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_con_getaddrs.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_con_getflags.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_con_getkey.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_con_getlocalsubkey.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_con_getrcache.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_con_getremotesubkey.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_con_getuserkey.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_con_init.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_con_initivector.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_con_setaddrs.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_con_setaddrs_from_fd.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_con_setflags.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_con_setivector.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_con_setkey.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_con_setlocalsubkey.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_con_setrcache.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_con_setremotesubkey.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_con_setuserkey.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_context.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_getauthenticator.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_getcksumtype.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_getkeytype.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_getlocalseqnumber.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_getremoteseqnumber.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_setcksumtype.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_setkeytype.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_setlocalseqnumber.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_auth_setremoteseqnumber.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_build_principal.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_build_principal_ext.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_build_principal_va.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_build_principal_va_ext.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_c_enctype_compare.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_c_make_checksum.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_cache_end_seq_get.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_cache_get_first.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_cache_match.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_cache_next.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_clear_mcred.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_close.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_copy_cache.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_copy_creds.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_copy_match_f.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_default.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_default_name.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_destroy.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_end_seq_get.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_gen_new.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_get_config.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_get_flags.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_get_friendly_name.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_get_full_name.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_get_kdc_offset.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_get_lifetime.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_get_name.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_get_ops.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_get_prefix_ops.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_get_principal.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_get_type.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_get_version.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_initialize.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_last_change_time.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_move.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_new_unique.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_next_cred.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_register.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_remove_cred.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_resolve.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_retrieve_cred.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_set_config.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_set_default_name.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_set_flags.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_set_friendly_name.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_set_kdc_offset.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_start_seq_get.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_store_cred.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_support_switch.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cc_switch.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ccache.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ccache_intro.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cccol_cursor_free.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cccol_cursor_new.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cccol_cursor_next.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cccol_last_change_time.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_change_password.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_check_transited.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_checksum_is_collision_proof.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_checksum_is_keyed.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_checksumsize.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_cksumtype_to_enctype.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_clear_error_message.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_clear_error_string.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_closelog.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_compare_creds.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_config_file_free.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_config_free_strings.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_config_get_bool.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_config_get_bool_default.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_config_get_list.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_config_get_string.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_config_get_string_default.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_config_get_strings.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_config_get_time.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_config_get_time_default.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_config_parse_file_multi.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_config_parse_string_multi.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_config_vget_bool.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_config_vget_bool_default.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_config_vget_list.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_config_vget_string.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_config_vget_string_default.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_config_vget_strings.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_config_vget_time.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_config_vget_time_default.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_copy_address.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_copy_addresses.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_copy_context.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_copy_creds.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_copy_creds_contents.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_copy_data.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_copy_host_realm.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_copy_keyblock.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_copy_keyblock_contents.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_copy_principal.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_copy_ticket.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_create_checksum.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_create_checksum_iov.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_credential.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_creds.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_creds_get_ticket_flags.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_crypto.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_crypto_destroy.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_crypto_fx_cf2.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_crypto_getblocksize.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_crypto_getconfoundersize.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_crypto_getenctype.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_crypto_getpadsize.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_crypto_init.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_crypto_iov.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_data_alloc.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_data_cmp.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_data_copy.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_data_ct_cmp.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_data_free.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_data_realloc.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_data_zero.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_decrypt.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_decrypt_EncryptedData.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_decrypt_iov_ivec.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_deprecated.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_digest.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_digest_probe.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_eai_to_heim_errno.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_encrypt.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_encrypt_EncryptedData.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_encrypt_iov_ivec.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_enctype_disable.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_enctype_enable.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_enctype_valid.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_enctypes_compatible_keys.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_error.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_expand_hostname.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_expand_hostname_realms.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_fcc_ops.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_fileformats.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_find_padata.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_free_address.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_free_addresses.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_free_config_files.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_free_context.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_free_cred_contents.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_free_creds.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_free_creds_contents.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_free_data.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_free_data_contents.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_free_error_string.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_free_host_realm.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_free_keyblock.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_free_keyblock_contents.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_free_krbhst.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_free_principal.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_free_ticket.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_free_unparsed_name.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_fwd_tgt_creds.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_generate_random_block.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_generate_subkey.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_generate_subkey_extended.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_all_client_addrs.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_all_server_addrs.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_cred_from_kdc.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_cred_from_kdc_opt.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_credentials.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_creds.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_default_config_files.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_default_in_tkt_etypes.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_default_principal.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_default_realm.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_default_realms.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_dns_canonicalize_hostname.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_extra_addresses.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_fcache_version.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_forwarded_creds.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_host_realm.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_ignore_addresses.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_in_cred.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_in_tkt_with_keytab.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_in_tkt_with_password.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_in_tkt_with_skey.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_init_creds.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_init_creds_keyblock.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_init_creds_keytab.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_init_creds_opt_alloc.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_init_creds_opt_free.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_init_creds_opt_get_error.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_init_creds_opt_init.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_init_creds_password.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_kdc_sec_offset.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_krb524hst.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_krb_admin_hst.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_krb_changepw_hst.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_krbhst.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_max_time_skew.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_use_admin_kdc.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_get_validated_creds.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_getportbyname.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_h_addr2addr.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_h_addr2sockaddr.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_h_errno_to_heim_errno.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_init_context.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_init_creds_free.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_init_creds_get.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_init_creds_get_error.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_init_creds_init.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_init_creds_intro.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_init_creds_set_keytab.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_init_creds_set_password.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_init_creds_set_service.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_init_creds_step.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_init_ets.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_initlog.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_introduction.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_is_config_principal.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_is_thread_safe.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_kerberos_enctypes.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_keyblock_get_enctype.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_keyblock_init.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_keyblock_zero.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_keytab.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_keytab_intro.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_keytab_key_proc.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_keytype_to_enctypes.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_keytype_to_enctypes_default.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_keytype_to_string.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_krbhst_format_string.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_krbhst_free.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_krbhst_get_addrinfo.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_krbhst_init.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_krbhst_next.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_krbhst_next_as_string.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_krbhst_reset.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_kt_add_entry.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_kt_close.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_kt_compare.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_kt_copy_entry_contents.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_kt_default.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_kt_default_modify_name.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_kt_default_name.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_kt_destroy.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_kt_end_seq_get.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_kt_free_entry.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_kt_get_entry.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_kt_get_full_name.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_kt_get_name.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_kt_get_type.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_kt_have_content.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_kt_next_entry.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_kt_read_service_key.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_kt_register.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_kt_remove_entry.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_kt_resolve.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_kt_start_seq_get.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_kuserok.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_log.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_log_msg.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_make_addrport.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_make_principal.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_max_sockaddr_size.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_mcc_ops.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_mk_req.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_mk_safe.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_openlog.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_pac.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_pac_get_buffer.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_pac_verify.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_parse_address.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_parse_name.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_parse_name_flags.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_parse_nametype.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_password_key_proc.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_plugin_register.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_prepend_config_files_default.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_princ_realm.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_princ_set_realm.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_principal.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_principal_compare.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_principal_compare_any_realm.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_principal_get_comp_string.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_principal_get_num_comp.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_principal_get_realm.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_principal_get_type.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_principal_intro.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_principal_is_krbtgt.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_principal_match.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_principal_set_realm.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_principal_set_type.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_print_address.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_random_to_key.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_rcache.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_rd_error.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_rd_req_ctx.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_rd_req_in_ctx_alloc.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_rd_req_in_set_keytab.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_rd_req_in_set_pac_check.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_rd_req_out_ctx_free.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_rd_req_out_get_server.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_rd_safe.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_realm_compare.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ret_address.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ret_addrs.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ret_authdata.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ret_creds.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ret_creds_tag.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ret_data.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ret_int16.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ret_int32.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ret_int8.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ret_keyblock.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ret_principal.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ret_string.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ret_stringz.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ret_times.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ret_uint16.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ret_uint32.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ret_uint8.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_set_config_files.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_set_default_in_tkt_etypes.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_set_default_realm.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_set_dns_canonicalize_hostname.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_set_error_message.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_set_error_string.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_set_extra_addresses.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_set_fcache_version.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_set_home_dir_access.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_set_ignore_addresses.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_set_kdc_sec_offset.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_set_max_time_skew.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_set_password.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_set_real_time.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_set_use_admin_kdc.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_sname_to_principal.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_sock_to_principal.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_sockaddr2address.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_sockaddr2port.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_sockaddr_uninteresting.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_storage.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_storage_clear_flags.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_storage_emem.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_storage_free.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_storage_from_data.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_storage_from_fd.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_storage_from_mem.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_storage_from_readonly_mem.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_storage_get_byteorder.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_storage_get_eof_code.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_storage_is_flags.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_storage_read.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_storage_seek.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_storage_set_byteorder.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_storage_set_eof_code.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_storage_set_flags.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_storage_set_max_alloc.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_storage_to_data.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_storage_truncate.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_storage_write.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_store_address.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_store_addrs.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_store_authdata.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_store_creds.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_store_creds_tag.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_store_data.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_store_int16.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_store_int32.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_store_int8.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_store_keyblock.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_store_principal.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_store_string.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_store_stringz.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_store_times.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_store_uint16.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_store_uint32.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_store_uint8.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_string_to_key.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_string_to_keytype.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_support.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ticket.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ticket_get_authorization_data_type.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ticket_get_client.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ticket_get_endtime.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ticket_get_flags.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_ticket_get_server.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_timeofday.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_unparse_name.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_unparse_name_fixed.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_unparse_name_fixed_flags.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_unparse_name_fixed_short.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_unparse_name_flags.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_unparse_name_short.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_us_timeofday.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_v4compat.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_verify_checksum.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_verify_checksum_iov.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_verify_init_creds.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_verify_opt_init.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_verify_opt_set_flags.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_verify_opt_set_keytab.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_verify_opt_set_secure.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_verify_opt_set_service.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_verify_user.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_verify_user_lrealm.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_verify_user_opt.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_vlog.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_vlog_msg.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_vset_error_string.3.gz
 OLD_FILES+=usr/share/man/man3/krb5_vwarn.3.gz
 OLD_FILES+=usr/share/man/man3/krb_afslog.3.gz
 OLD_FILES+=usr/share/man/man3/krb_afslog_uid.3.gz
 OLD_FILES+=usr/share/man/man3/ntlm_buf.3.gz
 OLD_FILES+=usr/share/man/man3/ntlm_core.3.gz
 OLD_FILES+=usr/share/man/man3/ntlm_type1.3.gz
 OLD_FILES+=usr/share/man/man3/ntlm_type2.3.gz
 OLD_FILES+=usr/share/man/man3/ntlm_type3.3.gz
 OLD_FILES+=usr/share/man/man5/krb5.conf.5.gz
 OLD_FILES+=usr/share/man/man8/hprop.8.gz
 OLD_FILES+=usr/share/man/man8/hpropd.8.gz
 OLD_FILES+=usr/share/man/man8/iprop-log.8.gz
 OLD_FILES+=usr/share/man/man8/iprop.8.gz
 OLD_FILES+=usr/share/man/man8/kadmin.8.gz
 OLD_FILES+=usr/share/man/man8/kadmind.8.gz
 OLD_FILES+=usr/share/man/man8/kcm.8.gz
 OLD_FILES+=usr/share/man/man8/kdc.8.gz
 OLD_FILES+=usr/share/man/man8/kdigest.8.gz
 OLD_FILES+=usr/share/man/man8/kerberos.8.gz
 OLD_FILES+=usr/share/man/man8/kimpersonate.8.gz
 OLD_FILES+=usr/share/man/man8/kpasswdd.8.gz
 OLD_FILES+=usr/share/man/man8/kstash.8.gz
 OLD_FILES+=usr/share/man/man8/ktutil.8.gz
 OLD_FILES+=usr/share/man/man8/pam_krb5.8.gz
 OLD_FILES+=usr/share/man/man8/pam_ksu.8.gz
 OLD_FILES+=usr/share/man/man8/string2key.8.gz
 OLD_FILES+=usr/share/man/man8/verify_krb5_conf.8.gz
 .endif
 
 .if ${MK_LDNS} == no
 OLD_FILES+=usr/lib/private/libldns.a
 OLD_FILES+=usr/lib/private/libldns.so
 OLD_LIBS+=usr/lib/private/libldns.so.5
 OLD_FILES+=usr/lib/private/libldns_p.a
 .if ${TARGET_ARCH} == "amd64" || ${TARGET_ARCH} == "powerpc64"
 OLD_FILES+=usr/lib32/private/libldns.a
 OLD_FILES+=usr/lib32/private/libldns.so
 OLD_LIBS+=usr/lib32/private/libldns.so.5
 OLD_FILES+=usr/lib32/private/libldns_p.a
 .endif
 .endif
 
 .if ${MK_LDNS_UTILS} == no
 OLD_FILES+=usr/bin/drill
 OLD_FILES+=usr/share/man/man1/drill.1.gz
 OLD_FILES+=usr/bin/host
 OLD_FILES+=usr/share/man/man1/host.1.gz
 .endif
 
 #.if ${MK_LIB32} == no
 # to be filled in
 #.endif
 
 .if ${MK_LIBCPLUSPLUS} == no
 OLD_LIBS+=lib/libcxxrt.so.1
 OLD_FILES+=usr/lib/libc++.a
 OLD_FILES+=usr/lib/libc++_p.a
 OLD_FILES+=usr/lib/libc++.so
 OLD_LIBS+=usr/lib/libc++.so.1
 OLD_FILES+=usr/lib/libcxxrt.a
 OLD_FILES+=usr/lib/libcxxrt.so
 OLD_FILES+=usr/lib/libcxxrt_p.a
 OLD_FILES+=usr/include/c++/v1/__bit_reference
 OLD_FILES+=usr/include/c++/v1/__config
 OLD_FILES+=usr/include/c++/v1/__debug
 OLD_FILES+=usr/include/c++/v1/__functional_03
 OLD_FILES+=usr/include/c++/v1/__functional_base
 OLD_FILES+=usr/include/c++/v1/__functional_base_03
 OLD_FILES+=usr/include/c++/v1/__hash_table
 OLD_FILES+=usr/include/c++/v1/__locale
 OLD_FILES+=usr/include/c++/v1/__mutex_base
 OLD_FILES+=usr/include/c++/v1/__split_buffer
 OLD_FILES+=usr/include/c++/v1/__sso_allocator
 OLD_FILES+=usr/include/c++/v1/__std_stream
 OLD_FILES+=usr/include/c++/v1/__tree
 OLD_FILES+=usr/include/c++/v1/__tuple
 OLD_FILES+=usr/include/c++/v1/__tuple_03
 OLD_FILES+=usr/include/c++/v1/__undef_min_max
 OLD_FILES+=usr/include/c++/v1/algorithm
 OLD_FILES+=usr/include/c++/v1/array
 OLD_FILES+=usr/include/c++/v1/atomic
 OLD_FILES+=usr/include/c++/v1/bitset
 OLD_FILES+=usr/include/c++/v1/cassert
 OLD_FILES+=usr/include/c++/v1/ccomplex
 OLD_FILES+=usr/include/c++/v1/cctype
 OLD_FILES+=usr/include/c++/v1/cerrno
 OLD_FILES+=usr/include/c++/v1/cfenv
 OLD_FILES+=usr/include/c++/v1/cfloat
 OLD_FILES+=usr/include/c++/v1/chrono
 OLD_FILES+=usr/include/c++/v1/cinttypes
 OLD_FILES+=usr/include/c++/v1/ciso646
 OLD_FILES+=usr/include/c++/v1/climits
 OLD_FILES+=usr/include/c++/v1/clocale
 OLD_FILES+=usr/include/c++/v1/cmath
 OLD_FILES+=usr/include/c++/v1/codecvt
 OLD_FILES+=usr/include/c++/v1/complex
 OLD_FILES+=usr/include/c++/v1/complex.h
 OLD_FILES+=usr/include/c++/v1/condition_variable
 OLD_FILES+=usr/include/c++/v1/csetjmp
 OLD_FILES+=usr/include/c++/v1/csignal
 OLD_FILES+=usr/include/c++/v1/cstdarg
 OLD_FILES+=usr/include/c++/v1/cstdbool
 OLD_FILES+=usr/include/c++/v1/cstddef
 OLD_FILES+=usr/include/c++/v1/cstdint
 OLD_FILES+=usr/include/c++/v1/cstdio
 OLD_FILES+=usr/include/c++/v1/cstdlib
 OLD_FILES+=usr/include/c++/v1/cstring
 OLD_FILES+=usr/include/c++/v1/ctgmath
 OLD_FILES+=usr/include/c++/v1/ctime
 OLD_FILES+=usr/include/c++/v1/cwchar
 OLD_FILES+=usr/include/c++/v1/cwctype
 OLD_FILES+=usr/include/c++/v1/cxxabi.h
 OLD_FILES+=usr/include/c++/v1/deque
 OLD_FILES+=usr/include/c++/v1/exception
 OLD_FILES+=usr/include/c++/v1/experimental/dynarray
 OLD_FILES+=usr/include/c++/v1/experimental/optional
 OLD_FILES+=usr/include/c++/v1/ext/__hash
 OLD_FILES+=usr/include/c++/v1/ext/hash_map
 OLD_FILES+=usr/include/c++/v1/ext/hash_set
 OLD_FILES+=usr/include/c++/v1/forward_list
 OLD_FILES+=usr/include/c++/v1/fstream
 OLD_FILES+=usr/include/c++/v1/functional
 OLD_FILES+=usr/include/c++/v1/future
 OLD_FILES+=usr/include/c++/v1/initializer_list
 OLD_FILES+=usr/include/c++/v1/iomanip
 OLD_FILES+=usr/include/c++/v1/ios
 OLD_FILES+=usr/include/c++/v1/iosfwd
 OLD_FILES+=usr/include/c++/v1/iostream
 OLD_FILES+=usr/include/c++/v1/istream
 OLD_FILES+=usr/include/c++/v1/iterator
 OLD_FILES+=usr/include/c++/v1/limits
 OLD_FILES+=usr/include/c++/v1/list
 OLD_FILES+=usr/include/c++/v1/locale
 OLD_FILES+=usr/include/c++/v1/map
 OLD_FILES+=usr/include/c++/v1/memory
 OLD_FILES+=usr/include/c++/v1/mutex
 OLD_FILES+=usr/include/c++/v1/new
 OLD_FILES+=usr/include/c++/v1/numeric
 OLD_FILES+=usr/include/c++/v1/ostream
 OLD_FILES+=usr/include/c++/v1/queue
 OLD_FILES+=usr/include/c++/v1/random
 OLD_FILES+=usr/include/c++/v1/ratio
 OLD_FILES+=usr/include/c++/v1/regex
 OLD_FILES+=usr/include/c++/v1/scoped_allocator
 OLD_FILES+=usr/include/c++/v1/set
 OLD_FILES+=usr/include/c++/v1/sstream
 OLD_FILES+=usr/include/c++/v1/stack
 OLD_FILES+=usr/include/c++/v1/stdexcept
 OLD_FILES+=usr/include/c++/v1/streambuf
 OLD_FILES+=usr/include/c++/v1/string
 OLD_FILES+=usr/include/c++/v1/strstream
 OLD_FILES+=usr/include/c++/v1/system_error
 OLD_FILES+=usr/include/c++/v1/tgmath.h
 OLD_FILES+=usr/include/c++/v1/thread
 OLD_FILES+=usr/include/c++/v1/tuple
 OLD_FILES+=usr/include/c++/v1/type_traits
 OLD_FILES+=usr/include/c++/v1/typeindex
 OLD_FILES+=usr/include/c++/v1/typeinfo
 OLD_FILES+=usr/include/c++/v1/unordered_map
 OLD_FILES+=usr/include/c++/v1/unordered_set
 OLD_FILES+=usr/include/c++/v1/unwind-arm.h
 OLD_FILES+=usr/include/c++/v1/unwind-itanium.h
 OLD_FILES+=usr/include/c++/v1/unwind.h
 OLD_FILES+=usr/include/c++/v1/utility
 OLD_FILES+=usr/include/c++/v1/valarray
 OLD_FILES+=usr/include/c++/v1/vector
 OLD_DIRS+=usr/include/c++/v1/experimental
 OLD_DIRS+=usr/include/c++/v1/ext
 OLD_DIRS+=usr/include/c++/v1
 .endif
 
 #.if ${MK_LIBTHR} == no
 # to be filled in
 #.endif
 
 #.if ${MK_LOCALES} == no
 # to be filled in
 #.endif
 
 .if ${MK_LOCATE} == no
 OLD_FILES+=etc/locate.rc
 OLD_FILES+=etc/periodic/weekly/310.locate
 OLD_FILES+=usr/bin/locate
 OLD_FILES+=usr/libexec/locate.bigram
 OLD_FILES+=usr/libexec/locate.code
 OLD_FILES+=usr/libexec/locate.concatdb
 OLD_FILES+=usr/libexec/locate.mklocatedb
 OLD_FILES+=usr/libexec/locate.updatedb
 OLD_FILES+=usr/share/man/man1/locate.1.gz
 OLD_FILES+=usr/share/man/man8/locate.updatedb.8.gz
 OLD_FILES+=usr/share/man/man8/updatedb.8.gz
 .endif
 
 .if ${MK_LPR} == no
 OLD_FILES+=etc/hosts.lpd
 OLD_FILES+=etc/printcap
+OLD_FILES+=etc/rc.d/lpd
 OLD_FILES+=usr/bin/lp
 OLD_FILES+=usr/bin/lpq
 OLD_FILES+=usr/bin/lpr
 OLD_FILES+=usr/bin/lprm
 OLD_FILES+=usr/libexec/lpr/ru/bjc-240.sh.sample
 OLD_FILES+=usr/libexec/lpr/ru/koi2alt
 OLD_FILES+=usr/libexec/lpr/ru/koi2855
 OLD_DIRS+=usr/libexec/lpr/ru
 OLD_FILES+=usr/libexec/lpr/lpf
 OLD_DIRS+=usr/libexec/lpr
 OLD_FILES+=usr/sbin/chkprintcap
 OLD_FILES+=usr/sbin/lpc
 OLD_FILES+=usr/sbin/lpd
 OLD_FILES+=usr/sbin/lptest
 OLD_FILES+=usr/sbin/pac
 OLD_FILES+=usr/share/doc/smm/07.lpd/paper.ascii.gz
 OLD_DIRS+=usr/share/doc/smm/07.lpd
 OLD_FILES+=usr/share/examples/etc/hosts.lpd
 OLD_FILES+=usr/share/examples/etc/printcap
 OLD_FILES+=usr/share/man/man1/lp.1.gz
 OLD_FILES+=usr/share/man/man1/lpq.1.gz
 OLD_FILES+=usr/share/man/man1/lpr.1.gz
 OLD_FILES+=usr/share/man/man1/lprm.1.gz
 OLD_FILES+=usr/share/man/man1/lptest.1.gz
 OLD_FILES+=usr/share/man/man5/printcap.5.gz
 OLD_FILES+=usr/share/man/man8/chkprintcap.8.gz
 OLD_FILES+=usr/share/man/man8/lpc.8.gz
 OLD_FILES+=usr/share/man/man8/lpd.8.gz
 OLD_FILES+=usr/share/man/man8/pac.8.gz
 .endif
 
 .if ${MK_MAIL} == no
 OLD_FILES+=etc/periodic/daily/130.clean-msgs
 OLD_FILES+=usr/bin/Mail
 OLD_FILES+=usr/bin/biff
 OLD_FILES+=usr/bin/from
 OLD_FILES+=usr/bin/mail
 OLD_FILES+=usr/bin/mailx
 OLD_FILES+=usr/bin/msgs
 OLD_FILES+=usr/libexec/comsat
 OLD_FILES+=usr/share/examples/etc/mail.rc
 OLD_FILES+=usr/share/man/man1/Mail.1.gz
 OLD_FILES+=usr/share/man/man1/biff.1.gz
 OLD_FILES+=usr/share/man/man1/from.1.gz
 OLD_FILES+=usr/share/man/man1/mail.1.gz
 OLD_FILES+=usr/share/man/man1/mailx.1.gz
 OLD_FILES+=usr/share/man/man1/msgs.1.gz
 OLD_FILES+=usr/share/man/man8/comsat.8.gz
 OLD_FILES+=usr/share/misc/mail.help
 OLD_FILES+=usr/share/misc/mail.tildehelp
 .endif
 
 .if ${MK_MAILWRAPPER} == no
 OLD_FILES+=etc/mail/mailer.conf
 .if ${MK_SENDMAIL} == no
 OLD_FILES+=usr/sbin/mailwrapper
 .endif
 OLD_FILES+=usr/share/man/man8/mailwrapper.8.gz
 .endif
 
 #.if ${MK_MAN} == no
 # This should add a dependency to a special target which removes all man pages.
 # Listing all of them here is overkill.
 #.endif
 
 .if ${MK_NDIS} == no
 OLD_FILES+=usr/sbin/ndiscvt
 OLD_FILES+=usr/sbin/ndisgen
 OLD_FILES+=usr/share/man/man8/ndiscvt.8.gz
 OLD_FILES+=usr/share/man/man8/ndisgen.8.gz
 OLD_FILES+=usr/share/misc/windrv_stub.c
 .endif
 
 .if ${MK_NETCAT} == no
 OLD_FILES+=usr/bin/nc
 OLD_FILES+=usr/share/man/man1/nc.1.gz
 .endif
 
 .if ${MK_NIS} == no
 OLD_FILES+=usr/bin/ypcat
 OLD_FILES+=usr/bin/ypchfn
 OLD_FILES+=usr/bin/ypchpass
 OLD_FILES+=usr/bin/ypchsh
 OLD_FILES+=usr/bin/ypmatch
 OLD_FILES+=usr/bin/yppasswd
 OLD_FILES+=usr/bin/ypwhich
 OLD_FILES+=usr/include/ypclnt.h
 OLD_FILES+=usr/lib/libypclnt.a
 OLD_FILES+=usr/lib/libypclnt.so
 OLD_LIBS+=usr/lib/libypclnt.so.4
 OLD_FILES+=usr/lib/libypclnt_p.a
 .if ${TARGET_ARCH} == "amd64" || ${TARGET_ARCH} == "powerpc64"
 OLD_FILES+=usr/lib32/libypclnt.a
 OLD_FILES+=usr/lib32/libypclnt.so
 OLD_LIBS+=usr/lib32/libypclnt.so.4
 OLD_FILES+=usr/lib32/libypclnt_p.a
 .endif
 OLD_FILES+=usr/libexec/mknetid
 OLD_FILES+=usr/libexec/yppwupdate
 OLD_FILES+=usr/libexec/ypxfr
 OLD_FILES+=usr/sbin/rpc.yppasswdd
 OLD_FILES+=usr/sbin/rpc.ypupdated
 OLD_FILES+=usr/sbin/rpc.ypxfrd
 OLD_FILES+=usr/sbin/yp_mkdb
 OLD_FILES+=usr/sbin/ypbind
 OLD_FILES+=usr/sbin/ypinit
 OLD_FILES+=usr/sbin/yppoll
 OLD_FILES+=usr/sbin/yppush
 OLD_FILES+=usr/sbin/ypserv
 OLD_FILES+=usr/sbin/ypset
 OLD_FILES+=usr/share/man/man1/ypcat.1.gz
 OLD_FILES+=usr/share/man/man1/ypchfn.1.gz
 OLD_FILES+=usr/share/man/man1/ypchpass.1.gz
 OLD_FILES+=usr/share/man/man1/ypchsh.1.gz
 OLD_FILES+=usr/share/man/man1/ypmatch.1.gz
 OLD_FILES+=usr/share/man/man1/yppasswd.1.gz
 OLD_FILES+=usr/share/man/man1/ypwhich.1.gz
 OLD_FILES+=usr/share/man/man5/netid.5.gz
 OLD_FILES+=usr/share/man/man8/mknetid.8.gz
 OLD_FILES+=usr/share/man/man8/rpc.yppasswdd.8.gz
 OLD_FILES+=usr/share/man/man8/rpc.ypxfrd.8.gz
 OLD_FILES+=usr/share/man/man8/yp_mkdb.8.gz
 OLD_FILES+=usr/share/man/man8/ypbind.8.gz
 OLD_FILES+=usr/share/man/man8/ypinit.8.gz
 OLD_FILES+=usr/share/man/man8/yppoll.8.gz
 OLD_FILES+=usr/share/man/man8/yppush.8.gz
 OLD_FILES+=usr/share/man/man8/ypserv.8.gz
 OLD_FILES+=usr/share/man/man8/ypset.8.gz
 OLD_FILES+=usr/share/man/man8/ypxfr.8.gz
 OLD_FILES+=var/yp/Makefile
 OLD_FILES+=var/yp/Makefile.dist
 .endif
 
 .if ${MK_NLS} == no
 OLD_FILES+=usr/tests/bin/sh/builtins/locale1.0
 # to be filled in
 .endif
 
 .if ${MK_NTP} == no
 OLD_FILES+=etc/ntp.conf
 OLD_FILES+=etc/periodic/daily/480.status-ntpd
 OLD_FILES+=usr/bin/ntpq
 OLD_FILES+=usr/sbin/ntp-keygen
 OLD_FILES+=usr/sbin/ntpd
 OLD_FILES+=usr/sbin/ntpdate
 OLD_FILES+=usr/sbin/ntpdc
 OLD_FILES+=usr/sbin/ntptime
 OLD_FILES+=usr/sbin/sntp
 OLD_FILES+=usr/share/doc/ntp/accopt.html
 OLD_FILES+=usr/share/doc/ntp/assoc.html
 OLD_FILES+=usr/share/doc/ntp/audio.html
 OLD_FILES+=usr/share/doc/ntp/authopt.html
 OLD_FILES+=usr/share/doc/ntp/build.html
 OLD_FILES+=usr/share/doc/ntp/clockopt.html
 OLD_FILES+=usr/share/doc/ntp/config.html
 OLD_FILES+=usr/share/doc/ntp/confopt.html
 OLD_FILES+=usr/share/doc/ntp/copyright.html
 OLD_FILES+=usr/share/doc/ntp/debug.html
 OLD_FILES+=usr/share/doc/ntp/driver1.html
 OLD_FILES+=usr/share/doc/ntp/driver10.html
 OLD_FILES+=usr/share/doc/ntp/driver11.html
 OLD_FILES+=usr/share/doc/ntp/driver12.html
 OLD_FILES+=usr/share/doc/ntp/driver16.html
 OLD_FILES+=usr/share/doc/ntp/driver18.html
 OLD_FILES+=usr/share/doc/ntp/driver19.html
 OLD_FILES+=usr/share/doc/ntp/driver2.html
 OLD_FILES+=usr/share/doc/ntp/driver20.html
 OLD_FILES+=usr/share/doc/ntp/driver22.html
 OLD_FILES+=usr/share/doc/ntp/driver26.html
 OLD_FILES+=usr/share/doc/ntp/driver27.html
 OLD_FILES+=usr/share/doc/ntp/driver28.html
 OLD_FILES+=usr/share/doc/ntp/driver29.html
 OLD_FILES+=usr/share/doc/ntp/driver3.html
 OLD_FILES+=usr/share/doc/ntp/driver30.html
 OLD_FILES+=usr/share/doc/ntp/driver32.html
 OLD_FILES+=usr/share/doc/ntp/driver33.html
 OLD_FILES+=usr/share/doc/ntp/driver34.html
 OLD_FILES+=usr/share/doc/ntp/driver35.html
 OLD_FILES+=usr/share/doc/ntp/driver36.html
 OLD_FILES+=usr/share/doc/ntp/driver37.html
 OLD_FILES+=usr/share/doc/ntp/driver4.html
 OLD_FILES+=usr/share/doc/ntp/driver5.html
 OLD_FILES+=usr/share/doc/ntp/driver6.html
 OLD_FILES+=usr/share/doc/ntp/driver7.html
 OLD_FILES+=usr/share/doc/ntp/driver8.html
 OLD_FILES+=usr/share/doc/ntp/driver9.html
 OLD_FILES+=usr/share/doc/ntp/extern.html
 OLD_FILES+=usr/share/doc/ntp/hints.html
 OLD_FILES+=usr/share/doc/ntp/howto.html
 OLD_FILES+=usr/share/doc/ntp/index.html
 OLD_FILES+=usr/share/doc/ntp/kern.html
 OLD_FILES+=usr/share/doc/ntp/ldisc.html
 OLD_FILES+=usr/share/doc/ntp/measure.html
 OLD_FILES+=usr/share/doc/ntp/miscopt.html
 OLD_FILES+=usr/share/doc/ntp/monopt.html
 OLD_FILES+=usr/share/doc/ntp/mx4200data.html
 OLD_FILES+=usr/share/doc/ntp/notes.html
 OLD_FILES+=usr/share/doc/ntp/ntpd.html
 OLD_FILES+=usr/share/doc/ntp/ntpdate.html
 OLD_FILES+=usr/share/doc/ntp/ntpdc.html
 OLD_FILES+=usr/share/doc/ntp/ntpq.html
 OLD_FILES+=usr/share/doc/ntp/ntptime.html
 OLD_FILES+=usr/share/doc/ntp/ntptrace.html
 OLD_FILES+=usr/share/doc/ntp/parsedata.html
 OLD_FILES+=usr/share/doc/ntp/parsenew.html
 OLD_FILES+=usr/share/doc/ntp/patches.html
 OLD_FILES+=usr/share/doc/ntp/porting.html
 OLD_FILES+=usr/share/doc/ntp/pps.html
 OLD_FILES+=usr/share/doc/ntp/prefer.html
 OLD_FILES+=usr/share/doc/ntp/quick.html
 OLD_FILES+=usr/share/doc/ntp/rdebug.html
 OLD_FILES+=usr/share/doc/ntp/refclock.html
 OLD_FILES+=usr/share/doc/ntp/release.html
 OLD_FILES+=usr/share/doc/ntp/tickadj.html
 OLD_DIRS+=usr/share/doc/ntp
 OLD_FILES+=usr/share/examples/etc/ntp.conf
 OLD_FILES+=usr/share/man/man5/ntp.conf.5.gz
 OLD_FILES+=usr/share/man/man5/ntp.keys.5.gz
 OLD_FILES+=usr/share/man/man8/ntp-keygen.8.gz
 OLD_FILES+=usr/share/man/man8/ntpd.8.gz
 OLD_FILES+=usr/share/man/man8/ntpdate.8.gz
 OLD_FILES+=usr/share/man/man8/ntpdc.8.gz
 OLD_FILES+=usr/share/man/man8/ntpq.8.gz
 OLD_FILES+=usr/share/man/man8/ntptime.8.gz
 .endif
 
 #.if ${MK_OBJC} == no
 # to be filled in
 #.endif
 
 .if ${MK_OPENSSH} == no
 OLD_FILES+=usr/bin/sftp
 OLD_FILES+=usr/bin/ssh
 OLD_FILES+=usr/bin/ssh-add
 OLD_FILES+=usr/bin/ssh-agent
 OLD_FILES+=usr/bin/ssh-copy-id
 OLD_FILES+=usr/bin/ssh-keygen
 OLD_FILES+=usr/bin/ssh-keyscan
 OLD_FILES+=usr/lib/private/libssh.a
 OLD_FILES+=usr/lib/private/libssh.so
 OLD_LIBS+=usr/lib/private/libssh.so.5
 OLD_FILES+=usr/lib/private/libssh_p.a
 .if ${TARGET_ARCH} == "amd64" || ${TARGET_ARCH} == "powerpc64"
 OLD_FILES+=usr/lib32/private/libssh.a
 OLD_FILES+=usr/lib32/private/libssh.so
 OLD_LIBS+=usr/lib32/private/libssh.so.5
 OLD_FILES+=usr/lib32/private/libssh_p.a
 .endif
 OLD_FILES+=usr/libexec/sftp-server
 OLD_FILES+=usr/libexec/ssh-keysign
 OLD_FILES+=usr/libexec/ssh-pkcs11-helper
 OLD_FILES+=usr/sbin/sshd
 .endif
 
 .if ${MK_OPENSSL} == no
 OLD_FILES+=etc/rc.d/keyserv
 .endif
 
 .if ${MK_PC_SYSINSTALL} == no
 # backend-partmanager
 OLD_FILES+=usr/share/pc-sysinstall/backend-partmanager/create-part.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-partmanager/delete-part.sh
 # backend-query
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/detect-emulation.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/detect-laptop.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/detect-nics.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/disk-info.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/disk-list.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/disk-part.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/enable-net.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/get-packages.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/list-components.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/list-config.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/list-mirrors.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/list-packages.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/list-rsync-backups.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/list-tzones.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/query-langs.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/send-logs.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/setup-ssh-keys.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/set-mirror.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/sys-mem.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/test-live.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/test-netup.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/update-part-list.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/xkeyboard-layouts.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/xkeyboard-models.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend-query/xkeyboard-variants.sh
 # backend
 OLD_FILES+=usr/share/pc-sysinstall/backend/functions-bsdlabel.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend/functions-cleanup.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend/functions-disk.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend/functions-extractimage.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend/functions-ftp.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend/functions-installcomponents.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend/functions-installpackages.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend/functions-localize.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend/functions-mountdisk.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend/functions-mountoptical.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend/functions-networking.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend/functions-newfs.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend/functions-parse.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend/functions-packages.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend/functions-runcommands.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend/functions-unmount.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend/functions-upgrade.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend/functions-users.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend/functions.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend/installimage.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend/parseconfig.sh
 OLD_FILES+=usr/share/pc-sysinstall/backend/startautoinstall.sh
 # conf
 OLD_FILES+=usr/share/pc-sysinstall/conf/avail-langs
 OLD_FILES+=usr/share/pc-sysinstall/conf/exclude-from-upgrade
 OLD_FILES+=usr/share/pc-sysinstall/conf/license/bsd-en.txt
 OLD_FILES+=usr/share/pc-sysinstall/conf/license/intel-en.txt
 OLD_FILES+=usr/share/pc-sysinstall/conf/license/nvidia-en.txt
 OLD_FILES+=usr/share/pc-sysinstall/conf/pc-sysinstall.conf
 # doc
 OLD_FILES+=usr/share/pc-sysinstall/doc/help-disk-list
 OLD_FILES+=usr/share/pc-sysinstall/doc/help-disk-size
 OLD_FILES+=usr/share/pc-sysinstall/doc/help-index
 OLD_FILES+=usr/share/pc-sysinstall/doc/help-start-autoinstall
 # examples
 OLD_FILES+=usr/share/examples/pc-sysinstall/README
 OLD_FILES+=usr/share/examples/pc-sysinstall/pc-autoinstall.conf
 OLD_FILES+=usr/share/examples/pc-sysinstall/pcinstall.cfg.fbsd-netinstall
 OLD_FILES+=usr/share/examples/pc-sysinstall/pcinstall.cfg.geli
 OLD_FILES+=usr/share/examples/pc-sysinstall/pcinstall.cfg.gmirror
 OLD_FILES+=usr/share/examples/pc-sysinstall/pcinstall.cfg.netinstall
 OLD_FILES+=usr/share/examples/pc-sysinstall/pcinstall.cfg.restore
 OLD_FILES+=usr/share/examples/pc-sysinstall/pcinstall.cfg.rsync
 OLD_FILES+=usr/share/examples/pc-sysinstall/pcinstall.cfg.upgrade
 OLD_FILES+=usr/share/examples/pc-sysinstall/pcinstall.cfg.zfs
 # pc-sysinstall
 OLD_FILES+=usr/sbin/pc-sysinstall
 OLD_FILES+=usr/share/man/man8/pc-sysinstall.8.gz
 OLD_DIRS+=usr/share/pc-sysinstall/backend
 OLD_DIRS+=usr/share/pc-sysinstall/backend-partmanager
 OLD_DIRS+=usr/share/pc-sysinstall/backend-query
 OLD_DIRS+=usr/share/pc-sysinstall/conf/license
 OLD_DIRS+=usr/share/pc-sysinstall/conf
 OLD_DIRS+=usr/share/pc-sysinstall/doc
 OLD_DIRS+=usr/share/pc-sysinstall
 OLD_DIRS+=usr/share/examples/pc-sysinstall
 .endif
 
 .if ${MK_PF} == no
 OLD_FILES+=etc/periodic/security/520.pfdenied
 OLD_FILES+=etc/pf.os
 OLD_FILES+=etc/rc.d/ftp-proxy
 OLD_FILES+=sbin/pfctl
 OLD_FILES+=sbin/pflogd
 OLD_FILES+=usr/libexec/tftp-proxy
 OLD_FILES+=usr/sbin/ftp-proxy
 OLD_FILES+=usr/share/examples/etc/pf.os
 OLD_FILES+=usr/share/examples/pf/ackpri
 OLD_FILES+=usr/share/examples/pf/faq-example1
 OLD_FILES+=usr/share/examples/pf/faq-example2
 OLD_FILES+=usr/share/examples/pf/faq-example3
 OLD_FILES+=usr/share/examples/pf/pf.conf
 OLD_FILES+=usr/share/examples/pf/queue1
 OLD_FILES+=usr/share/examples/pf/queue2
 OLD_FILES+=usr/share/examples/pf/queue3
 OLD_FILES+=usr/share/examples/pf/queue4
 OLD_FILES+=usr/share/examples/pf/spamd
 OLD_DIRS+=usr/share/examples/pf
 OLD_FILES+=usr/share/man/man4/pf.4.gz
 OLD_FILES+=usr/share/man/man4/pflog.4.gz
 OLD_FILES+=usr/share/man/man4/pfsync.4.gz
 OLD_FILES+=usr/share/man/man5/pf.conf.5.gz
 OLD_FILES+=usr/share/man/man5/pf.os.5.gz
 OLD_FILES+=usr/share/man/man8/ftp-proxy.8.gz
 OLD_FILES+=usr/share/man/man8/pfctl.8.gz
 OLD_FILES+=usr/share/man/man8/pflogd.8.gz
 OLD_FILES+=usr/share/man/man8/tftp-proxy.8.gz
 .endif
 
 .if ${MK_PKGBOOTSTRAP} == no
 OLD_FILES+=usr/sbin/pkg
 OLD_FILES+=usr/share/man/man7/pkg.7.gz
 .endif
 
 .if ${MK_PORTSNAP} == no
 OLD_FILES+=etc/portsnap.conf
 OLD_FILES+=usr/libexec/make_index
 OLD_FILES+=usr/libexec/phttpget
 OLD_FILES+=usr/sbin/portsnap
 OLD_FILES+=usr/share/examples/etc/portsnap.conf
 OLD_FILES+=usr/share/man/man8/portsnap.8.gz
 .endif
 
 .if ${MK_PPP} == no
 OLD_FILES+=etc/ppp/ppp.conf
 OLD_DIRS+=etc/ppp
 OLD_FILES+=usr/sbin/ppp
 OLD_FILES+=usr/sbin/pppctl
 OLD_FILES+=usr/share/man/man8/ppp.8.gz
 OLD_FILES+=usr/share/man/man8/pppctl.8.gz
 .endif
 
 .if ${MK_PROFILE} == no
 OLD_FILES+=usr/lib/libalias_cuseeme_p.a
 OLD_FILES+=usr/lib/libalias_dummy_p.a
 OLD_FILES+=usr/lib/libalias_ftp_p.a
 OLD_FILES+=usr/lib/libalias_irc_p.a
 OLD_FILES+=usr/lib/libalias_nbt_p.a
 OLD_FILES+=usr/lib/libalias_p.a
 OLD_FILES+=usr/lib/libalias_pptp_p.a
 OLD_FILES+=usr/lib/libalias_skinny_p.a
 OLD_FILES+=usr/lib/libalias_smedia_p.a
 OLD_FILES+=usr/lib/libarchive_p.a
 OLD_FILES+=usr/lib/libasn1_p.a
 OLD_FILES+=usr/lib/libbegemot_p.a
 OLD_FILES+=usr/lib/libbluetooth_p.a
 OLD_FILES+=usr/lib/libbsdxml_p.a
 OLD_FILES+=usr/lib/libbsm_p.a
 OLD_FILES+=usr/lib/libbsnmp_p.a
 OLD_FILES+=usr/lib/libbz2_p.a
 OLD_FILES+=usr/lib/libc_p.a
 OLD_FILES+=usr/lib/libcalendar_p.a
 OLD_FILES+=usr/lib/libcam_p.a
 OLD_FILES+=usr/lib/libcom_err_p.a
 OLD_FILES+=usr/lib/libcompat_p.a
 OLD_FILES+=usr/lib/libcrypt_p.a
 OLD_FILES+=usr/lib/libcrypto_p.a
 OLD_FILES+=usr/lib/libcurses_p.a
 OLD_FILES+=usr/lib/libcursesw_p.a
 OLD_FILES+=usr/lib/libdevinfo_p.a
 OLD_FILES+=usr/lib/libdevstat_p.a
 OLD_FILES+=usr/lib/libdialog_p.a
 OLD_FILES+=usr/lib/libedit_p.a
 OLD_FILES+=usr/lib/libelf_p.a
 OLD_FILES+=usr/lib/libfetch_p.a
 OLD_FILES+=usr/lib/libfl_p.a
 OLD_FILES+=usr/lib/libform_p.a
 OLD_FILES+=usr/lib/libformw_p.a
 OLD_FILES+=usr/lib/libgcc_p.a
 OLD_FILES+=usr/lib/libgeom_p.a
 OLD_FILES+=usr/lib/libgnuregex_p.a
 OLD_FILES+=usr/lib/libgssapi_krb5_p.a
 OLD_FILES+=usr/lib/libgssapi_p.a
 OLD_FILES+=usr/lib/libhdb_p.a
 OLD_FILES+=usr/lib/libheimbase_p.a
 OLD_FILES+=usr/lib/libheimsqlite_p.a
 OLD_FILES+=usr/lib/libhistory_p.a
 OLD_FILES+=usr/lib/libipsec_p.a
 OLD_FILES+=usr/lib/libjail_p.a
 OLD_FILES+=usr/lib/libkadm5clnt_p.a
 OLD_FILES+=usr/lib/libkadm5srv_p.a
 OLD_FILES+=usr/lib/libkafs5_p.a
 OLD_FILES+=usr/lib/libkdc_p.a
 OLD_FILES+=usr/lib/libkiconv_p.a
 OLD_FILES+=usr/lib/libkrb5_p.a
 OLD_FILES+=usr/lib/libkvm_p.a
 OLD_FILES+=usr/lib/libl_p.a
 OLD_FILES+=usr/lib/libln_p.a
 OLD_FILES+=usr/lib/libm_p.a
 OLD_FILES+=usr/lib/libmagic_p.a
 OLD_FILES+=usr/lib/libmd_p.a
 OLD_FILES+=usr/lib/libmemstat_p.a
 OLD_FILES+=usr/lib/libmenu_p.a
 OLD_FILES+=usr/lib/libmenuw_p.a
 OLD_FILES+=usr/lib/libmilter_p.a
 OLD_FILES+=usr/lib/libmp_p.a
 OLD_FILES+=usr/lib/libncurses_p.a
 OLD_FILES+=usr/lib/libncursesw_p.a
 OLD_FILES+=usr/lib/libnetgraph_p.a
 OLD_FILES+=usr/lib/libngatm_p.a
 OLD_FILES+=usr/lib/libopie_p.a
 OLD_FILES+=usr/lib/libpanel_p.a
 OLD_FILES+=usr/lib/libpanelw_p.a
 OLD_FILES+=usr/lib/libpcap_p.a
 OLD_FILES+=usr/lib/libpmc_p.a
 OLD_FILES+=usr/lib/libpthread_p.a
 OLD_FILES+=usr/lib/libradius_p.a
 OLD_FILES+=usr/lib/libroken_p.a
 OLD_FILES+=usr/lib/librpcsvc_p.a
 OLD_FILES+=usr/lib/librt_p.a
 OLD_FILES+=usr/lib/libsbuf_p.a
 OLD_FILES+=usr/lib/libsdp_p.a
 OLD_FILES+=usr/lib/libsmb_p.a
 OLD_FILES+=usr/lib/libssl_p.a
 OLD_FILES+=usr/lib/libstdc++_p.a
 OLD_FILES+=usr/lib/libsupc++_p.a
 OLD_FILES+=usr/lib/libtacplus_p.a
 OLD_FILES+=usr/lib/libtermcap_p.a
 OLD_FILES+=usr/lib/libtermcapw_p.a
 OLD_FILES+=usr/lib/libtermlib_p.a
 OLD_FILES+=usr/lib/libtermlibw_p.a
 OLD_FILES+=usr/lib/libthr_p.a
 OLD_FILES+=usr/lib/libthread_db_p.a
 OLD_FILES+=usr/lib/libtinfo_p.a
 OLD_FILES+=usr/lib/libtinfow_p.a
 OLD_FILES+=usr/lib/libufs_p.a
 OLD_FILES+=usr/lib/libugidfw_p.a
 OLD_FILES+=usr/lib/libusbhid_p.a
 OLD_FILES+=usr/lib/libutil_p.a
 OLD_FILES+=usr/lib/libvgl_p.a
 OLD_FILES+=usr/lib/libwind_p.a
 OLD_FILES+=usr/lib/libwrap_p.a
 OLD_FILES+=usr/lib/liby_p.a
 OLD_FILES+=usr/lib/libypclnt_p.a
 OLD_FILES+=usr/lib/libz_p.a
 OLD_FILES+=usr/lib/private/libldns_p.a
 OLD_FILES+=usr/lib/private/libssh_p.a
 .endif
 
 .if ${MK_RCMDS} == no
 OLD_FILES+=bin/rcp
 OLD_FILES+=etc/rc.d/rwho
 OLD_FILES+=etc/periodic/daily/140.clean-rwho 
 OLD_FILES+=etc/periodic/daily/430.status-rwho
 OLD_FILES+=rescue/rcp
 OLD_FILES+=usr/bin/rlogin
 OLD_FILES+=usr/bin/rsh
 OLD_FILES+=usr/bin/ruptime
 OLD_FILES+=usr/bin/rwho
 OLD_FILES+=usr/libexec/rlogind
 OLD_FILES+=usr/libexec/rshd
 OLD_FILES+=usr/sbin/rwhod
 OLD_FILES+=usr/share/man/man1/rcp.1.gz
 OLD_FILES+=usr/share/man/man1/rlogin.1.gz
 OLD_FILES+=usr/share/man/man1/rsh.1.gz
 OLD_FILES+=usr/share/man/man1/ruptime.1.gz
 OLD_FILES+=usr/share/man/man1/rwho.1.gz
 OLD_FILES+=usr/share/man/man8/rlogind.8.gz
 OLD_FILES+=usr/share/man/man8/rshd.8.gz
 OLD_FILES+=usr/share/man/man8/rwhod.8.gz
 .endif
 
 .if ${MK_RCS} == no
 OLD_FILES+=usr/bin/ci
 OLD_FILES+=usr/bin/co
 OLD_FILES+=usr/bin/ident
 OLD_FILES+=usr/bin/merge
 OLD_FILES+=usr/bin/rcs
 OLD_FILES+=usr/bin/rcsclean
 OLD_FILES+=usr/bin/rcsdiff
 OLD_FILES+=usr/bin/rcsfreeze
 OLD_FILES+=usr/bin/rcsmerge
 OLD_FILES+=usr/bin/rlog
 OLD_FILES+=usr/sbin/etcupdate
 OLD_FILES+=usr/share/man/man1/ci.1.gz
 OLD_FILES+=usr/share/man/man1/co.1.gz
 OLD_FILES+=usr/share/man/man1/ident.1.gz
 OLD_FILES+=usr/share/man/man1/merge.1.gz
 OLD_FILES+=usr/share/man/man1/rcs.1.gz
 OLD_FILES+=usr/share/man/man1/rcsclean.1.gz
 OLD_FILES+=usr/share/man/man1/rcsdiff.1.gz
 OLD_FILES+=usr/share/man/man1/rcsfreeze.1.gz
 OLD_FILES+=usr/share/man/man1/rcsintro.1.gz
 OLD_FILES+=usr/share/man/man1/rcsmerge.1.gz
 OLD_FILES+=usr/share/man/man1/rlog.1.gz
 OLD_FILES+=usr/share/man/man5/rcsfile.5.gz
 OLD_FILES+=usr/share/man/man8/etcupdate.8.gz
 .endif
 
 #.if ${MK_RESCUE} == no
 # to be filled in or replaced with a special target
 #.endif
 
 .if ${MK_ROUTED} == no
 OLD_FILES+=sbin/routed
 OLD_FILES+=sbin/rtquery
 OLD_FILES+=usr/share/man/man8/routed.8.gz
 OLD_FILES+=usr/share/man/man8/rtquery.8.gz
 .endif
 
 .if ${MK_SENDMAIL} == no
 OLD_FILES+=etc/periodic/daily/150.clean-hoststat
 OLD_FILES+=etc/periodic/daily/440.status-mailq
 OLD_FILES+=etc/periodic/daily/460.status-mail-rejects
 OLD_FILES+=etc/periodic/daily/500.queuerun
 .if ${MK_MAILWRAPPER} == no
 OLD_FILES+=bin/rmail
 .endif
 OLD_FILES+=usr/bin/vacation
 OLD_FILES+=usr/include/libmilter/mfapi.h
 OLD_FILES+=usr/include/libmilter/mfdef.h
 OLD_DIRS+=usr/include/libmilter
 OLD_FILES+=usr/lib/libmilter.a
 OLD_FILES+=usr/lib/libmilter.so
 OLD_LIBS+=usr/lib/libmilter.so.5
 OLD_FILES+=usr/lib/libmilter_p.a
 .if ${TARGET_ARCH} == "amd64" || ${TARGET_ARCH} == "powerpc64"
 OLD_FILES+=usr/lib32/libmilter.a
 OLD_FILES+=usr/lib32/libmilter.so
 OLD_LIBS+=usr/lib32/libmilter.so.5
 OLD_FILES+=usr/lib32/libmilter_p.a
 .endif
 OLD_FILES+=usr/libexec/mail.local
 OLD_FILES+=usr/libexec/sendmail/sendmail
 OLD_FILES+=usr/libexec/smrsh
 OLD_FILES+=usr/sbin/editmap
 OLD_FILES+=usr/sbin/mailstats
 OLD_FILES+=usr/sbin/makemap
 OLD_FILES+=usr/sbin/praliases
 OLD_FILES+=usr/share/doc/smm/08.sendmailop/paper.ascii.gz
 OLD_DIRS+=usr/share/doc/smm/08.sendmailop
 OLD_FILES+=usr/share/man/man1/mailq.1.gz
 OLD_FILES+=usr/share/man/man1/newaliases.1.gz
 OLD_FILES+=usr/share/man/man1/vacation.1.gz
 OLD_FILES+=usr/share/man/man5/aliases.5.gz
 OLD_FILES+=usr/share/man/man8/editmap.8.gz
 OLD_FILES+=usr/share/man/man8/hoststat.8.gz
 OLD_FILES+=usr/share/man/man8/mail.local.8.gz
 OLD_FILES+=usr/share/man/man8/mailstats.8.gz
 OLD_FILES+=usr/share/man/man8/makemap.8.gz
 OLD_FILES+=usr/share/man/man8/praliases.8.gz
 OLD_FILES+=usr/share/man/man8/purgestat.8.gz
 OLD_FILES+=usr/share/man/man8/rmail.8.gz
 OLD_FILES+=usr/share/man/man8/sendmail.8.gz
 OLD_FILES+=usr/share/man/man8/smrsh.8.gz
 OLD_FILES+=usr/share/sendmail/cf/README
 OLD_FILES+=usr/share/sendmail/cf/cf/Makefile
 OLD_FILES+=usr/share/sendmail/cf/cf/README
 OLD_FILES+=usr/share/sendmail/cf/cf/chez.cs.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/clientproto.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/cs-hpux10.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/cs-hpux9.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/cs-osf1.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/cs-solaris2.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/cs-sunos4.1.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/cs-ultrix4.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/cyrusproto.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/generic-bsd4.4.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/generic-hpux10.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/generic-hpux9.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/generic-linux.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/generic-mpeix.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/generic-nextstep3.3.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/generic-osf1.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/generic-solaris.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/generic-sunos4.1.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/generic-ultrix4.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/huginn.cs.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/knecht.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/mail.cs.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/mail.eecs.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/mailspool.cs.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/python.cs.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/s2k-osf1.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/s2k-ultrix4.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/submit.cf
 OLD_FILES+=usr/share/sendmail/cf/cf/submit.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/tcpproto.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/ucbarpa.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/ucbvax.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/uucpproto.mc
 OLD_FILES+=usr/share/sendmail/cf/cf/vangogh.cs.mc
 OLD_DIRS+=usr/share/sendmail/cf/cf
 OLD_FILES+=usr/share/sendmail/cf/domain/Berkeley.EDU.m4
 OLD_FILES+=usr/share/sendmail/cf/domain/CS.Berkeley.EDU.m4
 OLD_FILES+=usr/share/sendmail/cf/domain/EECS.Berkeley.EDU.m4
 OLD_FILES+=usr/share/sendmail/cf/domain/S2K.Berkeley.EDU.m4
 OLD_FILES+=usr/share/sendmail/cf/domain/berkeley-only.m4
 OLD_FILES+=usr/share/sendmail/cf/domain/generic.m4
 OLD_DIRS+=usr/share/sendmail/cf/domain
 OLD_FILES+=usr/share/sendmail/cf/feature/accept_unqualified_senders.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/accept_unresolvable_domains.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/access_db.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/allmasquerade.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/always_add_domain.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/authinfo.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/badmx.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/bestmx_is_local.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/bitdomain.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/blacklist_recipients.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/block_bad_helo.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/compat_check.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/conncontrol.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/delay_checks.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/dnsbl.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/domaintable.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/enhdnsbl.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/generics_entire_domain.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/genericstable.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/greet_pause.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/ldap_routing.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/limited_masquerade.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/local_lmtp.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/local_no_masquerade.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/local_procmail.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/lookupdotdomain.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/loose_relay_check.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/mailertable.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/masquerade_entire_domain.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/masquerade_envelope.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/msp.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/mtamark.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/no_default_msa.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/nocanonify.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/notsticky.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/nouucp.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/nullclient.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/preserve_local_plus_detail.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/preserve_luser_host.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/promiscuous_relay.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/queuegroup.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/ratecontrol.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/redirect.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/relay_based_on_MX.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/relay_entire_domain.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/relay_hosts_only.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/relay_local_from.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/relay_mail_from.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/require_rdns.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/smrsh.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/stickyhost.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/use_client_ptr.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/use_ct_file.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/use_cw_file.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/uucpdomain.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/virtuser_entire_domain.m4
 OLD_FILES+=usr/share/sendmail/cf/feature/virtusertable.m4
 OLD_DIRS+=usr/share/sendmail/cf/feature
 OLD_FILES+=usr/share/sendmail/cf/hack/cssubdomain.m4
 OLD_DIRS+=usr/share/sendmail/cf/hack
 OLD_FILES+=usr/share/sendmail/cf/m4/cf.m4
 OLD_FILES+=usr/share/sendmail/cf/m4/cfhead.m4
 OLD_FILES+=usr/share/sendmail/cf/m4/proto.m4
 OLD_FILES+=usr/share/sendmail/cf/m4/version.m4
 OLD_DIRS+=usr/share/sendmail/cf/m4
 OLD_FILES+=usr/share/sendmail/cf/mailer/cyrus.m4
 OLD_FILES+=usr/share/sendmail/cf/mailer/cyrusv2.m4
 OLD_FILES+=usr/share/sendmail/cf/mailer/fax.m4
 OLD_FILES+=usr/share/sendmail/cf/mailer/local.m4
 OLD_FILES+=usr/share/sendmail/cf/mailer/mail11.m4
 OLD_FILES+=usr/share/sendmail/cf/mailer/phquery.m4
 OLD_FILES+=usr/share/sendmail/cf/mailer/pop.m4
 OLD_FILES+=usr/share/sendmail/cf/mailer/procmail.m4
 OLD_FILES+=usr/share/sendmail/cf/mailer/qpage.m4
 OLD_FILES+=usr/share/sendmail/cf/mailer/smtp.m4
 OLD_FILES+=usr/share/sendmail/cf/mailer/usenet.m4
 OLD_FILES+=usr/share/sendmail/cf/mailer/uucp.m4
 OLD_DIRS+=usr/share/sendmail/cf/mailer
 OLD_FILES+=usr/share/sendmail/cf/ostype/a-ux.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/aix3.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/aix4.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/aix5.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/altos.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/amdahl-uts.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/bsd4.3.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/bsd4.4.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/bsdi.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/bsdi1.0.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/bsdi2.0.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/darwin.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/dgux.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/domainos.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/dragonfly.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/dynix3.2.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/freebsd4.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/freebsd5.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/freebsd6.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/gnu.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/hpux10.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/hpux11.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/hpux9.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/irix4.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/irix5.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/irix6.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/isc4.1.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/linux.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/maxion.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/mklinux.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/mpeix.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/nextstep.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/openbsd.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/osf1.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/powerux.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/ptx2.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/qnx.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/riscos4.5.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/sco-uw-2.1.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/sco3.2.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/sinix.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/solaris11.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/solaris2.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/solaris2.ml.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/solaris2.pre5.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/solaris8.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/sunos3.5.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/sunos4.1.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/svr4.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/ultrix4.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/unicos.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/unicosmk.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/unicosmp.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/unixware7.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/unknown.m4
 OLD_FILES+=usr/share/sendmail/cf/ostype/uxpds.m4
 OLD_DIRS+=usr/share/sendmail/cf/ostype
 OLD_FILES+=usr/share/sendmail/cf/sendmail.schema
 OLD_FILES+=usr/share/sendmail/cf/sh/makeinfo.sh
 OLD_DIRS+=usr/share/sendmail/cf/sh
 OLD_FILES+=usr/share/sendmail/cf/siteconfig/uucp.cogsci.m4
 OLD_FILES+=usr/share/sendmail/cf/siteconfig/uucp.old.arpa.m4
 OLD_FILES+=usr/share/sendmail/cf/siteconfig/uucp.ucbarpa.m4
 OLD_FILES+=usr/share/sendmail/cf/siteconfig/uucp.ucbvax.m4
 OLD_DIRS+=usr/share/sendmail/cf/siteconfig
 OLD_DIRS+=usr/share/sendmail/cf
 OLD_DIRS+=usr/share/sendmail
 .endif
 
 .if ${MK_SHAREDOCS} == no
 OLD_FILES+=usr/share/doc/pjdfstest/README
 OLD_DIRS+=usr/share/doc/pjdfstest
 .endif
 
 #.if ${MK_SYSCONS} == no
 # to be filled in
 #.endif
 
 .if ${MK_TALK} == no
 OLD_FILES+=usr/bin/talk
 OLD_FILES+=usr/libexec/ntalkd
 OLD_FILES+=usr/share/man/man1/talk.1.gz
 OLD_FILES+=usr/share/man/man8/talkd.8.gz
 .endif
 
 .if ${MK_TCSH} == no
 OLD_FILES+=bin/csh
 OLD_FILES+=bin/tcsh
 OLD_FILES+=rescue/csh
 OLD_FILES+=rescue/tcsh
 OLD_FILES+=usr/share/examples/tcsh/complete.tcsh
 OLD_FILES+=usr/share/examples/tcsh/csh-mode.el
 OLD_DIRS+=usr/share/examples/tcsh
 OLD_FILES+=usr/share/man/man1/csh.1.gz
 OLD_FILES+=usr/share/man/man1/tcsh.1.gz
 OLD_FILES+=usr/share/nls/de_AT.ISO8859-1/tcsh.cat
 OLD_FILES+=usr/share/nls/de_AT.ISO8859-15/tcsh.cat
 OLD_FILES+=usr/share/nls/de_AT.UTF-8/tcsh.cat
 OLD_FILES+=usr/share/nls/de_CH.ISO8859-1/tcsh.cat
 OLD_FILES+=usr/share/nls/de_CH.ISO8859-15/tcsh.cat
 OLD_FILES+=usr/share/nls/de_CH.UTF-8/tcsh.cat
 OLD_FILES+=usr/share/nls/de_DE.ISO8859-1/tcsh.cat
 OLD_FILES+=usr/share/nls/de_DE.ISO8859-15/tcsh.cat
 OLD_FILES+=usr/share/nls/de_DE.UTF-8/tcsh.cat
 OLD_FILES+=usr/share/nls/el_GR.ISO8859-7/tcsh.cat
 OLD_FILES+=usr/share/nls/el_GR.UTF-8/tcsh.cat
 OLD_FILES+=usr/share/nls/es_ES.ISO8859-1/tcsh.cat
 OLD_FILES+=usr/share/nls/es_ES.ISO8859-15/tcsh.cat
 OLD_FILES+=usr/share/nls/es_ES.UTF-8/tcsh.cat
 OLD_FILES+=usr/share/nls/et_EE.ISO8859-15/tcsh.cat
 OLD_FILES+=usr/share/nls/et_EE.UTF-8/tcsh.cat
 OLD_FILES+=usr/share/nls/fi_FI.ISO8859-1/tcsh.cat
 OLD_FILES+=usr/share/nls/fi_FI.ISO8859-15/tcsh.cat
 OLD_FILES+=usr/share/nls/fi_FI.UTF-8/tcsh.cat
 OLD_FILES+=usr/share/nls/fr_BE.ISO8859-1/tcsh.cat
 OLD_FILES+=usr/share/nls/fr_BE.ISO8859-15/tcsh.cat
 OLD_FILES+=usr/share/nls/fr_BE.UTF-8/tcsh.cat
 OLD_FILES+=usr/share/nls/fr_CA.ISO8859-1/tcsh.cat
 OLD_FILES+=usr/share/nls/fr_CA.ISO8859-15/tcsh.cat
 OLD_FILES+=usr/share/nls/fr_CA.UTF-8/tcsh.cat
 OLD_FILES+=usr/share/nls/fr_CH.ISO8859-1/tcsh.cat
 OLD_FILES+=usr/share/nls/fr_CH.ISO8859-15/tcsh.cat
 OLD_FILES+=usr/share/nls/fr_CH.UTF-8/tcsh.cat
 OLD_FILES+=usr/share/nls/fr_FR.ISO8859-1/tcsh.cat
 OLD_FILES+=usr/share/nls/fr_FR.ISO8859-15/tcsh.cat
 OLD_FILES+=usr/share/nls/fr_FR.UTF-8/tcsh.cat
 OLD_FILES+=usr/share/nls/it_CH.ISO8859-1/tcsh.cat
 OLD_FILES+=usr/share/nls/it_CH.ISO8859-15/tcsh.cat
 OLD_FILES+=usr/share/nls/it_CH.UTF-8/tcsh.cat
 OLD_FILES+=usr/share/nls/it_IT.ISO8859-1/tcsh.cat
 OLD_FILES+=usr/share/nls/it_IT.ISO8859-15/tcsh.cat
 OLD_FILES+=usr/share/nls/it_IT.UTF-8/tcsh.cat
 OLD_FILES+=usr/share/nls/ja_JP.SJIS/tcsh.cat
 OLD_FILES+=usr/share/nls/ja_JP.UTF-8/tcsh.cat
 OLD_FILES+=usr/share/nls/ja_JP.eucJP/tcsh.cat
 OLD_FILES+=usr/share/nls/ru_RU.CP1251/tcsh.cat
 OLD_FILES+=usr/share/nls/ru_RU.CP866/tcsh.cat
 OLD_FILES+=usr/share/nls/ru_RU.ISO8859-5/tcsh.cat
 OLD_FILES+=usr/share/nls/ru_RU.KOI8-R/tcsh.cat
 OLD_FILES+=usr/share/nls/ru_RU.UTF-8/tcsh.cat
 OLD_FILES+=usr/share/nls/uk_UA.ISO8859-5/tcsh.cat
 OLD_FILES+=usr/share/nls/uk_UA.KOI8-U/tcsh.cat
 OLD_FILES+=usr/share/nls/uk_UA.UTF-8/tcsh.cat
 .endif
 
 .if ${MK_TELNET} == no
 OLD_FILES+=usr/bin/telnet
 OLD_FILES+=usr/libexec/telnetd
 OLD_FILES+=usr/share/man/man1/telnet.1.gz
 OLD_FILES+=usr/share/man/man8/telnetd.8.gz
 .endif
 
 .if ${MK_TESTS} == yes
 OLD_FILES+=usr/bin/atf-sh
 OLD_FILES+=usr/include/atf-c++/config.hpp
 OLD_FILES+=usr/include/atf-c/config.h
 OLD_LIBS+=usr/lib/libatf-c++.a
 OLD_LIBS+=usr/lib/libatf-c++.so
 OLD_LIBS+=usr/lib/libatf-c++.so.1
 OLD_LIBS+=usr/lib/libatf-c++.so.2
 OLD_LIBS+=usr/lib/libatf-c++_p.a
 OLD_LIBS+=usr/lib/libatf-c.a
 OLD_LIBS+=usr/lib/libatf-c.so
 OLD_LIBS+=usr/lib/libatf-c.so.1
 OLD_LIBS+=usr/lib/libatf-c_p.a
 OLD_LIBS+=usr/lib/private/libatf-c.so.0
 OLD_LIBS+=usr/lib/private/libatf-c++.so.1
 .if ${TARGET_ARCH} == "amd64" || ${TARGET_ARCH} == "powerpc64"
 OLD_LIBS+=usr/lib32/libatf-c++.a
 OLD_LIBS+=usr/lib32/libatf-c++.so
 OLD_LIBS+=usr/lib32/libatf-c++.so.1
 OLD_LIBS+=usr/lib32/libatf-c++.so.2
 OLD_LIBS+=usr/lib32/libatf-c++_p.a
 OLD_LIBS+=usr/lib32/libatf-c.a
 OLD_LIBS+=usr/lib32/libatf-c.so
 OLD_LIBS+=usr/lib32/libatf-c.so.1
 OLD_LIBS+=usr/lib32/libatf-c_p.a
 OLD_LIBS+=usr/lib32/private/libatf-c.so.0
 OLD_LIBS+=usr/lib32/private/libatf-c++.so.1
 .endif
 OLD_FILES+=usr/libdata/pkgconfig/atf-c++.pc
 OLD_FILES+=usr/libdata/pkgconfig/atf-c.pc
 OLD_FILES+=usr/libdata/pkgconfig/atf-sh.pc
 OLD_FILES+=usr/share/aclocal/atf-c++.m4
 OLD_FILES+=usr/share/aclocal/atf-c.m4
 OLD_FILES+=usr/share/aclocal/atf-common.m4
 OLD_FILES+=usr/share/aclocal/atf-sh.m4
 OLD_DIRS+=usr/share/aclocal
 OLD_FILES+=usr/tests/bin/chown/units_basics
 OLD_FILES+=usr/tests/bin/date/legacy_test
 OLD_FILES+=usr/tests/bin/sh/legacy_test
 OLD_FILES+=usr/tests/usr.bin/atf/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/atf/atf-sh/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/atf/atf-sh/atf_check_test
 OLD_FILES+=usr/tests/usr.bin/atf/atf-sh/config_test
 OLD_FILES+=usr/tests/usr.bin/atf/atf-sh/integration_test
 OLD_FILES+=usr/tests/usr.bin/atf/atf-sh/misc_helpers
 OLD_FILES+=usr/tests/usr.bin/atf/atf-sh/normalize_test
 OLD_FILES+=usr/tests/usr.bin/atf/atf-sh/tc_test
 OLD_FILES+=usr/tests/usr.bin/atf/atf-sh/tp_test
 OLD_DIRS+=usr/tests/usr.bin/atf/atf-sh
 OLD_DIRS+=usr/tests/usr.bin/atf
 OLD_FILES+=usr/tests/lib/atf/libatf-c/test_helpers_test
 OLD_FILES+=usr/tests/lib/atf/test-programs/fork_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c++/application_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c++/config_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c++/detail/expand_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c++/detail/parser_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c++/detail/sanity_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c++/detail/ui_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c++/env_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c++/exceptions_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c++/expand_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c++/fs_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c++/parser_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c++/process_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c++/sanity_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c++/pkg_config_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c++/text_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c++/ui_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c/config_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c/dynstr_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c/env_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c/fs_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c/list_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c/map_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c/pkg_config_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c/process_helpers
 OLD_FILES+=usr/tests/lib/atf/libatf-c/process_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c/sanity_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c/text_test
 OLD_FILES+=usr/tests/lib/atf/libatf-c/user_test
 .if ${MK_MAKE} == yes
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/expected.status.2
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/expected.status.3
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/expected.status.4
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/expected.status.5
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/expected.status.6
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/expected.status.7
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/expected.stderr.2
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/expected.stderr.3
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/expected.stderr.4
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/expected.stderr.5
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/expected.stderr.6
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/expected.stderr.7
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/expected.stdout.2
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/expected.stdout.3
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/expected.stdout.4
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/expected.stdout.5
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/expected.stdout.6
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/expected.stdout.7
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd/libtest.a
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/expected.status.2
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/expected.status.3
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/expected.status.4
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/expected.status.5
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/expected.status.6
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/expected.status.7
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/expected.stderr.2
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/expected.stderr.3
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/expected.stderr.4
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/expected.stderr.5
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/expected.stderr.6
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/expected.stderr.7
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/expected.stdout.2
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/expected.stdout.3
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/expected.stdout.4
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/expected.stdout.5
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/expected.stdout.6
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/expected.stdout.7
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod/libtest.a
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/expected.status.2
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/expected.status.3
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/expected.status.4
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/expected.status.5
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/expected.status.6
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/expected.status.7
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/expected.stderr.2
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/expected.stderr.3
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/expected.stderr.4
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/expected.stderr.5
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/expected.stderr.6
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/expected.stderr.7
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/expected.stdout.2
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/expected.stdout.3
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/expected.stdout.4
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/expected.stdout.5
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/expected.stdout.6
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/expected.stdout.7
 OLD_FILES+=usr/tests/usr.bin/make/archives/fmt_oldbsd/libtest.a
 OLD_FILES+=usr/tests/usr.bin/make/archives/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/basic/t0/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/basic/t0/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/basic/t0/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/basic/t0/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/basic/t0/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/basic/t1/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/basic/t1/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/basic/t1/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/basic/t1/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/basic/t1/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/basic/t1/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/basic/t2/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/basic/t2/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/basic/t2/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/basic/t2/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/basic/t2/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/basic/t2/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/basic/t3/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/basic/t3/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/basic/t3/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/basic/t3/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/basic/t3/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/basic/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/execution/ellipsis/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/execution/ellipsis/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/execution/ellipsis/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/execution/ellipsis/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/execution/ellipsis/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/execution/ellipsis/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/execution/empty/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/execution/empty/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/execution/empty/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/execution/empty/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/execution/empty/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/execution/empty/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/execution/joberr/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/execution/joberr/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/execution/joberr/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/execution/joberr/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/execution/joberr/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/execution/joberr/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/execution/plus/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/execution/plus/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/execution/plus/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/execution/plus/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/execution/plus/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/execution/plus/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/execution/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/shell/builtin/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/shell/builtin/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/shell/builtin/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/shell/builtin/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/shell/builtin/expected.status.2
 OLD_FILES+=usr/tests/usr.bin/make/shell/builtin/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/shell/builtin/expected.stderr.2
 OLD_FILES+=usr/tests/usr.bin/make/shell/builtin/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/shell/builtin/expected.stdout.2
 OLD_FILES+=usr/tests/usr.bin/make/shell/builtin/sh
 OLD_FILES+=usr/tests/usr.bin/make/shell/meta/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/shell/meta/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/shell/meta/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/shell/meta/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/shell/meta/expected.status.2
 OLD_FILES+=usr/tests/usr.bin/make/shell/meta/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/shell/meta/expected.stderr.2
 OLD_FILES+=usr/tests/usr.bin/make/shell/meta/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/shell/meta/expected.stdout.2
 OLD_FILES+=usr/tests/usr.bin/make/shell/meta/sh
 OLD_FILES+=usr/tests/usr.bin/make/shell/path/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/shell/path/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/shell/path/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/shell/path/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/shell/path/expected.status.2
 OLD_FILES+=usr/tests/usr.bin/make/shell/path/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/shell/path/expected.stderr.2
 OLD_FILES+=usr/tests/usr.bin/make/shell/path/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/shell/path/expected.stdout.2
 OLD_FILES+=usr/tests/usr.bin/make/shell/path/sh
 OLD_FILES+=usr/tests/usr.bin/make/shell/path_select/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/shell/path_select/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/shell/path_select/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/shell/path_select/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/shell/path_select/expected.status.2
 OLD_FILES+=usr/tests/usr.bin/make/shell/path_select/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/shell/path_select/expected.stderr.2
 OLD_FILES+=usr/tests/usr.bin/make/shell/path_select/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/shell/path_select/expected.stdout.2
 OLD_FILES+=usr/tests/usr.bin/make/shell/path_select/shell
 OLD_FILES+=usr/tests/usr.bin/make/shell/replace/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/shell/replace/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/shell/replace/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/shell/replace/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/shell/replace/expected.status.2
 OLD_FILES+=usr/tests/usr.bin/make/shell/replace/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/shell/replace/expected.stderr.2
 OLD_FILES+=usr/tests/usr.bin/make/shell/replace/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/shell/replace/expected.stdout.2
 OLD_FILES+=usr/tests/usr.bin/make/shell/replace/shell
 OLD_FILES+=usr/tests/usr.bin/make/shell/select/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/shell/select/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/shell/select/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/shell/select/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/shell/select/expected.status.2
 OLD_FILES+=usr/tests/usr.bin/make/shell/select/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/shell/select/expected.stderr.2
 OLD_FILES+=usr/tests/usr.bin/make/shell/select/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/shell/select/expected.stdout.2
 OLD_FILES+=usr/tests/usr.bin/make/shell/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/basic/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/basic/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/basic/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/basic/TEST1.a
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/basic/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/basic/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/basic/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/src_wild1/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/src_wild1/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/src_wild1/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/src_wild1/TEST1.a
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/src_wild1/TEST2.a
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/src_wild1/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/src_wild1/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/src_wild1/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/src_wild2/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/src_wild2/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/src_wild2/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/src_wild2/TEST1.a
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/src_wild2/TEST2.a
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/src_wild2/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/src_wild2/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/src_wild2/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/suffixes/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/syntax/directive-t0/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/syntax/directive-t0/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/syntax/directive-t0/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/syntax/directive-t0/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/syntax/directive-t0/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/syntax/directive-t0/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/syntax/enl/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/syntax/enl/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/syntax/enl/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/syntax/enl/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/syntax/enl/expected.status.2
 OLD_FILES+=usr/tests/usr.bin/make/syntax/enl/expected.status.3
 OLD_FILES+=usr/tests/usr.bin/make/syntax/enl/expected.status.4
 OLD_FILES+=usr/tests/usr.bin/make/syntax/enl/expected.status.5
 OLD_FILES+=usr/tests/usr.bin/make/syntax/enl/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/syntax/enl/expected.stderr.2
 OLD_FILES+=usr/tests/usr.bin/make/syntax/enl/expected.stderr.3
 OLD_FILES+=usr/tests/usr.bin/make/syntax/enl/expected.stderr.4
 OLD_FILES+=usr/tests/usr.bin/make/syntax/enl/expected.stderr.5
 OLD_FILES+=usr/tests/usr.bin/make/syntax/enl/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/syntax/enl/expected.stdout.2
 OLD_FILES+=usr/tests/usr.bin/make/syntax/enl/expected.stdout.3
 OLD_FILES+=usr/tests/usr.bin/make/syntax/enl/expected.stdout.4
 OLD_FILES+=usr/tests/usr.bin/make/syntax/enl/expected.stdout.5
 OLD_FILES+=usr/tests/usr.bin/make/syntax/funny-targets/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/syntax/funny-targets/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/syntax/funny-targets/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/syntax/funny-targets/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/syntax/funny-targets/expected.status.2
 OLD_FILES+=usr/tests/usr.bin/make/syntax/funny-targets/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/syntax/funny-targets/expected.stderr.2
 OLD_FILES+=usr/tests/usr.bin/make/syntax/funny-targets/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/syntax/funny-targets/expected.stdout.2
 OLD_FILES+=usr/tests/usr.bin/make/syntax/semi/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/syntax/semi/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/syntax/semi/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/syntax/semi/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/syntax/semi/expected.status.2
 OLD_FILES+=usr/tests/usr.bin/make/syntax/semi/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/syntax/semi/expected.stderr.2
 OLD_FILES+=usr/tests/usr.bin/make/syntax/semi/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/syntax/semi/expected.stdout.2
 OLD_FILES+=usr/tests/usr.bin/make/syntax/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t0/2/1/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t0/2/1/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t0/2/1/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t0/2/1/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t0/2/1/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t0/2/1/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t0/2/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t0/mk/sys.mk
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t0/mk/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t0/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t1/2/1/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t1/2/1/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t1/2/1/cleanup
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t1/2/1/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t1/2/1/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t1/2/1/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t1/2/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t1/mk/sys.mk
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t1/mk/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t1/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t2/2/1/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t2/2/1/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t2/2/1/cleanup
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t2/2/1/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t2/2/1/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t2/2/1/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t2/2/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t2/mk/sys.mk
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t2/mk/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/t2/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/sysmk/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/variables/modifier_M/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/variables/modifier_M/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/variables/modifier_M/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/variables/modifier_M/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/variables/modifier_M/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/variables/modifier_M/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/variables/modifier_t/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/variables/modifier_t/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/variables/modifier_t/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/variables/modifier_t/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/variables/modifier_t/expected.status.2
 OLD_FILES+=usr/tests/usr.bin/make/variables/modifier_t/expected.status.3
 OLD_FILES+=usr/tests/usr.bin/make/variables/modifier_t/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/variables/modifier_t/expected.stderr.2
 OLD_FILES+=usr/tests/usr.bin/make/variables/modifier_t/expected.stderr.3
 OLD_FILES+=usr/tests/usr.bin/make/variables/modifier_t/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/variables/modifier_t/expected.stdout.2
 OLD_FILES+=usr/tests/usr.bin/make/variables/modifier_t/expected.stdout.3
 OLD_FILES+=usr/tests/usr.bin/make/variables/opt_V/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/variables/opt_V/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/variables/opt_V/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/variables/opt_V/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/variables/opt_V/expected.status.2
 OLD_FILES+=usr/tests/usr.bin/make/variables/opt_V/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/variables/opt_V/expected.stderr.2
 OLD_FILES+=usr/tests/usr.bin/make/variables/opt_V/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/variables/opt_V/expected.stdout.2
 OLD_FILES+=usr/tests/usr.bin/make/variables/t0/legacy_test
 OLD_FILES+=usr/tests/usr.bin/make/variables/t0/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/variables/t0/Makefile.test
 OLD_FILES+=usr/tests/usr.bin/make/variables/t0/expected.status.1
 OLD_FILES+=usr/tests/usr.bin/make/variables/t0/expected.stderr.1
 OLD_FILES+=usr/tests/usr.bin/make/variables/t0/expected.stdout.1
 OLD_FILES+=usr/tests/usr.bin/make/variables/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/Kyuafile
 OLD_FILES+=usr/tests/usr.bin/make/common.sh
 OLD_FILES+=usr/tests/usr.bin/make/test-new.mk
 OLD_DIRS+=usr/tests/usr.bin/make/variables/t0
 OLD_DIRS+=usr/tests/usr.bin/make/variables/opt_V
 OLD_DIRS+=usr/tests/usr.bin/make/variables/modifier_t
 OLD_DIRS+=usr/tests/usr.bin/make/variables/modifier_M
 OLD_DIRS+=usr/tests/usr.bin/make/variables
 OLD_DIRS+=usr/tests/usr.bin/make/sysmk/t2/mk
 OLD_DIRS+=usr/tests/usr.bin/make/sysmk/t2/2/1
 OLD_DIRS+=usr/tests/usr.bin/make/sysmk/t2/2
 OLD_DIRS+=usr/tests/usr.bin/make/sysmk/t2
 OLD_DIRS+=usr/tests/usr.bin/make/sysmk/t1/mk
 OLD_DIRS+=usr/tests/usr.bin/make/sysmk/t1/2/1
 OLD_DIRS+=usr/tests/usr.bin/make/sysmk/t1/2
 OLD_DIRS+=usr/tests/usr.bin/make/sysmk/t1
 OLD_DIRS+=usr/tests/usr.bin/make/sysmk/t0/mk
 OLD_DIRS+=usr/tests/usr.bin/make/sysmk/t0/2/1
 OLD_DIRS+=usr/tests/usr.bin/make/sysmk/t0/2
 OLD_DIRS+=usr/tests/usr.bin/make/sysmk/t0
 OLD_DIRS+=usr/tests/usr.bin/make/sysmk
 OLD_DIRS+=usr/tests/usr.bin/make/syntax/semi
 OLD_DIRS+=usr/tests/usr.bin/make/syntax/funny-targets
 OLD_DIRS+=usr/tests/usr.bin/make/syntax/enl
 OLD_DIRS+=usr/tests/usr.bin/make/syntax/directive-t0
 OLD_DIRS+=usr/tests/usr.bin/make/syntax
 OLD_DIRS+=usr/tests/usr.bin/make/suffixes/src_wild2
 OLD_DIRS+=usr/tests/usr.bin/make/suffixes/src_wild1
 OLD_DIRS+=usr/tests/usr.bin/make/suffixes/basic
 OLD_DIRS+=usr/tests/usr.bin/make/suffixes
 OLD_DIRS+=usr/tests/usr.bin/make/shell/select
 OLD_DIRS+=usr/tests/usr.bin/make/shell/replace
 OLD_DIRS+=usr/tests/usr.bin/make/shell/path_select
 OLD_DIRS+=usr/tests/usr.bin/make/shell/path
 OLD_DIRS+=usr/tests/usr.bin/make/shell/meta
 OLD_DIRS+=usr/tests/usr.bin/make/shell/builtin
 OLD_DIRS+=usr/tests/usr.bin/make/shell
 OLD_DIRS+=usr/tests/usr.bin/make/execution/plus
 OLD_DIRS+=usr/tests/usr.bin/make/execution/joberr
 OLD_DIRS+=usr/tests/usr.bin/make/execution/empty
 OLD_DIRS+=usr/tests/usr.bin/make/execution/ellipsis
 OLD_DIRS+=usr/tests/usr.bin/make/execution
 OLD_DIRS+=usr/tests/usr.bin/make/basic/t3
 OLD_DIRS+=usr/tests/usr.bin/make/basic/t2
 OLD_DIRS+=usr/tests/usr.bin/make/basic/t1
 OLD_DIRS+=usr/tests/usr.bin/make/basic/t0
 OLD_DIRS+=usr/tests/usr.bin/make/basic
 OLD_DIRS+=usr/tests/usr.bin/make/archives/fmt_oldbsd
 OLD_DIRS+=usr/tests/usr.bin/make/archives/fmt_44bsd_mod
 OLD_DIRS+=usr/tests/usr.bin/make/archives/fmt_44bsd
 OLD_DIRS+=usr/tests/usr.bin/make/archives
 OLD_DIRS+=usr/tests/usr.bin/make
 OLD_FILES+=usr/tests/usr.bin/yacc/legacy_test
 OLD_FILES+=usr/tests/usr.bin/yacc/regress.00.out
 OLD_FILES+=usr/tests/usr.bin/yacc/regress.01.out
 OLD_FILES+=usr/tests/usr.bin/yacc/regress.02.out
 OLD_FILES+=usr/tests/usr.bin/yacc/regress.03.out
 OLD_FILES+=usr/tests/usr.bin/yacc/regress.04.out
 OLD_FILES+=usr/tests/usr.bin/yacc/regress.05.out
 OLD_FILES+=usr/tests/usr.bin/yacc/regress.06.out
 OLD_FILES+=usr/tests/usr.bin/yacc/regress.07.out
 OLD_FILES+=usr/tests/usr.bin/yacc/regress.08.out
 OLD_FILES+=usr/tests/usr.bin/yacc/regress.09.out
 OLD_FILES+=usr/tests/usr.bin/yacc/regress.10.out
 OLD_FILES+=usr/tests/usr.bin/yacc/regress.11.out
 OLD_FILES+=usr/tests/usr.bin/yacc/regress.12.out
 OLD_FILES+=usr/tests/usr.bin/yacc/regress.13.out
 OLD_FILES+=usr/tests/usr.bin/yacc/regress.14.out
 OLD_FILES+=usr/tests/usr.bin/yacc/regress.sh
 OLD_FILES+=usr/tests/usr.bin/yacc/undefined.y
 .endif
 .else
 # ATF libraries.
 OLD_FILES+=usr/bin/atf-sh
 OLD_DIRS+=usr/include/atf-c
 OLD_FILES+=usr/include/atf-c/build.h
 OLD_FILES+=usr/include/atf-c/check.h
 OLD_FILES+=usr/include/atf-c/config.h
 OLD_FILES+=usr/include/atf-c/defs.h
 OLD_FILES+=usr/include/atf-c/error.h
 OLD_FILES+=usr/include/atf-c/error_fwd.h
 OLD_FILES+=usr/include/atf-c/macros.h
 OLD_FILES+=usr/include/atf-c/tc.h
 OLD_FILES+=usr/include/atf-c/tp.h
 OLD_FILES+=usr/include/atf-c/utils.h
 OLD_FILES+=usr/include/atf-c.h
 OLD_DIRS+=usr/include/atf-c++
 OLD_FILES+=usr/include/atf-c++/build.hpp
 OLD_FILES+=usr/include/atf-c++/check.hpp
 OLD_FILES+=usr/include/atf-c++/config.hpp
 OLD_FILES+=usr/include/atf-c++/macros.hpp
 OLD_FILES+=usr/include/atf-c++/tests.hpp
 OLD_FILES+=usr/include/atf-c++/utils.hpp
 OLD_FILES+=usr/include/atf-c++.hpp
 OLD_FILES+=usr/lib/libatf-c_p.a
 OLD_FILES+=usr/lib/libatf-c.so.1
 OLD_FILES+=usr/lib/libatf-c.so
 OLD_FILES+=usr/lib/libatf-c++.a
 OLD_FILES+=usr/lib/libatf-c++_p.a
 OLD_FILES+=usr/lib/libatf-c++.so.1
 OLD_FILES+=usr/lib/libatf-c++.so
 OLD_FILES+=usr/lib/libatf-c.a
 OLD_FILES+=usr/libexec/atf-check
 OLD_DIRS+=usr/share/atf
 OLD_FILES+=usr/share/atf/libatf-sh.subr
 OLD_DIRS+=usr/share/doc/atf
 OLD_FILES+=usr/share/doc/atf/AUTHORS
 OLD_FILES+=usr/share/doc/atf/COPYING
 OLD_FILES+=usr/share/doc/atf/NEWS
 OLD_FILES+=usr/share/doc/atf/README
 OLD_FILES+=usr/share/man/man1/atf-check.1.gz
 OLD_FILES+=usr/share/man/man1/atf-sh.1.gz
 OLD_FILES+=usr/share/man/man1/atf-test-program.1.gz
 OLD_FILES+=usr/share/man/man3/atf-c-api.3.gz
 OLD_FILES+=usr/share/man/man3/atf-c++-api.3.gz
 OLD_FILES+=usr/share/man/man3/atf-sh-api.3.gz
 OLD_FILES+=usr/share/man/man4/atf-test-case.4.gz
 OLD_FILES+=usr/share/mk/atf.test.mk
 
 # Test suite.
 . if exists(${DESTDIR}${TESTSBASE})
 TESTS_DIRS!=find ${DESTDIR}${TESTSBASE} -type d | sed -e 's,^${DESTDIR}/,,'; echo
 OLD_DIRS+=${TESTS_DIRS}
 TESTS_FILES!=find ${DESTDIR}${TESTSBASE} \! -type d | sed -e 's,^${DESTDIR}/,,'; echo
 OLD_FILES+=${TESTS_FILES}
 . endif
 .endif	# Test suite.
 
 #.if ${MK_TOOLCHAIN} == no
 # to be filled in
 #.endif
 
 .if ${MK_UNBOUND} == no
 OLD_FILES+=etc/rc.d/local_unbound
 OLD_FILES+=usr/lib/private/libunbound.a
 OLD_FILES+=usr/lib/private/libunbound.so
 OLD_LIBS+=usr/lib/private/libunbound.so.5
 OLD_FILES+=usr/lib/private/libunbound_p.a
 .if ${TARGET_ARCH} == "amd64" || ${TARGET_ARCH} == "powerpc64"
 OLD_FILES+=usr/lib32/private/libunbound.a
 OLD_FILES+=usr/lib32/private/libunbound.so
 OLD_LIBS+=usr/lib32/private/libunbound.so.5
 OLD_FILES+=usr/lib32/private/libunbound_p.a
 .endif
 OLD_FILES+=usr/sbin/local-unbound-setup
 OLD_FILES+=usr/sbin/unbound
 OLD_FILES+=usr/sbin/unbound-anchor
 OLD_FILES+=usr/sbin/unbound-checkconf
 OLD_FILES+=usr/sbin/unbound-control
 OLD_FILES+=usr/sbin/unbound-control-setup
 .endif
 
 .if ${MK_USB} == no
 OLD_FILES+=etc/devd/uauth.conf
 OLD_FILES+=etc/devd/usb.conf
 .endif
 
 .if ${MK_UTMPX} == no
 OLD_FILES+=etc/periodic/monthly/200.accounting
 OLD_FILES+=usr/bin/last
 OLD_FILES+=usr/bin/users
 OLD_FILES+=usr/bin/who
 OLD_FILES+=usr/sbin/ac
 OLD_FILES+=usr/sbin/lastlogin
 OLD_FILES+=usr/sbin/utx
 OLD_FILES+=usr/share/man/man1/last.1.gz
 OLD_FILES+=usr/share/man/man1/users.1.gz
 OLD_FILES+=usr/share/man/man1/who.1.gz
 OLD_FILES+=usr/share/man/man8/ac.8.gz
 OLD_FILES+=usr/share/man/man8/lastlogin.8.gz
 OLD_FILES+=usr/share/man/man8/utx.8.gz
 .endif
 
 .if ${MK_WIRELESS} == no
 OLD_FILES+=etc/regdomain.xml
+OLD_FILES+=etc/rc.d/hostapd
+OLD_FILES+=etc/rc.d/wpa_supplicant
 OLD_FILES+=usr/sbin/ancontrol
 OLD_FILES+=usr/sbin/hostapd
 OLD_FILES+=usr/sbin/hostapd_cli
 OLD_FILES+=usr/sbin/ndis_events
 OLD_FILES+=usr/sbin/wlandebug
 .if ${TARGET_ARCH} == "i386"
 OLD_FILES+=usr/sbin/wlconfig
 .endif
 OLD_FILES+=usr/sbin/wpa_cli
 OLD_FILES+=usr/sbin/wpa_passphrase
 OLD_FILES+=usr/sbin/wpa_supplicant
 OLD_FILES+=usr/share/examples/etc/regdomain.xml
 OLD_FILES+=usr/share/examples/etc/wpa_supplicant.conf
 OLD_FILES+=usr/share/examples/hostapd/hostapd.conf
 OLD_FILES+=usr/share/examples/hostapd/hostapd.eap_user
 OLD_FILES+=usr/share/examples/hostapd/hostapd.wpa_psk
 OLD_DIRS+=usr/share/examples/hostapd
 OLD_FILES+=usr/share/man/man5/hostapd.conf.5.gz
 OLD_FILES+=usr/share/man/man5/wpa_supplicant.conf.5.gz
 OLD_FILES+=usr/share/man/man8/ancontrol.8.gz
 OLD_FILES+=usr/share/man/man8/hostapd.8.gz
 OLD_FILES+=usr/share/man/man8/hostapd_cli.8.gz
 .if ${TARGET_ARCH} == "i386"
 OLD_FILES+=usr/share/man/man8/i386/wlconfig.8.gz
 .endif
 OLD_FILES+=usr/share/man/man8/ndis_events.8.gz
 OLD_FILES+=usr/share/man/man8/wlandebug.8.gz
 OLD_FILES+=usr/share/man/man8/wpa_cli.8.gz
 OLD_FILES+=usr/share/man/man8/wpa_passphrase.8.gz
 OLD_FILES+=usr/share/man/man8/wpa_supplicant.8.gz
 .endif
 
 .if ${MK_SVNLITE} == no || ${MK_SVN} == yes
 OLD_FILES+=usr/bin/svnlite
 OLD_FILES+=usr/bin/svnliteadmin
 OLD_FILES+=usr/bin/svnlitedumpfilter
 OLD_FILES+=usr/bin/svnlitelook
 OLD_FILES+=usr/bin/svnlitemucc
 OLD_FILES+=usr/bin/svnliterdump
 OLD_FILES+=usr/bin/svnliteserve
 OLD_FILES+=usr/bin/svnlitesync
 OLD_FILES+=usr/bin/svnliteversion
 OLD_FILES+=usr/share/man/man1/svnlite.1.gz
 .endif
 
 .if ${MK_SVN} == no
 OLD_FILES+=usr/bin/svn
 OLD_FILES+=usr/bin/svnadmin
 OLD_FILES+=usr/bin/svndumpfilter
 OLD_FILES+=usr/bin/svnlook
 OLD_FILES+=usr/bin/svnmucc
 OLD_FILES+=usr/bin/svnrdump
 OLD_FILES+=usr/bin/svnserve
 OLD_FILES+=usr/bin/svnsync
 OLD_FILES+=usr/bin/svnversion
 .endif
 
 .if ${MK_DMAGENT} == no
 OLD_FILES+=usr/libexec/dma
 OLD_FILES+=usr/libexec/dma-mbox-create
 OLD_FILES+=usr/share/man/man8/dma.8.gz
 OLD_FILES+=usr/share/examples/dma/mailer.conf
 .endif
 
 .if ${MK_HYPERV} == no
 OLD_FILES+=etc/devd/hyperv.conf
 OLD_FILES+=usr/libexec/hyperv/hv_set_ifconfig
 OLD_FILES+=usr/libexec/hyperv/hv_get_dns_info
 OLD_FILES+=usr/libexec/hyperv/hv_get_dhcp_info
 OLD_FILES+=usr/sbin/hv_kvp_daemon
 OLD_FILES+=usr/share/man/man8/hv_kvp_daemon.8.gz
 .endif
Index: projects/clang360-import/tools/build/options/WITHOUT_AUTOFS
===================================================================
--- projects/clang360-import/tools/build/options/WITHOUT_AUTOFS	(nonexistent)
+++ projects/clang360-import/tools/build/options/WITHOUT_AUTOFS	(revision 277778)
@@ -0,0 +1,4 @@
+.\" $FreeBSD$
+Set to not build
+.Xr autofs 4
+related programs, libraries, and kernel modules.

Property changes on: projects/clang360-import/tools/build/options/WITHOUT_AUTOFS
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+FreeBSD=%H
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Index: projects/clang360-import/tools/build/options/WITHOUT_BHYVE
===================================================================
--- projects/clang360-import/tools/build/options/WITHOUT_BHYVE	(nonexistent)
+++ projects/clang360-import/tools/build/options/WITHOUT_BHYVE	(revision 277778)
@@ -0,0 +1,6 @@
+.\" $FreeBSD$
+Set to not build or install
+.Xr bhyve 8 ,
+associated utilities, and examples.
+.Pp
+This option only affects amd64/amd64.

Property changes on: projects/clang360-import/tools/build/options/WITHOUT_BHYVE
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+FreeBSD=%H
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Index: projects/clang360-import/tools/build/options/WITHOUT_HAST
===================================================================
--- projects/clang360-import/tools/build/options/WITHOUT_HAST	(nonexistent)
+++ projects/clang360-import/tools/build/options/WITHOUT_HAST	(revision 277778)
@@ -0,0 +1,4 @@
+.\" $FreeBSD$
+Set to not build
+.Xr hastd 8
+and related utilities.

Property changes on: projects/clang360-import/tools/build/options/WITHOUT_HAST
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+FreeBSD=%H
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Index: projects/clang360-import/usr.sbin/Makefile
===================================================================
--- projects/clang360-import/usr.sbin/Makefile	(revision 277777)
+++ projects/clang360-import/usr.sbin/Makefile	(revision 277778)
@@ -1,338 +1,341 @@
 #	From: @(#)Makefile	5.20 (Berkeley) 6/12/93
 # $FreeBSD$
 
 .include <src.opts.mk>
 
 SUBDIR=	adduser \
 	arp \
-	autofs \
 	binmiscctl \
 	bootparamd \
 	bsdconfig \
 	cdcontrol \
 	chkgrp \
 	chown \
 	chroot \
 	ckdist \
 	clear_locks \
 	crashinfo \
 	cron \
 	ctladm \
 	ctld \
 	daemon \
 	dconschat \
 	devinfo \
 	digictl \
 	diskinfo \
 	dumpcis \
 	extattr \
 	extattrctl \
 	fifolog \
 	fstyp \
 	fwcontrol \
 	getfmac \
 	getpmac \
 	gstat \
 	i2c \
 	ifmcstat \
 	inetd \
 	iostat \
 	kldxref \
 	mailwrapper \
 	makefs \
 	memcontrol \
 	mergemaster \
 	mfiutil \
 	mixer \
 	mlxcontrol \
 	mountd \
 	mptutil \
 	mtest \
 	${_mtree} \
 	newsyslog \
 	nfscbd \
 	nfsd \
 	nfsdumpstate \
 	nfsrevoke \
 	nfsuserd \
 	nmtree \
 	nologin \
 	${_pc_sysinstall} \
 	pciconf \
 	periodic \
 	powerd \
 	procctl \
 	pstat \
 	pw \
 	pwd_mkdb \
 	quot \
 	rarpd \
 	rmt \
 	rpcbind \
 	rpc.lockd \
 	rpc.statd \
 	rpc.umntall \
 	rtprio \
 	service \
 	services_mkdb \
 	setfib \
 	setfmac \
 	setpmac \
 	smbmsg \
 	snapinfo \
 	spray \
 	syslogd \
 	sysrc \
 	tcpdchk \
 	tcpdmatch \
 	tcpdrop \
 	tcpdump \
 	timed \
 	traceroute \
 	trpt \
 	tzsetup \
 	ugidfw \
 	vigr \
 	vipw \
 	wake \
 	watch \
 	watchdogd \
 	zic
 
 # NB: keep these sorted by MK_* knobs
 
 .if ${MK_ACCT} != "no"
 SUBDIR+=	accton
 SUBDIR+=	sa
 .endif
 
 .if ${MK_AMD} != "no"
 SUBDIR+=	amd
 .endif
 
 .if ${MK_AUDIT} != "no"
 SUBDIR+=	audit
 SUBDIR+=	auditd
 .if ${MK_OPENSSL} != "no"
 SUBDIR+=	auditdistd
 .endif
 SUBDIR+=	auditreduce
 SUBDIR+=	praudit
 .endif
 
 .if ${MK_AUTHPF} != "no"
 SUBDIR+=	authpf
+.endif
+
+.if ${MK_AUTOFS} != "no"
+SUBDIR+=	autofs
 .endif
 
 .if ${MK_BLUETOOTH} != "no"
 SUBDIR+=	bluetooth
 .endif
 
 .if ${MK_BSDINSTALL} != "no"
 SUBDIR+=	bsdinstall
 .endif
 
 .if ${MK_BSNMP} != "no"
 SUBDIR+=	bsnmpd
 .endif
 
 .if ${MK_CTM} != "no"
 SUBDIR+=	ctm
 .endif
 
 .if ${MK_FLOPPY} != "no"
 SUBDIR+=	fdcontrol
 SUBDIR+=	fdformat
 SUBDIR+=	fdread
 SUBDIR+=	fdwrite
 .endif
 
 .if ${MK_FMTREE} != "no"
 SUBDIR+=	mtree
 .endif
 
 .if ${MK_FREEBSD_UPDATE} != "no"
 SUBDIR+=	freebsd-update
 .endif
 
 .if ${MK_GSSAPI} != "no"
 SUBDIR+=	gssd
 .endif
 
 .if ${MK_GPIO} != "no"
 SUBDIR+=	gpioctl
 .endif
 
 .if ${MK_INET6} != "no"
 SUBDIR+=	ip6addrctl
 SUBDIR+=	mld6query
 SUBDIR+=	ndp
 SUBDIR+=	rip6query
 SUBDIR+=	route6d
 SUBDIR+=	rrenumd
 SUBDIR+=	rtadvctl
 SUBDIR+=	rtadvd
 SUBDIR+=	rtsold
 SUBDIR+=	traceroute6
 .endif
 
 .if ${MK_IPFW} != "no"
 SUBDIR+=	ipfwpcap
 .endif
 
 .if ${MK_ISCSI} != "no"
 SUBDIR+=	iscsid
 .endif
 
 .if ${MK_JAIL} != "no"
 SUBDIR+=	jail
 SUBDIR+=	jexec
 SUBDIR+=	jls
 .endif
 
 # XXX MK_SYSCONS
 .if ${MK_LEGACY_CONSOLE} != "no"
 SUBDIR+=	kbdcontrol
 SUBDIR+=	kbdmap
 SUBDIR+=	moused
 SUBDIR+=	vidcontrol
 .endif
 
 .if ${MK_LIBTHR} != "no" || ${MK_LIBPTHREAD} != "no"
 .if ${MK_PPP} != "no"
 SUBDIR+=	pppctl
 .endif
 .if ${MK_NS_CACHING} != "no"
 SUBDIR+=	nscd
 .endif
 .endif
 
 .if ${MK_LPR} != "no"
 SUBDIR+=	lpr
 .endif
 
 .if ${MK_MAN_UTILS} != "no"
 SUBDIR+=	manctl
 .endif
 
 .if ${MK_NAND} != "no"
 SUBDIR+=	nandsim
 SUBDIR+=	nandtool
 .endif
 
 .if ${MK_NETGRAPH} != "no"
 SUBDIR+=	flowctl
 SUBDIR+=	lmcconfig
 SUBDIR+=	ngctl
 SUBDIR+=	nghook
 .endif
 
 .if ${MK_NIS} != "no"
 SUBDIR+=	rpc.yppasswdd
 SUBDIR+=	rpc.ypupdated
 SUBDIR+=	rpc.ypxfrd
 SUBDIR+=	ypbind
 SUBDIR+=	yp_mkdb
 SUBDIR+=	yppoll
 SUBDIR+=	yppush
 SUBDIR+=	ypserv
 SUBDIR+=	ypset
 .endif
 
 .if ${MK_NTP} != "no"
 SUBDIR+=	ntp
 .endif
 
 .if ${MK_OPENSSL} != "no"
 SUBDIR+=	keyserv
 .endif
 
 .if ${MK_PC_SYSINSTALL} != "no"
 _pc_sysinstall=	pc-sysinstall
 .endif
 
 .if ${MK_PF} != "no"
 SUBDIR+=	ftp-proxy
 .endif
 
 .if ${MK_PKGBOOTSTRAP} != "no"
 SUBDIR+=	pkg
 .endif
 
 # XXX MK_TOOLCHAIN?
 .if ${MK_PMC} != "no"
 SUBDIR+=	pmcannotate
 SUBDIR+=	pmccontrol
 SUBDIR+=	pmcstat
 SUBDIR+=	pmcstudy
 .endif
 
 .if ${MK_PORTSNAP} != "no"
 SUBDIR+=	portsnap
 .endif
 
 .if ${MK_PPP} != "no"
 SUBDIR+=	ppp
 .endif
 
 .if ${MK_QUOTAS} != "no"
 SUBDIR+=	edquota
 SUBDIR+=	quotaon
 SUBDIR+=	repquota
 .endif
 
 .if ${MK_RCMDS} != "no"
 SUBDIR+=	rwhod
 .endif
 
 .if ${MK_RCS} != "no"
 SUBDIR+=	etcupdate
 .endif
 
 .if ${MK_SENDMAIL} != "no"
 SUBDIR+=	editmap
 SUBDIR+=	mailstats
 SUBDIR+=	makemap
 SUBDIR+=	praliases
 SUBDIR+=	sendmail
 .endif
 
 .if ${MK_TESTS} != "no"
 SUBDIR+=	tests
 .endif
 
 .if ${MK_TOOLCHAIN} != "no"
 SUBDIR+=	config
 SUBDIR+=	crunch
 .endif
 
 .if ${MK_UNBOUND} != "no"
 SUBDIR+=	unbound
 .endif
 
 .if ${MK_USB} != "no"
 SUBDIR+=	uathload
 SUBDIR+=	uhsoctl
 SUBDIR+=	usbconfig
 SUBDIR+=	usbdump
 .endif
 
 .if ${MK_UTMPX} != "no"
 SUBDIR+=	ac
 SUBDIR+=	lastlogin
 SUBDIR+=	utx
 .endif
 
 .if ${MK_WIRELESS} != "no"
 SUBDIR+=	ancontrol
 SUBDIR+=	wlandebug
 SUBDIR+=	wpa
 .endif
 
 .include <bsd.arch.inc.mk>
 
 SUBDIR:=	${SUBDIR:O}
 
 SUBDIR_PARALLEL=
 
 .include <bsd.subdir.mk>
Index: projects/clang360-import/usr.sbin/Makefile.amd64
===================================================================
--- projects/clang360-import/usr.sbin/Makefile.amd64	(revision 277777)
+++ projects/clang360-import/usr.sbin/Makefile.amd64	(revision 277778)
@@ -1,33 +1,35 @@
 # $FreeBSD$
 
 # kgzip: builds, but missing support files
 # mptable: broken (not 64 bit clean)
 # pnpinfo: crashes (not really useful anyway)
 .if ${MK_ACPI} != "no"
 SUBDIR+=	acpi
 .endif
 .if ${MK_APM} != "no"
 SUBDIR+=	apm
 .endif
 SUBDIR+=	asf
+.if ${MK_BHYVE} != "no"
 SUBDIR+=	bhyve
 SUBDIR+=	bhyvectl
 SUBDIR+=	bhyveload
+.endif
 SUBDIR+=	boot0cfg
 .if ${MK_TOOLCHAIN} != "no"
 SUBDIR+=	btxld
 .endif
 SUBDIR+=	cpucontrol
 .if ${MK_HYPERV} != "no"
 SUBDIR+=	hyperv
 .endif
 SUBDIR+=	kgmon
 SUBDIR+=	lptcontrol
 SUBDIR+=	mount_smbfs
 SUBDIR+=	mptable
 .if ${MK_NDIS} != "no"
 SUBDIR+=	ndiscvt
 .endif
 SUBDIR+=	sicontrol
 SUBDIR+=	spkrtest
 SUBDIR+=	zzz
Index: projects/clang360-import/usr.sbin/pw/pw_group.c
===================================================================
--- projects/clang360-import/usr.sbin/pw/pw_group.c	(revision 277777)
+++ projects/clang360-import/usr.sbin/pw/pw_group.c	(revision 277778)
@@ -1,442 +1,438 @@
 /*-
  * Copyright (C) 1996
  *	David L. Nugent.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY DAVID L. NUGENT AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL DAVID L. NUGENT OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #ifndef lint
 static const char rcsid[] =
   "$FreeBSD$";
 #endif /* not lint */
 
 #include <ctype.h>
 #include <err.h>
 #include <termios.h>
 #include <stdbool.h>
 #include <unistd.h>
 #include <grp.h>
 #include <libutil.h>
 
 #include "pw.h"
 #include "bitmap.h"
 
 
 static struct passwd *lookup_pwent(const char *user);
 static void	delete_members(char ***members, int *grmembers, int *i,
     struct carg *arg, struct group *grp);
 static int      print_group(struct group * grp, int pretty);
 static gid_t    gr_gidpolicy(struct userconf * cnf, struct cargs * args);
 
 int
 pw_group(struct userconf * cnf, int mode, struct cargs * args)
 {
 	int		rc;
 	struct carg    *a_newname = getarg(args, 'l');
 	struct carg    *a_name = getarg(args, 'n');
 	struct carg    *a_gid = getarg(args, 'g');
 	struct carg    *arg;
 	struct group   *grp = NULL;
 	int	        grmembers = 0;
 	char           **members = NULL;
 
 	static struct group fakegroup =
 	{
 		"nogroup",
 		"*",
 		-1,
 		NULL
 	};
 
 	if (a_gid != NULL) {
-		const char *teststr;
-		teststr = a_gid->val;
-		if (*teststr == '-')
-			teststr++;
-		if (strspn(teststr, "0123456789") != strlen(teststr))
+		if (strspn(a_gid->val, "0123456789") != strlen(a_gid->val))
 			errx(EX_USAGE, "-g expects a number");
 	}
 
 	if (mode == M_LOCK || mode == M_UNLOCK)
 		errx(EX_USAGE, "'lock' command is not available for groups");
 
 	/*
 	 * With M_NEXT, we only need to return the
 	 * next gid to stdout
 	 */
 	if (mode == M_NEXT) {
 		gid_t next = gr_gidpolicy(cnf, args);
 		if (getarg(args, 'q'))
 			return next;
 		printf("%ld\n", (long)next);
 		return EXIT_SUCCESS;
 	}
 
 	if (mode == M_PRINT && getarg(args, 'a')) {
 		int             pretty = getarg(args, 'P') != NULL;
 
 		SETGRENT();
 		while ((grp = GETGRENT()) != NULL)
 			print_group(grp, pretty);
 		ENDGRENT();
 		return EXIT_SUCCESS;
 	}
 	if (a_gid == NULL) {
 		if (a_name == NULL)
 			errx(EX_DATAERR, "group name or id required");
 
 		if (mode != M_ADD && grp == NULL && isdigit((unsigned char)*a_name->val)) {
 			(a_gid = a_name)->ch = 'g';
 			a_name = NULL;
 		}
 	}
 	grp = (a_name != NULL) ? GETGRNAM(a_name->val) : GETGRGID((gid_t) atoi(a_gid->val));
 
 	if (mode == M_UPDATE || mode == M_DELETE || mode == M_PRINT) {
 		if (a_name == NULL && grp == NULL)	/* Try harder */
 			grp = GETGRGID(atoi(a_gid->val));
 
 		if (grp == NULL) {
 			if (mode == M_PRINT && getarg(args, 'F')) {
 				char	*fmems[1];
 				fmems[0] = NULL;
 				fakegroup.gr_name = a_name ? a_name->val : "nogroup";
 				fakegroup.gr_gid = a_gid ? (gid_t) atol(a_gid->val) : -1;
 				fakegroup.gr_mem = fmems;
 				return print_group(&fakegroup, getarg(args, 'P') != NULL);
 			}
 			errx(EX_DATAERR, "unknown group `%s'", a_name ? a_name->val : a_gid->val);
 		}
 		if (a_name == NULL)	/* Needed later */
 			a_name = addarg(args, 'n', grp->gr_name);
 
 		/*
 		 * Handle deletions now
 		 */
 		if (mode == M_DELETE) {
 			gid_t           gid = grp->gr_gid;
 
 			rc = delgrent(grp);
 			if (rc == -1)
 				err(EX_IOERR, "group '%s' not available (NIS?)", grp->gr_name);
 			else if (rc != 0) {
 				warn("group update");
 				return EX_IOERR;
 			}
 			pw_log(cnf, mode, W_GROUP, "%s(%ld) removed", a_name->val, (long) gid);
 			return EXIT_SUCCESS;
 		} else if (mode == M_PRINT)
 			return print_group(grp, getarg(args, 'P') != NULL);
 
 		if (a_gid)
 			grp->gr_gid = (gid_t) atoi(a_gid->val);
 
 		if (a_newname != NULL)
 			grp->gr_name = pw_checkname((u_char *)a_newname->val, 0);
 	} else {
 		if (a_name == NULL)	/* Required */
 			errx(EX_DATAERR, "group name required");
 		else if (grp != NULL)	/* Exists */
 			errx(EX_DATAERR, "group name `%s' already exists", a_name->val);
 
 		extendarray(&members, &grmembers, 200);
 		members[0] = NULL;
 		grp = &fakegroup;
 		grp->gr_name = pw_checkname((u_char *)a_name->val, 0);
 		grp->gr_passwd = "*";
 		grp->gr_gid = gr_gidpolicy(cnf, args);
 		grp->gr_mem = members;
 	}
 
 	/*
 	 * This allows us to set a group password Group passwords is an
 	 * antique idea, rarely used and insecure (no secure database) Should
 	 * be discouraged, but it is apparently still supported by some
 	 * software.
 	 */
 
 	if ((arg = getarg(args, 'h')) != NULL ||
 	    (arg = getarg(args, 'H')) != NULL) {
 		if (strcmp(arg->val, "-") == 0)
 			grp->gr_passwd = "*";	/* No access */
 		else {
 			int             fd = atoi(arg->val);
 			int		precrypt = (arg->ch == 'H');
 			int             b;
 			int             istty = isatty(fd);
 			struct termios  t;
 			char           *p, line[256];
 
 			if (istty) {
 				if (tcgetattr(fd, &t) == -1)
 					istty = 0;
 				else {
 					struct termios  n = t;
 
 					/* Disable echo */
 					n.c_lflag &= ~(ECHO);
 					tcsetattr(fd, TCSANOW, &n);
 					printf("%sassword for group %s:", (mode == M_UPDATE) ? "New p" : "P", grp->gr_name);
 					fflush(stdout);
 				}
 			}
 			b = read(fd, line, sizeof(line) - 1);
 			if (istty) {	/* Restore state */
 				tcsetattr(fd, TCSANOW, &t);
 				fputc('\n', stdout);
 				fflush(stdout);
 			}
 			if (b < 0) {
 				warn("-h file descriptor");
 				return EX_OSERR;
 			}
 			line[b] = '\0';
 			if ((p = strpbrk(line, " \t\r\n")) != NULL)
 				*p = '\0';
 			if (!*line)
 				errx(EX_DATAERR, "empty password read on file descriptor %d", fd);
 			if (precrypt) {
 				if (strchr(line, ':') != NULL)
 					return EX_DATAERR;
 				grp->gr_passwd = line;
 			} else
 				grp->gr_passwd = pw_pwcrypt(line);
 		}
 	}
 
 	if (((arg = getarg(args, 'M')) != NULL ||
 	    (arg = getarg(args, 'd')) != NULL ||
 	    (arg = getarg(args, 'm')) != NULL) && arg->val) {
 		int	i = 0;
 		char   *p;
 		struct passwd	*pwd;
 
 		/* Make sure this is not stay NULL with -M "" */
 		extendarray(&members, &grmembers, 200);
 		if (arg->ch == 'd')
 			delete_members(&members, &grmembers, &i, arg, grp);
 		else if (arg->ch == 'm') {
 			int	k = 0;
 
 			if (grp->gr_mem != NULL) {
 				while (grp->gr_mem[k] != NULL) {
 					if (extendarray(&members, &grmembers, i + 2) != -1)
 						members[i++] = grp->gr_mem[k];
 					k++;
 				}
 			}
 		}
 
 		if (arg->ch != 'd')
 			for (p = strtok(arg->val, ", \t"); p != NULL; p = strtok(NULL, ", \t")) {
 				int	j;
 
 				/*
 				 * Check for duplicates
 				 */
 				pwd = lookup_pwent(p);
 				for (j = 0; j < i && strcmp(members[j], pwd->pw_name) != 0; j++)
 					;
 				if (j == i && extendarray(&members, &grmembers, i + 2) != -1)
 					members[i++] = newstr(pwd->pw_name);
 			}
 		while (i < grmembers)
 			members[i++] = NULL;
 		grp->gr_mem = members;
 	}
 
 	if (getarg(args, 'N') != NULL)
 		return print_group(grp, getarg(args, 'P') != NULL);
 
 	if (mode == M_ADD && (rc = addgrent(grp)) != 0) {
 		if (rc == -1)
 			warnx("group '%s' already exists", grp->gr_name);
 		else
 			warn("group update");
 		return EX_IOERR;
 	} else if (mode == M_UPDATE && (rc = chggrent(a_name->val, grp)) != 0) {
 		if (rc == -1)
 			warnx("group '%s' not available (NIS?)", grp->gr_name);
 		else
 			warn("group update");
 		return EX_IOERR;
 	}
 
 	arg = a_newname != NULL ? a_newname : a_name;
 	/* grp may have been invalidated */
 	if ((grp = GETGRNAM(arg->val)) == NULL)
 		errx(EX_SOFTWARE, "group disappeared during update");
 
 	pw_log(cnf, mode, W_GROUP, "%s(%ld)", grp->gr_name, (long) grp->gr_gid);
 
 	free(members);
 
 	return EXIT_SUCCESS;
 }
 
 
 /*
  * Lookup a passwd entry using a name or UID.
  */
 static struct passwd *
 lookup_pwent(const char *user)
 {
 	struct passwd *pwd;
 
 	if ((pwd = GETPWNAM(user)) == NULL &&
 	    (!isdigit((unsigned char)*user) ||
 	    (pwd = getpwuid((uid_t) atoi(user))) == NULL))
 		errx(EX_NOUSER, "user `%s' does not exist", user);
 
 	return (pwd);
 }
 
 
 /*
  * Delete requested members from a group.
  */
 static void
 delete_members(char ***members, int *grmembers, int *i, struct carg *arg,
     struct group *grp)
 {
 	bool matchFound;
 	char *user;
 	char *valueCopy;
 	char *valuePtr;
 	int k;
 	struct passwd *pwd;
 
 	if (grp->gr_mem == NULL)
 		return;
 
 	k = 0;
 	while (grp->gr_mem[k] != NULL) {
 		matchFound = false;
 		if ((valueCopy = strdup(arg->val)) == NULL)
 			errx(EX_UNAVAILABLE, "out of memory");
 		valuePtr = valueCopy;
 		while ((user = strsep(&valuePtr, ", \t")) != NULL) {
 			pwd = lookup_pwent(user);
 			if (strcmp(grp->gr_mem[k], pwd->pw_name) == 0) {
 				matchFound = true;
 				break;
 			}
 		}
 		free(valueCopy);
 
 		if (!matchFound &&
 		    extendarray(members, grmembers, *i + 2) != -1)
 			(*members)[(*i)++] = grp->gr_mem[k];
 
 		k++;
 	}
 
 	return;
 }
 
 
 static          gid_t
 gr_gidpolicy(struct userconf * cnf, struct cargs * args)
 {
 	struct group   *grp;
 	gid_t           gid = (gid_t) - 1;
 	struct carg    *a_gid = getarg(args, 'g');
 
 	/*
 	 * Check the given gid, if any
 	 */
 	if (a_gid != NULL) {
 		gid = (gid_t) atol(a_gid->val);
 
 		if ((grp = GETGRGID(gid)) != NULL && getarg(args, 'o') == NULL)
 			errx(EX_DATAERR, "gid `%ld' has already been allocated", (long) grp->gr_gid);
 	} else {
 		struct bitmap   bm;
 
 		/*
 		 * We need to allocate the next available gid under one of
 		 * two policies a) Grab the first unused gid b) Grab the
 		 * highest possible unused gid
 		 */
 		if (cnf->min_gid >= cnf->max_gid) {	/* Sanity claus^H^H^H^Hheck */
 			cnf->min_gid = 1000;
 			cnf->max_gid = 32000;
 		}
 		bm = bm_alloc(cnf->max_gid - cnf->min_gid + 1);
 
 		/*
 		 * Now, let's fill the bitmap from the password file
 		 */
 		SETGRENT();
 		while ((grp = GETGRENT()) != NULL)
 			if ((gid_t)grp->gr_gid >= (gid_t)cnf->min_gid &&
                             (gid_t)grp->gr_gid <= (gid_t)cnf->max_gid)
 				bm_setbit(&bm, grp->gr_gid - cnf->min_gid);
 		ENDGRENT();
 
 		/*
 		 * Then apply the policy, with fallback to reuse if necessary
 		 */
 		if (cnf->reuse_gids)
 			gid = (gid_t) (bm_firstunset(&bm) + cnf->min_gid);
 		else {
 			gid = (gid_t) (bm_lastset(&bm) + 1);
 			if (!bm_isset(&bm, gid))
 				gid += cnf->min_gid;
 			else
 				gid = (gid_t) (bm_firstunset(&bm) + cnf->min_gid);
 		}
 
 		/*
 		 * Another sanity check
 		 */
 		if (gid < cnf->min_gid || gid > cnf->max_gid)
 			errx(EX_SOFTWARE, "unable to allocate a new gid - range fully used");
 		bm_dealloc(&bm);
 	}
 	return gid;
 }
 
 
 static int
 print_group(struct group * grp, int pretty)
 {
 	if (!pretty) {
 		char           *buf = NULL;
 
 		buf = gr_make(grp);
 		printf("%s\n", buf);
 		free(buf);
 	} else {
 		int             i;
 
 		printf("Group Name: %-15s   #%lu\n"
 		       "   Members: ",
 		       grp->gr_name, (long) grp->gr_gid);
 		if (grp->gr_mem != NULL) {
 			for (i = 0; grp->gr_mem[i]; i++)
 				printf("%s%s", i ? "," : "", grp->gr_mem[i]);
 		}
 		fputs("\n\n", stdout);
 	}
 	return EXIT_SUCCESS;
 }
Index: projects/clang360-import/usr.sbin/pw/pw_user.c
===================================================================
--- projects/clang360-import/usr.sbin/pw/pw_user.c	(revision 277777)
+++ projects/clang360-import/usr.sbin/pw/pw_user.c	(revision 277778)
@@ -1,1348 +1,1345 @@
 /*-
  * Copyright (C) 1996
  *	David L. Nugent.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY DAVID L. NUGENT AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL DAVID L. NUGENT OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * 
  */
 
 #ifndef lint
 static const char rcsid[] =
   "$FreeBSD$";
 #endif /* not lint */
 
 #include <ctype.h>
 #include <err.h>
 #include <fcntl.h>
 #include <sys/param.h>
 #include <dirent.h>
 #include <paths.h>
 #include <termios.h>
 #include <sys/types.h>
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <unistd.h>
 #include <login_cap.h>
 #include <pwd.h>
 #include <grp.h>
 #include <libutil.h>
 #include "pw.h"
 #include "bitmap.h"
 
 #define LOGNAMESIZE (MAXLOGNAME-1)
 
 static		char locked_str[] = "*LOCKED*";
 
 static int      print_user(struct passwd * pwd, int pretty, int v7);
 static uid_t    pw_uidpolicy(struct userconf * cnf, struct cargs * args);
 static uid_t    pw_gidpolicy(struct userconf * cnf, struct cargs * args, char *nam, gid_t prefer);
 static time_t   pw_pwdpolicy(struct userconf * cnf, struct cargs * args);
 static time_t   pw_exppolicy(struct userconf * cnf, struct cargs * args);
 static char    *pw_homepolicy(struct userconf * cnf, struct cargs * args, char const * user);
 static char    *pw_shellpolicy(struct userconf * cnf, struct cargs * args, char *newshell);
 static char    *pw_password(struct userconf * cnf, struct cargs * args, char const * user);
 static char    *shell_path(char const * path, char *shells[], char *sh);
 static void     rmat(uid_t uid);
 static void     rmopie(char const * name);
 
 /*-
  * -C config      configuration file
  * -q             quiet operation
  * -n name        login name
  * -u uid         user id
  * -c comment     user name/comment
  * -d directory   home directory
  * -e date        account expiry date
  * -p date        password expiry date
  * -g grp         primary group
  * -G grp1,grp2   additional groups
  * -m [ -k dir ]  create and set up home
  * -s shell       name of login shell
  * -o             duplicate uid ok
  * -L class       user class
  * -l name        new login name
  * -h fd          password filehandle
  * -H fd          encrypted password filehandle
  * -F             force print or add
  *   Setting defaults:
  * -D             set user defaults
  * -b dir         default home root dir
  * -e period      default expiry period
  * -p period      default password change period
  * -g group       default group
  * -G             grp1,grp2.. default additional groups
  * -L class       default login class
  * -k dir         default home skeleton
  * -s shell       default shell
  * -w method      default password method
  */
 
 int
 pw_user(struct userconf * cnf, int mode, struct cargs * args)
 {
 	int	        rc, edited = 0;
 	char           *p = NULL;
 	char					 *passtmp;
 	struct carg    *a_name;
 	struct carg    *a_uid;
 	struct carg    *arg;
 	struct passwd  *pwd = NULL;
 	struct group   *grp;
 	struct stat     st;
 	char            line[_PASSWORD_LEN+1];
 	FILE	       *fp;
 	char *dmode_c;
 	void *set = NULL;
 
 	static struct passwd fakeuser =
 	{
 		NULL,
 		"*",
 		-1,
 		-1,
 		0,
 		"",
 		"User &",
 		"/nonexistent",
 		"/bin/sh",
 		0
 #if defined(__FreeBSD__)
 		,0
 #endif
 	};
 
 
 	/*
 	 * With M_NEXT, we only need to return the
 	 * next uid to stdout
 	 */
 	if (mode == M_NEXT)
 	{
 		uid_t next = pw_uidpolicy(cnf, args);
 		if (getarg(args, 'q'))
 			return next;
 		printf("%ld:", (long)next);
 		pw_group(cnf, mode, args);
 		return EXIT_SUCCESS;
 	}
 
 	/*
 	 * We can do all of the common legwork here
 	 */
 
 	if ((arg = getarg(args, 'b')) != NULL) {
 		cnf->home = arg->val;
 	}
 
 	if ((arg = getarg(args, 'M')) != NULL) {
 		dmode_c = arg->val;
 		if ((set = setmode(dmode_c)) == NULL)
 			errx(EX_DATAERR, "invalid directory creation mode '%s'",
 			    dmode_c);
 		cnf->homemode = getmode(set, _DEF_DIRMODE);
 		free(set);
 	}
 
 	/*
 	 * If we'll need to use it or we're updating it,
 	 * then create the base home directory if necessary
 	 */
 	if (arg != NULL || getarg(args, 'm') != NULL) {
 		int	l = strlen(cnf->home);
 
 		if (l > 1 && cnf->home[l-1] == '/')	/* Shave off any trailing path delimiter */
 			cnf->home[--l] = '\0';
 
 		if (l < 2 || *cnf->home != '/')		/* Check for absolute path name */
 			errx(EX_DATAERR, "invalid base directory for home '%s'", cnf->home);
 
 		if (stat(cnf->home, &st) == -1) {
 			char	dbuf[MAXPATHLEN];
 
 			/*
 			 * This is a kludge especially for Joerg :)
 			 * If the home directory would be created in the root partition, then
 			 * we really create it under /usr which is likely to have more space.
 			 * But we create a symlink from cnf->home -> "/usr" -> cnf->home
 			 */
 			if (strchr(cnf->home+1, '/') == NULL) {
 				strcpy(dbuf, "/usr");
 				strncat(dbuf, cnf->home, MAXPATHLEN-5);
 				if (mkdir(dbuf, _DEF_DIRMODE) != -1 || errno == EEXIST) {
 					chown(dbuf, 0, 0);
 					/*
 					 * Skip first "/" and create symlink:
 					 * /home -> usr/home
 					 */
 					symlink(dbuf+1, cnf->home);
 				}
 				/* If this falls, fall back to old method */
 			}
 			strlcpy(dbuf, cnf->home, sizeof(dbuf));
 			p = dbuf;
 			if (stat(dbuf, &st) == -1) {
 				while ((p = strchr(p + 1, '/')) != NULL) {
 					*p = '\0';
 					if (stat(dbuf, &st) == -1) {
 						if (mkdir(dbuf, _DEF_DIRMODE) == -1)
 							goto direrr;
 						chown(dbuf, 0, 0);
 					} else if (!S_ISDIR(st.st_mode))
 						errx(EX_OSFILE, "'%s' (root home parent) is not a directory", dbuf);
 					*p = '/';
 				}
 			}
 			if (stat(dbuf, &st) == -1) {
 				if (mkdir(dbuf, _DEF_DIRMODE) == -1) {
 				direrr:	err(EX_OSFILE, "mkdir '%s'", dbuf);
 				}
 				chown(dbuf, 0, 0);
 			}
 		} else if (!S_ISDIR(st.st_mode))
 			errx(EX_OSFILE, "root home `%s' is not a directory", cnf->home);
 	}
 
 	if ((arg = getarg(args, 'e')) != NULL)
 		cnf->expire_days = atoi(arg->val);
 
 	if ((arg = getarg(args, 'y')) != NULL)
 		cnf->nispasswd = arg->val;
 
 	if ((arg = getarg(args, 'p')) != NULL && arg->val)
 		cnf->password_days = atoi(arg->val);
 
 	if ((arg = getarg(args, 'g')) != NULL) {
 		if (!*(p = arg->val))	/* Handle empty group list specially */
 			cnf->default_group = "";
 		else {
 			if ((grp = GETGRNAM(p)) == NULL) {
 				if (!isdigit((unsigned char)*p) || (grp = GETGRGID((gid_t) atoi(p))) == NULL)
 					errx(EX_NOUSER, "group `%s' does not exist", p);
 			}
 			cnf->default_group = newstr(grp->gr_name);
 		}
 	}
 	if ((arg = getarg(args, 'L')) != NULL)
 		cnf->default_class = pw_checkname((u_char *)arg->val, 0);
 
 	if ((arg = getarg(args, 'G')) != NULL && arg->val) {
 		int i = 0;
 
 		for (p = strtok(arg->val, ", \t"); p != NULL; p = strtok(NULL, ", \t")) {
 			if ((grp = GETGRNAM(p)) == NULL) {
 				if (!isdigit((unsigned char)*p) || (grp = GETGRGID((gid_t) atoi(p))) == NULL)
 					errx(EX_NOUSER, "group `%s' does not exist", p);
 			}
 			if (extendarray(&cnf->groups, &cnf->numgroups, i + 2) != -1)
 				cnf->groups[i++] = newstr(grp->gr_name);
 		}
 		while (i < cnf->numgroups)
 			cnf->groups[i++] = NULL;
 	}
 
 	if ((arg = getarg(args, 'k')) != NULL) {
 		if (stat(cnf->dotdir = arg->val, &st) == -1 || !S_ISDIR(st.st_mode))
 			errx(EX_OSFILE, "skeleton `%s' is not a directory or does not exist", cnf->dotdir);
 	}
 
 	if ((arg = getarg(args, 's')) != NULL)
 		cnf->shell_default = arg->val;
 
 	if ((arg = getarg(args, 'w')) != NULL)
 		cnf->default_password = boolean_val(arg->val, cnf->default_password);
 	if (mode == M_ADD && getarg(args, 'D')) {
 		if (getarg(args, 'n') != NULL)
 			errx(EX_DATAERR, "can't combine `-D' with `-n name'");
 		if ((arg = getarg(args, 'u')) != NULL && (p = strtok(arg->val, ", \t")) != NULL) {
 			if ((cnf->min_uid = (uid_t) atoi(p)) == 0)
 				cnf->min_uid = 1000;
 			if ((p = strtok(NULL, " ,\t")) == NULL || (cnf->max_uid = (uid_t) atoi(p)) < cnf->min_uid)
 				cnf->max_uid = 32000;
 		}
 		if ((arg = getarg(args, 'i')) != NULL && (p = strtok(arg->val, ", \t")) != NULL) {
 			if ((cnf->min_gid = (gid_t) atoi(p)) == 0)
 				cnf->min_gid = 1000;
 			if ((p = strtok(NULL, " ,\t")) == NULL || (cnf->max_gid = (gid_t) atoi(p)) < cnf->min_gid)
 				cnf->max_gid = 32000;
 		}
 
 		arg = getarg(args, 'C');
 		if (write_userconfig(arg ? arg->val : NULL))
 			return EXIT_SUCCESS;
 		warn("config update");
 		return EX_IOERR;
 	}
 
 	if (mode == M_PRINT && getarg(args, 'a')) {
 		int             pretty = getarg(args, 'P') != NULL;
 		int		v7 = getarg(args, '7') != NULL;
 		SETPWENT();
 		while ((pwd = GETPWENT()) != NULL)
 			print_user(pwd, pretty, v7);
 		ENDPWENT();
 		return EXIT_SUCCESS;
 	}
 
 	if ((a_name = getarg(args, 'n')) != NULL)
 		pwd = GETPWNAM(pw_checkname((u_char *)a_name->val, 0));
 	a_uid = getarg(args, 'u');
 
 	if (a_uid == NULL) {
 		if (a_name == NULL)
 			errx(EX_DATAERR, "user name or id required");
 
 		/*
 		 * Determine whether 'n' switch is name or uid - we don't
 		 * really don't really care which we have, but we need to
 		 * know.
 		 */
 		if (mode != M_ADD && pwd == NULL
 		    && strspn(a_name->val, "0123456789") == strlen(a_name->val)
 		    && *a_name->val) {
 			(a_uid = a_name)->ch = 'u';
 			a_name = NULL;
 		}
 	} else {
-		const char *teststr = a_uid->val;
-		if (*teststr == '-')
-			teststr++;
-		if (strspn(teststr, "0123456789") != strlen(teststr))
+		if (strspn(a_uid->val, "0123456789") != strlen(a_uid->val))
 			errx(EX_USAGE, "-u expects a number");
 	}
 
 	/*
 	 * Update, delete & print require that the user exists
 	 */
 	if (mode == M_UPDATE || mode == M_DELETE ||
 	    mode == M_PRINT  || mode == M_LOCK   || mode == M_UNLOCK) {
 
 		if (a_name == NULL && pwd == NULL)	/* Try harder */
 			pwd = GETPWUID(atoi(a_uid->val));
 
 		if (pwd == NULL) {
 			if (mode == M_PRINT && getarg(args, 'F')) {
 				fakeuser.pw_name = a_name ? a_name->val : "nouser";
 				fakeuser.pw_uid = a_uid ? (uid_t) atol(a_uid->val) : -1;
 				return print_user(&fakeuser,
 						  getarg(args, 'P') != NULL,
 						  getarg(args, '7') != NULL);
 			}
 			if (a_name == NULL)
 				errx(EX_NOUSER, "no such uid `%s'", a_uid->val);
 			errx(EX_NOUSER, "no such user `%s'", a_name->val);
 		}
 
 		if (a_name == NULL)	/* May be needed later */
 			a_name = addarg(args, 'n', newstr(pwd->pw_name));
 
 		/*
 		 * The M_LOCK and M_UNLOCK functions simply add or remove
 		 * a "*LOCKED*" prefix from in front of the password to
 		 * prevent it decoding correctly, and therefore prevents
 		 * access. Of course, this only prevents access via
 		 * password authentication (not ssh, kerberos or any
 		 * other method that does not use the UNIX password) but
 		 * that is a known limitation.
 		 */
 
 		if (mode == M_LOCK) {
 			if (strncmp(pwd->pw_passwd, locked_str, sizeof(locked_str)-1) == 0)
 				errx(EX_DATAERR, "user '%s' is already locked", pwd->pw_name);
 			passtmp = malloc(strlen(pwd->pw_passwd) + sizeof(locked_str));
 			if (passtmp == NULL)	/* disaster */
 				errx(EX_UNAVAILABLE, "out of memory");
 			strcpy(passtmp, locked_str);
 			strcat(passtmp, pwd->pw_passwd);
 			pwd->pw_passwd = passtmp;
 			edited = 1;
 		} else if (mode == M_UNLOCK) {
 			if (strncmp(pwd->pw_passwd, locked_str, sizeof(locked_str)-1) != 0)
 				errx(EX_DATAERR, "user '%s' is not locked", pwd->pw_name);
 			pwd->pw_passwd += sizeof(locked_str)-1;
 			edited = 1;
 		} else if (mode == M_DELETE) {
 			/*
 			 * Handle deletions now
 			 */
 			char            file[MAXPATHLEN];
 			char            home[MAXPATHLEN];
 			uid_t           uid = pwd->pw_uid;
 			struct group    *gr;
 			char            grname[LOGNAMESIZE];
 
 			if (strcmp(pwd->pw_name, "root") == 0)
 				errx(EX_DATAERR, "cannot remove user 'root'");
 
 			if (!PWALTDIR()) {
 				/*
 				 * Remove opie record from /etc/opiekeys
 		        	 */
 
 				rmopie(pwd->pw_name);
 
 				/*
 				 * Remove crontabs
 				 */
 				snprintf(file, sizeof(file), "/var/cron/tabs/%s", pwd->pw_name);
 				if (access(file, F_OK) == 0) {
 					sprintf(file, "crontab -u %s -r", pwd->pw_name);
 					system(file);
 				}
 			}
 			/*
 			 * Save these for later, since contents of pwd may be
 			 * invalidated by deletion
 			 */
 			sprintf(file, "%s/%s", _PATH_MAILDIR, pwd->pw_name);
 			strlcpy(home, pwd->pw_dir, sizeof(home));
 			gr = GETGRGID(pwd->pw_gid);
 			if (gr != NULL)
 				strlcpy(grname, gr->gr_name, LOGNAMESIZE);
 			else
 				grname[0] = '\0';
 
 			rc = delpwent(pwd);
 			if (rc == -1)
 				err(EX_IOERR, "user '%s' does not exist", pwd->pw_name);
 			else if (rc != 0) {
 				warn("passwd update");
 				return EX_IOERR;
 			}
 
 			if (cnf->nispasswd && *cnf->nispasswd=='/') {
 				rc = delnispwent(cnf->nispasswd, a_name->val);
 				if (rc == -1)
 					warnx("WARNING: user '%s' does not exist in NIS passwd", pwd->pw_name);
 				else if (rc != 0)
 					warn("WARNING: NIS passwd update");
 				/* non-fatal */
 			}
 
 			grp = GETGRNAM(a_name->val);
 			if (grp != NULL &&
 			    (grp->gr_mem == NULL || *grp->gr_mem == NULL) &&
 			    strcmp(a_name->val, grname) == 0)
 				delgrent(GETGRNAM(a_name->val));
 			SETGRENT();
 			while ((grp = GETGRENT()) != NULL) {
 				int i, j;
 				char group[MAXLOGNAME];
 				if (grp->gr_mem != NULL) {
 					for (i = 0; grp->gr_mem[i] != NULL; i++) {
 						if (!strcmp(grp->gr_mem[i], a_name->val)) {
 							for (j = i; grp->gr_mem[j] != NULL; j++)
 								grp->gr_mem[j] = grp->gr_mem[j+1];
 							strlcpy(group, grp->gr_name, MAXLOGNAME);
 							chggrent(group, grp);
 						}
 					}
 				}
 			}
 			ENDGRENT();
 
 			pw_log(cnf, mode, W_USER, "%s(%ld) account removed", a_name->val, (long) uid);
 
 			if (!PWALTDIR()) {
 				/*
 				 * Remove mail file
 				 */
 				remove(file);
 
 				/*
 				 * Remove at jobs
 				 */
 				if (getpwuid(uid) == NULL)
 					rmat(uid);
 
 				/*
 				 * Remove home directory and contents
 				 */
 				if (getarg(args, 'r') != NULL && *home == '/' && getpwuid(uid) == NULL) {
 					if (stat(home, &st) != -1) {
 						rm_r(home, uid);
 						pw_log(cnf, mode, W_USER, "%s(%ld) home '%s' %sremoved",
 						       a_name->val, (long) uid, home,
 						       stat(home, &st) == -1 ? "" : "not completely ");
 					}
 				}
 			}
 			return EXIT_SUCCESS;
 		} else if (mode == M_PRINT)
 			return print_user(pwd,
 					  getarg(args, 'P') != NULL,
 					  getarg(args, '7') != NULL);
 
 		/*
 		 * The rest is edit code
 		 */
 		if ((arg = getarg(args, 'l')) != NULL) {
 			if (strcmp(pwd->pw_name, "root") == 0)
 				errx(EX_DATAERR, "can't rename `root' account");
 			pwd->pw_name = pw_checkname((u_char *)arg->val, 0);
 			edited = 1;
 		}
 
 		if ((arg = getarg(args, 'u')) != NULL && isdigit((unsigned char)*arg->val)) {
 			pwd->pw_uid = (uid_t) atol(arg->val);
 			edited = 1;
 			if (pwd->pw_uid != 0 && strcmp(pwd->pw_name, "root") == 0)
 				errx(EX_DATAERR, "can't change uid of `root' account");
 			if (pwd->pw_uid == 0 && strcmp(pwd->pw_name, "root") != 0)
 				warnx("WARNING: account `%s' will have a uid of 0 (superuser access!)", pwd->pw_name);
 		}
 
 		if ((arg = getarg(args, 'g')) != NULL && pwd->pw_uid != 0) {	/* Already checked this */
 			gid_t newgid = (gid_t) GETGRNAM(cnf->default_group)->gr_gid;
 			if (newgid != pwd->pw_gid) {
 				edited = 1;
 				pwd->pw_gid = newgid;
 			}
 		}
 
 		if ((arg = getarg(args, 'p')) != NULL) {
 			if (*arg->val == '\0' || strcmp(arg->val, "0") == 0) {
 				if (pwd->pw_change != 0) {
 					pwd->pw_change = 0;
 					edited = 1;
 				}
 			}
 			else {
 				time_t          now = time(NULL);
 				time_t          expire = parse_date(now, arg->val);
 
 				if (pwd->pw_change != expire) {
 					pwd->pw_change = expire;
 					edited = 1;
 				}
 			}
 		}
 
 		if ((arg = getarg(args, 'e')) != NULL) {
 			if (*arg->val == '\0' || strcmp(arg->val, "0") == 0) {
 				if (pwd->pw_expire != 0) {
 					pwd->pw_expire = 0;
 					edited = 1;
 				}
 			}
 			else {
 				time_t          now = time(NULL);
 				time_t          expire = parse_date(now, arg->val);
 
 				if (pwd->pw_expire != expire) {
 					pwd->pw_expire = expire;
 					edited = 1;
 				}
 			}
 		}
 
 		if ((arg = getarg(args, 's')) != NULL) {
 			char *shell = shell_path(cnf->shelldir, cnf->shells, arg->val);
 			if (shell == NULL)
 				shell = "";
 			if (strcmp(shell, pwd->pw_shell) != 0) {
 				pwd->pw_shell = shell;
 				edited = 1;
 			}
 		}
 
 		if (getarg(args, 'L')) {
 			if (cnf->default_class == NULL)
 				cnf->default_class = "";
 			if (strcmp(pwd->pw_class, cnf->default_class) != 0) {
 				pwd->pw_class = cnf->default_class;
 				edited = 1;
 			}
 		}
 
 		if ((arg  = getarg(args, 'd')) != NULL) {
 			if (strcmp(pwd->pw_dir, arg->val))
 				edited = 1;
 			if (stat(pwd->pw_dir = arg->val, &st) == -1) {
 				if (getarg(args, 'm') == NULL && strcmp(pwd->pw_dir, "/nonexistent") != 0)
 				  warnx("WARNING: home `%s' does not exist", pwd->pw_dir);
 			} else if (!S_ISDIR(st.st_mode))
 				warnx("WARNING: home `%s' is not a directory", pwd->pw_dir);
 		}
 
 		if ((arg = getarg(args, 'w')) != NULL &&
 		    getarg(args, 'h') == NULL && getarg(args, 'H') == NULL) {
 			login_cap_t *lc;
 
 			lc = login_getpwclass(pwd);
 			if (lc == NULL ||
 			    login_setcryptfmt(lc, "sha512", NULL) == NULL)
 				warn("setting crypt(3) format");
 			login_close(lc);
 			pwd->pw_passwd = pw_password(cnf, args, pwd->pw_name);
 			edited = 1;
 		}
 
 	} else {
 		login_cap_t *lc;
 
 		/*
 		 * Add code
 		 */
 
 		if (a_name == NULL)	/* Required */
 			errx(EX_DATAERR, "login name required");
 		else if ((pwd = GETPWNAM(a_name->val)) != NULL)	/* Exists */
 			errx(EX_DATAERR, "login name `%s' already exists", a_name->val);
 
 		/*
 		 * Now, set up defaults for a new user
 		 */
 		pwd = &fakeuser;
 		pwd->pw_name = a_name->val;
 		pwd->pw_class = cnf->default_class ? cnf->default_class : "";
 		pwd->pw_uid = pw_uidpolicy(cnf, args);
 		pwd->pw_gid = pw_gidpolicy(cnf, args, pwd->pw_name, (gid_t) pwd->pw_uid);
 		pwd->pw_change = pw_pwdpolicy(cnf, args);
 		pwd->pw_expire = pw_exppolicy(cnf, args);
 		pwd->pw_dir = pw_homepolicy(cnf, args, pwd->pw_name);
 		pwd->pw_shell = pw_shellpolicy(cnf, args, NULL);
 		lc = login_getpwclass(pwd);
 		if (lc == NULL || login_setcryptfmt(lc, "sha512", NULL) == NULL)
 			warn("setting crypt(3) format");
 		login_close(lc);
 		pwd->pw_passwd = pw_password(cnf, args, pwd->pw_name);
 		edited = 1;
 
 		if (pwd->pw_uid == 0 && strcmp(pwd->pw_name, "root") != 0)
 			warnx("WARNING: new account `%s' has a uid of 0 (superuser access!)", pwd->pw_name);
 	}
 
 	/*
 	 * Shared add/edit code
 	 */
 	if ((arg = getarg(args, 'c')) != NULL) {
 		char	*gecos = pw_checkname((u_char *)arg->val, 1);
 		if (strcmp(pwd->pw_gecos, gecos) != 0) {
 			pwd->pw_gecos = gecos;
 			edited = 1;
 		}
 	}
 
 	if ((arg = getarg(args, 'h')) != NULL ||
 	    (arg = getarg(args, 'H')) != NULL) {
 		if (strcmp(arg->val, "-") == 0) {
 			if (!pwd->pw_passwd || *pwd->pw_passwd != '*') {
 				pwd->pw_passwd = "*";	/* No access */
 				edited = 1;
 			}
 		} else {
 			int             fd = atoi(arg->val);
 			int		precrypt = (arg->ch == 'H');
 			int             b;
 			int             istty = isatty(fd);
 			struct termios  t;
 			login_cap_t	*lc;
 
 			if (istty) {
 				if (tcgetattr(fd, &t) == -1)
 					istty = 0;
 				else {
 					struct termios  n = t;
 
 					/* Disable echo */
 					n.c_lflag &= ~(ECHO);
 					tcsetattr(fd, TCSANOW, &n);
 					printf("%s%spassword for user %s:",
 					     (mode == M_UPDATE) ? "new " : "",
 					     precrypt ? "encrypted " : "",
 					     pwd->pw_name);
 					fflush(stdout);
 				}
 			}
 			b = read(fd, line, sizeof(line) - 1);
 			if (istty) {	/* Restore state */
 				tcsetattr(fd, TCSANOW, &t);
 				fputc('\n', stdout);
 				fflush(stdout);
 			}
 			if (b < 0) {
 				warn("-%c file descriptor", precrypt ? 'H' :
 				    'h');
 				return EX_IOERR;
 			}
 			line[b] = '\0';
 			if ((p = strpbrk(line, "\r\n")) != NULL)
 				*p = '\0';
 			if (!*line)
 				errx(EX_DATAERR, "empty password read on file descriptor %d", fd);
 			if (precrypt) {
 				if (strchr(line, ':') != NULL)
 					return EX_DATAERR;
 				pwd->pw_passwd = line;
 			} else {
 				lc = login_getpwclass(pwd);
 				if (lc == NULL ||
 				    login_setcryptfmt(lc, "sha512", NULL) == NULL)
 					warn("setting crypt(3) format");
 				login_close(lc);
 				pwd->pw_passwd = pw_pwcrypt(line);
 			}
 			edited = 1;
 		}
 	}
 
 	/*
 	 * Special case: -N only displays & exits
 	 */
 	if (getarg(args, 'N') != NULL)
 		return print_user(pwd,
 				  getarg(args, 'P') != NULL,
 				  getarg(args, '7') != NULL);
 
 	if (mode == M_ADD) {
 		edited = 1;	/* Always */
 		rc = addpwent(pwd);
 		if (rc == -1) {
 			warnx("user '%s' already exists", pwd->pw_name);
 			return EX_IOERR;
 		} else if (rc != 0) {
 			warn("passwd file update");
 			return EX_IOERR;
 		}
 		if (cnf->nispasswd && *cnf->nispasswd=='/') {
 			rc = addnispwent(cnf->nispasswd, pwd);
 			if (rc == -1)
 				warnx("User '%s' already exists in NIS passwd", pwd->pw_name);
 			else
 				warn("NIS passwd update");
 			/* NOTE: we treat NIS-only update errors as non-fatal */
 		}
 	} else if (mode == M_UPDATE || mode == M_LOCK || mode == M_UNLOCK) {
 		if (edited) {	/* Only updated this if required */
 			rc = chgpwent(a_name->val, pwd);
 			if (rc == -1) {
 				warnx("user '%s' does not exist (NIS?)", pwd->pw_name);
 				return EX_IOERR;
 			} else if (rc != 0) {
 				warn("passwd file update");
 				return EX_IOERR;
 			}
 			if ( cnf->nispasswd && *cnf->nispasswd=='/') {
 				rc = chgnispwent(cnf->nispasswd, a_name->val, pwd);
 				if (rc == -1)
 					warn("User '%s' not found in NIS passwd", pwd->pw_name);
 				else
 					warn("NIS passwd update");
 				/* NOTE: NIS-only update errors are not fatal */
 			}
 		}
 	}
 
 	/*
 	 * Ok, user is created or changed - now edit group file
 	 */
 
 	if (mode == M_ADD || getarg(args, 'G') != NULL) {
 		int i, j;
 		/* First remove the user from all group */
 		SETGRENT();
 		while ((grp = GETGRENT()) != NULL) {
 			char group[MAXLOGNAME];
 			if (grp->gr_mem == NULL)
 				continue;
 			for (i = 0; grp->gr_mem[i] != NULL; i++) {
 				if (strcmp(grp->gr_mem[i] , pwd->pw_name) != 0)
 					continue;
 				for (j = i; grp->gr_mem[j] != NULL ; j++)
 					grp->gr_mem[j] = grp->gr_mem[j+1];
 				strlcpy(group, grp->gr_name, MAXLOGNAME);
 				chggrent(group, grp);
 			}
 		}
 		ENDGRENT();
 
 		/* now add to group where needed */
 		for (i = 0; cnf->groups[i] != NULL; i++) {
 			grp = GETGRNAM(cnf->groups[i]);
 			grp = gr_add(grp, pwd->pw_name);
 			/*
 			 * grp can only be NULL in 2 cases:
 			 * - the new member is already a member
 			 * - a problem with memory occurs
 			 * in both cases we want to skip now.
 			 */
 			if (grp == NULL)
 				continue;
 			chggrent(cnf->groups[i], grp);
 			free(grp);
 		}
 	}
 
 
 	/* go get a current version of pwd */
 	pwd = GETPWNAM(a_name->val);
 	if (pwd == NULL) {
 		/* This will fail when we rename, so special case that */
 		if (mode == M_UPDATE && (arg = getarg(args, 'l')) != NULL) {
 			a_name->val = arg->val;		/* update new name */
 			pwd = GETPWNAM(a_name->val);	/* refetch renamed rec */
 		}
 	}
 	if (pwd == NULL)	/* can't go on without this */
 		errx(EX_NOUSER, "user '%s' disappeared during update", a_name->val);
 
 	grp = GETGRGID(pwd->pw_gid);
 	pw_log(cnf, mode, W_USER, "%s(%ld):%s(%ld):%s:%s:%s",
 	       pwd->pw_name, (long) pwd->pw_uid,
 	    grp ? grp->gr_name : "unknown", (long) (grp ? grp->gr_gid : -1),
 	       pwd->pw_gecos, pwd->pw_dir, pwd->pw_shell);
 
 	/*
 	 * If adding, let's touch and chown the user's mail file. This is not
 	 * strictly necessary under BSD with a 0755 maildir but it also
 	 * doesn't hurt anything to create the empty mailfile
 	 */
 	if (mode == M_ADD) {
 		if (!PWALTDIR()) {
 			sprintf(line, "%s/%s", _PATH_MAILDIR, pwd->pw_name);
 			close(open(line, O_RDWR | O_CREAT, 0600));	/* Preserve contents &
 									 * mtime */
 			chown(line, pwd->pw_uid, pwd->pw_gid);
 		}
 	}
 
 	/*
 	 * Let's create and populate the user's home directory. Note
 	 * that this also `works' for editing users if -m is used, but
 	 * existing files will *not* be overwritten.
 	 */
 	if (!PWALTDIR() && getarg(args, 'm') != NULL && pwd->pw_dir && *pwd->pw_dir == '/' && pwd->pw_dir[1]) {
 		copymkdir(pwd->pw_dir, cnf->dotdir, cnf->homemode, pwd->pw_uid, pwd->pw_gid);
 		pw_log(cnf, mode, W_USER, "%s(%ld) home %s made",
 		       pwd->pw_name, (long) pwd->pw_uid, pwd->pw_dir);
 	}
 
 
 	/*
 	 * Finally, send mail to the new user as well, if we are asked to
 	 */
 	if (mode == M_ADD && !PWALTDIR() && cnf->newmail && *cnf->newmail && (fp = fopen(cnf->newmail, "r")) != NULL) {
 		FILE           *pfp = popen(_PATH_SENDMAIL " -t", "w");
 		
 		if (pfp == NULL)
 			warn("sendmail");
 		else {
 			fprintf(pfp, "From: root\n" "To: %s\n" "Subject: Welcome!\n\n", pwd->pw_name);
 			while (fgets(line, sizeof(line), fp) != NULL) {
 				/* Do substitutions? */
 				fputs(line, pfp);
 			}
 			pclose(pfp);
 			pw_log(cnf, mode, W_USER, "%s(%ld) new user mail sent",
 			    pwd->pw_name, (long) pwd->pw_uid);
 		}
 		fclose(fp);
 	}
 
 	return EXIT_SUCCESS;
 }
 
 
 static          uid_t
 pw_uidpolicy(struct userconf * cnf, struct cargs * args)
 {
 	struct passwd  *pwd;
 	uid_t           uid = (uid_t) - 1;
 	struct carg    *a_uid = getarg(args, 'u');
 
 	/*
 	 * Check the given uid, if any
 	 */
 	if (a_uid != NULL) {
 		uid = (uid_t) atol(a_uid->val);
 
 		if ((pwd = GETPWUID(uid)) != NULL && getarg(args, 'o') == NULL)
 			errx(EX_DATAERR, "uid `%ld' has already been allocated", (long) pwd->pw_uid);
 	} else {
 		struct bitmap   bm;
 
 		/*
 		 * We need to allocate the next available uid under one of
 		 * two policies a) Grab the first unused uid b) Grab the
 		 * highest possible unused uid
 		 */
 		if (cnf->min_uid >= cnf->max_uid) {	/* Sanity
 							 * claus^H^H^H^Hheck */
 			cnf->min_uid = 1000;
 			cnf->max_uid = 32000;
 		}
 		bm = bm_alloc(cnf->max_uid - cnf->min_uid + 1);
 
 		/*
 		 * Now, let's fill the bitmap from the password file
 		 */
 		SETPWENT();
 		while ((pwd = GETPWENT()) != NULL)
 			if (pwd->pw_uid >= (uid_t) cnf->min_uid && pwd->pw_uid <= (uid_t) cnf->max_uid)
 				bm_setbit(&bm, pwd->pw_uid - cnf->min_uid);
 		ENDPWENT();
 
 		/*
 		 * Then apply the policy, with fallback to reuse if necessary
 		 */
 		if (cnf->reuse_uids || (uid = (uid_t) (bm_lastset(&bm) + cnf->min_uid + 1)) > cnf->max_uid)
 			uid = (uid_t) (bm_firstunset(&bm) + cnf->min_uid);
 
 		/*
 		 * Another sanity check
 		 */
 		if (uid < cnf->min_uid || uid > cnf->max_uid)
 			errx(EX_SOFTWARE, "unable to allocate a new uid - range fully used");
 		bm_dealloc(&bm);
 	}
 	return uid;
 }
 
 
 static          uid_t
 pw_gidpolicy(struct userconf * cnf, struct cargs * args, char *nam, gid_t prefer)
 {
 	struct group   *grp;
 	gid_t           gid = (uid_t) - 1;
 	struct carg    *a_gid = getarg(args, 'g');
 
 	/*
 	 * If no arg given, see if default can help out
 	 */
 	if (a_gid == NULL && cnf->default_group && *cnf->default_group)
 		a_gid = addarg(args, 'g', cnf->default_group);
 
 	/*
 	 * Check the given gid, if any
 	 */
 	SETGRENT();
 	if (a_gid != NULL) {
 		if ((grp = GETGRNAM(a_gid->val)) == NULL) {
 			gid = (gid_t) atol(a_gid->val);
 			if ((gid == 0 && !isdigit((unsigned char)*a_gid->val)) || (grp = GETGRGID(gid)) == NULL)
 				errx(EX_NOUSER, "group `%s' is not defined", a_gid->val);
 		}
 		gid = grp->gr_gid;
 	} else if ((grp = GETGRNAM(nam)) != NULL &&
 	    (grp->gr_mem == NULL || grp->gr_mem[0] == NULL)) {
 		gid = grp->gr_gid;  /* Already created? Use it anyway... */
 	} else {
 		struct cargs    grpargs;
 		char            tmp[32];
 
 		LIST_INIT(&grpargs);
 		addarg(&grpargs, 'n', nam);
 
 		/*
 		 * We need to auto-create a group with the user's name. We
 		 * can send all the appropriate output to our sister routine
 		 * bit first see if we can create a group with gid==uid so we
 		 * can keep the user and group ids in sync. We purposely do
 		 * NOT check the gid range if we can force the sync. If the
 		 * user's name dups an existing group, then the group add
 		 * function will happily handle that case for us and exit.
 		 */
 		if (GETGRGID(prefer) == NULL) {
 			sprintf(tmp, "%lu", (unsigned long) prefer);
 			addarg(&grpargs, 'g', tmp);
 		}
 		if (getarg(args, 'N'))
 		{
 			addarg(&grpargs, 'N', NULL);
 			addarg(&grpargs, 'q', NULL);
 			gid = pw_group(cnf, M_NEXT, &grpargs);
 		}
 		else
 		{
 			pw_group(cnf, M_ADD, &grpargs);
 			if ((grp = GETGRNAM(nam)) != NULL)
 				gid = grp->gr_gid;
 		}
 		a_gid = LIST_FIRST(&grpargs);
 		while (a_gid != NULL) {
 			struct carg    *t = LIST_NEXT(a_gid, list);
 			LIST_REMOVE(a_gid, list);
 			a_gid = t;
 		}
 	}
 	ENDGRENT();
 	return gid;
 }
 
 
 static          time_t
 pw_pwdpolicy(struct userconf * cnf, struct cargs * args)
 {
 	time_t          result = 0;
 	time_t          now = time(NULL);
 	struct carg    *arg = getarg(args, 'p');
 
 	if (arg != NULL) {
 		if ((result = parse_date(now, arg->val)) == now)
 			errx(EX_DATAERR, "invalid date/time `%s'", arg->val);
 	} else if (cnf->password_days > 0)
 		result = now + ((long) cnf->password_days * 86400L);
 	return result;
 }
 
 
 static          time_t
 pw_exppolicy(struct userconf * cnf, struct cargs * args)
 {
 	time_t          result = 0;
 	time_t          now = time(NULL);
 	struct carg    *arg = getarg(args, 'e');
 
 	if (arg != NULL) {
 		if ((result = parse_date(now, arg->val)) == now)
 			errx(EX_DATAERR, "invalid date/time `%s'", arg->val);
 	} else if (cnf->expire_days > 0)
 		result = now + ((long) cnf->expire_days * 86400L);
 	return result;
 }
 
 
 static char    *
 pw_homepolicy(struct userconf * cnf, struct cargs * args, char const * user)
 {
 	struct carg    *arg = getarg(args, 'd');
 
 	if (arg)
 		return arg->val;
 	else {
 		static char     home[128];
 
 		if (cnf->home == NULL || *cnf->home == '\0')
 			errx(EX_CONFIG, "no base home directory set");
 		sprintf(home, "%s/%s", cnf->home, user);
 		return home;
 	}
 }
 
 static char    *
 shell_path(char const * path, char *shells[], char *sh)
 {
 	if (sh != NULL && (*sh == '/' || *sh == '\0'))
 		return sh;	/* specified full path or forced none */
 	else {
 		char           *p;
 		char            paths[_UC_MAXLINE];
 
 		/*
 		 * We need to search paths
 		 */
 		strlcpy(paths, path, sizeof(paths));
 		for (p = strtok(paths, ": \t\r\n"); p != NULL; p = strtok(NULL, ": \t\r\n")) {
 			int             i;
 			static char     shellpath[256];
 
 			if (sh != NULL) {
 				sprintf(shellpath, "%s/%s", p, sh);
 				if (access(shellpath, X_OK) == 0)
 					return shellpath;
 			} else
 				for (i = 0; i < _UC_MAXSHELLS && shells[i] != NULL; i++) {
 					sprintf(shellpath, "%s/%s", p, shells[i]);
 					if (access(shellpath, X_OK) == 0)
 						return shellpath;
 				}
 		}
 		if (sh == NULL)
 			errx(EX_OSFILE, "can't find shell `%s' in shell paths", sh);
 		errx(EX_CONFIG, "no default shell available or defined");
 		return NULL;
 	}
 }
 
 
 static char    *
 pw_shellpolicy(struct userconf * cnf, struct cargs * args, char *newshell)
 {
 	char           *sh = newshell;
 	struct carg    *arg = getarg(args, 's');
 
 	if (newshell == NULL && arg != NULL)
 		sh = arg->val;
 	return shell_path(cnf->shelldir, cnf->shells, sh ? sh : cnf->shell_default);
 }
 
 #define	SALTSIZE	32
 
 static char const chars[] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ./";
 
 char           *
 pw_pwcrypt(char *password)
 {
 	int             i;
 	char            salt[SALTSIZE + 1];
 	char		*cryptpw;
 
 	static char     buf[256];
 
 	/*
 	 * Calculate a salt value
 	 */
 	for (i = 0; i < SALTSIZE; i++)
 		salt[i] = chars[arc4random_uniform(sizeof(chars) - 1)];
 	salt[SALTSIZE] = '\0';
 
 	cryptpw = crypt(password, salt);
 	if (cryptpw == NULL)
 		errx(EX_CONFIG, "crypt(3) failure");
 	return strcpy(buf, cryptpw);
 }
 
 
 static char    *
 pw_password(struct userconf * cnf, struct cargs * args, char const * user)
 {
 	int             i, l;
 	char            pwbuf[32];
 
 	switch (cnf->default_password) {
 	case -1:		/* Random password */
 		l = (arc4random() % 8 + 8);	/* 8 - 16 chars */
 		for (i = 0; i < l; i++)
 			pwbuf[i] = chars[arc4random_uniform(sizeof(chars)-1)];
 		pwbuf[i] = '\0';
 
 		/*
 		 * We give this information back to the user
 		 */
 		if (getarg(args, 'h') == NULL && getarg(args, 'H') == NULL &&
 		    getarg(args, 'N') == NULL) {
 			if (isatty(STDOUT_FILENO))
 				printf("Password for '%s' is: ", user);
 			printf("%s\n", pwbuf);
 			fflush(stdout);
 		}
 		break;
 
 	case -2:		/* No password at all! */
 		return "";
 
 	case 0:		/* No login - default */
 	default:
 		return "*";
 
 	case 1:		/* user's name */
 		strlcpy(pwbuf, user, sizeof(pwbuf));
 		break;
 	}
 	return pw_pwcrypt(pwbuf);
 }
 
 
 static int
 print_user(struct passwd * pwd, int pretty, int v7)
 {
 	if (!pretty) {
 		char            *buf;
 
 		if (!v7)
 			pwd->pw_passwd = (pwd->pw_passwd == NULL) ? "" : "*";
 
 		buf = v7 ? pw_make_v7(pwd) : pw_make(pwd);
 		printf("%s\n", buf);
 		free(buf);
 	} else {
 		int		j;
 		char           *p;
 		struct group   *grp = GETGRGID(pwd->pw_gid);
 		char            uname[60] = "User &", office[60] = "[None]",
 		                wphone[60] = "[None]", hphone[60] = "[None]";
 		char		acexpire[32] = "[None]", pwexpire[32] = "[None]";
 		struct tm *    tptr;
 
 		if ((p = strtok(pwd->pw_gecos, ",")) != NULL) {
 			strlcpy(uname, p, sizeof(uname));
 			if ((p = strtok(NULL, ",")) != NULL) {
 				strlcpy(office, p, sizeof(office));
 				if ((p = strtok(NULL, ",")) != NULL) {
 					strlcpy(wphone, p, sizeof(wphone));
 					if ((p = strtok(NULL, "")) != NULL) {
 						strlcpy(hphone, p,
 						    sizeof(hphone));
 					}
 				}
 			}
 		}
 		/*
 		 * Handle '&' in gecos field
 		 */
 		if ((p = strchr(uname, '&')) != NULL) {
 			int             l = strlen(pwd->pw_name);
 			int             m = strlen(p);
 
 			memmove(p + l, p + 1, m);
 			memmove(p, pwd->pw_name, l);
 			*p = (char) toupper((unsigned char)*p);
 		}
 		if (pwd->pw_expire > (time_t)0 && (tptr = localtime(&pwd->pw_expire)) != NULL)
 			strftime(acexpire, sizeof acexpire, "%c", tptr);
 		if (pwd->pw_change > (time_t)0 && (tptr = localtime(&pwd->pw_change)) != NULL)
 			strftime(pwexpire, sizeof pwexpire, "%c", tptr);
 		printf("Login Name: %-15s   #%-12ld Group: %-15s   #%ld\n"
 		       " Full Name: %s\n"
 		       "      Home: %-26.26s      Class: %s\n"
 		       "     Shell: %-26.26s     Office: %s\n"
 		       "Work Phone: %-26.26s Home Phone: %s\n"
 		       "Acc Expire: %-26.26s Pwd Expire: %s\n",
 		       pwd->pw_name, (long) pwd->pw_uid,
 		       grp ? grp->gr_name : "(invalid)", (long) pwd->pw_gid,
 		       uname, pwd->pw_dir, pwd->pw_class,
 		       pwd->pw_shell, office, wphone, hphone,
 		       acexpire, pwexpire);
 	        SETGRENT();
 		j = 0;
 		while ((grp=GETGRENT()) != NULL)
 		{
 			int     i = 0;
 			if (grp->gr_mem != NULL) {
 				while (grp->gr_mem[i] != NULL)
 				{
 					if (strcmp(grp->gr_mem[i], pwd->pw_name)==0)
 					{
 						printf(j++ == 0 ? "    Groups: %s" : ",%s", grp->gr_name);
 						break;
 					}
 					++i;
 				}
 			}
 		}
 		ENDGRENT();
 		printf("%s", j ? "\n" : "");
 	}
 	return EXIT_SUCCESS;
 }
 
 char    *
 pw_checkname(u_char *name, int gecos)
 {
 	char showch[8];
 	u_char const *badchars, *ch, *showtype;
 	int reject;
 
 	ch = name;
 	reject = 0;
 	if (gecos) {
 		/* See if the name is valid as a gecos (comment) field. */
 		badchars = ":!@";
 		showtype = "gecos field";
 	} else {
 		/* See if the name is valid as a userid or group. */
 		badchars = " ,\t:+&#%$^()!@~*?<>=|\\/\"";
 		showtype = "userid/group name";
 		/* Userids and groups can not have a leading '-'. */
 		if (*ch == '-')
 			reject = 1;
 	}
 	if (!reject) {
 		while (*ch) {
 			if (strchr(badchars, *ch) != NULL || *ch < ' ' ||
 			    *ch == 127) {
 				reject = 1;
 				break;
 			}
 			/* 8-bit characters are only allowed in GECOS fields */
 			if (!gecos && (*ch & 0x80)) {
 				reject = 1;
 				break;
 			}
 			ch++;
 		}
 	}
 	/*
 	 * A `$' is allowed as the final character for userids and groups,
 	 * mainly for the benefit of samba.
 	 */
 	if (reject && !gecos) {
 		if (*ch == '$' && *(ch + 1) == '\0') {
 			reject = 0;
 			ch++;
 		}
 	}
 	if (reject) {
 		snprintf(showch, sizeof(showch), (*ch >= ' ' && *ch < 127)
 		    ? "`%c'" : "0x%02x", *ch);
 		errx(EX_DATAERR, "invalid character %s at position %td in %s",
 		    showch, (ch - name), showtype);
 	}
 	if (!gecos && (ch - name) > LOGNAMESIZE)
 		errx(EX_DATAERR, "name too long `%s' (max is %d)", name,
 		    LOGNAMESIZE);
 	return (char *)name;
 }
 
 
 static void
 rmat(uid_t uid)
 {
 	DIR            *d = opendir("/var/at/jobs");
 
 	if (d != NULL) {
 		struct dirent  *e;
 
 		while ((e = readdir(d)) != NULL) {
 			struct stat     st;
 
 			if (strncmp(e->d_name, ".lock", 5) != 0 &&
 			    stat(e->d_name, &st) == 0 &&
 			    !S_ISDIR(st.st_mode) &&
 			    st.st_uid == uid) {
 				char            tmp[MAXPATHLEN];
 
 				sprintf(tmp, "/usr/bin/atrm %s", e->d_name);
 				system(tmp);
 			}
 		}
 		closedir(d);
 	}
 }
 
 static void
 rmopie(char const * name)
 {
 	static const char etcopie[] = "/etc/opiekeys";
 	FILE   *fp = fopen(etcopie, "r+");
 
 	if (fp != NULL) {
 		char	tmp[1024];
 		off_t	atofs = 0;
 		int	length = strlen(name);
 
 		while (fgets(tmp, sizeof tmp, fp) != NULL) {
 			if (strncmp(name, tmp, length) == 0 && tmp[length]==' ') {
 				if (fseek(fp, atofs, SEEK_SET) == 0) {
 					fwrite("#", 1, 1, fp);	/* Comment username out */
 				}
 				break;
 			}
 			atofs = ftell(fp);
 		}
 		/*
 		 * If we got an error of any sort, don't update!
 		 */
 		fclose(fp);
 	}
 }
 
Index: projects/clang360-import/usr.sbin/pw/tests/pw_usershow.sh
===================================================================
--- projects/clang360-import/usr.sbin/pw/tests/pw_usershow.sh	(revision 277777)
+++ projects/clang360-import/usr.sbin/pw/tests/pw_usershow.sh	(nonexistent)
@@ -1,19 +0,0 @@
-# $FreeBSD$
-
-# Import helper functions
-. $(atf_get_srcdir)/helper_functions.shin
-
-
-# Test negative uid are still valid
-# PR: 196514
-atf_test_case show_user_with_negative_number
-show_user_with_negative_number_body() {
-	populate_etc_skel
-	atf_check -s exit:0 \
-		-o inline:"root:*:0:0::0:0:Charlie &:/root:/bin/csh\n" \
-		${PW} usershow -n root -u -1
-}
-
-atf_init_test_cases() {
-	atf_add_test_case show_user_with_negative_number
-}

Property changes on: projects/clang360-import/usr.sbin/pw/tests/pw_usershow.sh
___________________________________________________________________
Deleted: svn:eol-style
## -1 +0,0 ##
-native
\ No newline at end of property
Deleted: svn:executable
## -1 +0,0 ##
-*
\ No newline at end of property
Deleted: svn:keywords
## -1 +0,0 ##
-FreeBSD=%H
\ No newline at end of property
Deleted: svn:mime-type
## -1 +0,0 ##
-text/plain
\ No newline at end of property
Index: projects/clang360-import/usr.sbin/pw/tests/pw_groupshow.sh
===================================================================
--- projects/clang360-import/usr.sbin/pw/tests/pw_groupshow.sh	(revision 277777)
+++ projects/clang360-import/usr.sbin/pw/tests/pw_groupshow.sh	(nonexistent)
@@ -1,19 +0,0 @@
-# $FreeBSD$
-
-# Import helper functions
-. $(atf_get_srcdir)/helper_functions.shin
-
-
-# Test negative uid are still valid
-# PR: 196514
-atf_test_case show_group_with_negative_number
-show_group_with_negative_number_body() {
-	populate_etc_skel
-	atf_check -s exit:0 \
-		-o inline:"wheel:*:0:root\n" \
-		${PW} groupshow -n wheel -g -1
-}
-
-atf_init_test_cases() {
-	atf_add_test_case show_group_with_negative_number
-}

Property changes on: projects/clang360-import/usr.sbin/pw/tests/pw_groupshow.sh
___________________________________________________________________
Deleted: svn:eol-style
## -1 +0,0 ##
-native
\ No newline at end of property
Deleted: svn:executable
## -1 +0,0 ##
-*
\ No newline at end of property
Deleted: svn:keywords
## -1 +0,0 ##
-FreeBSD=%H
\ No newline at end of property
Deleted: svn:mime-type
## -1 +0,0 ##
-text/plain
\ No newline at end of property
Index: projects/clang360-import/usr.sbin/pw/tests/Makefile
===================================================================
--- projects/clang360-import/usr.sbin/pw/tests/Makefile	(revision 277777)
+++ projects/clang360-import/usr.sbin/pw/tests/Makefile	(revision 277778)
@@ -1,33 +1,31 @@
 # $FreeBSD$
 
 TESTSRC=	${.CURDIR}/../../../contrib/netbsd-tests/usr.sbin/useradd
 .PATH: ${TESTSRC}
 
 TESTSDIR=	${TESTSBASE}/usr.sbin/pw
 
 ATF_TESTS_SH=	pw_etcdir \
 		pw_lock \
 		pw_groupdel \
 		pw_groupmod \
-		pw_groupshow \
 		pw_useradd \
 		pw_userdel \
-		pw_usermod \
-		pw_usershow
+		pw_usermod
 
 .for tp in ${ATF_TESTS_SH}
 TEST_METADATA.${tp}+=	required_user="root"
 .endfor
 
 FILES=		group helper_functions.shin master.passwd
 FILESDIR=       ${TESTSDIR}
 
 ATF_TESTS_SH+=	pw_test
 # - user{add,del} does not exist on FreeBSD; use pw user{add,del} instead
 # - The command passes on FreeBSD
 ATF_TESTS_SH_SED_pw_test=	-e 's/useradd /pw useradd /'
 ATF_TESTS_SH_SED_pw_test+=	-e 's/userdel /pw userdel /'
 ATF_TESTS_SH_SED_pw_test+=	-e '/atf_expect_fail "PR bin\/39546"/d'
 ATF_TESTS_SH_SRC_pw_test=	t_useradd.sh
 
 .include <bsd.test.mk>
Index: projects/clang360-import
===================================================================
--- projects/clang360-import	(revision 277777)
+++ projects/clang360-import	(revision 277778)

Property changes on: projects/clang360-import
___________________________________________________________________
Modified: svn:mergeinfo
## -0,0 +0,1 ##
   Merged /head:r277719-277776