[Driver] Sync ARM behavior between clang-as and gas.

[danalbert]

Summary

The ARM gas driver previously enabled NEON for ARMv7 and up, and a
handful of other extensions for ARMv8 and up (although only if the
architecture version was a part of the triple; the -march flag was
not honored). Neither of these are actually guaranteed, and the
behavior does not match the integrated assembler.

Note that I've elected to always pass an explicit -march flag to gas
if the user has not specified one. I'm not certain if Clang's default
ARM version matches GNU's, so being explicit allows us to keep the
same behavior if that isn't the case. This also makes it clear that
the correct architecture is passed to gas based on -mcpu.

[peter.smith]

My main concern is that this changes the default behaviour for arm-linux-gnueabi and arm-linux-gnueabihf targets. I've put some suggestions on what I think the behaviour should be.

clang/lib/Driver/ToolChains/Arch/ARM.cpp

277

I'm a bit worried that we've changed the default behaviour for gnueabi[hf] targets here.
For example with:

.text
vmov.32 d13[1], r6 ; Needs VFPv2
vadd.i32 d0, d0, d0 ; Needs Neon

I get with --target=armv7a-linux (no environment, -mfloat-abi will disable floating point, and neon)

clang: warning: unknown platform, assuming -mfloat-abi=soft
neon.s:2:9: error: instruction requires: VFP2
        vmov.32 d13[1],r6
        ^
neon.s:3:9: error: instruction requires: NEON
        vadd.i32 d0, d0, d0
        ^

With the target=armv7a-linux-gnueabi armv7a-linux-gnueabihf or explicitly adding -mfloat-abi=softfp the integrated assembler will happily assemble it.
GNU needs -mfpu=neon to assemble the file:

arm-linux-gnueabihf-as -march=armv7-a neon.s 
neon.s: Assembler messages:
neon.s:2: Error: selected processor does not support ARM mode `vmov.32 d13[1],r6'
neon.s:3: Error: selected processor does not support ARM mode `vadd.i32 d0,d0,d0'

It is a similar story for armv8 and crypto.

I think we should have something like:

if (Triple.isLinux() && getARMSubArchVersionNumber(Triple) >= 8)
   return "crypto-neon-fp-armv8";
if (Triple.isAndroid() || Triple.isLinux() && getARMSubArchVersionNumber(Triple) >= 7)
    return "neon";
return "";

389

I'm wondering whether you need this bit of code anymore? In D53121 there needed to be a switch between vfpv3-d16 and neon based on Android version. With --target=armv7a-linux-android or --target=arm-linux-android -march=armv7a or any v7a -mcpu applicable to Android then you'll get feature Neon by default and won't need to do this? We could then move getDefaultFPUName out of ARM.cpp

clang/lib/Driver/ToolChains/Gnu.cpp

692

I think we'd not want to do this for -mfloat-abi=soft as this disables the FPU in the integrated assembler. It seems like -mfloat-abi has no effect at all on the gnu assembler, it will happily assemble neon instructions with -mfloat-abi=soft -mfpu=neon.

clang/test/Driver/linux-as.c

3

the target arm-linux (effectively arm-linux-unknown) defaults to -mfloat-abi=soft which disables the FPU for the integrated assembler. While these test cases are not wrong, the number of v7a + linux targets without an FPU using entirely software floating point is likely to be very small. We should have some more that have arm-linux-gnueabi and arm-linux-gnueabihf.

[danalbert]

Updated to address some review comments:

• Additional tests for gnueabi/gnueabihf
• Fixed behavior for -mfpu=neon -mfloat-abi=soft, added test.

[danalbert]

clang/lib/Driver/ToolChains/Arch/ARM.cpp

277

I suppose it depends on which direction you want the behavior change to go. I assumed those samples _shouldn't_ assemble since they're not enabling NEON. The fact that the direct arm-linux-gnueabihf-as doesn't enable NEON by default makes me assume that NEON is not an assumed feature of the gnueabihf environment.

