[ARM] Add Driver support for emitting the missing Tag_ABI_enum_size build attribute values

[labrinea]

Summary

The ABI for the ARM architecture describes four build attribute values for the size of enumeration types. Currently, Clang cannot instruct LLVM to emit the value 0 (use of enums is prohibited) and 3 (every enumeration visible across an ABI-complying interface contains a value needing 32 bits to encode). This patch adds the Driver flags '-fno-enums' and '-fabi-enums' to indicate the missing values. The build attribute values are passed to LLVM via metadata in the IR.

This patch depends on Emit the missing Tag_ABI_enum_size build attribute values.

[rengolin]

Hi Alexandros,

My interpretation of Tag_ABI_enum_size is that value 3 is that all enums are 32-bit and value 4 is that only those ABI-visible (ie. public interfaces) have to be 32-bits. This is similar to the other PCS tags.

So, the table is:

• 0: no enums
• 1: short enums
• 2: all 32-bit
• 3: public 32-bit

With the default being 2 in GCC.

My reading of your code here is that you assume short|abi = short, which doesn't match the table in the ABI.

lib/Basic/Targets.cpp

5407

Isn't ABIEnums 4? Shouldn't this be:

Opts.ShortEnums || !Opts.ABIEnums

Is it even valid to have ABIEnums && ShortEnums at the same time?

lib/Driver/Tools.cpp

5731

If this is true, why go the extra complexity of mapping all possible states? Why not just use one line:

Enum = Args.getLastArg(options::OPT_fno_enums, options::OPT_fshort_enums, options::OPT_fabi_enums);

and be done with it? Short and ABI are not compatible, it's either one or the other.

5741

This code is confusing and merging with each other. Please add some empty lines between them.

[labrinea]

lib/Basic/Targets.cpp

5407

My understanding is that ABIEnums requires 32-bit enums across an ABI-complying interface, but allows short enums outside of it. Therefore __ARM_SIZEOF_MINIMAL_ENUM could be any of 1 or 4.

ABIEnums && ShortEnums cannot be both set at the same time.

lib/Driver/Tools.cpp

5731

I don't like this complicated logic either but it can handle cases like:
-fshort-enums -fno-enums -fabi-enums -fno-abi-enums
where -fno-enums should win. I've added a test for this sequence (test/Driver/clang_f_opts.c, line 459)
The suggested logic would ignore '-fno-abi-enums', which is the last argument. If we are happy with rejecting all the preceding flags and keeping just the last one this would work:

Args.getLastArg(options::OPT_fno_enums, options::OPT_fshort_enums, options::OPT_fno_short_enums,
                options::OPT_fabi_enums, options::OPT_fno_abi_enums);

Alternatively an equally ugly logic that handles complicated sequences is:

