[Propeller] Match debug info filenames from profiles to distinguish internal linkage functions with the same names.

[rahmanl]

Summary

Basic block sections profiles are ingested based on the function name. However, conflicts may occur when internal linkage functions with the same symbol name are linked into the binary (for instance static functions defined in different modules). Currently, these functions cannot be optimized unless we use -funique-internal-linkage-names (D89617) to enforce unique symbol names.

However, we have found that -funique-internal-linkage-names does not play well with inline assembly code which refers to the symbol via its symbol name. For example, the Linux kernel does not build with this option.

This patch implements a new feature which allows differentiating profiles based on the debug info filenames associated with each function. When specified, the given path is compared against the debug info filename of the matching function and profile is ingested only when the debug info filenames match. Backward-compatibility is guaranteed as omitting the specifiers from the profile would allow them to be matched by function name only. Also specifiers can be included for a subset of functions only.

[rahmanl]

Add test.

[rahmanl]

Add test cases.

[rahmanl]

• Implement selective profile reading. Profile for each function is only retrieved if it corresponds to a function in the current module.

[rahmanl]

• Implement selective profile reading. Profile for each function is only retrieved if it corresponds to a function in the current module.

[rahmanl]

• Cleanup.

[tmsriram]

Just to add to the limitations of -funique-internal-linkage-functions, even the alias attribute can cause problems. Any attribute that takes the name of a function as a string, alias / asm, will not work with this option as it involves changing the source. The kernel has plenty of these and hence we need a better solution.

llvm/lib/CodeGen/BasicBlockSectionsProfileReader.cpp

47

Isn't this a refactoring change that should go into a separate patch?

60

Should the comments be changed to reflect how module names can be specified?

95

How is this valid now?

132

Here somehow, can you get the linkage type of Alias and discard cases where it is a non internal linkage function? I haven't thought of how to do it yet.

135

First of all, you shouldnt be checking DIFilename.empty() here, that case must be dismissed much earlier above. If DIFilename is empty, simply don't check anything as this is equal to doing the default and do it immediately after getting DIFilename above.

The condition must also look like this:

return It != FunctionNameToDIFilename.end() ? It->second.equals(DIFilename) : false;

If It->second is empty and we have specified a module, we should conclude false, WDYT?

149

Why would this be problem now and not earlier? Add a comment to make it clear how duplicate function names could happen.

166

Not a great optimization but only internal linkage function definitions here really matter right?

I am not sure but it appears to me that you are storing every defined function name in the map to make the other check work. That is not wrong but you may be able to do something better.

Here is an idea:
Store only internal linkage functions in the map. If you cannot find it in the map, then clearly it is not an internal linkage function name corresponding to this module and its cluster info can be safely discarded. However, there is an argument that global linkage functions can also have their modules specified but should be made beyond the scope of this feature. WDYT?

llvm/test/CodeGen/X86/basic-block-sections-clusters-error.ll

21

Ah okay, that's how you get duplicate profiles. Understood but please make sure this is documented in the code above. Also, this case could have occurred even before where you specify multiple profiles for the same function.

[rahmanl]

Thanks for the quick feedback @tmsriram

llvm/lib/CodeGen/BasicBlockSectionsProfileReader.cpp

47

Thanks. Checked in a small patch: https://github.com/llvm/llvm-project/commit/ef8dedc79ce02710ffba6a3005e05672702f555f

95

I silenced this error handling to allow the condition to imply that the profile must be skipped.

132

Yes. This is doable in the doInitialization call. However, I am not sure if we should discard these cases. My point is "if the debug-info-filename is specified, we should require that it is matched. If it is omitted, then it will be matched with anything".

135

This is a bit subtle. If debug-info-filename specifier is empty, we should still check that the function can be found in the module. This won't change the final result, but it makes the internal logic consistent with the case when debug-info-filename is specified (where both function name and debug-info filename are checked).

166

If you cannot find it in the map, then clearly it is not an internal linkage function name corresponding to this module and its cluster info can be safely discarded.

But we are not supposed to discard the profiles for global linkage functions. right?

[rahmanl]

• address comments.

[rahmanl]

• Extract filename via DICompileUnits. Match on filename attribute only.

[shenhan]

Thanks for implementing this.

llvm/lib/CodeGen/BasicBlockSectionsProfileReader.cpp

124

nit: backslash can be dropped in "Unknown string found: \'".