It's not up to me whether NEON is available by default for ARMv7 for non-Android, but I do think that the behavior should be consistent regardless of the assembler being used. Right now we have no FPU by default with the integrated assembler and NEON by default with GAS. This change makes GAS have the same behavior as the integrated assembler, since I assume that is the better traveled path and afaict is the one that has had more effort put in to it.

If that's not right, I can change this so that the integrated assembler _also_ gets FPU features that are not necessarily available for the given architecture, but I wanted to clarify that that is what you're asking for first.

389

I don't understand. This bit of code is the piece that provides the NEON default. If I remove this then Android ARMv7 targets revert to no FPU features.

clang/lib/Driver/ToolChains/Gnu.cpp

692

Added a check for soft float ABI and added a test to match.

clang/test/Driver/linux-as.c

3

Added a handful. Not really sure what needs to be tested here, but I covered the basic cases.

[peter.smith]

Thanks for the update. To summarise I'd like to keep the integrated and non-integrated assembler in synch for Linux like Android, even at the risk of adding an fpu when it isn't needed. I think that given how difficult it is to not use NEON, I think the mfloat-abi=soft guard you've put on will be sufficient. By the way, I'm hoping we aren't talking past each other with the default for armv7-a. I've tried to put as much of what I understand in the comments and I hope the answers make sense, or you'll be able to correct me where I'm wrong. If the timezone delayed comments aren't working well it may be worth finding me on IRC, I usually leave the office about 6:30pm but I can easily arrange a time and log on later if you wanted to discuss.

I also spotted something else on line 251 of ARM.cpp with respect to Android that might be worth looking at. I've left a comment although it isn't related to this patch.

clang/lib/Driver/ToolChains/Arch/ARM.cpp

251

Not strictly related to this patch, but you'll probably want to make that (SubArch >= 7), I tried --target=armv8a-linux-android as an experiment and got my floating point support removed.

277

I suppose it depends on which direction you want the behavior change to go. I assumed those samples _shouldn't_ assemble since they're not enabling NEON. The fact that the direct arm-linux-gnueabihf-as doesn't enable NEON by default makes me assume that NEON is not an assumed feature of the gnueabihf environment.

It is true that LLVM and GNU have unfortunately chosen a different default for armv7-a and NEON and armv8-a and crypo. I agree that NEON is not an assumed feature of either a gnueabi or gnueabihf GCC toolchain. My understanding is that GNU chose to not include any extensions in the base architecture and LLVM chose the most common configuration for the default.

Right now we have no FPU by default with the integrated assembler and NEON by default with GAS. This change makes GAS have the same behavior as the integrated assembler, since I assume that is the better traveled path and afaict is the one that has had more effort put in to it.

Are you sure that we have no FPU by default with the integrated assembler for armv7-a and armv8-a? I've put an explanation in the next comment that explains how it gets set even when there is no +neon on the -cc1 or -cc1as command line.

If that's not right, I can change this so that the integrated assembler _also_ gets FPU features that are not necessarily available for the given architecture, but I wanted to clarify that that is what you're asking for first.

My personal view is that "clang -fintegrated-as <some options implying armv7-a or above> neon.s" should give the same result as "clang -fno-integrated-as <some options implying armv7-a or above> neon.s". My reasoning is that is the least surprising position for users, and doesn't change old behaviour. That view is arguable and the opposite is also logically consistent, maybe worth reaching out to some more reviewers to see what they think.

Right now I can't even find a way to disable neon in the integrated assembler apart from -mfloat-abi=soft so I'm not overly concerned about passing -mfpu=neon to GNU-as. FWIW the only link I could find for people not wanting neon was https://github.com/ldc-developers/ldc/issues/1752

Eventually when we support the recent gcc -march=name[+extension…] format in https://gcc.gnu.org/onlinedocs/gcc/ARM-Options.html then we'll need to revisit this.

389

