[AIX] Add mabi=vec-extabi options to enable the AIX extended and default vector ABIs.

[ZarkoCA]

Summary

Added support for the options mabi=vec-extabi and mabi=vec-default which are analogous to qvecnvol and qnovecnvol when using XL on AIX.
The extended Altivec ABI on AIX is enabled using mabi=vec-extabi in clang and vec-extabi in llc.

[Xiangling_L]

clang/docs/ClangCommandLineReference.rst

2888

s/On/on;

clang/lib/Driver/ToolChains/Clang.cpp

4614–4634

On clang, when we do:
clang -target powerpc-ibm-aix-xcoff -maltivec -S -emit-llvm test_faltivec.c, clang driver passes -target-cpu pwr4 as default arch to frontend without issuing any error.

However, with XL, we have:
"-qaltivec" is not compatible with "-qarch=pwr4". "-qnoaltivec" is being set. The same error will be issued if pwr5 is used as well.

So I suppose for AIX in clang, when user use -maltivec without specifying arch level, we can do:

1. by default pass -target-cpu pwr6 to frontend

or 2) issue error for "-qarch=pwr4"+ enable altivec
or 3) issue error for -qacrh = pwr4 + diable altivec like XL does?

Also we should emit error when user use -maltivec with -mcpu=pwr5.

[Xiangling_L]

clang/lib/CodeGen/BackendUtil.cpp

552

The ABI specifies When the option to use nonvolatile vector registers is enalbed. the compilation environment must also predefine __EXTABI__. I didn't see this. Should we also cover this in this patch?

clang/lib/Driver/ToolChains/Clang.cpp

4622

I would suggest s/haveMaltivec/HasAltivec to be consistent with other places where if altivec enabled is tested.

4624

Any reason why we cannot use Args.getLastArg here for OPT_maltivec as well?

4634

Since we are defaulting to default altivec ABI, so I think the logic here should be if (HasAltivec && !Args.getLastArg(options::OPT_mvecnvol)), then we emit D.Diag(diag::err_aix_default_altivec_abi) error?

clang/test/CodeGen/altivec.c

55

Could we also add a testcase to test -mvecnvol/-mnovecnvol are AIX only options?

[hubert.reinterpretcast]

There's frontend changes anyway, so there should be changes for the predefined macros?

[Xiangling_L]

llvm/lib/CodeGen/CommandFlags.cpp

525

Should we also check -vecnvol option is used for AIX only somewhere?

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

6973

minor:
remove '.'

llvm/test/CodeGen/PowerPC/aix-AppendingLinkage.ll

4 ↗

