Profile-guided optimizations (PGO)

CMakeLists.txt

@@ -91,6 +91,7 @@ elseif(D_VERSION EQUAL 2)
     set(DDMDFE_PATH ddmd)
     set(LDC_EXE ldc2)
     set(LDMD_EXE ldmd2)
+    set(LDCPROFDATA_EXE ldc-profdata)
     set(RUNTIME druntime)
     append("-DDMDV2" CMAKE_CXX_FLAGS)
 else()
@@ -99,6 +100,7 @@ endif()
 
 set(LDC_EXE_NAME ${PROGRAM_PREFIX}${LDC_EXE}${PROGRAM_SUFFIX})
 set(LDMD_EXE_NAME ${PROGRAM_PREFIX}${LDMD_EXE}${PROGRAM_SUFFIX})
+set(LDCPROFDATA_EXE_NAME ${PROGRAM_PREFIX}${LDCPROFDATA_EXE}${PROGRAM_SUFFIX})
 
 file(MAKE_DIRECTORY
     ${PROJECT_BINARY_DIR}
@@ -435,6 +437,18 @@ source_group("Source Files\\ir" FILES ${IR_SRC})
 source_group("Header Files\\ir" FILES ${IR_HDR})
 source_group("Generated Files" REGULAR_EXPRESSION "(id\\.[cdh]|impcnvtab\\.c)$")
 
+
+#
+# Enable PGO if supported for this platform and LLVM version.
+# LLVM >= 3.7 is required for PGO.
+#
+set(LDC_WITH_PGO False)  # must be a valid Python boolean constant (case sensitive)
+if (NOT (LDC_LLVM_VER LESS 307))
+    message(STATUS "Building LDC with PGO support")
+    add_definitions(-DLDC_WITH_PGO)
+    set(LDC_WITH_PGO True)
+endif()
+
 #
 # Includes, defines.
 #
@@ -670,6 +684,22 @@ set_target_properties(
 )
 target_link_libraries(not  ${LLVM_LIBRARIES} ${TERMINFO_LIBS} ${CMAKE_DL_LIBS} ${LLVM_LDFLAGS})
 
+# Build ldc-profdata for converting profile data formats (source version depends on LLVM version)
+set(LDCPROFDATA_SRC utils/llvm-profdata-${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.cpp)
+if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LDCPROFDATA_SRC})
+    add_executable(ldc-profdata ${LDCPROFDATA_SRC})
+    set_target_properties(
+        ldc-profdata PROPERTIES
+        OUTPUT_NAME "${LDCPROFDATA_EXE_NAME}"
+        RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin
+        COMPILE_FLAGS "${LLVM_CXXFLAGS} ${CMAKE_CXX_FLAGS_RELEASE}"
+        LINK_FLAGS "${SANITIZE_LDFLAGS}"
+    )
+    target_link_libraries(ldc-profdata  ${LLVM_LIBRARIES} ${TERMINFO_LIBS} ${CMAKE_DL_LIBS} ${LLVM_LDFLAGS})
+    install(TARGETS ${LDCPROFDATA_EXE} DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
+endif()
+
+
 #
 # LDMD
 #

ddmd/attrib.d

@@ -1103,6 +1103,21 @@ public:
             }
             return createNewScope(sc, sc.stc, sc.linkage, sc.protection, sc.explicitProtection, sc.structalign, inlining);
         }
+        else if (IN_LLVM && ident == Id.LDC_profile_instr) {
+            bool emitInstr = true;
+            if (!args || args.dim != 1 || !DtoCheckProfileInstrPragma((*args)[0], emitInstr)) {
+                error("pragma(LDC_profile_instr, true or false) expected");
+                (*args)[0] = new ErrorExp();
+            } else {
+                // Only create a new scope if the emitInstrumentation flag is changed
+                if (sc.emitInstrumentation != emitInstr) {
+                    auto newscope = sc.copy();
+                    newscope.emitInstrumentation = emitInstr;
+                    return newscope;
+                }
+            }
+        }
+
         return sc;
     }
 