151–152

Do you think we shall make this more tolerant? Instead of returning a invalidProfileError, just drop the profile for this specific function?

164

Could you spell out the full type?

172

I'll apply this to create_llvm_prof too.

178–179

This mean there are no function definitions in the module? Is it an error?
(If it is a real error, we can make it more meaningful, like "module does not contain function defintions, etc...")

[rahmanl]

• Address reviewer comments.

llvm/lib/CodeGen/BasicBlockSectionsProfileReader.cpp

151–152

I suggest we have a hard failure in such cases. Silently dropping such cases may lead to uncaught performance drops. However, avoiding duplicates is something that the profile processing tool can easily do.

178–179

Removed. It was debug printing.

[rahmanl]

• rebase.

[shenhan]

Locally tested the patch.

LGTM

llvm/include/llvm/CodeGen/BasicBlockSectionsProfileReader.h

 // sections profile. The cluster info will be used by the basic-block-sections
 // pass to arrange basic blocks in their sections.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CODEGEN_BASICBLOCKSECTIONSPROFILEREADER_H
 #define LLVM_CODEGEN_BASICBLOCKSECTIONSPROFILEREADER_H
 
+#include "llvm/ADT/SmallString.h"
+#include "llvm/IR/Module.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/LineIterator.h"
 #include "llvm/Support/MemoryBuffer.h"
-
 using namespace llvm;
 
 namespace llvm {
 
 // The cluster information for a machine basic block.
 struct BBClusterInfo {
   // Unique ID for this basic block.
   unsigned BBID;
public:
   // profile exist for the function \p FuncName, and the second element
   // representing the basic block sections profile (cluster info) for this
   // function. If the first element is true and the second element is empty, it
   // means unique basic block sections are desired for all basic blocks of the
   // function.
   std::pair<bool, SmallVector<BBClusterInfo>>
   getBBClusterInfoForFunction(StringRef FuncName) const;
 
-  /// Read profiles of basic blocks if available here.
-  void initializePass() override;
+  bool doInitialization(Module &M) override;
 
 private:
   StringRef getAliasName(StringRef FuncName) const {
     auto R = FuncAliasMap.find(FuncName);
     return R == FuncAliasMap.end() ? FuncName : R->second;
   }
 
   // This contains the basic-block-sections profile.
   const MemoryBuffer *MBuf = nullptr;
 
+  // Maps from every function name in the module to its debug info filename or
+  // empty string if no debug info is available.
+  StringMap<SmallString<128>> FunctionNameToDIFilename;
+
+  // Reads the basic block sections profile and stores the profile for all
+  // functions matching this module.
+  Error ReadProfile();
+
   // This encapsulates the BB cluster information for the whole program.
   //
   // For every function name, it contains the cluster information for (all or
   // some of) its basic blocks. The cluster information for every basic block
   // includes its cluster ID along with the position of the basic block in that
   // cluster.
   ProgramBBClusterInfoMapTy ProgramBBClusterInfo;
 

llvm/lib/CodeGen/BasicBlockSections.cpp

public:
   /// Identify basic blocks that need separate sections and prepare to emit them
   /// accordingly.
   bool runOnMachineFunction(MachineFunction &MF) override;
 };
 
 } // end anonymous namespace
 
 char BasicBlockSections::ID = 0;