if (Arg *Enum = Args.getLastArg(options::OPT_fno_enums,
             ShortEnums ? options::OPT_fshort_enums : options::OPT_INVALID,
               ABIEnums ? options::OPT_fabi_enums   : options::OPT_INVALID)) {

[rengolin]

lib/Basic/Targets.cpp

5407

If all four options are mutually exclusive, than they should be a single integer option, not multiple boolean ones.

lib/Driver/Tools.cpp

5731

I disagree. These are different flags controlling the same thing, so the last-option wins.

How does -ffast-math vs its internal options are handled? How is -O handled? Or the other ABI flags like vfp, hard-float?

Easier still, have a look at unsigned/signed char below. Last arg wins.

[rengolin]

How does GCC behave with those arguments?

Thinking back now, we may be required to follow, as the principle of least surprise has to hold.

[labrinea]

Your suggestion that if all four options are mutually exclusive, then they should be a single integer option, totally makes sense to me. We could use a single integer option and make the old boolean flags deprecated (i.e. map '-fshort-enums' and 'fno-short enums' to the new integer option). My concern is that we have to be GCC compatible. I will communicate this to the GNU community.

[labrinea]

Hi Renato, apologies for the long silence. Unfortunately this work is more complicated than I initially thought. We'll have to rethink about it thoroughly. I am going to abandon the patch for now. Thank you for reviewing this.

include/clang/Basic/DiagnosticSemaKinds.td

 def warn_ctor_parm_shadows_field:
   Warning<"constructor parameter %0 shadows the field %1 of %2">,
   InGroup<ShadowFieldInConstructor>, DefaultIgnore;
 def warn_modifying_shadowing_decl :
   Warning<"modifying constructor parameter %0 that shadows a "
           "field of %1">,
   InGroup<ShadowFieldInConstructorModified>, DefaultIgnore;
 
+def err_enums_not_permitted:
+  Error<"enumeration types are prohibited">;
+
 // C++ decomposition declarations
 def err_decomp_decl_context : Error<
   "decomposition declaration not permitted in this context">;
 def warn_cxx14_compat_decomp_decl : Warning<
   "decomposition declarations are incompatible with "
   "C++ standards before C++1z">, DefaultIgnore, InGroup<CXXPre1zCompat>;
 def ext_decomp_decl : ExtWarn<
   "decomposition declarations are a C++1z extension">, InGroup<CXX1z>;

include/clang/Basic/LangOptions.def

 BENIGN_LANGOPT(ObjCGCBitmapPrint , 1, 0, "printing of GC's bitmap layout for __weak/__strong ivars")
 
 BENIGN_LANGOPT(AccessControl     , 1, 1, "C++ access control")
 LANGOPT(CharIsSigned      , 1, 1, "signed char")
 LANGOPT(ShortWChar        , 1, 0, "unsigned short wchar_t")
 ENUM_LANGOPT(MSPointerToMemberRepresentationMethod, PragmaMSPointersToMembersKind, 2, PPTMK_BestCase, "member-pointer representation method")
 ENUM_LANGOPT(DefaultCallingConv, DefaultCallingConvention, 3, DCC_None, "default calling convention")
 
+LANGOPT(NoEnums           , 1, 0, "prohibit the use of enum types")
 LANGOPT(ShortEnums        , 1, 0, "short enum types")
+LANGOPT(ABIEnums          , 1, 0, "enums contain a value needing 32 bits to encode")
 
 LANGOPT(OpenCL            , 1, 0, "OpenCL")
 LANGOPT(OpenCLVersion     , 32, 0, "OpenCL version")
 LANGOPT(NativeHalfType    , 1, 0, "Native half type support")
 LANGOPT(NativeHalfArgsAndReturns, 1, 0, "Native half args and returns")
 LANGOPT(HalfArgsAndReturns, 1, 0, "half args and returns")
 LANGOPT(CUDA              , 1, 0, "CUDA")
 LANGOPT(OpenMP            , 32, 0, "OpenMP support and version of OpenMP (31, 40 or 45)")

include/clang/Driver/Options.td

 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_abi_enums : Flag<["-"], "fno-abi-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 fdiagnostics_absolute_paths : Flag<["-"], "fdiagnostics-absolute-paths">, Group<f_Group>,
   Flags<[CC1Option, CoreOption]>, HelpText<"Print absolute paths in diagnostics">;
 def fno_spell_checking : Flag<["-"], "fno-spell-checking">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Disable spell-checking">;

 def fprofile_arcs : Flag<["-"], "fprofile-arcs">, Group<f_Group>;
 def fno_profile_arcs : Flag<["-"], "fno-profile-arcs">, 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 fno_enums : Flag<["-"], "fno-enums">, Group<f_Group>, Flags<[CC1Option]>,
+  HelpText<"Disable enumeration types">;
 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 fabi_enums : Flag<["-"], "fabi-enums">, Group<f_Group>, Flags<[CC1Option]>,
+  HelpText<"All enums contain a value needing 32 bits to encode">;
 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]>;

lib/Basic/Targets.cpp

if ((FPU & NeonFPU) && !SoftFloat && ArchVersion >= 7) {
       // floating-point even when it is present in VFP.
       Builder.defineMacro("__ARM_NEON_FP",
                           "0x" + llvm::utohexstr(HW_FP & ~HW_FP_DP));
     }
 
     Builder.defineMacro("__ARM_SIZEOF_WCHAR_T",
                         Opts.ShortWChar ? "2" : "4");
 
+    if (!Opts.NoEnums)
       Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM",