(On Diff #298986)

May I ask why would we want to add -vecnvol for those testcases? As I noticed, they don't need altivec feature enabled.

[hubert.reinterpretcast]

I have two concerns over the choice of the option form/name.

Firstly, there's an -mabi= option that is used to select for ABI extensions. The choice of using an -mabi= suboption for selecting between the extended vector ABI and the default vector ABI should be considered.
Secondly, the vecnvol name does not allude to its relation with the vector-extended ABI.

-mabi=aixvecextabi was suggested when I discussed this with someone who is familiar with GCC. The choice of extabi at the end is to match the spelling of the __EXTABI__ macro.

[hubert.reinterpretcast]

In D89684#2341922, @hubert.reinterpretcast wrote:

-mabi=aixvecextabi was suggested when I discussed this with someone who is familiar with GCC. The choice of extabi at the end is to match the spelling of the __EXTABI__ macro.

To reduce the length of the option, and with the hopes that future vector-related ABI extensions on Power have more specific naming than just being the "extended" ABI, the updated suggestion is -mabi=vec-extabi.

[DiggerLin]

clang/docs/ClangCommandLineReference.rst

2890

I think it should be

.. option:: -mvecnvol, -mnovecnvol
  Only supported On AIX. Specify usage of volatile and nonvolatile vector registers, the extended vector ABI on AIX. Defaults to '-mnovecnvol' when Altivec is enabled.

clang/lib/Driver/ToolChains/Clang.cpp

4634

I think we do not need a new variable here. we can write as
if (A->getOption().matches(options::OPT_mnovecnvol) && Args.getLastArg(OPT_maltivec)

[ZarkoCA]

Addressed comments:

1. Changed name of options to mabi=vec-extabi and mabi=vec-default
2. Reworked logic for selecting the options in Clang.cpp
3. Added mattr=-altivec instead of using mabi-vec-extabi to tests that failed previously.

[ZarkoCA]

clang/lib/CodeGen/BackendUtil.cpp

552

Thanks, that was an oversight.

clang/lib/Driver/ToolChains/Clang.cpp

4614–4634

I think what XL does is probably the correct thing but in clang/llvm it looks like the hasAltivec setting is determined by the cpu level and the compiler simply ignores it when it's not supported by the cpu.

For now, I'd like to follow the existing logic as all the other PPC targets and then I can follow up with a patch that emits an error when selecting altivec when the cpu doesn't support it.

4622

I reworked this so that I hopefully remove any confusion.

llvm/lib/CodeGen/CommandFlags.cpp

525

Is there a way to check whether an llc option is target specific?

llvm/test/CodeGen/PowerPC/aix-AppendingLinkage.ll

4 ↗

(On Diff #298986)

It is odd but those test cases hit the error llvm/lib/Target/PowerPC/PPCISelLowering.cpp:6908 when that wasn't enabled. However, adding mattr=-altivec also suppresses it. It seems like specifying mcpu=pwr4 doesn't not completely remove all altivec opts?

[Xiangling_L]

clang/lib/Driver/ToolChains/Clang.cpp

4616

I am wondering what cases are not covered by Triple.isOSAIX()? Why do we also query Triple.isOSBinFormatXCOFF()?

4617

I see your intention here is to find if there are any -mabi=vec-extabi or -mabi=vec-default option specifying. If I am correct, why we need to loop through whole Args? Can we just use hasArg query?

clang/lib/Frontend/CompilerInvocation.cpp

1444

ditto.

clang/test/CodeGen/altivec.c

2–16

Based on the code added in BackendUtil:551, should we also add a case for compiling a source to assembly?

llvm/include/llvm/Target/TargetMachine.h

246 ↗

(On Diff #305136)

I don't see this function gets invoked anywhere,can we remove it?

llvm/include/llvm/Target/TargetOptions.h

179

-mabi=vec-extabi is the FE option, should we s/-mabi=vec-extabi/-vec-extabi?

llvm/lib/CodeGen/CommandFlags.cpp

286

Based on the naming convention in this file context, this seems should be EnableAIXExtendedAltivecABI.

287

Can we add a testcase for this backend option?

llvm/test/CodeGen/PowerPC/aix-default-vec-abi.ll

1 ↗

(On Diff #305136)

Can we simplify the testcase to only contain one vector type parameter? I think that would be sufficient to trigger the error.

4 ↗

(On Diff #305136)

ditto: can we simplify the testcase?

llvm/test/CodeGen/PowerPC/aix-xcoff-mergeable-str.ll

7 ↗

(On Diff #305136)

I am wondering why do we remove -data-sections=false here?

[DiggerLin]

LGTM.

[ZarkoCA]

Addressed comments:
Added and fixed test cases and changed option selection logic.

[ZarkoCA]

clang/lib/Driver/ToolChains/Clang.cpp

4616

The path isn't selected if someone were to select -powerpc-unknown-xcoff as a target for example. It looks like the Triple.isOSAIX() is true when we we have aix in the target triple.

clang/test/CodeGen/altivec.c

2–16

Added in lines 15-18

llvm/include/llvm/Target/TargetOptions.h

179

Good catch, fixed.

llvm/lib/CodeGen/CommandFlags.cpp

287

Added in llvm/test/CodeGen/PowerPC/aix-vec-abi.c

[Xiangling_L]

clang/lib/Driver/ToolChains/Clang.cpp

4616

The path isn't selected if someone were to select -powerpc-unknown-xcoff as a target for example. It looks like the Triple.isOSAIX() is true when we we have aix in the target triple.

My understanding is that the AIX altivec ABI is target-dependent, it has nothing to do with binary format.

4617

The common query Args.hasArg(options::OPT_maltivec) is better to put in an upper level if;
Also after you do that, the last else if can be replaced by a else;
Another issue is that when we on AIX with -maltivec + extended/defautlt altivec abi enabled, we do duplicate checking in #4615 & #4613 if blocks.

Maybe we can refactor these two if blocks into:

if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ_vec_extabi,
                             options::OPT_mabi_EQ_vec_default)) {
  if (!Triple.isOSAIX()) {
    D.Diag(diag::err_drv_unsupported_opt_for_target)
        << A->getSpelling() << RawTriple.str();
  } else {
    if (Args.hasArg(options::OPT_maltivec)) {
      if (Args.hasArg(options::OPT_mabi_EQ_vec_extabi)) {
        CmdArgs.push_back("-mabi=vec-extabi");
      } else if (Args.hasArg(options::OPT_mabi_EQ_vec_default)) {
        D.Diag(diag::err_aix_default_altivec_abi);
      } else {
        D.Diag(diag::err_aix_default_altivec_abi);
      }
    } else {
      D.Diag(diag::err_aix_altivec);
    }
  }
}

4633

ditto.

clang/lib/Frontend/CompilerInvocation.cpp

1443

Should we also check if target feature altivec[-target-feature +altivec] is enabled when using these two options? If so, we should also add related testcases.

1445

ditto.

clang/test/CodeGen/altivec.c

2–16

It looks line 2& 4, line 3&5 are duplicated.

2–16

Added in lines 15-18

Sorry, I should make my point clearer. Based on current testcases, there are two things:

1. line 15-18 are actually duplication to 10,11, 13. 14. Because all of them are testing if the driver will emit error when not specifying -maltivec with -mabi=vec-default/-mabi=vec-extabi, i.e compiling from .c to .ll and .c to .s won't affect how driver works,

2. BackendUtil:551 The code I mentioned is actually affecting how BE behaves when we enable AIX altivec in the FE[or driver]. So the testcase I am looking for is something like:

// RUN:  %clang -target powerpc-unknown-aix -S -maltivec -mabi=vec-extabi %s  | FileCheck  %s
// CHECK: LLVM ERROR: the extended Altivec AIX ABI is not yet supported

llvm/test/CodeGen/PowerPC/aix-func-dsc-gen.ll

2 ↗

(On Diff #306509)

I am not sure if this is for all testcases where you add -mattr=-altivec, but I tried the first three. They all passed without this option. Could you double check this?

llvm/test/CodeGen/PowerPC/aix-vec-abi.ll

2

May I ask why we use pwr8 for this test?

[ZarkoCA]

clang/lib/Frontend/CompilerInvocation.cpp

1443

Both of these options require that -maltivec is also selected which sets -target-feature +altivec.

clang/test/CodeGen/altivec.c

2–16

As far as I understand, testing the assembly path is a bit tricky mainly due to how Altivec is determined to be on for all powerpc targets.

The tests in this file won't trigger the Altivec ABI errors because they are calling convention ABIs and there is no parameter passing or returns. In fact, they will generate assembly because the default CPU has the Altivec attribute enabled.

I wrote tests that will use the Altivec calling convention ABI in those cases we trigger earlier errors such as "vector type is unimplemented on AIX".

But, I did a test which shows that the driver passes the -mabi=vec-extabi option.

llvm/test/CodeGen/PowerPC/aix-func-dsc-gen.ll

2 ↗

(On Diff #306509)

You're right,it doesn't look like it's needed any longer.

[ZarkoCA]

Addressed comments and added a test to check whether the driver passes these options.

[Xiangling_L]

clang/lib/Frontend/CompilerInvocation.cpp

1443

Both of these options require that -maltivec is also selected which sets -target-feature +altivec.

It seems the scenario you pointed out are driver invocation use case. But when users invoke clang -cc1 not driver with -mabi=ext-abi/default, should we also check if the user specify -target-feature +altivec as well? For now, based on my observation, if invoking cc1 without -target-feature +altivec but with -mabi=ext-abi only like // RUN: %clang_cc1 -mabi=vec-extabi -triple powerpc64-unknown-aix -emit-llvm %s -o - | FileCheck %s, the error is error: unknown type name 'vector'. Should we explicitly say -target-feature +altivec is required as what we do for driver?

clang/test/Driver/aix-vec-extabi.c

3

minor: We can omit --check-prefix=CHECK

llvm/include/llvm/Target/TargetOptions.h

179

minor:
s/AIXExtendedAltivecABI/EnableAIXExtendedAltivecABI

[ZarkoCA]

Addressed some of the comments.

[Xiangling_L]

clang/include/clang/Basic/LangOptions.def

186

minor nit: remove extra spaces in front of 1.

clang/lib/Frontend/CompilerInvocation.cpp

1445

I am wondering why do we add !T.isOSBinFormatXCOFF() back?

1449

Just a record here, as we discussed offline, we don't need to emit this error in frontend.

clang/test/CodeGen/altivec.c

7

When user specify -maltivec / -target-feature +altivec without using any abi option, the compiler will assume default altivec abi. In this situation, since default abi hasn’t been implemented, we should emit an error. So can we also add testcases for :

// RUN: not %clang -S -emit-llvm -maltivec -target powerpc-unknown-aix %s 2>&1 | FileCheck %s --check-prefix=AIX-ERROR
and
// RUN: not %clang_cc1 -target-feature +altivec -triple powerpc-unknown-aix -emit-llvm %s 2>&1 | FileCheck %s --check-prefix=AIX-ERROR

[ZarkoCA]

Went back to old option selection logic as updated version did not emit an error when selecting 'maltivec` but not mabi=vec-extabi.

Fixed formatting.

[ZarkoCA]

clang/test/CodeGen/altivec.c

7

That's a good catch, the error was able to be generated previously but reworking the logic in Clang.cpp with the previous diff caused it to not be emitted. I went back to the older logic which emits the error in cases like where maltivec is specified without mabi=vec-extabi.

As for the cc1 error, currently the not vector types error catch that before we emit the Altivec ABI error since at this time there isn't a good way to check for target-feature +altivec in cc1.

llvm/test/CodeGen/PowerPC/aix-vec-abi.ll

2

Sorry for missing this earlier, I wanted to specify a CPU that has Altivec instructions enabled so that hasAltivec true without the user specifying it.

[Xiangling_L]

clang/lib/Driver/ToolChains/Clang.cpp

4624

line 4624 to line 4635 can be simplified to :

if (Triple.isOSAIX() && Args.hasArg(options::OPT_maltivec) {
  if (Args.hasArg(options::OPT_mabi_EQ_vec_extabi)) {
    CmdArgs.push_back("-mabi=vec-extabi");
  } else {
    D.Diag(diag::err_aix_default_altivec_abi);
  }
}

or even simplify line 4617 -4636 to the following if it works:

if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ_vec_extabi,
                             options::OPT_mabi_EQ_vec_default)) {
  if (!Triple.isOSAIX())
    D.Diag(diag::err_drv_unsupported_opt_for_target)
        << A->getSpelling() << RawTriple.str();

  if (!Args.hasArg(options::OPT_maltivec))
    D.Diag(diag::err_aix_altivec);

  if (Args.hasArg(options::OPT_mabi_EQ_vec_default))
    D.Diag(diag::err_aix_default_altivec_abi);

  CmdArgs.push_back("-mabi=vec-extabi");
} else if (Triple.isOSAIX() && Args.hasArg(options::OPT_maltivec) {
    D.Diag(diag::err_aix_default_altivec_abi);
}

clang/lib/Frontend/CompilerInvocation.cpp

1445

Hi Zarko, is the above comment missed being addressed?

[ZarkoCA]

Simplified option logic as per suggestion.
Removed stray isXCOFF reference.

[ZarkoCA]

clang/lib/Driver/ToolChains/Clang.cpp

4624

I really like the first suggestion, thank you.

clang/lib/Frontend/CompilerInvocation.cpp

1445

Sorry, that one snuck back in there after I thought I removed it.

[Xiangling_L]

LGTM. Thanks!

clang/docs/ClangCommandLineReference.rst

 .. program:: clang
 
 Only supported on X86 and RISC-V. Otherwise accepted for compatibility with GCC.
 
 .. option:: -mtvos-version-min=<arg>, -mappletvos-version-min=<arg>
 
 .. option:: -municode<arg>
 
+.. option:: -mabi=vec-extabi, -mabi=vec-default
+
+Only supported on AIX. Specify usage of the extended vector ABI on AIX and of non-volatile vector registers. Defaults to '-mabi=default' when Altivec is enabled.
+
 .. option:: -mvx, -mno-vx
 
 .. option:: -mwarn-nonportable-cfstrings, -mno-warn-nonportable-cfstrings
 
 .. option:: -mwatchos-version-min=<arg>
 
 .. option:: -mwavefrontsize64, -mno-wavefrontsize64
 

clang/include/clang/Basic/CodeGenOptions.def

 CODEGENOPT(RegisterGlobalDtorsWithAtExit, 1, 1) ///< Use atexit or __cxa_atexit to register global destructors.
 CODEGENOPT(CXXCtorDtorAliases, 1, 0) ///< Emit complete ctors/dtors as linker
                                      ///< aliases to base ctors when possible.
 CODEGENOPT(DataSections      , 1, 0) ///< Set when -fdata-sections is enabled.
 CODEGENOPT(UniqueSectionNames, 1, 1) ///< Set for -funique-section-names.
 CODEGENOPT(UniqueBasicBlockSectionNames, 1, 1) ///< Set for -funique-basic-block-section-names,
                                                ///< Produce unique section names with
                                                ///< basic block sections.
+CODEGENOPT(EnableAIXExtendedAltivecABI, 1, 0) ///< Set for -mabi=vec-extabi. Enables the extended Altivec ABI on AIX.
 ENUM_CODEGENOPT(FramePointer, FramePointerKind, 2, FramePointerKind::None) /// frame-pointer: all,non-leaf,none
 
 CODEGENOPT(DisableFree       , 1, 0) ///< Don't free memory.
 CODEGENOPT(DiscardValueNames , 1, 0) ///< Discard Value Names from the IR (LLVMContext flag)
 CODEGENOPT(DisableLLVMPasses , 1, 0) ///< Don't run any LLVM IR passes to get
                                      ///< the pristine IR generated by the
                                      ///< frontend.
 CODEGENOPT(DisableLifetimeMarkers, 1, 0) ///< Don't emit any lifetime markers

clang/include/clang/Basic/DiagnosticDriverKinds.td

def warn_drv_libstdcxx_not_found : Warning<
   InGroup<DiagGroup<"stdlibcxx-not-found">>;
 
 def err_drv_cannot_mix_options : Error<"cannot specify '%1' along with '%0'">;
 
 def err_drv_invalid_object_mode : Error<"OBJECT_MODE setting %0 is not recognized and is not a valid setting.">;
 
 def err_drv_invalid_sve_vector_bits : Error<
   "'-msve-vector-bits' is not supported without SVE enabled">;
+
+def err_aix_default_altivec_abi : Error<
+  "The default Altivec ABI on AIX is not yet supported, use '-mabi=vec-extabi' for the extended Altivec ABI">;
+
+def err_aix_altivec : Error<"'-mabi=vec-extabi' and '-mabi=vec-default' require '-maltivec'">;
 }

clang/include/clang/Basic/LangOptions.def

 VALUE_LANGOPT(PackStruct  , 32, 0,
               "default struct packing maximum alignment")
 VALUE_LANGOPT(MaxTypeAlign  , 32, 0,
               "default maximum alignment for types")
 VALUE_LANGOPT(AlignDouble            , 1, 0, "Controls if doubles should be aligned to 8 bytes (x86 only)")
 VALUE_LANGOPT(DoubleSize            , 32, 0, "width of double")
 VALUE_LANGOPT(LongDoubleSize        , 32, 0, "width of long double")
 LANGOPT(PPCIEEELongDouble            , 1, 0, "use IEEE 754 quadruple-precision for long double")
+LANGOPT(EnableAIXExtendedAltivecABI        , 1, 0, "__EXTABI__  predefined macro")
 COMPATIBLE_VALUE_LANGOPT(PICLevel    , 2, 0, "__PIC__ level")
 COMPATIBLE_VALUE_LANGOPT(PIE         , 1, 0, "is pie")
 LANGOPT(ROPI                         , 1, 0, "Read-only position independence")
 LANGOPT(RWPI                         , 1, 0, "Read-write position independence")
 COMPATIBLE_LANGOPT(GNUInline         , 1, 0, "GNU inline semantics")
 COMPATIBLE_LANGOPT(NoInlineDefine    , 1, 0, "__NO_INLINE__ predefined macro")
 COMPATIBLE_LANGOPT(Deprecated        , 1, 0, "__DEPRECATED predefined macro")
 COMPATIBLE_LANGOPT(FastMath          , 1, 0, "fast FP math optimizations, and __FAST_MATH__ predefined macro")

clang/include/clang/Driver/Options.td

 def faltivec : Flag<["-"], "faltivec">, Group<f_Group>, Flags<[NoXarchOption]>;
 def fno_altivec : Flag<["-"], "fno-altivec">, Group<f_Group>, Flags<[NoXarchOption]>;
 def maltivec : Flag<["-"], "maltivec">, Group<m_ppc_Features_Group>;
 def mno_altivec : Flag<["-"], "mno-altivec">, Group<m_ppc_Features_Group>;
 def mpcrel: Flag<["-"], "mpcrel">, Group<m_ppc_Features_Group>;
 def mno_pcrel: Flag<["-"], "mno-pcrel">, Group<m_ppc_Features_Group>;
 def mspe : Flag<["-"], "mspe">, Group<m_ppc_Features_Group>;
 def mno_spe : Flag<["-"], "mno-spe">, Group<m_ppc_Features_Group>;
+def mabi_EQ_vec_extabi : Flag<["-"], "mabi=vec-extabi">, Group<m_Group>, Flags<[CC1Option]>,
+  HelpText<"Enable the extended Altivec ABI on AIX (AIX only). Uses volatile and nonvolatile vector registers">;
+def mabi_EQ_vec_default : Flag<["-"], "mabi=vec-default">, Group<m_Group>, Flags<[CC1Option]>,
+  HelpText<"Enable the default Altivec ABI on AIX (AIX only). Uses only volatile vector registers.">;
 def mvsx : Flag<["-"], "mvsx">, Group<m_ppc_Features_Group>;
 def mno_vsx : Flag<["-"], "mno-vsx">, Group<m_ppc_Features_Group>;
 def msecure_plt : Flag<["-"], "msecure-plt">, 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 mpower9_vector : Flag<["-"], "mpower9-vector">,

clang/lib/Basic/Targets/OSTargets.h

protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     DefineStd(Builder, "unix", Opts);
     Builder.defineMacro("_IBMR2");
     Builder.defineMacro("_POWER");
 
     Builder.defineMacro("_AIX");
 
+    if (Opts.EnableAIXExtendedAltivecABI)
+      Builder.defineMacro("__EXTABI__");
+
     unsigned Major, Minor, Micro;
     Triple.getOSVersion(Major, Minor, Micro);
 
     // Define AIX OS-Version Macros.
     // Includes logic for legacy versions of AIX; no specific intent to support.
     std::pair<int, int> OsVersion = {Major, Minor};
     if (OsVersion >= std::make_pair(3, 2)) Builder.defineMacro("_AIX32");
     if (OsVersion >= std::make_pair(4, 1)) Builder.defineMacro("_AIX41");

clang/lib/CodeGen/BackendUtil.cpp

static bool initTargetOptions(DiagnosticsEngine &Diags,
   Options.TLSSize = CodeGenOpts.TLSSize;
   Options.EmulatedTLS = CodeGenOpts.EmulatedTLS;
   Options.ExplicitEmulatedTLS = CodeGenOpts.ExplicitEmulatedTLS;
   Options.DebuggerTuning = CodeGenOpts.getDebuggerTuning();
   Options.EmitStackSizeSection = CodeGenOpts.StackSizeSection;
   Options.EmitAddrsig = CodeGenOpts.Addrsig;
   Options.ForceDwarfFrameSection = CodeGenOpts.ForceDwarfFrameSection;
   Options.EmitCallSiteInfo = CodeGenOpts.EmitCallSiteInfo;
+  Options.EnableAIXExtendedAltivecABI = CodeGenOpts.EnableAIXExtendedAltivecABI;
   Options.ValueTrackingVariableLocations =
       CodeGenOpts.ValueTrackingVariableLocations;
   Options.XRayOmitFunctionIndex = CodeGenOpts.XRayOmitFunctionIndex;
 
   Options.MCOptions.SplitDwarfFile = CodeGenOpts.SplitDwarfFile;
   Options.MCOptions.MCRelaxAll = CodeGenOpts.RelaxAll;
   Options.MCOptions.MCSaveTempLabels = CodeGenOpts.SaveTempLabels;
   Options.MCOptions.MCUseDwarfDirectory = !CodeGenOpts.NoDwarfDirectoryAsm;

clang/lib/Driver/ToolChains/Clang.cpp

for (const Arg *A : Args.filtered(options::OPT_frewrite_map_file,
         D.Diag(diag::err_drv_no_such_file) << Map;
       } else {
         CmdArgs.push_back("-frewrite-map-file");
         CmdArgs.push_back(A->getValue());
         A->claim();
       }
     }
   }
 
+  if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ_vec_extabi,
+                               options::OPT_mabi_EQ_vec_default)) {
+    if (!Triple.isOSAIX()) {
+      D.Diag(diag::err_drv_unsupported_opt_for_target)
+          << A->getSpelling() << RawTriple.str();
+    } else {
+      if (Args.hasArg(options::OPT_maltivec)) {
+        if (Args.hasArg(options::OPT_mabi_EQ_vec_extabi)) {
+          CmdArgs.push_back("-mabi=vec-extabi");
+        } else if (Args.hasArg(options::OPT_mabi_EQ_vec_default)) {
+          D.Diag(diag::err_aix_default_altivec_abi);
+        } else {
+          D.Diag(diag::err_aix_default_altivec_abi);
+        }
+      } else {
+        D.Diag(diag::err_aix_altivec);
+      }
+    }
+  }
+
   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 (!Args.hasFlag(options::OPT_fjump_tables, options::OPT_fno_jump_tables,

clang/lib/Frontend/CompilerInvocation.cpp

if (O.matches(OPT_fpcc_struct_return) ||
       Opts.setStructReturnConvention(CodeGenOptions::SRCK_InRegs);
     }
   }
 
   if (T.isOSAIX() && (Args.hasArg(OPT_mignore_xcoff_visibility) ||
                       !Args.hasArg(OPT_fvisibility)))
     Opts.IgnoreXCOFFVisibility = 1;
 
+  if (Arg *A =
+          Args.getLastArg(OPT_mabi_EQ_vec_default, OPT_mabi_EQ_vec_extabi)) {
+    if (!T.isOSAIX() || !T.isOSBinFormatXCOFF())
+      Diags.Report(diag::err_drv_unsupported_opt_for_target)
+          << A->getSpelling() << T.str();
+
+    if (!Args.hasArg(OPT_maltivec))
+      Diags.Report(diag::err_aix_altivec);
+
+    const Option &O = A->getOption();
+    if (O.matches(OPT_mabi_EQ_vec_default))
+      Diags.Report(diag::err_aix_default_altivec_abi)
+          << A->getSpelling() << T.str();
+    else {
+      assert(O.matches(OPT_mabi_EQ_vec_extabi));
+      Opts.EnableAIXExtendedAltivecABI = 1;
+    }
+  }
+
   Opts.DependentLibraries = Args.getAllArgValues(OPT_dependent_lib);
   Opts.LinkerOptions = Args.getAllArgValues(OPT_linker_option);
   bool NeedLocTracking = false;
 
   Opts.OptRecordFile = std::string(Args.getLastArgValue(OPT_opt_record_file));
   if (!Opts.OptRecordFile.empty())
     NeedLocTracking = true;
 
#include "clang/Basic/LangStandards.def"
   Opts.PackStruct = getLastArgIntValue(Args, OPT_fpack_struct_EQ, 0, Diags);
   Opts.MaxTypeAlign = getLastArgIntValue(Args, OPT_fmax_type_align_EQ, 0, Diags);
   Opts.AlignDouble = Args.hasArg(OPT_malign_double);
   Opts.DoubleSize = getLastArgIntValue(Args, OPT_mdouble_EQ, 0, Diags);
   Opts.LongDoubleSize = Args.hasArg(OPT_mlong_double_128)
                             ? 128
                             : Args.hasArg(OPT_mlong_double_64) ? 64 : 0;
   Opts.PPCIEEELongDouble = Args.hasArg(OPT_mabi_EQ_ieeelongdouble);
+  Opts.EnableAIXExtendedAltivecABI = Args.hasArg(OPT_mabi_EQ_vec_extabi);
   Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
   Opts.ROPI = Args.hasArg(OPT_fropi);
   Opts.RWPI = Args.hasArg(OPT_frwpi);
   Opts.PIE = Args.hasArg(OPT_pic_is_pie);
   Opts.Static = Args.hasArg(OPT_static_define);
   Opts.DumpRecordLayoutsSimple = Args.hasArg(OPT_fdump_record_layouts_simple);
   Opts.DumpRecordLayouts = Opts.DumpRecordLayoutsSimple
                         || Args.hasArg(OPT_fdump_record_layouts);

clang/test/CodeGen/altivec.c

 // RUN: %clang_cc1 -target-feature +altivec -triple powerpc-unknown-unknown -emit-llvm %s -o - | FileCheck %s
-
+// RUN: %clang_cc1 -target-feature +altivec -mabi=vec-extabi -triple powerpc-unknown-aix -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -target-feature +altivec -mabi=vec-extabi -triple powerpc64-unknown-aix -emit-llvm %s -o - | FileCheck %s
+// RUN: not %clang_cc1 -target-feature +altivec -mabi=vec-default -triple powerpc-unknown-aix -emit-llvm %s 2>&1 | FileCheck %s --check-prefix=AIX-ERROR
+// RUN: not %clang_cc1 -target-feature +altivec -mabi=vec-default -triple powerpc64-unknown-aix -emit-llvm %s 2>&1 | FileCheck %s --check-prefix=AIX-ERROR
+ 
+// RUN: %clang -S -emit-llvm -maltivec -mabi=vec-extabi -target powerpc-unknown-aix %s -o - | FileCheck %s
+// RUN: not %clang -S -emit-llvm -mabi=vec-default -target powerpc-unknown-aix %s 2>&1  | FileCheck  %s --check-prefix=AIX-ATVER
+// RUN: not %clang -S -emit-llvm -mabi=vec-extabi -target powerpc-unknown-aix %s 2>&1  | FileCheck  %s --check-prefix=AIX-ATVER
+// RUN: %clang -S -emit-llvm -maltivec -mabi=vec-extabi -target powerpc64-unknown-aix %s -o - | FileCheck %s
+// RUN: not %clang -S -emit-llvm -mabi=vec-default -target powerpc64-unknown-aix %s 2>&1  | FileCheck  %s --check-prefix=AIX-ATVER
+// RUN: not %clang -S -emit-llvm -mabi=vec-extabi -target powerpc64-unknown-aix %s 2>&1  | FileCheck  %s --check-prefix=AIX-ATVER
+// RUN: not %clang -S -mabi=vec-default -target powerpc-unknown-aix %s 2>&1  | FileCheck  %s --check-prefix=AIX-ATVER
+// RUN: not %clang -S -mabi=vec-extabi -target powerpc-unknown-aix %s 2>&1  | FileCheck  %s --check-prefix=AIX-ATVER
+// RUN: not %clang -S -mabi=vec-default -target powerpc64-unknown-aix %s 2>&1  | FileCheck  %s --check-prefix=AIX-ATVER
+// RUN: not %clang -S -mabi=vec-extabi -target powerpc64-unknown-aix %s 2>&1  | FileCheck  %s --check-prefix=AIX-ATVER
 // Check initialization
 
 vector int test0 = (vector int)(1);       // CHECK: @test0 = global <4 x i32> <i32 1, i32 1, i32 1, i32 1>
 vector float test1 = (vector float)(1.0); // CHECK: @test1 = global <4 x float> <float 1.000000e+{{0+}}, float 1.000000e+{{0+}}, float 1.000000e+{{0+}}, float 1.000000e+{{0+}}>
 
 // CHECK: @v1 = global <16 x i8> <i8 0, i8 0, i8 0, i8 1, i8 0, i8 0, i8 0, i8 2, i8 0, i8 0, i8 0, i8 3, i8 0, i8 0, i8 0, i8 4>
 vector char v1 = (vector char)((vector int)(1, 2, 3, 4));
 // CHECK: @v2 = global <16 x i8> <i8 63, i8 -128, i8 0, i8 0, i8 64, i8 0, i8 0, i8 0, i8 64, i8 64, i8 0, i8 0, i8 64, i8 -128, i8 0, i8 0>

 void test3() {
   vector int vi;
   vi++;                                    // CHECK: add <4 x i32> {{.*}} <i32 1, i32 1, i32 1, i32 1>
   vector unsigned int vui;
   --vui;                                   // CHECK: add <4 x i32> {{.*}} <i32 -1, i32 -1, i32 -1, i32 -1>
   vector float vf;
   vf++;                                    // CHECK: fadd <4 x float> {{.*}} <float 1.000000e+{{0+}}, float 1.000000e+{{0+}}, float 1.000000e+{{0+}}, float 1.000000e+{{0+}}>
 }
+
+// AIX-ERROR:  error: The default Altivec ABI on AIX is not yet supported, use '-mabi=vec-extabi' for the extended Altivec ABI
+// AIX-ATVER:  error: '-mabi=vec-extabi' and '-mabi=vec-default' require '-maltivec'

clang/test/Driver/aix-vec-extabi.c

+// RUN:  %clang -### -target powerpc-unknown-aix -S -maltivec -mabi=vec-extabi %s 2>&1 | \
+// RUN:  FileCheck %s
+
+// CHECK: {{.*}}clang{{.*}}" "-cc1"
+// CHECK: "-mabi=vec-extabi"
+
+// RUN:  %clang -### -target powerpc-unknown-aix -S -maltivec -mabi=vec-default %s 2>&1 | \
+// RUN:  FileCheck %s --check-prefix=ERROR
+
+// ERROR: The default Altivec ABI on AIX is not yet supported, use '-mabi=vec-extabi' for the extended Altivec ABI

clang/test/Preprocessor/aix-vec_extabi.c

+// RUN: %clang -target powerpc-ibm-aix-xcoff -mcpu=pwr8 -E -dM -maltivec -mabi=vec-extabi %s -o - 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=EXTABI
+// RUN: %clang  -target powerpc64-ibm-aix-xcoff -mcpu=pwr8 -E -dM -maltivec -mabi=vec-extabi %s -o - 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=EXTABI
+// RUN: not %clang  -target powerpc-ibm-aix-xcoff -mcpu=pwr8 -E -dM -maltivec -mabi=vec-default %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=DFLTABI
+// RUN: not %clang -target powerpc64-ibm-aix-xcoff -mcpu=pwr8 -E -dM -maltivec -mabi=vec-default %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix=DFLTABI
+
+
+// EXTABI:  #define __EXTABI__
+// DFLTABI: The default Altivec ABI on AIX is not yet supported, use '-mabi=vec-extabi' for the extended Altivec ABI

llvm/include/llvm/CodeGen/CommandFlags.h

 llvm::FloatABI::ABIType getFloatABIForCalls();
 
 llvm::FPOpFusion::FPOpFusionMode getFuseFPOps();
 
 bool getDontPlaceZerosInBSS();
 
 bool getEnableGuaranteedTailCallOpt();
 
+bool getEnableAIXExtendedAltivecABI();
+
 bool getDisableTailCalls();
 
 bool getStackSymbolOrdering();
 
 unsigned getOverrideStackAlignment();
 
 bool getStackRealign();
 

llvm/include/llvm/Target/TargetOptions.h

enum class GlobalISelAbortMode {
     DisableWithDiag // Disable the abort but emit a diagnostic on failure.
   };
 
   class TargetOptions {
   public:
     TargetOptions()
         : UnsafeFPMath(false), NoInfsFPMath(false), NoNaNsFPMath(false),
           NoTrappingFPMath(true), NoSignedZerosFPMath(false),
+          EnableAIXExtendedAltivecABI(false),
           HonorSignDependentRoundingFPMathOption(false), NoZerosInBSS(false),
           GuaranteedTailCallOpt(false), StackSymbolOrdering(true),
           EnableFastISel(false), EnableGlobalISel(false), UseInitArray(false),
           DisableIntegratedAS(false), RelaxELFRelocations(false),
           FunctionSections(false), DataSections(false),
           IgnoreXCOFFVisibility(false), UniqueSectionNames(true),
           UniqueBasicBlockSectionNames(false), TrapUnreachable(false),
           NoTrapAfterNoreturn(false), TLSSize(0), EmulatedTLS(false),
public:
     unsigned NoTrappingFPMath : 1;
 
     /// NoSignedZerosFPMath - This flag is enabled when the
     /// -enable-no-signed-zeros-fp-math is specified on the command line. This
     /// specifies that optimizations are allowed to treat the sign of a zero
     /// argument or result as insignificant.
     unsigned NoSignedZerosFPMath : 1;
 
+    /// EnableAIXExtendedAltivecABI - This flag returns true when -vec-extabi is
+    /// specified. The code generator is then able to use both volatile and
+    /// nonvolitle vector regisers. When false, the code generator only uses
+    /// volatile vector registers which is the default setting on AIX.
+    unsigned EnableAIXExtendedAltivecABI : 1;
+
     /// HonorSignDependentRoundingFPMath - This returns true when the
     /// -enable-sign-dependent-rounding-fp-math is specified.  If this returns
     /// false (the default), the code generator is allowed to assume that the
     /// rounding behavior is the default (round-to-zero for all floating point
     /// to integer conversions, and round-to-nearest for all other arithmetic
     /// truncations).  If this is enabled (set to true), the code generator must
     /// assume that the rounding mode may dynamically change.
     unsigned HonorSignDependentRoundingFPMathOption : 1;

llvm/lib/CodeGen/CommandFlags.cpp

 CGOPT(ExceptionHandling, ExceptionModel)
 CGOPT_EXP(CodeGenFileType, FileType)
 CGOPT(FramePointer::FP, FramePointerUsage)
 CGOPT(bool, EnableUnsafeFPMath)
 CGOPT(bool, EnableNoInfsFPMath)
 CGOPT(bool, EnableNoNaNsFPMath)
 CGOPT(bool, EnableNoSignedZerosFPMath)
 CGOPT(bool, EnableNoTrappingFPMath)
+CGOPT(bool, EnableAIXExtendedAltivecABI)
 CGOPT(DenormalMode::DenormalModeKind, DenormalFPMath)
 CGOPT(DenormalMode::DenormalModeKind, DenormalFP32Math)
 CGOPT(bool, EnableHonorSignDependentRoundingFPMath)
 CGOPT(FloatABI::ABIType, FloatABIForCalls)
 CGOPT(FPOpFusion::FPOpFusionMode, FuseFPOps)
 CGOPT(bool, DontPlaceZerosInBSS)
 CGOPT(bool, EnableGuaranteedTailCallOpt)
 CGOPT(bool, DisableTailCalls)
#define CGBINDOPT(NAME)                                                        \
   CGBINDOPT(FuseFPOps);
 
   static cl::opt<bool> DontPlaceZerosInBSS(
       "nozero-initialized-in-bss",
       cl::desc("Don't place zero-initialized symbols into bss section"),
       cl::init(false));
   CGBINDOPT(DontPlaceZerosInBSS);
 
+  static cl::opt<bool> EnableAIXExtendedAltivecABI(
+      "vec-extabi", cl::desc("Enable the AIX Extended Altivec ABI."),
+      cl::init(false));
+  CGBINDOPT(EnableAIXExtendedAltivecABI);
+
   static cl::opt<bool> EnableGuaranteedTailCallOpt(
       "tailcallopt",
       cl::desc(
           "Turn fastcc calls into tail calls by (potentially) changing ABI."),
       cl::init(false));
   CGBINDOPT(EnableGuaranteedTailCallOpt);
 
   static cl::opt<bool> DisableTailCalls(
codegen::InitTargetOptionsFromCodeGenFlags(const Triple &TheTriple) {
 
   // FIXME: Should have separate input and output flags
   Options.setFPDenormalMode(DenormalMode(DenormKind, DenormKind));
 
   Options.HonorSignDependentRoundingFPMathOption =
       getEnableHonorSignDependentRoundingFPMath();
   if (getFloatABIForCalls() != FloatABI::Default)
     Options.FloatABIType = getFloatABIForCalls();
+  Options.EnableAIXExtendedAltivecABI = getEnableAIXExtendedAltivecABI();
   Options.NoZerosInBSS = getDontPlaceZerosInBSS();
   Options.GuaranteedTailCallOpt = getEnableGuaranteedTailCallOpt();
   Options.StackAlignmentOverride = getOverrideStackAlignment();
   Options.StackSymbolOrdering = getStackSymbolOrdering();
   Options.UseInitArray = !getUseCtors();
   Options.RelaxELFRelocations = getRelaxELFRelocations();
   Options.DataSections =
       getExplicitDataSections().getValueOr(TheTriple.hasDefaultDataSections());

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

static bool CC_AIX(unsigned ValNo, MVT ValVT, MVT LocVT,
                    CCState &State) {
 
   const PPCSubtarget &Subtarget = static_cast<const PPCSubtarget &>(
       State.getMachineFunction().getSubtarget());
   const bool IsPPC64 = Subtarget.isPPC64();
   const Align PtrAlign = IsPPC64 ? Align(8) : Align(4);
   const MVT RegVT = IsPPC64 ? MVT::i64 : MVT::i32;
 
+  if (ValVT.isVector() && !State.getMachineFunction()
+                               .getTarget()
+                               .Options.EnableAIXExtendedAltivecABI)
+    report_fatal_error("the default Altivec AIX ABI is not yet supported");
+
+  if (ValVT.isVector() && State.getMachineFunction()
+                              .getTarget()
+                              .Options.EnableAIXExtendedAltivecABI)
+    report_fatal_error("the extended Altivec AIX ABI is not yet supported");
+
   assert((!ValVT.isInteger() ||
           (ValVT.getFixedSizeInBits() <= RegVT.getFixedSizeInBits())) &&
          "Integer argument exceeds register size: should have been legalized");
 
   if (ValVT == MVT::f128)
     report_fatal_error("f128 is unimplemented on AIX.");
 
   if (ArgFlags.isNest())

llvm/test/CodeGen/PowerPC/aix-vec-abi.ll

+; RUN: not --crash llc < %s -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr8 2>&1 | FileCheck %s --check-prefix=DFLTERROR
+; RUN: not --crash llc < %s -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr8 2>&1 | FileCheck %s --check-prefix=DFLTERROR
+
+; RUN: not --crash llc < %s -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr8 -vec-extabi 2>&1 | FileCheck %s --check-prefix=VEXTERROR
+; RUN: not --crash llc < %s -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr8 -vec-extabi 2>&1 | FileCheck %s --check-prefix=VEXTERROR
+
+define void @vec_callee(<4 x i32> %vec1) {
+    ret void 
+}
+
+; DFLTERROR:  LLVM ERROR: the default Altivec AIX ABI is not yet supported
+; VEXTERROR:  LLVM ERROR: the extended Altivec AIX ABI is not yet supported