ddmd/declaration.h

@@ -543,6 +543,10 @@ class FuncDeclaration : public Declaration
 
     // true if set with the pragma(LDC_never_inline); statement
     bool neverInline;
+
+    // Whether to emit instrumentation code if -fprofile-instr-generate is specified,
+    // the value is set with pragma(LDC_profile_instr, true|false)
+    bool emitInstrumentation;
 #endif
 
     Identifier *outId;                  // identifier for out statement

ddmd/dscope.d

@@ -167,6 +167,11 @@ struct Scope
     // user defined attributes
     UserAttributeDeclaration userAttribDecl;
 
+version(IN_LLVM)
+{
+    bool emitInstrumentation = true;   // whether to emit instrumentation with -fprofile-instr-generate
+}
+
     DocComment* lastdc;        // documentation comment for last symbol at this scope
     uint[void*] anchorCounts;  // lookup duplicate anchor name count
     Identifier prevAnchor;     // qualified symbol name of last doc anchor

ddmd/func.d

@@ -426,6 +426,10 @@ public:
 
         // true if set with the pragma(LDC_never_inline); statement
         bool neverInline = false;
+
+        // Whether to emit instrumentation code if -fprofile-instr-generate is specified,
+        // the value is set with pragma(LDC_profile_instr, true|false)
+        bool emitInstrumentation = true;
     }
 
     Identifier outId;                   // identifier for out statement
@@ -637,6 +641,11 @@ public:
         inlining = sc.inlining;
         protection = sc.protection;
         userAttribDecl = sc.userAttribDecl;
+        version(IN_LLVM)
+        {
+            emitInstrumentation = sc.emitInstrumentation;
+        }
+
         if (!originalType)
             originalType = type.syntaxCopy();
         if (!type.deco)

ddmd/globals.d

@@ -207,6 +207,10 @@ struct Param
         bool verbose_cg;
         bool hasObjectiveC;
 
+        // Profile-guided optimization:
+        bool genInstrProf;             // Whether to generate PGO instrumented code
+        const(char)* datafileInstrProf; // Either the input or output file for PGO data
+
         // target stuff
         const(void)* targetTriple; // const llvm::Triple*
 

ddmd/globals.h

@@ -206,6 +206,10 @@ struct Param
     bool verbose_cg;
     bool hasObjectiveC;
 
+    // Profile-guided optimization:
+    bool genInstrProf;             // Whether to generate PGO instrumented code
+    const char *datafileInstrProf; // Either the input or output file for PGO data
+
     const llvm::Triple *targetTriple;
 
     // Codegen cl options

ddmd/idgen.d

@@ -393,6 +393,7 @@ Msgtable[] msgtable =
     { "LDC_global_crt_ctor" },
     { "LDC_global_crt_dtor" },
     { "LDC_extern_weak" },
+    { "LDC_profile_instr" },
 
     // IN_LLVM: LDC-specific traits.
     { "targetCPU" },

ddmd/scope.h

@@ -119,6 +119,10 @@ struct Scope
 
     UserAttributeDeclaration *userAttribDecl;   // user defined attributes
 
+#if IN_LLVM
+    bool emitInstrumentation;   // whether to emit instrumentation with -fprofile-instr-generate
+#endif
+
     DocComment *lastdc;         // documentation comment for last symbol at this scope
     AA *anchorCounts;           // lookup duplicate anchor name count
     Identifier *prevAnchor;     // qualified symbol name of last doc anchor

ddmd/statement.d

@@ -54,6 +54,10 @@ import ddmd.staticassert;
 import ddmd.target;
 import ddmd.tokens;
 import ddmd.visitor;