-                        Opts.ShortEnums ? "1" : "4");
+                          Opts.ShortEnums || Opts.ABIEnums ? "1" : "4");
 
     if (ArchVersion >= 6 && CPUAttr != "6M" && CPUAttr != "8M_BASE") {
       Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
       Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
       Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
       Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
     }
 
void getTargetDefines(const LangOptions &Opts,
     Builder.defineMacro("__ARM_FP16_FORMAT_IEEE", "1");
     Builder.defineMacro("__ARM_FP16_ARGS", "1");
 
     if (Opts.UnsafeFPMath)
       Builder.defineMacro("__ARM_FP_FAST", "1");
 
     Builder.defineMacro("__ARM_SIZEOF_WCHAR_T", Opts.ShortWChar ? "2" : "4");
 
+    if (!Opts.NoEnums)
       Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM",
-                        Opts.ShortEnums ? "1" : "4");
+                          Opts.ShortEnums || Opts.ABIEnums ? "1" : "4");
 
     if (FPU == NeonMode) {
       Builder.defineMacro("__ARM_NEON", "1");
       // 64-bit NEON supports half, single and double precision operations.
       Builder.defineMacro("__ARM_NEON_FP", "0xE");
     }
 
     if (CRC)

lib/CodeGen/CodeGenModule.cpp

 #include "llvm/ADT/Triple.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/ProfileData/InstrProfReader.h"
+#include "llvm/Support/ARMBuildAttributes.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MD5.h"
 
 using namespace clang;
 using namespace CodeGen;
 
 static const char AnnotationSection[] = "llvm.metadata";