-INITIALIZE_PASS(BasicBlockSections, "bbsections-prepare",
+INITIALIZE_PASS_BEGIN(BasicBlockSections, "bbsections-prepare",
+                "Prepares for basic block sections, by splitting functions "
+                "into clusters of basic blocks.",
+                false, false)
+INITIALIZE_PASS_DEPENDENCY(BasicBlockSectionsProfileReader)
+INITIALIZE_PASS_END(BasicBlockSections, "bbsections-prepare",
                 "Prepares for basic block sections, by splitting functions "
                 "into clusters of basic blocks.",
                 false, false)
 
 // This function updates and optimizes the branching instructions of every basic
 // block in a given function to account for changes in the layout.
 static void
 updateBranches(MachineFunction &MF,

llvm/lib/CodeGen/BasicBlockSectionsProfileReader.cpp

 //===-- BasicBlockSectionsProfileReader.cpp -------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Implementation of the basic block sections profile reader pass. It parses
 // and stores the basic block sections profile file (which is specified via the
 // `-basic-block-sections` flag).
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/BasicBlockSectionsProfileReader.h"
 #include "llvm/ADT/SmallSet.h"
+#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/CodeGen/Passes.h"
+#include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/LineIterator.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/Path.h"
+#include <llvm/ADT/STLExtras.h>
 
 using namespace llvm;
 
 char BasicBlockSectionsProfileReader::ID = 0;
+
 INITIALIZE_PASS(BasicBlockSectionsProfileReader, "bbsections-profile-reader",
                 "Reads and parses a basic block sections profile.", false,
                 false)
 
 bool BasicBlockSectionsProfileReader::isFunctionHot(StringRef FuncName) const {
   return getBBClusterInfoForFunction(FuncName).first;
 }
 
 std::pair<bool, SmallVector<BBClusterInfo>>
 BasicBlockSectionsProfileReader::getBBClusterInfoForFunction(
     StringRef FuncName) const {
-  std::pair<bool, SmallVector<BBClusterInfo>> cluster_info(false, {});
   auto R = ProgramBBClusterInfo.find(getAliasName(FuncName));
-  if (R != ProgramBBClusterInfo.end()) {
-    cluster_info.second = R->second;
-    cluster_info.first = true;
-  }
-  return cluster_info;
+  return (R != ProgramBBClusterInfo.end()
+              ? std::pair(true, R->second)
+              : std::pair(false, SmallVector<BBClusterInfo>{}));
 }
 
 // Basic Block Sections can be enabled for a subset of machine basic blocks.
 // This is done by passing a file containing names of functions for which basic
 // block sections are desired.  Additionally, machine basic block ids of the
 // functions can also be specified for a finer granularity. Moreover, a cluster
 // of basic blocks could be assigned to the same section.
 // A file with basic block sections for all of function main and three blocks
 // for function foo (of which 1 and 2 are placed in a cluster) looks like this:
 // ----------------------------
 // list.txt:
 // !main
 // !foo
 // !!1 2
 // !!4
-static Error getBBClusterInfo(const MemoryBuffer *MBuf,
-                              ProgramBBClusterInfoMapTy &ProgramBBClusterInfo,
-                              StringMap<StringRef> &FuncAliasMap) {
+Error BasicBlockSectionsProfileReader::ReadProfile() {
   assert(MBuf);
   line_iterator LineIt(*MBuf, /*SkipBlanks=*/true, /*CommentMarker=*/'#');
 
   auto invalidProfileError = [&](auto Message) {
     return make_error<StringError>(
         Twine("Invalid profile " + MBuf->getBufferIdentifier() + " at line " +
               Twine(LineIt.line_number()) + ": " + Message),
         inconvertibleErrorCode());
for (; !LineIt.is_at_eof(); ++LineIt) {
     if (S[0] == '@')
       continue;
     // Check for the leading "!"
     if (!S.consume_front("!") || S.empty())
       break;
     // Check for second "!" which indicates a cluster of basic blocks.
     if (S.consume_front("!")) {
       if (FI == ProgramBBClusterInfo.end())
-        return invalidProfileError(
-            "Cluster list does not follow a function name specifier.");
+        continue;
       SmallVector<StringRef, 4> BBIDs;
       S.split(BBIDs, ' ');
       // Reset current cluster position.
       CurrentPosition = 0;
       for (auto BBIDStr : BBIDs) {
         unsigned long long BBID;
         if (getAsUnsignedInteger(BBIDStr, 10, BBID))
           return invalidProfileError(Twine("Unsigned integer expected: '") +
                                      BBIDStr + "'.");
         if (!FuncBBIDs.insert(BBID).second)
           return invalidProfileError(Twine("Duplicate basic block id found '") +
                                      BBIDStr + "'.");
         if (BBID == 0 && CurrentPosition)
           return invalidProfileError("Entry BB (0) does not begin a cluster.");
 
         FI->second.emplace_back(
             BBClusterInfo{((unsigned)BBID), CurrentCluster, CurrentPosition++});
       }
       CurrentCluster++;
-    } else { // This is a function name specifier.
+    } else {
+      // This is a function name specifier. It may include a debug info filename
+      // specifier starting with `M=`.
+      auto [AliasesStr, DIFilenameStr] = S.split(' ');
+      SmallString<128> DIFilename;
+      if (DIFilenameStr.startswith("M="))
+        DIFilename =
+            sys::path::remove_leading_dotslash(DIFilenameStr.substr(2));
+      else if (!DIFilenameStr.empty())
+        return invalidProfileError("Unknown string found: \'" + DIFilenameStr +
+                                   "'.");
       // Function aliases are separated using '/'. We use the first function
       // name for the cluster info mapping and delegate all other aliases to
       // this one.
       SmallVector<StringRef, 4> Aliases;
-      S.split(Aliases, '/');
+      AliasesStr.split(Aliases, '/');
+      bool FunctionFound = any_of(Aliases, [&](StringRef Alias) {
+        auto It = FunctionNameToDIFilename.find(Alias);
+        return It != FunctionNameToDIFilename.end()
+                   ? (DIFilename.empty() || It->second.empty() ||
+                      It->second.equals(DIFilename))
+                   : false;
+      });
+      if (!FunctionFound) {
+        FI= ProgramBBClusterInfo.end();
+        continue;
+      }
       for (size_t i = 1; i < Aliases.size(); ++i)
         FuncAliasMap.try_emplace(Aliases[i], Aliases.front());
 
       // Prepare for parsing clusters of this function name.
       // Start a new cluster map for this function name.
-      FI = ProgramBBClusterInfo.try_emplace(Aliases.front()).first;
+      auto R = ProgramBBClusterInfo.try_emplace(Aliases.front());
+      if (!R.second)
+        return invalidProfileError(
+            "Duplicate function specifier for function: " + Aliases.front());
+      FI = R.first;
       CurrentCluster = 0;
       FuncBBIDs.clear();
     }
   }
   return Error::success();
 }
 
-void BasicBlockSectionsProfileReader::initializePass() {
+bool BasicBlockSectionsProfileReader::doInitialization(Module &M) {
   if (!MBuf)
-    return;
-  if (auto Err = getBBClusterInfo(MBuf, ProgramBBClusterInfo, FuncAliasMap))
+    return false;
+  // Get the function name to debug info filename mapping.
+  FunctionNameToDIFilename.clear();
+  for (auto &F : M) {
+    SmallString<128> DIFilename;
+    if (F.isDeclaration()) continue;
+    auto *Subprogram = F.getSubprogram();
+    if (Subprogram) {
+      llvm::DIScope *Scope = Subprogram->getScope();
+      if (Scope)
+        sys::path::append(DIFilename, Scope->getDirectory(),
+                          Scope->getFilename());
+    }
+    bool inserted =
+        FunctionNameToDIFilename
+            .try_emplace(F.getName(),
+                         sys::path::remove_leading_dotslash(DIFilename))
+            .second;
+    assert(inserted);
+  }
+  if (auto Err = ReadProfile())
     report_fatal_error(std::move(Err));
+  return false;
 }
 
 ImmutablePass *
 llvm::createBasicBlockSectionsProfileReaderPass(const MemoryBuffer *Buf) {
   return new BasicBlockSectionsProfileReader(Buf);
 }

llvm/test/CodeGen/X86/basic-block-sections-clusters-error.ll

 ; BB cluster sections error handling
-; RUN: echo '!f' > %t1
+; RUN: echo '!dummy' > %t1
 ; RUN: echo '!!1 4' >> %t1
 ; RUN: echo '!!1' >> %t1
 ; RUN: not --crash llc < %s -O0 -mtriple=x86_64-pc-linux -function-sections -basic-block-sections=%t1 2>&1 | FileCheck %s --check-prefix=CHECK-ERROR1
 ; CHECK-ERROR1: LLVM ERROR: Invalid profile {{.*}} at line 3: Duplicate basic block id found '1'.
-; RUN: echo '!f' > %t2
+; RUN: echo '!dummy' > %t2
 ; RUN: echo '!!4 0' >> %t2
 ; RUN: not --crash llc < %s -O0 -mtriple=x86_64-pc-linux -function-sections -basic-block-sections=%t2 2>&1 | FileCheck %s --check-prefix=CHECK-ERROR2
 ; CHECK-ERROR2: LLVM ERROR: Invalid profile {{.*}} at line 2: Entry BB (0) does not begin a cluster.
-; RUN: echo '!f' > %t3
+; RUN: echo '!dummy' > %t3
 ; RUN: echo '!!-1' >> %t3
 ; RUN: not --crash llc < %s -O0 -mtriple=x86_64-pc-linux -function-sections -basic-block-sections=%t3 2>&1 | FileCheck %s --check-prefix=CHECK-ERROR3
 ; CHECK-ERROR3: LLVM ERROR: Invalid profile {{.*}} at line 2: Unsigned integer expected: '-1'.
-; RUN: echo '!!1' > %t4
-; RUN: echo '!f' >> %t4
-; RUN: not --crash llc < %s -O0 -mtriple=x86_64-pc-linux -function-sections -basic-block-sections=%t4 2>&1 | FileCheck %s --check-prefix=CHECK-ERROR4
-; CHECK-ERROR4: LLVM ERROR: Invalid profile {{.*}} at line 1: Cluster list does not follow a function name specifier.
+; RUN: echo '!dummy /path/to/filename' > %t4
+; RUN: not --crash llc < %s -O0 -mtriple=x86_64 -function-sections -basic-block-sections=%t4 2>&1 | FileCheck %s --check-prefix=CHECK-ERROR4
+; CHECK-ERROR4: LLVM ERROR: Invalid profile {{.*}} at line 1: Unknown string found: '/path/to/filename'.
 
 define i32 @dummy(i32 %x, i32 %y, i32 %z) {
   entry:
     %tmp = mul i32 %x, %y
     %tmp2 = add i32 %tmp, %z
     ret i32 %tmp2
 }

llvm/test/CodeGen/X86/basic-block-sections-module1.ll

+;; Specify the correct module name.
+; RUN: echo '!test M=/path/to/dir/test_filename' > %t1
+; RUN: echo '!!0' >> %t1
+; RUN: llc < %s -mtriple=x86_64 -function-sections -basic-block-sections=%t1 | FileCheck %s -check-prefix=RIGHT-MODULE
+;; Specify no module name.
+; RUN: echo '!test' > %t2
+; RUN: echo '!!0' >> %t2
+; RUN: llc < %s -mtriple=x86_64 -function-sections -basic-block-sections=%t2  | FileCheck %s -check-prefix=NO-MODULE
+;; Specify incorrect module names.
+; RUN: echo '!test M=test_filename' > %t3
+; RUN: echo '!!0' >> %t3
+; RUN: llc < %s -mtriple=x86_64 -function-sections -basic-block-sections=%t3  | FileCheck %s -check-prefix=WRONG-MODULE
+; RUN: echo '!test M=./path/to/dir/test_filename' > %t4
+; RUN: echo '!!0' >> %t4
+; RUN: llc < %s -mtriple=x86_64 -function-sections -basic-block-sections=%t4  | FileCheck %s -check-prefix=WRONG-MODULE
+
+define dso_local i32 @test(i32 noundef %0) #0 !dbg !10 {
+  %2 = alloca i32, align 4
+  %3 = alloca i32, align 4
+  store i32 %0, i32* %3, align 4
+  %4 = load i32, i32* %3, align 4
+  %5 = icmp slt i32 %4, 0
+  br i1 %5, label %6, label %7
+6:                                                ; preds = %1
+  store i32 -1, i32* %2, align 4
+  ret i32 0
+7:
+  ret i32 1
+}
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!2, !3}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1)
+!1 = !DIFile(filename: "test_filename", directory: "/path/to/dir")
+!2 = !{i32 7, !"Dwarf Version", i32 5}
+!3 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = distinct !DISubprogram(name: "test", scope: !1, unit: !0)
+
+;; Check that the split section is created when using the correct module name, or no module name.
+;
+; RIGHT-MODULE: .section        .text.split.test,"ax",@progbits
+; NO-MODULE: .section        .text.split.test,"ax",@progbits
+; WRONG-MODULE-NOT: .section    .text.split.test,"ax",@progbits

llvm/test/CodeGen/X86/basic-block-sections-module2.ll

+;; Specify the correct module name.
+; RUN: echo '!test1 M=./test_dirname1/test_filename1' > %t1
+; RUN: echo '!!0' >> %t1
+; RUN: echo '!test2 M=.//test_filename2' >> %t1
+; RUN: echo '!!0' >> %t1
+; RUN: echo '!test3 M=test_filename3' >> %t1
+; RUN: echo '!!0' >> %t1
+; RUN: echo '!test4 M=/test_dirname4/test_filename4' >> %t1
+; RUN: echo '!!0' >> %t1
+; RUN: llc < %s -mtriple=x86_64 -function-sections -basic-block-sections=%t1  | FileCheck %s -check-prefix=RIGHT-MODULE
+; RUN: echo '!test1 M=/test_dirname/test_filename1' > %t2
+; RUN: echo '!!0' >> %t2
+; RUN: echo '!test1 M=../test_filename1' >> %t2
+; RUN: echo '!!0' >> %t2
+; RUN: echo '!test2 M=.test_filename2' >> %t2
+; RUN: echo '!!0' >> %t2
+; RUN: echo '!test4 M=./test_dirname4/test_filename4' >> %t2
+; RUN: echo '!!0' >> %t2
+; RUN: llc < %s -mtriple=x86_64 -function-sections -basic-block-sections=%t2  | FileCheck %s -check-prefix=WRONG-MODULE
+
+define dso_local i32 @test1(i32 noundef %0) #0 !dbg !10 {
+  %2 = alloca i32, align 4
+  %3 = alloca i32, align 4
+  store i32 %0, i32* %3, align 4
+  %4 = load i32, i32* %3, align 4
+  %5 = icmp slt i32 %4, 0
+  br i1 %5, label %6, label %7
+6:                                                ; preds = %1
+  store i32 -1, i32* %2, align 4
+  ret i32 0
+7:
+  ret i32 1
+}
+
+define dso_local i32 @test2(i32 noundef %0) #0 !dbg !11 {
+  %2 = alloca i32, align 4
+  %3 = alloca i32, align 4
+  store i32 %0, i32* %3, align 4
+  %4 = load i32, i32* %3, align 4
+  %5 = icmp slt i32 %4, 0
+  br i1 %5, label %6, label %7
+6:                                                ; preds = %1
+  store i32 -1, i32* %2, align 4
+  ret i32 0
+7:
+  ret i32 1
+}
+
+define dso_local i32 @test3(i32 noundef %0) #0 !dbg !12 {
+  %2 = alloca i32, align 4
+  %3 = alloca i32, align 4
+  store i32 %0, i32* %3, align 4
+  %4 = load i32, i32* %3, align 4
+  %5 = icmp slt i32 %4, 0
+  br i1 %5, label %6, label %7
+6:                                                ; preds = %1
+  store i32 -1, i32* %2, align 4
+  ret i32 0
+7:
+  ret i32 1
+}
+
+define dso_local i32 @test4(i32 noundef %0) #0 !dbg !13 {
+  %2 = alloca i32, align 4
+  %3 = alloca i32, align 4
+  store i32 %0, i32* %3, align 4
+  %4 = load i32, i32* %3, align 4
+  %5 = icmp slt i32 %4, 0
+  br i1 %5, label %6, label %7
+6:                                                ; preds = %1
+  store i32 -1, i32* %2, align 4
+  ret i32 0
+7:
+  ret i32 1
+}
+
+!llvm.dbg.cu = !{!0, !1, !2, !3}
+!llvm.module.flags = !{!8, !9}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !4)
+!1 = distinct !DICompileUnit(language: DW_LANG_C99, file: !5)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !6)
+!3 = distinct !DICompileUnit(language: DW_LANG_C99, file: !7)
+!4 = !DIFile(filename: "test_filename1", directory: "test_dirname1")
+!5 = !DIFile(filename: "test_filename2", directory: "")
+!6 = !DIFile(filename: "test_filename3", directory: ".")
+!7 = !DIFile(filename: "test_filename4", directory: "/test_dirname4")
+!8 = !{i32 7, !"Dwarf Version", i32 5}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = distinct !DISubprogram(name: "test1", scope: !4, unit: !0)
+!11 = distinct !DISubprogram(name: "test2", scope: !5, unit: !1)
+!12 = distinct !DISubprogram(name: "test3", scope: !6, unit: !2)
+!13 = distinct !DISubprogram(name: "test4", scope: !7, unit: !3)
+
+;; Check that the split section is created when using the correct module name, or no module name.
+;
+; RIGHT-MODULE: .section        .text.split.test1,"ax",@progbits
+; RIGHT-MODULE: .section        .text.split.test2,"ax",@progbits
+; RIGHT-MODULE: .section        .text.split.test3,"ax",@progbits
+; RIGHT-MODULE: .section        .text.split.test4,"ax",@progbits
+; WRONG-MODULE-NOT: .section        .text.split.test{{[1-4]+}},"ax",@progbits