+version(IN_LLVM)
+{
+    import gen.dpragma;
+}
 
 extern (C++) Identifier fixupLabelName(Scope* sc, Identifier ident)
 {
@@ -3679,6 +3683,26 @@ public:
         {
             sc.func.neverInline = true;
         }
+        // IN_LLVM. FIXME Move to pragma.cpp
+        else if (ident == Id.LDC_profile_instr)
+        {
+            bool emitInstr = true;
+            if (!args || args.dim != 1 || !DtoCheckProfileInstrPragma((*args)[0], emitInstr))
+            {
+                error("pragma(LDC_profile_instr, true or false) expected");
+                goto Lerror;
+            }
+            else
+            {
+                FuncDeclaration fd = sc.func;
+                if (fd is null)
+                {
+                    error("pragma(LDC_profile_instr, ...) is not inside a function");
+                    goto Lerror;
+                }
+                fd.emitInstrumentation = emitInstr;
+            }
+        }
         else if (ident == Id.startaddress)
         {
             if (!args || args.dim != 1)
@@ -3803,6 +3827,10 @@ public:
     CaseStatements* cases;          // array of CaseStatement's
     int hasNoDefault;               // !=0 if no default statement
     int hasVars;                    // !=0 if has variable case values
+version(IN_LLVM)
+{
+    bool hasGotoDefault;            // true iff there is a `goto default` statement for this switch
+}
 
     extern (D) this(Loc loc, Expression c, Statement b, bool isFinal)
     {
@@ -3903,6 +3931,10 @@ public:
                     if (cs.exp.equals(gcs.exp))
                     {
                         gcs.cs = cs;
+version(IN_LLVM)
+{
+                        cs.gototarget = true;
+}
                         goto Lfoundcase;
                     }
                 }
@@ -3963,6 +3995,17 @@ public:
             cs = new CompoundStatement(loc, a);
             _body = cs;
         }
+version(IN_LLVM)
+{
+        /+ hasGotoDefault is set by GotoDefaultStatement.semantic
+         + at which point sdefault may still be null, therefore
+         + set sdefault.gototarget here.
+         +/
+        if (hasGotoDefault) {
+            assert(sdefault);
+            sdefault.gototarget = true;
+        }
+}
         sc.pop();
         return this;
     Lerror:
@@ -3992,6 +4035,7 @@ public:
 
     version(IN_LLVM)
     {
+        bool gototarget; // true iff this is the target of a 'goto case'
         void* bodyBB;  // llvm::BasicBlock*
         void* llvmIdx; // llvm::Value*
     }
@@ -4222,6 +4266,7 @@ public:
 
     version(IN_LLVM)
     {
+        bool gototarget; // true iff this is the target of a 'goto default'
         void* bodyBB;  // llvm::BasicBlock*
     }
 
@@ -4311,6 +4356,12 @@ public:
             error("goto default not allowed in final switch statement");
             return new ErrorStatement();
         }
+
+version(IN_LLVM)
+{
+        sw.hasGotoDefault = true;
+}
+
         return this;
     }
 

ddmd/statement.h

@@ -441,6 +441,10 @@ class SwitchStatement : public Statement
     int hasNoDefault;           // !=0 if no default statement
     int hasVars;                // !=0 if has variable case values
 
+#if IN_LLVM
+    bool hasGotoDefault;        // true iff there is a `goto default` statement for this switch
+#endif
+
     SwitchStatement(Loc loc, Expression *c, Statement *b, bool isFinal);
     Statement *syntaxCopy();
     Statement *semantic(Scope *sc);
@@ -458,6 +462,7 @@ class CaseStatement : public Statement
     int index;          // which case it is (since we sort this)
 
 #if IN_LLVM
+    bool gototarget; // true iff this is the target of a 'goto case'
     llvm::BasicBlock* bodyBB;
     llvm::Value* llvmIdx;
 #endif
@@ -492,6 +497,7 @@ class DefaultStatement : public Statement
     Statement *statement;
 
 #if IN_LLVM
+    bool gototarget; // true iff this is the target of a 'goto default'
     llvm::BasicBlock* bodyBB;
 #endif
 

driver/cl_options.cpp

@@ -424,6 +424,19 @@ cl::opt<unsigned char, true, CoverageParser> coverageAnalysis(
                     "minimum required coverage)"),
     cl::location(global.params.covPercent), cl::ValueOptional, cl::init(127));
 
