[Flang][RFC] Adding extension intrinsics

[kkwli0]

Summary

This RFC is for adding extension builtins to flang. The approach is to make use of the existing intrinsic module mechanism (i.e. __fortran_builtins.f90) to add the platforms specific builtins (e.g. fmsub builtin supported for PPC platform). The framework here is to add an intrinsic module (__fortran_ppc_intrinsics.f90) that the __Fortran_PPC_intrinsics.mod is implicitly "USEd" in every compilation.

This work is still WIP (e.g. no platform specific checking). Please comment. Thanks.

[klausler]

flang/lib/Evaluate/intrinsics.cpp

917 ↗

(On Diff #497108)

I still am not sure whether you need to have intrinsic table entries for these. If you declare these names via Fortran INTERFACE blocks or PROCEDURE statements in a built-in module, all of the dummy argument and result information will be completely specified there, and doesn't need to be redundantly specified here. These tables are for intrinsics in the standard Fortran language, because those intrinsics usually cannot be completely specified in Fortran itself, like I believe yours can be.

flang/lib/Semantics/semantics.cpp

475

If extBuiltinsScope is only ever going to hold these PPC intrinsics, please give it a less generic name, like ppcBuiltinsScope, so that it's more clear to the code reader what's going on here.

flang/module/__fortran_ppc_builtins.f90

1 ↗

(On Diff #497108)

Please update the first lines of these comment blocks when you copy & paste them into new files.

flang/module/__ppc_intrinsics.f90

1 ↗

(On Diff #497108)

Same here.

[kkwli0]

flang/lib/Evaluate/intrinsics.cpp

917 ↗

(On Diff #497108)

Thanks for the review. I think I can see the benefit of having the interface in the intrinsic module. However, I am not sure if it will push the error checking in the Lowering stage (IntrinsicCall.cpp).

flang/lib/Semantics/semantics.cpp

475

If extBuiltinsScope is only ever going to hold these PPC intrinsics, please give it a less generic name, like ppcBuiltinsScope, so that it's more clear to the code reader what's going on here.

Sure. I will change it to ppcBuiltinsScope. My original idea is that this field can take some other builtin table.

flang/module/__fortran_ppc_builtins.f90

1 ↗

(On Diff #497108)

Oops. Will fix it.

[kkwli0]

I update the patch that puts the interfaces in the module for further discussion. Thanks.

[klausler]

This is looking pretty good.

flang/include/flang/Semantics/semantics.h

282

As with the line above, please put the module name into the comment.

flang/lib/Evaluate/intrinsics.cpp

2354 ↗

(On Diff #497679)

Is this still needed here in intrinsics processing?

3168 ↗

(On Diff #497679)

Is this also still needed here in intrinsics processing?

flang/module/__fortran_ppc_intrinsics.f90

10

Is this a complete list of the PPC vector intrinsics, or are there more to come?

39

Do you want to also undefined SPECIFICS_R and PRIVATE_R? Or just leave all three macros defined at the end of the source file.

[klausler]

flang/module/__fortran_ppc_intrinsics.f90

13

The module might be more clear if it had a blanket PRIVATE statement and then a PUBLIC:: that exposed only the names of the generics.

Instead of explicit INTERFACE blocks for all of the functions, you could define two with ABSTRACT INTERFACE and then use simple PROCEDURE(interface name) statements in the generic interfaces. Maybe then you wouldn't even need any macros.

[kkwli0]

flang/include/flang/Semantics/semantics.h

282

Will do.

flang/lib/Evaluate/intrinsics.cpp

2354 ↗

(On Diff #497679)

Yes, the ppcBuiltinsScope_ is no longer needed.

3168 ↗

(On Diff #497679)

Will remove it.

flang/module/__fortran_ppc_intrinsics.f90

10

No, there are more for PPC non-vector and a lot more for vector intrinsics.

13

Yeah, I agree that this is a cleaner approach. However, for the non-vector PPC intrinsics, there are some variants in terms of number of arguments, types of arguments and also the argument keywords. I will try to group some of them to make use of the abstract interface and procedure statement.

39

I will undef if the macros stay.

[klausler]

Both of the continuous integration builds are failing on this patch; please resolve them before asking for final approval.

[kkwli0]

The change includes:

• address review comments
  • use abstract interface in __Fortran_PPC_intrinsics module
  • remove an unnecessary member
  • rename a member name to be less generic
• add arch check
• fix format

[klausler]

flang/module/__fortran_ppc_intrinsics.f90

24

These procedure statements can appear in the generic interface.

[kkwli0]

flang/module/__fortran_ppc_intrinsics.f90

24

It doesn't work. For the procedure-stmt in interface-specification, the standard only allows:
[ MODULE ] PROCEDURE [ :: ] specific-procedure-list

[kkwli0]

Fix pre-commit build failures

[klausler]

Well done, and thanks!

[kkwli0]

In D143951#4136473, @klausler wrote:

Well done, and thanks!

Thanks a lot for the review.

flang/include/flang/Semantics/semantics.h

public:
 
   // Locate and process the contents of a built-in module on demand
   Scope *GetBuiltinModule(const char *name);
 
   // Defines builtinsScope_ from the __Fortran_builtins module
   void UseFortranBuiltinsModule();
   const Scope *GetBuiltinsScope() const { return builtinsScope_; }
 
+  void UsePPCFortranBuiltinsModule();
+  const Scope *GetPPCBuiltinsScope() const { return ppcBuiltinsScope_; }
+
   // Saves a module file's parse tree so that it remains available
   // during semantics.
   parser::Program &SaveParseTree(parser::Program &&);
 
   // Ensures a common block definition does not conflict with previous
   // appearances in the program and consolidate information about
   // common blocks at the program level for later checks and lowering.
   // This can obviously not check any conflicts between different compilation
struct IndexVarInfo {
     parser::CharBlock location;
     IndexVarKind kind;
   };
   std::map<SymbolRef, const IndexVarInfo, SymbolAddressCompare>
       activeIndexVars_;
   UnorderedSymbolSet errorSymbols_;
   std::set<std::string> tempNames_;
   const Scope *builtinsScope_{nullptr}; // module __Fortran_builtins
+  const Scope *ppcBuiltinsScope_{nullptr}; // module __Fortran_PPC_intrinsics
   std::list<parser::Program> modFileParseTrees_;
   std::unique_ptr<CommonBlockMap> commonBlockMap_;
   bool anyDefinedIntrinsicOperator_{false};
 };
 
 class Semantics {
 public:
   explicit Semantics(SemanticsContext &context, parser::Program &program,

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

 #include "flang/Optimizer/Builder/Runtime/Intrinsics.h"
 #include "flang/Optimizer/Builder/Runtime/Numeric.h"
 #include "flang/Optimizer/Builder/Runtime/RTBuilder.h"
 #include "flang/Optimizer/Builder/Runtime/Reduction.h"
 #include "flang/Optimizer/Builder/Runtime/Stop.h"
 #include "flang/Optimizer/Builder/Runtime/Transformational.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
+#include "flang/Optimizer/Support/FIRContext.h"
 #include "flang/Optimizer/Support/FatalError.h"
 #include "flang/Optimizer/Support/Utils.h"
 #include "flang/Runtime/entry-names.h"
 #include "mlir/Dialect/Complex/IR/Complex.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/Math/IR/Math.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
static mlir::FunctionType genF80F80F80FuncType(mlir::MLIRContext *context) {
   return mlir::FunctionType::get(context, {t, t}, {t});
 }
 
 static mlir::FunctionType genF128F128F128FuncType(mlir::MLIRContext *context) {
   auto t = mlir::FloatType::getF128(context);
   return mlir::FunctionType::get(context, {t, t}, {t});
 }
 
+static mlir::FunctionType genF32F32F32F32FuncType(mlir::MLIRContext *context) {
+  auto t = mlir::FloatType::getF32(context);
+  return mlir::FunctionType::get(context, {t, t, t}, {t});
+}
+
+static mlir::FunctionType genF64F64F64F64FuncType(mlir::MLIRContext *context) {
+  auto t = mlir::FloatType::getF64(context);
+  return mlir::FunctionType::get(context, {t, t, t}, {t});
+}
+
 template <int Bits>
 static mlir::FunctionType genIntF64FuncType(mlir::MLIRContext *context) {
   auto t = mlir::FloatType::getF64(context);
   auto r = mlir::IntegerType::get(context, Bits);
   return mlir::FunctionType::get(context, {t}, {r});
 }
 
 template <int Bits>
static constexpr MathOperation mathOperations[] = {
     {"tanh", "tanhf", genF32F32FuncType, genMathOp<mlir::math::TanhOp>},
     {"tanh", "tanh", genF64F64FuncType, genMathOp<mlir::math::TanhOp>},
     {"tanh", "ctanhf", genComplexComplexFuncType<4>,
      genComplexMathOp<mlir::complex::TanhOp>},
     {"tanh", "ctanh", genComplexComplexFuncType<8>,
      genComplexMathOp<mlir::complex::TanhOp>},
 };
 
+static constexpr MathOperation ppcMathOperations[] = {
+    {"__ppc_fmadd", "llvm.fma.f32", genF32F32F32F32FuncType,
+     genMathOp<mlir::math::FmaOp>},
+    {"__ppc_fmadd", "llvm.fma.f64", genF64F64F64F64FuncType,
+     genMathOp<mlir::math::FmaOp>},
+    {"__ppc_fmsub", "llvm.ppc.fmsubs", genF32F32F32F32FuncType, genLibCall},
+    {"__ppc_fmsub", "llvm.ppc.fmsub", genF64F64F64F64FuncType, genLibCall},
+    {"__ppc_fnmadd", "llvm.ppc.fnmadds", genF32F32F32F32FuncType, genLibCall},
+    {"__ppc_fnmadd", "llvm.ppc.fnmadd", genF64F64F64F64FuncType, genLibCall},
+    {"__ppc_fnmsub", "llvm.ppc.fnmsub.f32", genF32F32F32F32FuncType,
+     genLibCall},
+    {"__ppc_fnmsub", "llvm.ppc.fnmsub.f64", genF64F64F64F64FuncType,
+     genLibCall},
+};
+
 // This helper class computes a "distance" between two function types.
 // The distance measures how many narrowing conversions of actual arguments
 // and result of "from" must be made in order to use "to" instead of "from".
 // For instance, the distance between ACOS(REAL(10)) and ACOS(REAL(8)) is
 // greater than the one between ACOS(REAL(10)) and ACOS(REAL(16)). This means
 // if no implementation of ACOS(REAL(10)) is available, it is better to use
 // ACOS(REAL(16)) with casts rather than ACOS(REAL(8)).
 // Note that this is not a symmetric distance and the order of "from" and "to"
private:
   std::array<int, dataSize> conversions = {};
   bool infinite = false; // When forbidden conversion or wrong argument number
 };
 
 using RtMap = Fortran::common::StaticMultimapView<MathOperation>;
 static constexpr RtMap mathOps(mathOperations);
 static_assert(mathOps.Verify() && "map must be sorted");
 
+// PPC
+static constexpr RtMap ppcMathOps(ppcMathOperations);
+static_assert(ppcMathOps.Verify() && "map must be sorted");
+
 /// Look for a MathOperation entry specifying how to lower a mathematical
 /// operation defined by \p name with its result' and operands' types
 /// specified in the form of a FunctionType \p funcType.
 /// If exact match for the given types is found, then the function
 /// returns a pointer to the corresponding MathOperation.
 /// Otherwise, the function returns nullptr.
 /// If there is a MathOperation that can be used with additional
 /// type casts for the operands or/and result (non-exact match),
 /// then it is returned via \p bestNearMatch argument, and
 /// \p bestMatchDistance specifies the FunctionDistance between
 /// the requested operation and the non-exact match.
 static const MathOperation *
 searchMathOperation(fir::FirOpBuilder &builder, llvm::StringRef name,
                     mlir::FunctionType funcType,
                     const MathOperation **bestNearMatch,
                     FunctionDistance &bestMatchDistance) {
   auto range = mathOps.equal_range(name);
+  auto mod = builder.getModule();
+
+  // Search ppcMathOps only if targetting PowerPC arch
+  if (fir::getTargetTriple(mod).isPPC() && range.first == range.second) {
+    range = ppcMathOps.equal_range(name);
+  }
   for (auto iter = range.first; iter != range.second && iter; ++iter) {
     const auto &impl = *iter;
     auto implType = impl.typeGenerator(builder.getContext());
     if (funcType == implType)
       return &impl; // exact match
 
     FunctionDistance distance(funcType, implType);
     if (distance.isSmallerThan(bestMatchDistance)) {

 }
 
 //===----------------------------------------------------------------------===//
 // IntrinsicLibrary
 //===----------------------------------------------------------------------===//
 
 static bool isIntrinsicModuleProcedure(llvm::StringRef name) {
   return name.startswith("c_") || name.startswith("compiler_") ||
-         name.startswith("ieee_");
+         name.startswith("ieee_") || name.startswith("__ppc_");
 }
 
 /// Return the generic name of an intrinsic module procedure specific name.
 /// Remove any "__builtin_" prefix, and any specific suffix of the form
 /// {_[ail]?[0-9]+}*, such as _1 or _a4.
 llvm::StringRef genericName(llvm::StringRef specificName) {
   const std::string builtin = "__builtin_";
   llvm::StringRef name = specificName.startswith(builtin)

flang/lib/Semantics/CMakeLists.txt

add_flang_library(FortranSemantics
   FortranCommon
   FortranParser
   FortranEvaluate
 
   LINK_COMPONENTS
   Support
   FrontendOpenMP
   FrontendOpenACC
+  TargetParser
 )

flang/lib/Semantics/resolve-names.cpp

 void ResolveNamesVisitor::HandleProcedureName(
     Symbol::Flag flag, const parser::Name &name) {
   CHECK(flag == Symbol::Flag::Function || flag == Symbol::Flag::Subroutine);
   auto *symbol{FindSymbol(NonDerivedTypeScope(), name)};
   if (!symbol) {
     if (IsIntrinsic(name.source, flag)) {
       symbol =
           &MakeSymbol(InclusiveScope(), name.source, Attrs{Attr::INTRINSIC});
+    } else if (const auto ppcBuiltinScope =
+                   currScope().context().GetPPCBuiltinsScope()) {
+      // Check if it is a builtin from the predefined module
+      symbol = FindSymbol(*ppcBuiltinScope, name);
+      if (!symbol)
+        symbol = &MakeSymbol(context().globalScope(), name.source, Attrs{});
     } else {
       symbol = &MakeSymbol(context().globalScope(), name.source, Attrs{});
     }
     Resolve(name, *symbol);
     if (!symbol->attrs().test(Attr::INTRINSIC)) {
       if (CheckImplicitNoneExternal(name.source, *symbol)) {
         MakeExternal(*symbol);
       }

flang/lib/Semantics/semantics.cpp

 #include "rewrite-parse-tree.h"
 #include "flang/Common/default-kinds.h"
 #include "flang/Parser/parse-tree-visitor.h"
 #include "flang/Parser/tools.h"
 #include "flang/Semantics/expression.h"
 #include "flang/Semantics/scope.h"
 #include "flang/Semantics/symbol.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/TargetParser/Host.h"
+#include "llvm/TargetParser/Triple.h"
 
 namespace Fortran::semantics {
 
 using NameToSymbolMap = std::multimap<parser::CharBlock, SymbolRef>;
 static void DoDumpSymbols(llvm::raw_ostream &, const Scope &, int indent = 0);
 static void PutIndent(llvm::raw_ostream &, int indent);
 
 static void GetSymbolNames(const Scope &scope, NameToSymbolMap &symbols) {
void SemanticsContext::UseFortranBuiltinsModule() {
   if (builtinsScope_ == nullptr) {
     builtinsScope_ = GetBuiltinModule("__fortran_builtins");
     if (builtinsScope_) {
       intrinsics_.SupplyBuiltins(*builtinsScope_);
     }
   }
 }
 
+void SemanticsContext::UsePPCFortranBuiltinsModule() {
+  if (ppcBuiltinsScope_ == nullptr) {
+    ppcBuiltinsScope_ = GetBuiltinModule("__fortran_ppc_intrinsics");
+  }
+}
+
 parser::Program &SemanticsContext::SaveParseTree(parser::Program &&tree) {
   return modFileParseTrees_.emplace_back(std::move(tree));
 }
 
 bool Semantics::Perform() {
   // Implicitly USE the __Fortran_builtins module so that special types
   // (e.g., __builtin_team_type) are available to semantics, esp. for
   // intrinsic checking.
   if (!program_.v.empty()) {
     const auto *frontModule{std::get_if<common::Indirection<parser::Module>>(
         &program_.v.front().u)};
     if (frontModule &&
-        std::get<parser::Statement<parser::ModuleStmt>>(frontModule->value().t)
-                .statement.v.source == "__fortran_builtins") {
+        (std::get<parser::Statement<parser::ModuleStmt>>(frontModule->value().t)
+                    .statement.v.source == "__fortran_builtins" ||
+            std::get<parser::Statement<parser::ModuleStmt>>(
+                frontModule->value().t)
+                    .statement.v.source == "__fortran_ppc_intrinsics")) {
       // Don't try to read the builtins module when we're actually building it.
     } else {
       context_.UseFortranBuiltinsModule();
+      llvm::Triple targetTriple{llvm::Triple(
+          llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple()))};
+      // Only use __Fortran_PPC_intrinsics module when targetting PowerPC arch
+      if (targetTriple.isPPC()) {
+        context_.UsePPCFortranBuiltinsModule();
+      }
     }
   }
   return ValidateLabels(context_, program_) &&
       parser::CanonicalizeDo(program_) && // force line break
       CanonicalizeAcc(context_.messages(), program_) &&
       CanonicalizeOmp(context_.messages(), program_) &&
       PerformStatementSemantics(context_, program_) &&
       ModFileWriter{context_}.WriteAll();

flang/module/__fortran_ppc_intrinsics.f90

+!===-- module/__fortran_ppc_intrinsics.f90 ---------------------------------===!
+!
+! 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
+!
+!===------------------------------------------------------------------------===!
+
+module __Fortran_PPC_intrinsics
+
+  private
+
+! fmadd, fmsub, fnmadd, fnmsub
+  abstract interface
+    elemental real(4) function func_r4r4r4r4(a, x, y)
+      real(4), intent(in) :: a, x, y
+    end function func_r4r4r4r4
+    elemental real(8) function func_r8r8r8r8(a, x, y)
+      real(8), intent(in) :: a, x, y
+    end function func_r8r8r8r8
+  end interface
+
+  procedure(func_r4r4r4r4) :: __ppc_fmadd_r4
+  procedure(func_r8r8r8r8) :: __ppc_fmadd_r8
+  interface fmadd
+    procedure :: __ppc_fmadd_r4
+    procedure :: __ppc_fmadd_r8
+  end interface fmadd
+  public :: fmadd
+
+  procedure(func_r4r4r4r4) :: __ppc_fmsub_r4
+  procedure(func_r8r8r8r8) :: __ppc_fmsub_r8
+  interface fmsub
+    procedure :: __ppc_fmsub_r4
+    procedure :: __ppc_fmsub_r8
+  end interface fmsub
+  public :: fmsub
+
+  procedure(func_r4r4r4r4) :: __ppc_fnmadd_r4
+  procedure(func_r8r8r8r8) :: __ppc_fnmadd_r8
+  interface fnmadd
+    procedure :: __ppc_fnmadd_r4
+    procedure :: __ppc_fnmadd_r8
+  end interface fnmadd
+  public :: fnmadd
+
+  procedure(func_r4r4r4r4) :: __ppc_fnmsub_r4
+  procedure(func_r8r8r8r8) :: __ppc_fnmsub_r8
+  interface fnmsub
+    procedure :: __ppc_fnmsub_r4
+    procedure :: __ppc_fnmsub_r8
+  end interface fnmsub
+  public :: fnmsub
+
+end module __Fortran_PPC_intrinsics

flang/test/Lower/ppc-intrinsics.f90

+! RUN: bbc -emit-fir %s -outline-intrinsics -o - | FileCheck --check-prefixes="CHECK-FIR" %s
+! RUN: %flang_fc1 -emit-llvm %s -o - | FileCheck --check-prefixes="CHECK-LLVMIR" %s
+! REQUIRES: target=powerpc{{.*}}
+
+! CHECK-LABEL: fmadd_testr
+subroutine fmadd_testr(a, x, y)
+  real :: a, x, y, z
+  z = fmadd(a, x, y)
+! CHECK-FIR: fir.call @fir.__ppc_fmadd.f32.f32.f32.f32
+! CHECK-LLVMIR: call contract float @llvm.fma.f32(float %{{[0-9]}}, float %{{[0-9]}}, float %{{[0-9]}})
+end
+
+! CHECK-LABEL: fmadd_testd
+subroutine fmadd_testd(a, x, y)
+  real(8) :: a, x, y, z
+  z = fmadd(a, x, y)
+! CHECK-FIR: fir.call @fir.__ppc_fmadd.f64.f64.f64.f64
+! CHECK-LLVMIR: call contract double @llvm.fma.f64(double %{{[0-9]}}, double %{{[0-9]}}, double %{{[0-9]}})
+end
+
+! CHECK-LABEL: fnmadd_testr
+subroutine fnmadd_testr(a, x, y)
+  real :: a, x, y, z
+  z = fnmadd(a, x, y)
+! CHECK-FIR: fir.call @fir.__ppc_fnmadd.f32.f32.f32.f32
+! CHECK-LLVMIR: call contract float @llvm.ppc.fnmadds(float %{{[0-9]}}, float %{{[0-9]}}, float %{{[0-9]}})
+end
+
+! CHECK-LABEL: fnmadd_testd
+subroutine fnmadd_testd(a, x, y)
+  real(8) :: a, x, y, z
+  z = fnmadd(a, x, y)
+! CHECK-FIR: fir.call @fir.__ppc_fnmadd.f64.f64.f64.f64
+! CHECK-LLVMIR: call contract double @llvm.ppc.fnmadd(double %{{[0-9]}}, double %{{[0-9]}}, double %{{[0-9]}})
+end
+
+! CHECK-LABEL: fmsub_testr
+subroutine fmsub_testr(a, x, y)
+  real :: a, x, y, z
+  z = fmsub(a, x, y)
+! CHECK-FIR: fir.call @fir.__ppc_fmsub.f32.f32.f32.f32
+! CHECK-LLVMIR: call contract float @llvm.ppc.fmsubs(float %{{[0-9]}}, float %{{[0-9]}}, float %{{[0-9]}})
+end
+
+! CHECK-LABEL: fmsub_testd
+subroutine fmsub_testd(a, x, y)
+  real(8) :: a, x, y, z
+  z = fmsub(a, x, y)
+! CHECK-FIR: fir.call @fir.__ppc_fmsub.f64.f64.f64.f64
+! CHECK-LLVMIR: call contract double @llvm.ppc.fmsub(double %{{[0-9]}}, double %{{[0-9]}}, double %{{[0-9]}})
+end
+
+! CHECK-LABEL: fnmsub_testr
+subroutine fnmsub_testr(a, x, y)
+  real :: a, x, y, z
+  z = fnmsub(a, x, y)
+! CHECK-FIR: fir.call @fir.__ppc_fnmsub.f32.f32.f32.f32
+! CHECK-LLVMIR: call contract float @llvm.ppc.fnmsub.f32(float %{{[0-9]}}, float %{{[0-9]}}, float %{{[0-9]}})
+end
+
+! CHECK-LABEL: fnmsub_testd
+subroutine fnmsub_testd(a, x, y)
+  real(8) :: a, x, y, z
+  z = fnmsub(a, x, y)
+! CHECK-FIR: fir.call @fir.__ppc_fnmsub.f64.f64.f64.f64
+! CHECK-LLVMIR: call contract double @llvm.ppc.fnmsub.f64(double %{{[0-9]}}, double %{{[0-9]}}, double %{{[0-9]}})
+end

flang/tools/f18/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   FrontendOpenACC
   FrontendOpenMP
   Support
   )
 
 set(MODULES
   "__fortran_builtins"
   "__fortran_ieee_exceptions"
   "__fortran_type_info"
+  "__fortran_ppc_intrinsics"
   "ieee_arithmetic"
   "ieee_exceptions"
   "ieee_features"
   "iso_c_binding"
   "iso_fortran_env"
   "omp_lib"
   "__fortran_builtins"
   "__fortran_type_info"
 )
 
 # Create module files directly from the top-level module source directory.
 # If CMAKE_CROSSCOMPILING, then the newly built flang-new executable was
 # cross compiled, and thus can't be executed on the build system and thus
 # can't be used for generating module files.
 if (NOT CMAKE_CROSSCOMPILING)
   foreach(filename ${MODULES})
     set(base ${FLANG_INTRINSIC_MODULES_DIR}/${filename})
     if(${filename} STREQUAL "__fortran_builtins")
       set(depends "")
+    elseif(${filename} STREQUAL "__fortran_ppc_intrinsics")
+      set(depends "")
     else()
       set(depends ${FLANG_INTRINSIC_MODULES_DIR}/__fortran_builtins.mod)
       if(NOT ${filename} STREQUAL "__fortran_type_info")
         set(depends ${FLANG_INTRINSIC_MODULES_DIR}/__fortran_type_info.mod)
       endif()
       if(${filename} STREQUAL "ieee_arithmetic" OR
          ${filename} STREQUAL "ieee_exceptions")
         set(depends ${FLANG_INTRINSIC_MODULES_DIR}/__fortran_ieee_exceptions.mod)