[flang] Add -fppc-native-vector-element-order option to control the element order in PowerPC vector types

[kkwli0]

Summary

This patch is to add a compiler option to control the element order in PowerPC vector types. For example,
on a little-endian platform, we may need to express the vector in the non-native element order. The vec_vcf intrinsic is updated for handling different vector element orders and new LIT tests are added.

Co-authored-by: Mark Danial <[e-mail]>
Co-authored-by: @DanielCChen

[awarzynski]

Thanks for working on this! I think that this needs a bit more work - please see my inline comment.

Edit: I've also uploaded https://reviews.llvm.org/D155931 to clarify. I hope that this helps.

Please also add a test to https://github.com/llvm/llvm-project/blob/b70e6e9681925ad06d9899462b9e43250be53f64/flang/test/Driver/frontend-forwarding.f90#L1

clang/include/clang/Driver/Options.td

5432

Why doesn't such option already exist in Flang? Just curious - feels like something quite generic rather than Fortran specific.

flang/lib/Frontend/CompilerInvocation.cpp

573

Please avoid "pushing" directly to llvmArgs. This variable is specfically for -mllvm and for debugging and experimental features. If that's the route that you want to take, then this change is not needed and you can just use -mllvm -fppc-native-vector-element-order=false" rather than introducing a new Flag.

957–960

Unrelated change.

[kkwli0]

flang/lib/Frontend/CompilerInvocation.cpp

573

The goal we want to achieve is to have a compiler option to control the element order. We would expect users to have flang-new -fppc-native-vector-element-order ... instead of specifying the flang-new -mllvm -fppc-native-vector-element-order=false .... Any suggestion is welcome.

[awarzynski]

flang/lib/Frontend/CompilerInvocation.cpp

573

The goal we want to achieve is to have a compiler option to control the element order.

Thanks for clarifying! Clearly -mllvm is not what you are after.

Any suggestion is welcome.

You need to identify the correct way to wire this up. It will depend on whether this is a codegen, lowering, or lang options. There are probably other categories to consider, but for those 3 you can check the following for inspiration:

• CodeGenOptions
• LangOptions
• LoweringOptions

You may need to introduce some new category. Ultimately, you will need to introduce some state somewhere and use your new flag to control it. llvm::cl option does not qualify :)

I hope that this helps. Let me know if you have any questions.

flang/lib/Optimizer/Builder/PPCIntrinsicCall.cpp

23–26

Driver options are defined in Options.td.

[kkwli0]

clang/include/clang/Driver/Options.td

5432

We couldn't find one similar to functionality.

flang/lib/Frontend/CompilerInvocation.cpp

957–960

Will remove the change.

flang/lib/Optimizer/Builder/PPCIntrinsicCall.cpp

23–26

Got it.

[kkwli0]

Thanks for the review. We took your suggestion and implement this option as one of LoweringOptions.

[DanielCChen]

flang/test/Driver/driver-help-hidden.f90

68

Do we need to test -fno-ppc-native-vector-element-order?

flang/test/Driver/driver-help.f90

64

Same comment as above.

182

Same comment as above.

[kkwli0]

• address review comments
  • update frontend forwarding test
  • update help file test
  • fix bug - accept -fppc-native-vector-element-order
• rebase

flang/test/Driver/driver-help-hidden.f90

68

Will do.

flang/test/Driver/driver-help.f90

64

Will do

182

Will do

[awarzynski]

@kkwli0 , thank you for addressing my comments. The driver logic looks good to me. I don't have the expertise to review the other parts, so would appreciate if one other reviewer approves before landing this.

clang/lib/Driver/ToolChains/Flang.cpp

143–146

You can use addAllArgs instead. See https://reviews.llvm.org/D156524.

flang/test/Lower/PowerPC/ppc-vec_cvf-elem-order.f90

2–3

IMHO, it really helps to have _all_ prefixes to be custom. This is basically a neat way of documenting _what_ is being tested (e.g. FIR vs LLVM). Also, I'd normally drop CHECK as that's just noise. This is a nit.

[kkwli0]

@awarzynski Thanks for reviewing the patch.

Update:

• fixed pre-merge build failure
• addressed review comments
• rebase

clang/lib/Driver/ToolChains/Flang.cpp

143–146

Will do

flang/test/Lower/PowerPC/ppc-vec_cvf-elem-order.f90

2–3

Will do

[nemanjai]

clang/include/clang/Driver/Options.td

5419–5421

Just out of curiosity, what does this mean for clang? What would it mean for someone to invoke something like:

clang --target=powerpc64le-unknown-linux-gnu -fppc-native-vector-element-order ...

[awarzynski]

clang/include/clang/Driver/Options.td

5419–5421

Options with FlangOnlyOption are not available in Clang:

• https://github.com/llvm/llvm-project/blob/3a100ea901ed79d6a06a5f018be2b4d3bbca51e8/clang/include/clang/Driver/Options.td#L71-L73

[nemanjai]

clang/include/clang/Driver/Options.td

5419–5421

Sounds good. I didn't see that this is in a block that sets that flag.

[DanielCChen]

LGTM.

[kkwli0]

Thanks. I will wait for a day to see if there are more comments.

clang/include/clang/Driver/Options.td