if (   Arch == llvm::Triple::arm
       || Arch == llvm::Triple::armeb
       || Arch == llvm::Triple::thumb
       || Arch == llvm::Triple::thumbeb) {
     // Width of wchar_t in bytes
     uint64_t WCharWidth =
         Context.getTypeSizeInChars(Context.getWideCharType()).getQuantity();
     getModule().addModuleFlag(llvm::Module::Error, "wchar_size", WCharWidth);
 
-    // The minimum width of an enum in bytes
-    uint64_t EnumWidth = Context.getLangOpts().ShortEnums ? 1 : 4;
-    getModule().addModuleFlag(llvm::Module::Error, "min_enum_size", EnumWidth);
+    // Generate a module flag which indicates the value of Tag_ABI_enum_size.
+    uint64_t EnumSizeBuildAttr;
+    if (Context.getLangOpts().NoEnums)
+      EnumSizeBuildAttr = llvm::ARMBuildAttrs::EnumProhibited;
+    else if (Context.getLangOpts().ShortEnums)
+      EnumSizeBuildAttr = llvm::ARMBuildAttrs::EnumSmallest;
+    else if (Context.getLangOpts().ABIEnums)
+      EnumSizeBuildAttr = llvm::ARMBuildAttrs::Enum32BitABI;
+    else
+      EnumSizeBuildAttr = llvm::ARMBuildAttrs::Enum32Bit;
+    getModule().addModuleFlag(llvm::Module::Error, "enumsize_buildattr",
+                              EnumSizeBuildAttr);
   }
 
   if (CodeGenOpts.SanitizeCfiCrossDso) {
     // Indicate that we want cross-DSO control flow integrity checks.
     getModule().addModuleFlag(llvm::Module::Override, "Cross-DSO CFI", 1);
   }
 
   if (LangOpts.CUDAIsDevice && getTriple().isNVPTX()) {

lib/Driver/Tools.cpp

 
   ToolChain::RTTIMode RTTIMode = getToolChain().getRTTIMode();
 
   if (KernelOrKext || (types::isCXX(InputType) &&
                        (RTTIMode == ToolChain::RM_DisabledExplicitly ||
                         RTTIMode == ToolChain::RM_DisabledImplicitly)))
     CmdArgs.push_back("-fno-rtti");
 
+  // -fshort-enums
+  bool ShortEnums = Args.hasFlag(options::OPT_fshort_enums,
+                                 options::OPT_fno_short_enums, false);
+  // -fabi-enums
+  bool ABIEnums = Args.hasFlag(options::OPT_fabi_enums,
+                               options::OPT_fno_abi_enums, false);
+
+  // The last of -fno-enums, -fshort-enums, -fabi-enums wins.
+  Arg *Enum;
+  if (ShortEnums && ABIEnums)
+    Enum = Args.getLastArg(options::OPT_fno_enums, options::OPT_fshort_enums,
+                           options::OPT_fabi_enums);
+  else if (ShortEnums)
+    Enum = Args.getLastArg(options::OPT_fno_enums, options::OPT_fshort_enums);
+  else if (ABIEnums)
+    Enum = Args.getLastArg(options::OPT_fno_enums, options::OPT_fabi_enums);
+  else
+    Enum = Args.getLastArg(options::OPT_fno_enums);
+  if (Enum) {
+    if (Enum->getOption().matches(options::OPT_fno_enums))
+      CmdArgs.push_back("-fno-enums");
+    else if (Enum->getOption().matches(options::OPT_fshort_enums))
+      CmdArgs.push_back("-fshort-enums");
+    else if (Enum->getOption().matches(options::OPT_fabi_enums))
+      CmdArgs.push_back("-fabi-enums");
+  } else if (getToolChain().getArch() == llvm::Triple::hexagon) {
     // -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 (Arg *A = Args.getLastArg(
           options::OPT_fsigned_char, options::OPT_fno_signed_char,
           options::OPT_funsigned_char, options::OPT_fno_unsigned_char)) {
     if (A->getOption().matches(options::OPT_funsigned_char) ||
         A->getOption().matches(options::OPT_fno_signed_char)) {
       CmdArgs.push_back("-fno-signed-char");

lib/Frontend/CompilerInvocation.cpp

#include "clang/Frontend/LangStandards.def"
   Opts.ModulesSearchAll = Opts.Modules &&
     !Args.hasArg(OPT_fno_modules_search_all) &&
     Args.hasArg(OPT_fmodules_search_all);
   Opts.ModulesErrorRecovery = !Args.hasArg(OPT_fno_modules_error_recovery);
   Opts.ImplicitModules = !Args.hasArg(OPT_fno_implicit_modules);
   Opts.CharIsSigned = Opts.OpenCL || !Args.hasArg(OPT_fno_signed_char);
   Opts.WChar = Opts.CPlusPlus && !Args.hasArg(OPT_fno_wchar);
   Opts.ShortWChar = Args.hasFlag(OPT_fshort_wchar, OPT_fno_short_wchar, false);
+  Opts.NoEnums = Args.hasArg(OPT_fno_enums);
   Opts.ShortEnums = Args.hasArg(OPT_fshort_enums);
+  Opts.ABIEnums = Args.hasArg(OPT_fabi_enums);
   Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
   Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
   if (!Opts.NoBuiltin)
     getAllNoBuiltinFuncValues(Args, Opts.NoBuiltinFuncs);
   Opts.NoMathBuiltin = Args.hasArg(OPT_fno_math_builtin);
   Opts.SizedDeallocation = Args.hasArg(OPT_fsized_deallocation);
   Opts.AlignedAllocation =
       Args.hasFlag(OPT_faligned_allocation, OPT_fno_aligned_allocation,

lib/Sema/SemaExpr.cpp

if (IDecl->getDefinition()) {
       D = IDecl->getDefinition();
       Result = D->getAvailability(Message);
     }
   }
 
   if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(D))
     if (Result == AR_Available) {
       const DeclContext *DC = ECD->getDeclContext();
-      if (const EnumDecl *TheEnumDecl = dyn_cast<EnumDecl>(DC))
+      if (const EnumDecl *TheEnumDecl = dyn_cast<EnumDecl>(DC)) {
+        if (getLangOpts().NoEnums)
+          Diag(TheEnumDecl->getLocation(), diag::err_enums_not_permitted);
         Result = TheEnumDecl->getAvailability(Message);
       }
+    }
 
   if (Result == AR_NotYetIntroduced) {
     // Don't do this for enums, they can't be redeclared.
     if (isa<EnumConstantDecl>(D) || isa<EnumDecl>(D))
       return AR_Available;
 
     bool Warn = !D->getAttr<AvailabilityAttr>()->isInherited();
     // Objective-C method declarations in categories are not modelled as

test/CodeGen/arm-metadata.c

 // RUN: %clang_cc1 -triple armv7a-linux-gnueabi -emit-llvm -o - %s | FileCheck -check-prefix=DEFAULT %s
+// RUN: %clang_cc1 -triple armv7a-linux-gnueabi -emit-llvm -o - %s -fno-enums | FileCheck -check-prefix=NO-ENUM %s
 // RUN: %clang_cc1 -triple armv7a-linux-gnueabi -emit-llvm -o - %s -fshort-enums | FileCheck -check-prefix=SHORT-ENUM %s
+// RUN: %clang_cc1 -triple armv7a-linux-gnueabi -emit-llvm -o - %s -fabi-enums | FileCheck -check-prefix=ABI-ENUM %s
 // RUN: %clang_cc1 -triple armv7a-linux-gnueabi -emit-llvm -o - %s -fshort-wchar | FileCheck -check-prefix=SHORT-WCHAR %s
 
 // DEFAULT:  !{{[0-9]+}} = !{i32 1, !"wchar_size", i32 4}
-// DEFAULT:   !{{[0-9]+}} = !{i32 1, !"min_enum_size", i32 4}
+// DEFAULT:   !{{[0-9]+}} = !{i32 1, !"enumsize_buildattr", i32 2}
 
 // SHORT-WCHAR: !{{[0-9]+}} = !{i32 1, !"wchar_size", i32 2}
-// SHORT-WCHAR:   !{{[0-9]+}} = !{i32 1, !"min_enum_size", i32 4}
+// SHORT-WCHAR:   !{{[0-9]+}} = !{i32 1, !"enumsize_buildattr", i32 2}
 
-// SHORT_ENUM:  !{{[0-9]+}} = !{i32 1, !"wchar_size", i32 4}
-// SHORT-ENUM:  !{{[0-9]+}} = !{i32 1, !"min_enum_size", i32 1}
+// NO-ENUM:  !{{[0-9]+}} = !{i32 1, !"enumsize_buildattr", i32 0}
+
+// SHORT-ENUM:  !{{[0-9]+}} = !{i32 1, !"wchar_size", i32 4}
+// SHORT-ENUM:  !{{[0-9]+}} = !{i32 1, !"enumsize_buildattr", i32 1}
+
+// ABI-ENUM:  !{{[0-9]+}} = !{i32 1, !"enumsize_buildattr", i32 3}

test/Driver/clang_f_opts.c

 // RUN:   | FileCheck --check-prefix=CHECK-NO-WARNING3 %s
 // CHECK-NO-WARNING3: optimization flag '-fprofile-correction' is not supported
 // CHECK-NO-WARNING3-NOT: argument unused
 // RUN: %clang -### -fprofile-correction -Wno-ignored-optimization-argument %s 2>&1 \
 // RUN:   | FileCheck --check-prefix=CHECK-NO-WARNING4 %s
 // CHECK-NO-WARNING4-NOT: not supported
 // CHECK-NO-WARNING4-NOT: argument unused
 
+// RUN: %clang -### -S -fno-enums %s 2>&1 | FileCheck -check-prefix=NOENUMS %s
+// NOENUMS: -fno-enums
+
+// RUN: %clang -### -S -fshort-enums %s 2>&1 | FileCheck -check-prefix=SHORTENUMS %s
+// SHORTENUMS: -fshort-enums
+
+// RUN: %clang -### -S -fabi-enums %s 2>&1 | FileCheck -check-prefix=ABIENUMS %s
+// ABIENUMS: -fabi-enums
+
+// RUN: %clang -### -S -fshort-enums -fno-enums -fabi-enums -fno-abi-enums %s 2>&1 | FileCheck -check-prefix=ENUMS %s
+// ENUMS: -fno-enums
+// ENUMS-NOT: -fabi-enums
+// ENUMS-NOT: -fshort-enums
+
 // RUN: %clang -### -S -fsigned-char %s 2>&1 | FileCheck -check-prefix=CHAR-SIGN1 %s
 // CHAR-SIGN1-NOT: -fno-signed-char
 
 // RUN: %clang -### -S -funsigned-char %s 2>&1 | FileCheck -check-prefix=CHAR-SIGN2 %s
 // CHAR-SIGN2: -fno-signed-char
 
 // RUN: %clang -### -S -fno-signed-char %s 2>&1 | FileCheck -check-prefix=CHAR-SIGN3 %s
 // CHAR-SIGN3: -fno-signed-char

test/Preprocessor/aarch64-target-features.c

 // CHECK: __ARM_FP16_ARGS 1
 // CHECK: __ARM_FP16_FORMAT_IEEE 1
 // CHECK-NOT: __ARM_FP_FAST 1
 // CHECK: __ARM_NEON 1
 // CHECK: __ARM_NEON_FP 0xE
 // CHECK: __ARM_PCS_AAPCS64 1
 // CHECK-NOT: __ARM_PCS 1
 // CHECK-NOT: __ARM_PCS_VFP 1
-// CHECK-NOT: __ARM_SIZEOF_MINIMAL_ENUM 1
+// CHECK: __ARM_SIZEOF_MINIMAL_ENUM 4
 // CHECK-NOT: __ARM_SIZEOF_WCHAR_T 2
 
 // RUN: %clang -target aarch64_be-eabi -x c -E -dM %s -o - | FileCheck %s -check-prefix CHECK-BIGENDIAN
 // CHECK-BIGENDIAN: __ARM_BIG_ENDIAN 1
 
 // RUN: %clang -target aarch64-none-linux-gnu -march=armv8-a+crypto -x c -E -dM %s -o - | FileCheck --check-prefix=CHECK-CRYPTO %s
 // RUN: %clang -target arm64-none-linux-gnu -march=armv8-a+crypto -x c -E -dM %s -o - | FileCheck --check-prefix=CHECK-CRYPTO %s
 // CHECK-CRYPTO: __ARM_FEATURE_CRYPTO 1

 // RUN: %clang -target aarch64-none-linux-gnu -ffast-math -x c -E -dM %s -o - | FileCheck --check-prefix=CHECK-FASTMATH %s
 // RUN: %clang -target arm64-none-linux-gnu -ffast-math -x c -E -dM %s -o - | FileCheck --check-prefix=CHECK-FASTMATH %s
 // CHECK-FASTMATH: __ARM_FP_FAST 1
 
 // RUN: %clang -target aarch64-none-linux-gnu -fshort-wchar -x c -E -dM %s -o - | FileCheck --check-prefix=CHECK-SHORTWCHAR %s
 // RUN: %clang -target arm64-none-linux-gnu -fshort-wchar -x c -E -dM %s -o - | FileCheck --check-prefix=CHECK-SHORTWCHAR %s
 // CHECK-SHORTWCHAR: __ARM_SIZEOF_WCHAR_T 2
 
+// RUN: %clang -target aarch64-none-linux-gnu -fno-enums -x c -E -dM %s -o - | FileCheck --check-prefix=CHECK-NOENUMS %s
+// RUN: %clang -target arm64-none-linux-gnu -fno-enums -x c -E -dM %s -o - | FileCheck --check-prefix=CHECK-NOENUMS %s
+// CHECK-NOENUMS-NOT: __ARM_SIZEOF_MINIMAL_ENUM
+
 // RUN: %clang -target aarch64-none-linux-gnu -fshort-enums -x c -E -dM %s -o - | FileCheck --check-prefix=CHECK-SHORTENUMS %s
 // RUN: %clang -target arm64-none-linux-gnu -fshort-enums -x c -E -dM %s -o - | FileCheck --check-prefix=CHECK-SHORTENUMS %s
 // CHECK-SHORTENUMS: __ARM_SIZEOF_MINIMAL_ENUM 1
 
+// RUN: %clang -target aarch64-none-linux-gnu -fabi-enums -x c -E -dM %s -o - | FileCheck --check-prefix=CHECK-ABIENUMS %s
+// RUN: %clang -target arm64-none-linux-gnu -fabi-enums -x c -E -dM %s -o - | FileCheck --check-prefix=CHECK-ABIENUMS %s
+// CHECK-ABIENUMS: __ARM_SIZEOF_MINIMAL_ENUM 1
+
 // RUN: %clang -target aarch64-none-linux-gnu -march=armv8-a+simd -x c -E -dM %s -o - | FileCheck --check-prefix=CHECK-NEON %s
 // RUN: %clang -target arm64-none-linux-gnu -march=armv8-a+simd -x c -E -dM %s -o - | FileCheck --check-prefix=CHECK-NEON %s
 // CHECK-NEON: __ARM_NEON 1
 // CHECK-NEON: __ARM_NEON_FP 0xE
 
 // RUN: %clang -target aarch64-none-eabi -march=armv8.1-a -x c -E -dM %s -o - | FileCheck --check-prefix=CHECK-V81A %s
 // CHECK-V81A: __ARM_FEATURE_QRDMX 1
 

test/Preprocessor/arm-target-features.c

 // RUN:        -x c -E -dM %s -o - | FileCheck -match-full-lines --check-prefix=CHECK-FASTMATH %s
 // RUN: %clang -target arm-none-linux-gnu -ffast-math -x c -E -dM %s -o -\
 // RUN:        | FileCheck -match-full-lines --check-prefix=CHECK-FASTMATH %s
 // CHECK-FASTMATH: #define __ARM_FP_FAST 1
 
 // RUN: %clang -target arm-none-linux-gnu -fshort-wchar -x c -E -dM %s -o - | FileCheck -match-full-lines --check-prefix=CHECK-SHORTWCHAR %s
 // CHECK-SHORTWCHAR:#define __ARM_SIZEOF_WCHAR_T 2
 
+// RUN: %clang -target arm-none-linux-gnu -fno-enums -x c -E -dM %s -o - | FileCheck -match-full-lines --check-prefix=CHECK-NOENUMS %s
+// CHECK-NOENUMS-NOT: __ARM_SIZEOF_MINIMAL_ENUM
+
 // RUN: %clang -target arm-none-linux-gnu -fshort-enums -x c -E -dM %s -o - | FileCheck -match-full-lines --check-prefix=CHECK-SHORTENUMS %s
 // CHECK-SHORTENUMS:#define __ARM_SIZEOF_MINIMAL_ENUM 1
 
+// RUN: %clang -target arm-none-linux-gnu -fabi-enums -x c -E -dM %s -o - | FileCheck -match-full-lines --check-prefix=CHECK-ABIENUMS %s
+// CHECK-ABIENUMS:#define __ARM_SIZEOF_MINIMAL_ENUM 1
+
 // Test that -mhwdiv has the right effect for a target CPU which has hwdiv enabled by default.
 // RUN: %clang -target armv7 -mcpu=cortex-a15 -x c -E -dM %s -o - | FileCheck -match-full-lines --check-prefix=HWDIV %s
 // RUN: %clang -target armv7 -mthumb -mcpu=cortex-a15 -x c -E -dM %s -o - | FileCheck -match-full-lines --check-prefix=HWDIV %s
 // RUN: %clang -target armv7 -mcpu=cortex-a15 -mhwdiv=arm -x c -E -dM %s -o - | FileCheck -match-full-lines --check-prefix=HWDIV %s
 // RUN: %clang -target armv7 -mthumb -mcpu=cortex-a15 -mhwdiv=thumb -x c -E -dM %s -o - | FileCheck -match-full-lines --check-prefix=HWDIV %s
 // HWDIV:#define __ARM_ARCH_EXT_IDIV__ 1
 
 // RUN: %clang -target arm -mcpu=cortex-a15 -mhwdiv=thumb -x c -E -dM %s -o - | FileCheck -match-full-lines --check-prefix=NOHWDIV %s

test/Sema/no-enums.c

+// RUN: %clang_cc1 -triple armv7-arm-none-eabi -fno-enums %s -verify
+// RUN: %clang_cc1 -triple thumbv7-arm-none-eabi -fno-enums %s -verify
+// RUN: %clang_cc1 -triple aarch64-arm-none-eabi -fno-enums %s -verify
+
+enum { foo } bar; // expected-error{{enumeration types are prohibited}}
+
+void InvalidUseofEnum() { bar = foo; }