+#if LDC_WITH_PGO
+cl::opt<std::string>
+    genfileInstrProf("fprofile-instr-generate", cl::value_desc("filename"),
+                     cl::desc("Generate instrumented code to collect "
+                              "execution counts (e.g. for PGO)"),
+                     cl::ValueOptional);
+
+cl::opt<std::string> usefileInstrProf(
+    "fprofile-instr-use", cl::value_desc("filename"),
+    cl::desc("Use instrumentation data for profile-guided optimization"),
+    cl::ValueRequired);
+#endif
+
 static cl::extrahelp footer(
     "\n"
     "-d-debug can also be specified without options, in which case it enables "

driver/cl_options.h

@@ -79,6 +79,11 @@ extern bool nonSafeBoundsChecks;
 
 extern cl::opt<unsigned, true> nestedTemplateDepth;
 
+#if LDC_WITH_PGO
+extern cl::opt<std::string> genfileInstrProf;
+extern cl::opt<std::string> usefileInstrProf;
+#endif
+
 // Arguments to -d-debug
 extern std::vector<std::string> debugArgs;
 // Arguments to -run

driver/codegenerator.d

@@ -33,6 +33,7 @@ extern (C++) void genCmain(Scope *sc) {
    */
   static __gshared const(char)[] code =
   q{
+      pragma(LDC_profile_instr, false):
       extern(C)
       {
           int _d_run_main(int argc, char **argv, void* mainFunc);

driver/linker.cpp

@@ -21,6 +21,7 @@
 #include "llvm/ADT/Triple.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/Linker/Linker.h"
+#include "llvm/ProfileData/InstrProf.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/Path.h"
@@ -165,6 +166,21 @@ static int linkObjToBinaryGcc(bool sharedLib, bool fullyStatic) {
     args.push_back(p);
   }
 
+  // Link with profile-rt library when generating an instrumented binary.
+  // profile-rt uses Phobos (MD5 hashing) and therefore must be passed on the
+  // commandline before Phobos.
+  if (global.params.genInstrProf) {
+#if LDC_LLVM_VER >= 308
+    if (global.params.targetTriple->isOSLinux()) {
+      // For Linux, explicitly define __llvm_profile_runtime as undefined
+      // symbol, so that the initialization part of profile-rt is linked in.
+      args.push_back(
+          ("-Wl,-u," + llvm::getInstrProfRuntimeHookVarName()).str());
+    }
+#endif
+    args.push_back("-lldc-profile-rt");
+  }
+
   // user libs
   for (unsigned i = 0; i < global.params.libfiles->dim; i++) {
     const char *p = static_cast<const char *>(global.params.libfiles->data[i]);
@@ -227,7 +243,11 @@ static int linkObjToBinaryGcc(bool sharedLib, bool fullyStatic) {
   switch (global.params.targetTriple->getOS()) {
   case llvm::Triple::Linux:
     addSoname = true;
-    if (!opts::disableLinkerStripDead) {
+    // Make sure we don't do --gc-sections when generating a profile-
+    // instrumented binary. The runtime relies on magic sections, which
+    // would be stripped by gc-section on older version of ld, see bug:
+    // https://sourceware.org/bugzilla/show_bug.cgi?id=19161
+    if (!opts::disableLinkerStripDead && !global.params.genInstrProf) {
       args.push_back("-Wl,--gc-sections");
     }
     if (global.params.targetTriple->getEnvironment() == llvm::Triple::Android) {
@@ -587,6 +607,14 @@ static int linkObjToBinaryWin(bool sharedLib) {
     args.push_back(p);
   }
 
+  // Link with profile-rt library when generating an instrumented binary
+  // profile-rt depends on Phobos (MD5 hashing).
+  if (global.params.genInstrProf) {
+    args.push_back("ldc-profile-rt.lib");
+    // profile-rt depends on ws2_32 for symbol `gethostname`
+    args.push_back("ws2_32.lib");
+  }
+
   // user libs
   for (unsigned i = 0; i < global.params.libfiles->dim; i++) {
     const char *p = static_cast<const char *>(global.params.libfiles->data[i]);