def fintrinsic_modules_path : Separate<["-"], "fintrinsic-modules-path">,  Group<f_Group>, MetaVarName<"<dir>">,
   DocBrief<[{This option specifies the location of pre-compiled intrinsic modules,
   if they are not in the default location expected by the compiler.}]>;
 
 defm backslash : OptInFC1FFlag<"backslash", "Specify that backslash in string introduces an escape character">;
 defm xor_operator : OptInFC1FFlag<"xor-operator", "Enable .XOR. as a synonym of .NEQV.">;
 defm logical_abbreviations : OptInFC1FFlag<"logical-abbreviations", "Enable logical abbreviations">;
 defm implicit_none : OptInFC1FFlag<"implicit-none", "No implicit typing allowed unless overridden by IMPLICIT statements">;
 defm underscoring : OptInFC1FFlag<"underscoring", "Appends one trailing underscore to external names">;
+defm ppc_native_vec_elem_order: BoolOptionWithoutMarshalling<"f", "ppc-native-vector-element-order",
+  PosFlag<SetTrue, [], "Specifies PowerPC native vector element order (default)">,
+  NegFlag<SetFalse, [], "Specifies PowerPC non-native vector element order">>;
 
 def fno_automatic : Flag<["-"], "fno-automatic">, Group<f_Group>,
   HelpText<"Implies the SAVE attribute for non-automatic local objects in subprograms unless RECURSIVE">;
 
 defm stack_arrays : BoolOptionWithoutMarshalling<"f", "stack-arrays",
   PosFlag<SetTrue, [], "Attempt to allocate array temporaries on the stack, no matter their size">,
   NegFlag<SetFalse, [], "Allocate array temporaries on the heap (default)">>;
 defm loop_versioning : BoolOptionWithoutMarshalling<"f", "version-loops-for-stride",
   PosFlag<SetTrue, [], "Create unit-strided versions of loops">,
    NegFlag<SetFalse, [], "Do not create unit-strided loops (default)">>;
 } // let Flags = [FC1Option, FlangOption, FlangOnlyOption]
 
 def J : JoinedOrSeparate<["-"], "J">,
   Flags<[RenderJoined, FlangOption, FC1Option, FlangOnlyOption]>,
   Group<gfortran_Group>,
   Alias<module_dir>;
 
 //===----------------------------------------------------------------------===//
 // FC1 Options

clang/lib/Driver/ToolChains/Flang.cpp

void Flang::addCodegenOptions(const ArgList &Args,
                               ArgStringList &CmdArgs) const {
   Arg *stackArrays =
       Args.getLastArg(options::OPT_Ofast, options::OPT_fstack_arrays,
                       options::OPT_fno_stack_arrays);
   if (stackArrays &&
       !stackArrays->getOption().matches(options::OPT_fno_stack_arrays))
     CmdArgs.push_back("-fstack-arrays");
 
   if (shouldLoopVersion(Args))
     CmdArgs.push_back("-fversion-loops-for-stride");
 
   Args.AddAllArgs(CmdArgs, {options::OPT_flang_experimental_hlfir,
-                            options::OPT_flang_experimental_polymorphism});
+                            options::OPT_flang_experimental_polymorphism,
+                            options::OPT_fno_ppc_native_vec_elem_order,
+                            options::OPT_fppc_native_vec_elem_order});
 }
 
 void Flang::addPicOptions(const ArgList &Args, ArgStringList &CmdArgs) const {
   // ParsePICArgs parses -fPIC/-fPIE and their variants and returns a tuple of
   // (RelocationModel, PICLevel, IsPIE).
   llvm::Reloc::Model RelocationModel;
   unsigned PICLevel;
   bool IsPIE;

flang/include/flang/Lower/CustomIntrinsicCall.h

lowerCustomIntrinsic(fir::FirOpBuilder &builder, mlir::Location loc,
                      const OperandGetter &getOperand, std::size_t numOperands,
                      Fortran::lower::StatementContext &stmtCtx);
 
 /// DEPRICATED: NEW CODE SHOULD USE THE VERSION OF genIntrinsicCall WITHOUT A
 /// StatementContext, DECLARED IN IntrinsicCall.h
 /// Generate the FIR+MLIR operations for the generic intrinsic \p name
 /// with argument \p args and expected result type \p resultType.
 /// Returned fir::ExtendedValue is the returned Fortran intrinsic value.
-fir::ExtendedValue genIntrinsicCall(fir::FirOpBuilder &builder,
-                                    mlir::Location loc, llvm::StringRef name,
-                                    std::optional<mlir::Type> resultType,
-                                    llvm::ArrayRef<fir::ExtendedValue> args,
-                                    StatementContext &stmtCtx);
+fir::ExtendedValue
+genIntrinsicCall(fir::FirOpBuilder &builder, mlir::Location loc,
+                 llvm::StringRef name, std::optional<mlir::Type> resultType,
+                 StatementContext &stmtCtx,
+                 Fortran::lower::AbstractConverter *converter = nullptr);
 
 } // namespace lower
 } // namespace Fortran
 
 #endif // FORTRAN_LOWER_CUSTOMINTRINSICCALL_H