My understanding is that adding the equivalent of -fpu=neon here has the effect of adding extra feature flags to the call to clang -cc1. I can observe the difference with -###. However when compiling these are then added back in by TargetInfo::CreateTargetInfo() by calls like initFeatureMap that take the default features from the target. When invoking -cc1as the createMCSubtargetInfo via a long chain of function calls will add the FeatureNEON bit for armv7-a unless the -neon feature has been cleared.

If I have it right I think the lack of floating point features in the clang -cc1 command line is not a problem as the defaults for armv7-a will put them in anyway unless they've been explicitly turned off via something like -mfloat-abi=soft. My information is based on reverse engineering the code so I could easily be missing something important though?

[danalbert]

clang/lib/Driver/ToolChains/Arch/ARM.cpp

251

I actually uploaded a fix for that yesterday: https://reviews.llvm.org/D58477

Didn't submit because I wanted to wait until I knew I'd be around to babysit build bots just in case.

389

Oh, I thought that the cc1 args were the full story. I'll need to do some more digging then to make sure that the behavior actually does match.

clang/lib/Driver/ToolChains/Arch/ARM.h

 
 FloatABI getARMFloatABI(const ToolChain &TC, const llvm::opt::ArgList &Args);
 ReadTPMode getReadTPMode(const ToolChain &TC, const llvm::opt::ArgList &Args);
 
 bool useAAPCSForMachO(const llvm::Triple &T);
 void getARMArchCPUFromArgs(const llvm::opt::ArgList &Args,
                            llvm::StringRef &Arch, llvm::StringRef &CPU,
                            bool FromAs = false);
+std::string getDefaultFPUName(const llvm::Triple &Triple);
 void getARMTargetFeatures(const ToolChain &TC, const llvm::Triple &Triple,
                           const llvm::opt::ArgList &Args,
                           llvm::opt::ArgStringList &CmdArgs,
                           std::vector<llvm::StringRef> &Features, bool ForAS);
 int getARMSubArchVersionNumber(const llvm::Triple &Triple);
 bool isARMMProfile(const llvm::Triple &Triple);
 
 } // end namespace arm
 } // end namespace tools
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_ARCH_ARM_H

clang/lib/Driver/ToolChains/Arch/ARM.cpp

default:
         break;
       case llvm::Triple::GNUEABI:
       case llvm::Triple::MuslEABI:
       case llvm::Triple::EABI:
         // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
         ABI = FloatABI::SoftFP;
         break;
       case llvm::Triple::Android:
         ABI = (SubArch == 7) ? FloatABI::SoftFP : FloatABI::Soft;
         break;
       default:
         // Assume "soft", but warn the user we are guessing.
         if (Triple.isOSBinFormatMachO() &&
             Triple.getSubArch() == llvm::Triple::ARMSubArch_v7em)
           ABI = FloatABI::Hard;
         else
           ABI = FloatABI::Soft;
 
         if (Triple.getOS() != llvm::Triple::UnknownOS ||
             !Triple.isOSBinFormatMachO())
           D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
         break;
       }
     }
   }
 
   assert(ABI != FloatABI::Invalid && "must select an ABI");
   return ABI;
 }
 