flang/include/flang/Lower/LoweringOptions.def

 
 /// If true, enable polymorphic type lowering feature. Off by default.
 ENUM_LOWERINGOPT(PolymorphicTypeImpl, unsigned, 1, 0)
 
 /// If true, lower to High level FIR before lowering to FIR.
 /// Off by default until fully ready.
 ENUM_LOWERINGOPT(LowerToHighLevelFIR, unsigned, 1, 0)
 
+/// If true, reverse PowerPC native vector element order.
+ENUM_LOWERINGOPT(NoPPCNativeVecElemOrder, unsigned, 1, 0)
+
 #undef LOWERINGOPT
 #undef ENUM_LOWERINGOPT

flang/include/flang/Optimizer/Builder/IntrinsicCall.h

 //===-- Builder/IntrinsicCall.h -- lowering of intrinsics -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_INTRINSICCALL_H
 #define FORTRAN_LOWER_INTRINSICCALL_H
 
+#include "flang/Lower/AbstractConverter.h"
 #include "flang/Optimizer/Builder/BoxValue.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/Runtime/Character.h"
 #include "flang/Optimizer/Builder/Runtime/Numeric.h"
 #include "flang/Optimizer/Builder/Runtime/RTBuilder.h"
 #include "flang/Runtime/entry-names.h"
 #include "flang/Runtime/iostat.h"
 #include "mlir/Dialect/Complex/IR/Complex.h"

 // TODO: Implementation is incomplete. Many intrinsics to tbd.
 
 /// Same as the other genIntrinsicCall version above, except that the result
 /// deallocation, if required, is not added to a StatementContext. Instead, an
 /// extra boolean result indicates if the result must be freed after use.
 std::pair<fir::ExtendedValue, bool>
 genIntrinsicCall(fir::FirOpBuilder &, mlir::Location, llvm::StringRef name,
                  std::optional<mlir::Type> resultType,
-                 llvm::ArrayRef<fir::ExtendedValue> args);
+                 llvm::ArrayRef<fir::ExtendedValue> args,
+                 Fortran::lower::AbstractConverter *converter = nullptr);
 
 /// Enums used to templatize and share lowering of MIN and MAX.
 enum class Extremum { Min, Max };
 
 // There are different ways to deal with NaNs in MIN and MAX.
 // Known existing behaviors are listed below and can be selected for
 // f18 MIN/MAX implementation.
 enum class ExtremumBehavior {

 /// Opaque class defining the argument lowering rules for all the argument of
 /// an intrinsic.
 struct IntrinsicArgumentLoweringRules;
 
 // TODO error handling -> return a code or directly emit messages ?
 struct IntrinsicLibrary {
 
   // Constructors.
-  explicit IntrinsicLibrary(fir::FirOpBuilder &builder, mlir::Location loc)
-      : builder{builder}, loc{loc} {}
+  explicit IntrinsicLibrary(
+      fir::FirOpBuilder &builder, mlir::Location loc,
+      Fortran::lower::AbstractConverter *converter = nullptr)
+      : builder{builder}, loc{loc}, converter{converter} {}
   IntrinsicLibrary() = delete;
   IntrinsicLibrary(const IntrinsicLibrary &) = delete;
 
   /// Generate FIR for call to Fortran intrinsic \p name with arguments \p arg
   /// and expected result type \p resultType. Return the result and a boolean
   /// that, if true, indicates that the result must be freed after use.
   std::pair<fir::ExtendedValue, bool>
   genIntrinsicCall(llvm::StringRef name, std::optional<mlir::Type> resultType,
fir::ExtendedValue readAndAddCleanUp(fir::MutableBoxValue resultMutableBox,
                                        mlir::Type resultType,
                                        llvm::StringRef errMsg);
 
   void setResultMustBeFreed() { resultMustBeFreed = true; }
 
   fir::FirOpBuilder &builder;
   mlir::Location loc;
   bool resultMustBeFreed = false;
+  Fortran::lower::AbstractConverter *converter = nullptr;
 };
 
 struct IntrinsicDummyArgument {
   const char *name = nullptr;
   fir::LowerIntrinsicArgAs lowerAs = fir::LowerIntrinsicArgAs::Value;
   bool handleDynamicOptional = false;
 };
 

flang/include/flang/Optimizer/Builder/PPCIntrinsicCall.h

 struct PPCIntrinsicLibrary : IntrinsicLibrary {
 
   // Constructors.
   explicit PPCIntrinsicLibrary(fir::FirOpBuilder &builder, mlir::Location loc)
       : IntrinsicLibrary(builder, loc) {}
   PPCIntrinsicLibrary() = delete;
   PPCIntrinsicLibrary(const PPCIntrinsicLibrary &) = delete;
 
+  // Helper functions for vector element ordering.
+  bool isBEVecElemOrderOnLE();
+  bool isNativeVecElemOrderOnLE();
+  bool changeVecElemOrder();
+
   // PPC MMA intrinsic generic handler
   template <MMAOp IntrId, MMAHandlerOp HandlerOp>
   void genMmaIntr(llvm::ArrayRef<fir::ExtendedValue>);
 
   // PPC intrinsic handlers.
   template <bool isImm>
   void genMtfsf(llvm::ArrayRef<fir::ExtendedValue>);
 

flang/lib/Frontend/CompilerInvocation.cpp

if (argValue == "utf-8") {
       diags.Report(clang::diag::err_drv_invalid_value)
           << arg->getAsString(args) << argValue;
     }
   }
 
   setUpFrontendBasedOnAction(opts);
   opts.dashX = dashX;
 
   return diags.getNumErrors() == numErrorsBefore;
 }
 
 // Generate the path to look for intrinsic modules
 static std::string getIntrinsicDir() {
   // TODO: Find a system independent API
   llvm::SmallString<128> driverPath;
   driverPath.assign(llvm::sys::fs::getMainExecutable(nullptr, nullptr));
   llvm::sys::path::remove_filename(driverPath);
if (args.hasArg(clang::driver::options::OPT_flang_experimental_hlfir) ||
       args.hasArg(clang::driver::options::OPT_emit_hlfir)) {
     res.loweringOpts.setLowerToHighLevelFIR(true);
   }
 
   if (args.hasArg(clang::driver::options::OPT_flang_experimental_polymorphism)) {
     res.loweringOpts.setPolymorphicTypeImpl(true);
   }
 
+  // -fno-ppc-native-vector-element-order
+  if (args.hasArg(clang::driver::options::OPT_fno_ppc_native_vec_elem_order)) {
+    res.loweringOpts.setNoPPCNativeVecElemOrder(true);
+  }
+
   success &= parseFrontendArgs(res.getFrontendOpts(), args, diags);
   parseTargetArgs(res.getTargetOpts(), args);
   parsePreprocessorArgs(res.getPreprocessorOpts(), args);
   parseCodeGenArgs(res.getCodeGenOpts(), args, diags);
   success &= parseDebugArgs(res.getCodeGenOpts(), args, diags);
   success &= parseSemaArgs(res, args, diags);
   success &= parseDialectArgs(res, args, diags);
   success &= parseDiagArgs(res, args, diags);

flang/lib/Lower/ConvertExpr.cpp

for (const auto &arg : llvm::enumerate(procRef.arguments())) {
       case fir::LowerIntrinsicArgAs::Inquired:
         operands.emplace_back(lowerIntrinsicArgumentAsInquired(*expr));
         continue;
       }
       llvm_unreachable("bad switch");
     }
     // Let the intrinsic library lower the intrinsic procedure call
     return Fortran::lower::genIntrinsicCall(builder, getLoc(), name, resultType,
-                                            operands, stmtCtx);
+                                            operands, stmtCtx, &converter);
   }
 
   /// helper to detect statement functions
   static bool
   isStatementFunctionCall(const Fortran::evaluate::ProcedureRef &procRef) {
     if (const Fortran::semantics::Symbol *symbol = procRef.proc().GetSymbol())
       if (const auto *details =
               symbol->detailsIf<Fortran::semantics::SubprogramDetails>())

flang/lib/Lower/CustomIntrinsicCall.cpp

 /// Generate the FIR+MLIR operations for the generic intrinsic \p name
 /// with arguments \p args and the expected result type \p resultType.
 /// Returned fir::ExtendedValue is the returned Fortran intrinsic value.
 fir::ExtendedValue
 Fortran::lower::genIntrinsicCall(fir::FirOpBuilder &builder, mlir::Location loc,
                                  llvm::StringRef name,
                                  std::optional<mlir::Type> resultType,
                                  llvm::ArrayRef<fir::ExtendedValue> args,
-                                 Fortran::lower::StatementContext &stmtCtx) {
+                                 Fortran::lower::StatementContext &stmtCtx,
+                                 Fortran::lower::AbstractConverter *converter) {
   auto [result, mustBeFreed] =
-      fir::genIntrinsicCall(builder, loc, name, resultType, args);
+      fir::genIntrinsicCall(builder, loc, name, resultType, args, converter);
   if (mustBeFreed) {
     mlir::Value addr = fir::getBase(result);
     if (auto *box = result.getBoxOf<fir::BoxValue>())
       addr =
           builder.create<fir::BoxAddrOp>(loc, box->getMemTy(), box->getAddr());
     fir::FirOpBuilder *bldr = &builder;
     stmtCtx.attachCleanup([=]() { bldr->create<fir::FreeMemOp>(loc, addr); });
   }

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

 
 //===----------------------------------------------------------------------===//
 // Public intrinsic call helpers
 //===----------------------------------------------------------------------===//
 
 std::pair<fir::ExtendedValue, bool>
 genIntrinsicCall(fir::FirOpBuilder &builder, mlir::Location loc,
                  llvm::StringRef name, std::optional<mlir::Type> resultType,
-                 llvm::ArrayRef<fir::ExtendedValue> args) {
-  return IntrinsicLibrary{builder, loc}.genIntrinsicCall(name, resultType,
-                                                         args);
+                 llvm::ArrayRef<fir::ExtendedValue> args,
+                 Fortran::lower::AbstractConverter *converter) {
+  return IntrinsicLibrary{builder, loc, converter}.genIntrinsicCall(
+      name, resultType, args);
 }
 
 mlir::Value genMax(fir::FirOpBuilder &builder, mlir::Location loc,
                    llvm::ArrayRef<mlir::Value> args) {
   assert(args.size() > 0 && "max requires at least one argument");
   return IntrinsicLibrary{builder, loc}
       .genExtremum<Extremum::Max, ExtremumBehavior::MinMaxss>(args[0].getType(),
                                                               args);

flang/lib/Optimizer/Builder/PPCIntrinsicCall.cpp

 
 #include "flang/Optimizer/Builder/PPCIntrinsicCall.h"
 #include "flang/Evaluate/common.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/MutableBox.h"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
 
 namespace fir {
 
 using PI = PPCIntrinsicLibrary;
 
 // PPC specific intrinsic handlers.
 static constexpr IntrinsicHandler ppcHandlers[]{
     {"__ppc_mma_assemble_acc",
      static_cast<IntrinsicLibrary::SubroutineGenerator>(
          &PI::genMmaIntr<MMAOp::AssembleAcc, MMAHandlerOp::SubToFunc>),
      {{{"acc", asAddr},
        {"arg1", asValue},
        {"arg2", asValue},
        {"arg3", asValue},

 static constexpr RtMap ppcMathOps(ppcMathOperations);
 static_assert(ppcMathOps.Verify() && "map must be sorted");
 
 std::pair<const MathOperation *, const MathOperation *>
 checkPPCMathOperationsRange(llvm::StringRef name) {
   return ppcMathOps.equal_range(name);
 }
 
+// Helper functions for vector element ordering.
+bool PPCIntrinsicLibrary::isBEVecElemOrderOnLE() {
+  return (Fortran::evaluate::isHostLittleEndian &&
+          converter->getLoweringOptions().getNoPPCNativeVecElemOrder());
+}
+bool PPCIntrinsicLibrary::isNativeVecElemOrderOnLE() {
+  return (Fortran::evaluate::isHostLittleEndian &&
+          !converter->getLoweringOptions().getNoPPCNativeVecElemOrder());
+}
+bool PPCIntrinsicLibrary::changeVecElemOrder() {
+  return (Fortran::evaluate::isHostLittleEndian !=
+          converter->getLoweringOptions().getNoPPCNativeVecElemOrder());
+}
+
 static mlir::FunctionType genMmaVpFuncType(mlir::MLIRContext *context,
                                            int quadCnt, int pairCnt, int vecCnt,
                                            int intCnt = 0,
                                            int vecElemBitSize = 8,
                                            int intBitSize = 32) {
   // Constructs a function type with the following signature:
   // Result type: __vector_pair
   // Arguments:
case VecOp::Convert: {
 
     return builder.createConvert(loc, firTy, conv);
   }
   case VecOp::Cvf: {
     assert(args.size() == 1);
 
     mlir::Value newArgs[]{vArg1};
     if (vecTyInfo.isFloat32()) {
-      // TODO: Handle element ordering
+      if (changeVecElemOrder())
         newArgs[0] = swapVectorWordPairs(builder, loc, newArgs[0]);
 
       const llvm::StringRef fname{"llvm.ppc.vsx.xvcvspdp"};
       auto ftype{
           genFuncType<Ty::RealVector<8>, Ty::RealVector<4>>(context, builder)};
       auto funcOp{builder.addNamedFunction(loc, fname, ftype)};
       auto callOp{builder.create<fir::CallOp>(loc, funcOp, newArgs)};
 
       return callOp.getResult(0);
     } else if (vecTyInfo.isFloat64()) {
       const llvm::StringRef fname{"llvm.ppc.vsx.xvcvdpsp"};
       auto ftype{
           genFuncType<Ty::RealVector<4>, Ty::RealVector<8>>(context, builder)};
       auto funcOp{builder.addNamedFunction(loc, fname, ftype)};
       newArgs[0] =
           builder.create<fir::CallOp>(loc, funcOp, newArgs).getResult(0);
       auto fvf32Ty{newArgs[0].getType()};
       auto f32type{mlir::FloatType::getF32(context)};
       auto mvf32Ty{mlir::VectorType::get(4, f32type)};
       newArgs[0] = builder.createConvert(loc, mvf32Ty, newArgs[0]);
 
-      // TODO: Handle element ordering
+      if (changeVecElemOrder())
         newArgs[0] = swapVectorWordPairs(builder, loc, newArgs[0]);
 
       return builder.createConvert(loc, fvf32Ty, newArgs[0]);
     }
     llvm_unreachable("invalid element integer kind");
   }
   default:
     llvm_unreachable("Invalid vector operation for generator");
   }

flang/test/Driver/driver-help-hidden.f90

 ! CHECK-NEXT:                        Enable Fortran 2003 polymorphism (experimental)
 ! CHECK-NEXT: -flarge-sizes          Use INTEGER(KIND=8) for the result type in size-related intrinsics
 ! CHECK-NEXT: -flogical-abbreviations Enable logical abbreviations
 ! CHECK-NEXT: -flto=<value> Set LTO mode
 ! CHECK-NEXT: -flto Enable LTO in 'full' mode
 ! CHECK-NEXT: -fno-automatic         Implies the SAVE attribute for non-automatic local objects in subprograms unless RECURSIVE
 ! CHECK-NEXT: -fno-color-diagnostics  Disable colors in diagnostics
 ! CHECK-NEXT: -fno-integrated-as     Disable the integrated assembler
+! CHECK-NEXT: -fno-ppc-native-vector-element-order
+! CHECK-NEXT:                        Specifies PowerPC non-native vector element order
 ! CHECK-NEXT: -fno-signed-zeros      Allow optimizations that ignore the sign of floating point zeros
 ! CHECK-NEXT: -fno-stack-arrays      Allocate array temporaries on the heap (default)
 ! CHECK-NEXT: -fno-version-loops-for-stride
 ! CHECK-NEXT:                        Do not create unit-strided loops (default)
 ! CHECK-NEXT: -fopenacc              Enable OpenACC
 ! CHECK-NEXT: -fopenmp-version=<value>
 ! CHECK-NEXT:                        Set OpenMP version (e.g. 45 for OpenMP 4.5, 50 for OpenMP 5.0). Default value is 50 for Clang and 11 for Flang
 ! CHECK-NEXT: -fopenmp               Parse OpenMP pragmas and generate parallel code.
 ! CHECK-NEXT: -foptimization-record-file=<file>
 ! CHECK-NEXT:                        Specify the output name of the file containing the optimization remarks. Implies -fsave-optimization-record. On Darwin platforms, this cannot be used with multiple -arch <arch> options.
 ! CHECK-NEXT: -foptimization-record-passes=<regex>
 ! CHECK-NEXT:                        Only include passes which match a specified regular expression in the generated optimization record (by default, include all passes)
 ! CHECK-NEXT: -fpass-plugin=<dsopath> Load pass plugin from a dynamic shared object file (only with new pass manager).
+! CHECK-NEXT: -fppc-native-vector-element-order
+! CHECK-NEXT:                        Specifies PowerPC native vector element order
 ! CHECK-NEXT: -freciprocal-math      Allow division operations to be reassociated
 ! CHECK-NEXT: -fsave-optimization-record=<format>
 ! CHECK-NEXT:                        Generate an optimization record file in a specific format
 ! CHECK-NEXT: -fsave-optimization-record
 ! CHECK-NEXT:                        Generate a YAML optimization record file
 ! CHECK-NEXT: -fstack-arrays         Attempt to allocate array temporaries on the stack, no matter their size
 ! CHECK-NEXT: -fsyntax-only          Run the preprocessor, parser and semantic analysis stages
 ! CHECK-NEXT: -funderscoring         Appends one trailing underscore to external names

flang/test/Driver/driver-help.f90

 ! HELP-NEXT:                        Specify where to find the compiled intrinsic modules
 ! HELP-NEXT: -flarge-sizes          Use INTEGER(KIND=8) for the result type in size-related intrinsics
 ! HELP-NEXT: -flogical-abbreviations Enable logical abbreviations
 ! HELP-NEXT: -flto=<value> Set LTO mode
 ! HELP-NEXT: -flto Enable LTO in 'full' mode
 ! HELP-NEXT: -fno-automatic         Implies the SAVE attribute for non-automatic local objects in subprograms unless RECURSIVE
 ! HELP-NEXT: -fno-color-diagnostics  Disable colors in diagnostics
 ! HELP-NEXT: -fno-integrated-as      Disable the integrated assembler
+! HELP-NEXT: -fno-ppc-native-vector-element-order
+! HELP-NEXT:                        Specifies PowerPC non-native vector element order
 ! HELP-NEXT: -fno-signed-zeros      Allow optimizations that ignore the sign of floating point zeros
 ! HELP-NEXT: -fno-stack-arrays      Allocate array temporaries on the heap (default)
 ! HELP-NEXT: -fno-version-loops-for-stride
 ! HELP-NEXT:                        Do not create unit-strided loops (default)
 ! HELP-NEXT: -fopenacc              Enable OpenACC
 ! HELP-NEXT: -fopenmp-version=<value>
 ! HELP-NEXT:                        Set OpenMP version (e.g. 45 for OpenMP 4.5, 50 for OpenMP 5.0). Default value is 50 for Clang and 11 for Flang
 ! HELP-NEXT: -fopenmp               Parse OpenMP pragmas and generate parallel code.
 ! HELP-NEXT: -foptimization-record-file=<file>
 ! HELP-NEXT:                        Specify the output name of the file containing the optimization remarks. Implies -fsave-optimization-record. On Darwin platforms, this cannot be used with multiple -arch <arch> options.
 ! HELP-NEXT: -foptimization-record-passes=<regex>
 ! HELP-NEXT:                        Only include passes which match a specified regular expression in the generated optimization record (by default, include all passes)
 ! HELP-NEXT: -fpass-plugin=<dsopath> Load pass plugin from a dynamic shared object file (only with new pass manager).
+! HELP-NEXT: -fppc-native-vector-element-order
+! HELP-NEXT:                        Specifies PowerPC native vector element order
 ! HELP-NEXT: -freciprocal-math      Allow division operations to be reassociated
 ! HELP-NEXT: -fsave-optimization-record=<format>
 ! HELP-NEXT:                        Generate an optimization record file in a specific format
 ! HELP-NEXT: -fsave-optimization-record
 ! HELP-NEXT:                        Generate a YAML optimization record file
 ! HELP-NEXT: -fstack-arrays         Attempt to allocate array temporaries on the stack, no matter their size
 ! HELP-NEXT: -fsyntax-only          Run the preprocessor, parser and semantic analysis stages
 ! HELP-NEXT: -funderscoring         Appends one trailing underscore to external names

 ! HELP-FC1-NEXT: -flarge-sizes          Use INTEGER(KIND=8) for the result type in size-related intrinsics
 ! HELP-FC1-NEXT: -flogical-abbreviations Enable logical abbreviations
 ! HELP-FC1-NEXT: -flto=<value>           Set LTO mode
 ! HELP-FC1-NEXT: -flto                   Enable LTO in 'full' mode
 ! HELP-FC1-NEXT: -fno-analyzed-objects-for-unparse
 ! HELP-FC1-NEXT:                        Do not use the analyzed objects when unparsing
 ! HELP-FC1-NEXT: -fno-automatic         Implies the SAVE attribute for non-automatic local objects in subprograms unless RECURSIVE
 ! HELP-FC1-NEXT: -fno-debug-pass-manager Disables debug printing for the new pass manager
+! HELP-FC1-NEXT: -fno-ppc-native-vector-element-order
+! HELP-FC1-NEXT:                        Specifies PowerPC non-native vector element order
 ! HELP-FC1-NEXT: -fno-reformat          Dump the cooked character stream in -E mode
 ! HELP-FC1-NEXT: -fno-signed-zeros      Allow optimizations that ignore the sign of floating point zeros
 ! HELP-FC1-NEXT: -fno-stack-arrays      Allocate array temporaries on the heap (default)
 ! HELP-FC1-NEXT: -fno-version-loops-for-stride
 ! HELP-FC1-NEXT:                        Do not create unit-strided loops (default)
 ! HELP-FC1-NEXT: -fopenacc              Enable OpenACC
 ! HELP-FC1-NEXT: -fopenmp-host-ir-file-path <value> 
 ! HELP-FC1-NEXT:                        Path to the IR file produced by the frontend for the host.
 ! HELP-FC1-NEXT: -fopenmp-is-target-device
 ! HELP-FC1-NEXT:                        Generate code only for an OpenMP target device.
 ! HELP-FC1-NEXT: -fopenmp-target-debug  Enable debugging in the OpenMP offloading device RTL
 ! HELP-FC1-NEXT: -fopenmp-version=<value>
 ! HELP-FC1-NEXT:                        Set OpenMP version (e.g. 45 for OpenMP 4.5, 50 for OpenMP 5.0). Default value is 50 for Clang and 11 for Flang
 ! HELP-FC1-NEXT: -fopenmp               Parse OpenMP pragmas and generate parallel code.
 ! HELP-FC1-NEXT: -fpass-plugin=<dsopath> Load pass plugin from a dynamic shared object file (only with new pass manager).
+! HELP-FC1-NEXT: -fppc-native-vector-element-order
+! HELP-FC1-NEXT:                        Specifies PowerPC native vector element order
 ! HELP-FC1-NEXT: -freciprocal-math      Allow division operations to be reassociated
 ! HELP-FC1-NEXT: -fstack-arrays         Attempt to allocate array temporaries on the stack, no matter their size
 ! HELP-FC1-NEXT: -fsyntax-only          Run the preprocessor, parser and semantic analysis stages
 ! HELP-FC1-NEXT: -funderscoring         Appends one trailing underscore to external names
 ! HELP-FC1-NEXT: -fversion-loops-for-stride
 ! HELP-FC1-NEXT:                        Create unit-strided versions of loops
 ! HELP-FC1-NEXT: -fxor-operator         Enable .XOR. as a synonym of .NEQV.
 ! HELP-FC1-NEXT: -help                  Display available options

flang/test/Driver/frontend-forwarding.f90

 ! RUN:     -fapprox-func \
 ! RUN:     -fno-signed-zeros \
 ! RUN:     -fassociative-math \
 ! RUN:     -freciprocal-math \
 ! RUN:     -fpass-plugin=Bye%pluginext \
 ! RUN:     -fversion-loops-for-stride \
 ! RUN:     -flang-experimental-polymorphism \
 ! RUN:     -flang-experimental-hlfir \
+! RUN:     -fno-ppc-native-vector-element-order \
+! RUN:     -fppc-native-vector-element-order \
 ! RUN:     -mllvm -print-before-all \
 ! RUN:     -save-temps=obj \
 ! RUN:     -P \
 ! RUN:   | FileCheck %s
 
 ! CHECK: "-P"
 ! CHECK: "-finput-charset=utf-8"
 ! CHECK: "-fdefault-double-8"
 ! CHECK: "-fdefault-integer-8"
 ! CHECK: "-fdefault-real-8"
 ! CHECK: "-flarge-sizes"
 ! CHECK: "-ffp-contract=fast"
 ! CHECK: "-menable-no-nans"
 ! CHECK: "-fapprox-func"
 ! CHECK: "-fno-signed-zeros"
 ! CHECK: "-mreassociate"
 ! CHECK: "-freciprocal-math"
 ! CHECK: "-fconvert=little-endian"
 ! CHECK: "-fpass-plugin=Bye
 ! CHECK: "-fversion-loops-for-stride"
 ! CHECK: "-flang-experimental-polymorphism"
 ! CHECK: "-flang-experimental-hlfir"
+! CHECK: "-fno-ppc-native-vector-element-order"
+! CHECK: "-fppc-native-vector-element-order"
 ! CHECK: "-mllvm" "-print-before-all"
 ! CHECK: "-save-temps=obj"

flang/test/Lower/PowerPC/ppc-vec_cvf-elem-order.f90

+! RUN: bbc -emit-fir %s -fno-ppc-native-vector-element-order=true -o - | FileCheck --check-prefixes="FIR" %s
+! RUN: %flang_fc1 -emit-llvm %s -fno-ppc-native-vector-element-order -o - | FileCheck --check-prefixes="LLVMIR" %s
+! REQUIRES: target=powerpc{{.*}}
+
+! CHECK-LABEL: vec_cvf_test_r4r8
+subroutine vec_cvf_test_r4r8(arg1)
+  vector(real(8)), intent(in) :: arg1
+  vector(real(4)) :: r
+  r = vec_cvf(arg1)
+
+! FIR: %[[arg:.*]] = fir.load %{{.*}} : !fir.ref<!fir.vector<2:f64>>
+! FIR: %[[carg:.*]] = fir.convert %[[arg]] : (!fir.vector<2:f64>) -> vector<2xf64>
+! FIR: %[[call:.*]] = fir.call @llvm.ppc.vsx.xvcvdpsp(%[[carg]]) fastmath<contract> : (vector<2xf64>) -> !fir.vector<4:f32>
+! FIR: %[[ccall:.*]] = fir.convert %[[call]] : (!fir.vector<4:f32>) -> vector<4xf32>
+! FIR: %[[r:.*]] = fir.convert %[[ccall]] : (vector<4xf32>) -> !fir.vector<4:f32>
+! FIR: fir.store %[[r]] to %{{.*}} : !fir.ref<!fir.vector<4:f32>>
+
+! LLVMIR: %[[arg:.*]] = load <2 x double>, ptr %{{.*}}, align 16
+! LLVMIR: %[[call:.*]] = call contract <4 x float> @llvm.ppc.vsx.xvcvdpsp(<2 x double> %[[arg]])
+! LLVMIR: store <4 x float> %[[call]], ptr %{{.*}}, align 16
+end subroutine vec_cvf_test_r4r8
+
+! CHECK-LABEL: vec_cvf_test_r8r4
+subroutine vec_cvf_test_r8r4(arg1)
+  vector(real(4)), intent(in) :: arg1
+  vector(real(8)) :: r
+  r = vec_cvf(arg1)
+
+! FIR: %[[arg:.*]] = fir.load %{{.*}} : !fir.ref<!fir.vector<4:f32>>
+! FIR: %[[carg:.*]] = fir.convert %[[arg]] : (!fir.vector<4:f32>) -> vector<4xf32>
+! FIR: %[[call:.*]] = fir.call @llvm.ppc.vsx.xvcvspdp(%[[carg]]) fastmath<contract> : (vector<4xf32>) -> !fir.vector<2:f64>
+! FIR: fir.store %[[call]] to %{{.*}} : !fir.ref<!fir.vector<2:f64>>
+
+! LLVMIR: %[[arg:.*]] = load <4 x float>, ptr %{{.*}}, align 16
+! LLVMIR: %[[r:.*]] = call contract <2 x double> @llvm.ppc.vsx.xvcvspdp(<4 x float> %[[arg]])
+! LLVMIR: store <2 x double> %[[r]], ptr %{{.*}}, align 16
+end subroutine vec_cvf_test_r8r4

flang/tools/bbc/bbc.cpp

static llvm::cl::opt<bool> enableOpenACC("fopenacc",
                                          llvm::cl::desc("enable openacc"),
                                          llvm::cl::init(false));
 
 static llvm::cl::opt<bool> enablePolymorphic(
     "polymorphic-type",
     llvm::cl::desc("enable polymorphic type lowering (experimental)"),
     llvm::cl::init(false));
 
+static llvm::cl::opt<bool> enableNoPPCNativeVecElemOrder(
+    "fno-ppc-native-vector-element-order",
+    llvm::cl::desc("no PowerPC native vector element order."),
+    llvm::cl::init(false));
+
 static llvm::cl::opt<bool> useHLFIR("hlfir",
                                     llvm::cl::desc("Lower to high level FIR"),
                                     llvm::cl::init(false));
 
 static llvm::cl::opt<bool> enableCUDA("fcuda",
                                       llvm::cl::desc("enable CUDA Fortran"),
                                       llvm::cl::init(false));
 
static mlir::LogicalResult convertFortranSourceToMLIR(
   mlir::MLIRContext ctx(registry);
   fir::support::loadNonCodegenDialects(ctx);
   auto &defKinds = semanticsContext.defaultKinds();
   fir::KindMapping kindMap(
       &ctx, llvm::ArrayRef<fir::KindTy>{fir::fromDefaultKinds(defKinds)});
   // Use default lowering options for bbc.
   Fortran::lower::LoweringOptions loweringOptions{};
   loweringOptions.setPolymorphicTypeImpl(enablePolymorphic);
+  loweringOptions.setNoPPCNativeVecElemOrder(enableNoPPCNativeVecElemOrder);
   loweringOptions.setLowerToHighLevelFIR(useHLFIR || emitHLFIR);
   auto burnside = Fortran::lower::LoweringBridge::create(
       ctx, semanticsContext, defKinds, semanticsContext.intrinsics(),
       semanticsContext.targetCharacteristics(), parsing.allCooked(), "",
       kindMap, loweringOptions, {});
   burnside.lower(parseTree, semanticsContext);
   mlir::ModuleOp mlirModule = burnside.getModule();
   if (enableOpenMP) {