+std::string arm::getDefaultFPUName(const llvm::Triple &Triple) {
+  if (Triple.isAndroid() && getARMSubArchVersionNumber(Triple) >= 7) {
+    return "neon";
+  }
+  return "";
+}
+
 void arm::getARMTargetFeatures(const ToolChain &TC,
                                const llvm::Triple &Triple,
                                const ArgList &Args,
                                ArgStringList &CmdArgs,
                                std::vector<StringRef> &Features,
                                bool ForAS) {
   const Driver &D = TC.getDriver();
 
void arm::getARMTargetFeatures(const ToolChain &TC,
   if (WaFPU) {
     if (FPUArg)
       D.Diag(clang::diag::warn_drv_unused_argument)
           << FPUArg->getAsString(Args);
     getARMFPUFeatures(D, WaFPU, Args, StringRef(WaFPU->getValue()).substr(6),
                       Features);
   } else if (FPUArg) {
     getARMFPUFeatures(D, FPUArg, Args, FPUArg->getValue(), Features);
-  } else if (Triple.isAndroid() && getARMSubArchVersionNumber(Triple) >= 7) {
-    const char *AndroidFPU = "neon";
-    if (!llvm::ARM::getFPUFeatures(llvm::ARM::parseFPU(AndroidFPU), Features))
+  } else {
+    std::string DefaultFPU = getDefaultFPUName(Triple);
+    if (DefaultFPU != "") {
+      if (!llvm::ARM::getFPUFeatures(llvm::ARM::parseFPU(DefaultFPU), Features))
         D.Diag(clang::diag::err_drv_clang_unsupported)
-          << std::string("-mfpu=") + AndroidFPU;
+            << std::string("-mfpu=") + DefaultFPU;
+    }
   }
 
   // Honor -mhwdiv=. ClangAs gives preference to -Wa,-mhwdiv=.
   const Arg *HDivArg = Args.getLastArg(options::OPT_mhwdiv_EQ);
   if (WaHDiv) {
     if (HDivArg)
       D.Diag(clang::diag::warn_drv_unused_argument)
           << HDivArg->getAsString(Args);

clang/lib/Driver/ToolChains/Gnu.cpp

if (CPUArg.equals_lower("krait"))
       CmdArgs.push_back("-mcpu=cortex-a15");
     else if(CPUArg.equals_lower("kryo"))
       CmdArgs.push_back("-mcpu=cortex-a57");
     else
       Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
   }
 }
 
+static bool hasMOrWaMArg(const ArgList &Args, const options::ID &Opt,
+                         const StringRef &AssemblerOpt) {
+  if (Args.getLastArg(Opt)) {
+    return true;
+  }
+
+  for (const Arg *A :
+       Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
+    StringRef Value = A->getValue();
+    if (Value.startswith(AssemblerOpt)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 void tools::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;
 
case llvm::Triple::sparcv9: {
     CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
     AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
     break;
   }
   case llvm::Triple::arm:
   case llvm::Triple::armeb:
   case llvm::Triple::thumb:
   case llvm::Triple::thumbeb: {
-    const llvm::Triple &Triple2 = getToolChain().getTriple();
-    CmdArgs.push_back(isArmBigEndian(Triple2, Args) ? "-EB" : "-EL");
-    switch (Triple2.getSubArch()) {
-    case llvm::Triple::ARMSubArch_v7:
-      CmdArgs.push_back("-mfpu=neon");
-      break;
-    case llvm::Triple::ARMSubArch_v8:
-      CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
-      break;
-    default:
-      break;
+    const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
+    CmdArgs.push_back(isArmBigEndian(Triple, Args) ? "-EB" : "-EL");
+    if (!hasMOrWaMArg(Args, options::OPT_march_EQ, "-march=")) {
+        CmdArgs.push_back(
+            Args.MakeArgString(std::string("-march=") + Triple.getArchName()));
+    }
+
+    arm::FloatABI FloatABI = arm::getARMFloatABI(getToolChain(), Args);
+    if (FloatABI != arm::FloatABI::Soft &&
+        !hasMOrWaMArg(Args, options::OPT_mfpu_EQ, "-mfpu=")) {
+      std::string DefaultFPU = arm::getDefaultFPUName(Triple);
+      if (DefaultFPU != "") {
+        CmdArgs.push_back(
+            Args.MakeArgString(std::string("-mfpu=") + DefaultFPU));
+      }
     }
 
-    switch (arm::getARMFloatABI(getToolChain(), Args)) {
+    switch (FloatABI) {
     case arm::FloatABI::Invalid: llvm_unreachable("must have an ABI!");
     case arm::FloatABI::Soft:
       CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=soft"));
       break;
     case arm::FloatABI::SoftFP:
       CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=softfp"));
       break;
     case arm::FloatABI::Hard:

clang/test/Driver/linux-as.c

 // Check passing options to the assembler for various linux targets.
 //
 // RUN: %clang -target arm-linux -### \
 // RUN:   -no-integrated-as -c %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=CHECK-ARM %s
-// CHECK-ARM: as{{(.exe)?}}" "-EL" "-mfloat-abi=soft"
+// CHECK-ARM: as{{(.exe)?}}" "-EL" "-march=armv4t" "-mfloat-abi=soft"
 //
 // RUN: %clang -target arm-linux -mcpu=cortex-a8 -### \
 // RUN:   -no-integrated-as -c %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=CHECK-ARM-MCPU %s
-// CHECK-ARM-MCPU: as{{(.exe)?}}" "-EL" "-mfloat-abi=soft" "-mcpu=cortex-a8"
+// CHECK-ARM-MCPU: as{{(.exe)?}}" "-EL" "-march=armv7" "-mfloat-abi=soft" "-mcpu=cortex-a8"
 //
 // RUN: %clang -target arm-linux -mfpu=neon -### \
 // RUN:   -no-integrated-as -c %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=CHECK-ARM-MFPU %s
-// CHECK-ARM-MFPU: as{{(.exe)?}}" "-EL" "-mfloat-abi=soft" "-mfpu=neon"
+// CHECK-ARM-MFPU: as{{(.exe)?}}" "-EL" "-march=armv4t" "-mfloat-abi=soft" "-mfpu=neon"
 //
 // RUN: %clang -target arm-linux -march=armv7-a -### \
 // RUN:   -no-integrated-as -c %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=CHECK-ARM-MARCH %s
 // CHECK-ARM-MARCH: as{{(.exe)?}}" "-EL" "-mfloat-abi=soft" "-march=armv7-a"
 //
 // RUN: %clang -target armeb-linux -mlittle-endian -mcpu=cortex-a8 -mfpu=neon -march=armv7-a -### \
 // RUN:   -no-integrated-as -c %s 2>&1 \

 //
 // RUN: %clang -target thumb-linux -mcpu=cortex-a8 -mfpu=neon -march=thumbebv7-a -mbig-endian -### \
 // RUN:   -no-integrated-as -c %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=CHECK-THUMBEB-ALL %s
 //
 // RUN: %clang -target armv7-linux -mcpu=cortex-a8 -### \
 // RUN:   -no-integrated-as -c %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=CHECK-ARM-TARGET %s
-// CHECK-ARM-TARGET: as{{(.exe)?}}" "-EL" "-mfpu=neon" "-mfloat-abi=soft" "-mcpu=cortex-a8"
+// CHECK-ARM-TARGET: as{{(.exe)?}}" "-EL" "-march=armv7" "-mfloat-abi=soft" "-mcpu=cortex-a8"
 //
 // RUN: %clang -target armebv7-linux -mcpu=cortex-a8 -### \
 // RUN:   -no-integrated-as -c %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=CHECK-ARMEB-TARGET %s
-// CHECK-ARMEB-TARGET: as{{(.exe)?}}" "-EB" "-mfpu=neon" "-mfloat-abi=soft" "-mcpu=cortex-a8"
+// CHECK-ARMEB-TARGET: as{{(.exe)?}}" "-EB" "-march=armebv7" "-mfloat-abi=soft" "-mcpu=cortex-a8"
 //
 // RUN: %clang -target thumbv7-linux -mcpu=cortex-a8 -### \
 // RUN:   -no-integrated-as -c %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=CHECK-THUMB-TARGET %s
-// CHECK-THUMB-TARGET: as{{(.exe)?}}" "-EL" "-mfpu=neon" "-mfloat-abi=soft" "-mcpu=cortex-a8"
+// CHECK-THUMB-TARGET: as{{(.exe)?}}" "-EL" "-march=armv7" "-mfloat-abi=soft" "-mcpu=cortex-a8"
 //
 // RUN: %clang -target thumbebv7-linux -mcpu=cortex-a8 -### \
 // RUN:   -no-integrated-as -c %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=CHECK-THUMBEB-TARGET %s
-// CHECK-THUMBEB-TARGET: as{{(.exe)?}}" "-EB" "-mfpu=neon" "-mfloat-abi=soft" "-mcpu=cortex-a8"
+// CHECK-THUMBEB-TARGET: as{{(.exe)?}}" "-EB" "-march=armebv7" "-mfloat-abi=soft" "-mcpu=cortex-a8"
 //
 // RUN: %clang -target armv8-linux -mcpu=cortex-a53 -### \
 // RUN:   -no-integrated-as -c %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=CHECK-ARM-TARGET-V8 %s
-// CHECK-ARM-TARGET-V8: as{{(.exe)?}}" "-EL" "-mfpu=crypto-neon-fp-armv8" "-mfloat-abi=soft" "-mcpu=cortex-a53"
+// CHECK-ARM-TARGET-V8: as{{(.exe)?}}" "-EL" "-march=armv8" "-mfloat-abi=soft" "-mcpu=cortex-a53"
 //
 // RUN: %clang -target armebv8-linux -mcpu=cortex-a53 -### \
 // RUN:   -no-integrated-as -c %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=CHECK-ARMEB-TARGET-V8 %s
-// CHECK-ARMEB-TARGET-V8: as{{(.exe)?}}" "-EB" "-mfpu=crypto-neon-fp-armv8" "-mfloat-abi=soft" "-mcpu=cortex-a53"
+// CHECK-ARMEB-TARGET-V8: as{{(.exe)?}}" "-EB" "-march=armebv8" "-mfloat-abi=soft" "-mcpu=cortex-a53"
 //
 // RUN: %clang -target thumbv8-linux -mcpu=cortex-a53 -### \
 // RUN:   -no-integrated-as -c %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=CHECK-THUMB-TARGET-V8 %s
-// CHECK-THUMB-TARGET-V8: as{{(.exe)?}}" "-EL" "-mfpu=crypto-neon-fp-armv8" "-mfloat-abi=soft" "-mcpu=cortex-a53"
+// CHECK-THUMB-TARGET-V8: as{{(.exe)?}}" "-EL" "-march=armv8" "-mfloat-abi=soft" "-mcpu=cortex-a53"
 //
 // RUN: %clang -target thumbebv8-linux -mcpu=cortex-a53 -### \
 // RUN:   -no-integrated-as -c %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=CHECK-THUMBEB-TARGET-V8 %s
-// CHECK-THUMBEB-TARGET-V8: as{{(.exe)?}}" "-EB" "-mfpu=crypto-neon-fp-armv8" "-mfloat-abi=soft" "-mcpu=cortex-a53"
+// CHECK-THUMBEB-TARGET-V8: as{{(.exe)?}}" "-EB" "-march=armebv8" "-mfloat-abi=soft" "-mcpu=cortex-a53"
 //
 // RUN: %clang -target arm-linux -mfloat-abi=hard -### \
 // RUN:   -no-integrated-as -c %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=CHECK-ARM-MFLOAT-ABI %s
-// CHECK-ARM-MFLOAT-ABI: as{{(.exe)?}}" "-EL" "-mfloat-abi=hard"
+// CHECK-ARM-MFLOAT-ABI: as{{(.exe)?}}" "-EL" "-march=armv4t" "-mfloat-abi=hard"
 //
-// RUN: %clang -target arm-linux-androideabi -### \
+// RUN: %clang -target arm-linux-androideabi16 -### \
 // RUN:   -no-integrated-as -c %s 2>&1 \
-// RUN:   | FileCheck -check-prefix=CHECK-ARM-ANDROID %s
-// CHECK-ARM-ANDROID: as{{(.exe)?}}" "-EL" "-mfloat-abi=soft"
+// RUN:   | FileCheck -check-prefix=CHECK-ARM5-ANDROID %s
+// CHECK-ARM5-ANDROID: as{{(.exe)?}}" "-EL" "-march=armv4t" "-mfloat-abi=soft"
 //
-// RUN: %clang -target arm-linux-androideabi -march=armv7-a -### \
+// RUN: %clang -target arm-linux-androideabi16 -march=armv7-a -### \
 // RUN:   -no-integrated-as -c %s 2>&1 \
-// RUN:   | FileCheck -check-prefix=CHECK-ARM-ANDROID-SOFTFP %s
-// CHECK-ARM-ANDROID-SOFTFP: as{{(.exe)?}}" "-EL" "-mfloat-abi=softfp" "-march=armv7-a"
+// RUN:   | FileCheck -check-prefix=CHECK-MARCH-ARM7-ANDROID %s
+// CHECK-MARCH-ARM7-ANDROID: as{{(.exe)?}}" "-EL" "-mfpu=neon" "-mfloat-abi=softfp" "-march=armv7-a"
+//
+// RUN: %clang -target armv7a-linux-androideabi16 -### \
+// RUN:   -no-integrated-as -c %s 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHECK-ARM7-ANDROID %s
+// CHECK-ARM7-ANDROID: as{{(.exe)?}}" "-EL" "-march=armv7" "-mfpu=neon" "-mfloat-abi=softfp"
+//
+// RUN: %clang -target armv7a-linux-androideabi16 -mfpu=vfp3-d16 -### \
+// RUN:   -no-integrated-as -c %s 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHECK-ARM7-ANDROID-MFPU %s
+// CHECK-ARM7-ANDROID-MFPU: as{{(.exe)?}}" "-EL" "-march=armv7" "-mfloat-abi=softfp" "-mfpu=vfp3-d16"
+//
+// RUN: %clang -target armv7a-linux-androideabi16 -mfloat-abi=soft -### \
+// RUN:   -no-integrated-as -c %s 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHECK-ARM7-SOFT-ANDROID %s
+// CHECK-ARM7-SOFT-ANDROID: as{{(.exe)?}}" "-EL" "-march=armv7" "-mfloat-abi=soft"
+//
+// RUN: %clang -target arm-linux-gnueabi -### \
+// RUN:   -no-integrated-as -c %s 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHECK-ARM-GNU %s
+// CHECK-ARM-GNU: as{{(.exe)?}}" "-EL" "-march=armv4t" "-mfloat-abi=softfp"
+//
+// RUN: %clang -target armv7a-linux-gnueabi -### \
+// RUN:   -no-integrated-as -c %s 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHECK-ARM7-GNU %s
+// CHECK-ARM7-GNU: as{{(.exe)?}}" "-EL" "-march=armv7" "-mfloat-abi=softfp"
+//
+// RUN: %clang -target arm-linux-gnueabihf -### \
+// RUN:   -no-integrated-as -c %s 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHECK-ARM-GNUHF %s
+// CHECK-ARM-GNUHF: as{{(.exe)?}}" "-EL" "-march=armv6kz" "-mfloat-abi=hard"
+//
+// RUN: %clang -target armv7a-linux-gnueabihf -### \
+// RUN:   -no-integrated-as -c %s 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHECK-ARM7-GNUHF %s
+// CHECK-ARM7-GNUHF: as{{(.exe)?}}" "-EL" "-march=armv7" "-mfloat-abi=hard"
 //
 // RUN: %clang -target arm-linux-eabi -mhard-float -### \
 // RUN:   -no-integrated-as -c %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=CHECK-ARM-HARDFP %s
-// CHECK-ARM-HARDFP: as{{(.exe)?}}" "-EL" "-mfloat-abi=hard"
+// CHECK-ARM-HARDFP: as{{(.exe)?}}" "-EL" "-march=armv4t" "-mfloat-abi=hard"
 //
 // RUN: %clang -target aarch64-linux-gnu -mcpu=cortex-a53 -### \
 // RUN:   -no-integrated-as -c %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=CHECK-ARM64-MCPU %s
 // CHECK-ARM64-MCPU: as{{(.exe)?}}" "-EL" "-mcpu=cortex-a53"
 //
 // RUN: %clang -target aarch64-linux-gnu -march=armv8-a -### \
 // RUN:   -no-integrated-as -c %s 2>&1 \