[Lldb-commits] [llvm] [lldb] [flang] [clang] [clang] Split out DebugOptions.def into its own top-level options group. (PR #75530)
Juergen Ributzka via lldb-commits
lldb-commits at lists.llvm.org
Mon Dec 18 10:41:02 PST 2023
https://github.com/ributzka updated https://github.com/llvm/llvm-project/pull/75530
>From 665c0c25159cb046683f91711015300aaabba93d Mon Sep 17 00:00:00 2001
From: Juergen Ributzka <juergen at ributzka.de>
Date: Wed, 6 Dec 2023 10:20:21 -0800
Subject: [PATCH 1/3] [clang] Split out DebugOptions.def into its own top-level
options group.
This change moves all debug options out of the CodeGenOptions and creates a
dedicated top-level DebugOptions data struture. All uses of the debug options
are updated to reference the new location. No functional changes are intented
with this change.
---
clang/include/clang/Basic/CodeGenOptions.def | 3 -
clang/include/clang/Basic/CodeGenOptions.h | 51 +---
clang/include/clang/Basic/DebugOptions.def | 15 +-
clang/include/clang/Basic/DebugOptions.h | 111 +++++++++
clang/include/clang/Basic/TargetInfo.h | 2 -
clang/include/clang/CodeGen/BackendUtil.h | 6 +-
clang/include/clang/CodeGen/ModuleBuilder.h | 3 +-
clang/include/clang/Driver/Options.td | 68 +++---
clang/include/clang/Driver/ToolChain.h | 6 +-
.../include/clang/Frontend/CompilerInstance.h | 15 +-
.../clang/Frontend/CompilerInvocation.h | 41 +++-
clang/lib/Basic/CMakeLists.txt | 1 +
clang/lib/Basic/CodeGenOptions.cpp | 37 +--
clang/lib/Basic/DebugOptions.cpp | 40 ++++
clang/lib/CodeGen/BackendConsumer.h | 13 +-
clang/lib/CodeGen/BackendUtil.cpp | 103 ++++----
clang/lib/CodeGen/CGBlocks.cpp | 5 +-
clang/lib/CodeGen/CGDebugInfo.cpp | 220 +++++++++---------
clang/lib/CodeGen/CGDebugInfo.h | 4 +-
clang/lib/CodeGen/CGDecl.cpp | 7 +-
clang/lib/CodeGen/CGHLSLRuntime.cpp | 5 +-
clang/lib/CodeGen/CGOpenMPRuntime.cpp | 22 +-
clang/lib/CodeGen/CGStmt.cpp | 5 +-
clang/lib/CodeGen/CGStmtOpenMP.cpp | 7 +-
clang/lib/CodeGen/CGVTables.cpp | 28 +--
clang/lib/CodeGen/CodeGenAction.cpp | 109 +++++----
clang/lib/CodeGen/CodeGenFunction.cpp | 5 +-
clang/lib/CodeGen/CodeGenModule.cpp | 31 +--
clang/lib/CodeGen/CodeGenModule.h | 6 +-
clang/lib/CodeGen/ModuleBuilder.cpp | 18 +-
.../ObjectFilePCHContainerOperations.cpp | 29 +--
clang/lib/Driver/ToolChains/Clang.cpp | 70 +++---
clang/lib/Driver/ToolChains/CommonArgs.cpp | 26 +--
clang/lib/Driver/ToolChains/CommonArgs.h | 5 +-
clang/lib/Driver/ToolChains/Cuda.cpp | 6 +-
clang/lib/Driver/ToolChains/Cuda.h | 2 +-
clang/lib/Driver/ToolChains/Flang.cpp | 6 +-
clang/lib/Driver/ToolChains/HIPSPV.cpp | 4 +-
clang/lib/Driver/ToolChains/HIPSPV.h | 2 +-
clang/lib/Driver/ToolChains/MSVC.h | 7 +-
clang/lib/Frontend/CompilerInstance.cpp | 20 +-
clang/lib/Frontend/CompilerInvocation.cpp | 202 +++++++++-------
.../lib/Frontend/Rewrite/FrontendActions.cpp | 4 +-
.../DependencyScanning/ModuleDepCollector.cpp | 4 +-
.../clang-import-test/clang-import-test.cpp | 4 +-
clang/unittests/CodeGen/TestCompiler.h | 3 +-
.../unittests/Frontend/CodeGenActionTest.cpp | 2 +-
.../Frontend/CompilerInvocationTest.cpp | 18 +-
.../Clang/ClangExpressionParser.cpp | 2 +-
llvm/include/llvm/Frontend/Debug/Options.h | 4 +-
50 files changed, 769 insertions(+), 638 deletions(-)
create mode 100644 clang/include/clang/Basic/DebugOptions.h
create mode 100644 clang/lib/Basic/DebugOptions.cpp
diff --git a/clang/include/clang/Basic/CodeGenOptions.def b/clang/include/clang/Basic/CodeGenOptions.def
index 0acb5ae134ea24..7508163458c42b 100644
--- a/clang/include/clang/Basic/CodeGenOptions.def
+++ b/clang/include/clang/Basic/CodeGenOptions.def
@@ -430,9 +430,6 @@ ENUM_CODEGENOPT(ZeroCallUsedRegs, llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind,
/// non-deleting destructors. (No effect on Microsoft ABI.)
CODEGENOPT(CtorDtorReturnThis, 1, 0)
-/// FIXME: Make DebugOptions its own top-level .def file.
-#include "DebugOptions.def"
-
#undef CODEGENOPT
#undef ENUM_CODEGENOPT
#undef VALUE_CODEGENOPT
diff --git a/clang/include/clang/Basic/CodeGenOptions.h b/clang/include/clang/Basic/CodeGenOptions.h
index 6952b48e898a81..6db8c73a66b18a 100644
--- a/clang/include/clang/Basic/CodeGenOptions.h
+++ b/clang/include/clang/Basic/CodeGenOptions.h
@@ -15,15 +15,11 @@
#include "clang/Basic/Sanitizers.h"
#include "clang/Basic/XRayInstr.h"
-#include "llvm/ADT/FloatingPointMode.h"
-#include "llvm/Frontend/Debug/Options.h"
#include "llvm/Frontend/Driver/CodeGenOptions.h"
#include "llvm/Support/CodeGen.h"
#include "llvm/Support/Regex.h"
#include "llvm/Target/TargetOptions.h"
#include "llvm/Transforms/Instrumentation/AddressSanitizerOptions.h"
-#include <map>
-#include <memory>
#include <string>
#include <vector>
@@ -98,12 +94,6 @@ class CodeGenOptions : public CodeGenOptionsBase {
IAD_Intel,
};
- enum DebugSrcHashKind {
- DSH_MD5,
- DSH_SHA1,
- DSH_SHA256,
- };
-
// This field stores one of the allowed values for the option
// -fbasic-block-sections=. The allowed values with this option are:
// {"labels", "all", "list=<file>", "none"}.
@@ -158,12 +148,6 @@ class CodeGenOptions : public CodeGenOptionsBase {
Never, // No loop is assumed to be finite.
};
- enum AssignmentTrackingOpts {
- Disabled,
- Enabled,
- Forced,
- };
-
/// The code model to use (-mcmodel).
std::string CodeModel;
@@ -191,22 +175,13 @@ class CodeGenOptions : public CodeGenOptionsBase {
/// Enable additional debugging information.
std::string DebugPass;
- /// The string to embed in debug information as the current working directory.
- std::string DebugCompilationDir;
-
/// The string to embed in coverage mapping as the current working directory.
std::string CoverageCompilationDir;
- /// The string to embed in the debug information for the compile unit, if
- /// non-empty.
- std::string DwarfDebugFlags;
-
/// The string containing the commandline for the llvm.commandline metadata,
/// if non-empty.
std::string RecordCommandLine;
- llvm::SmallVector<std::pair<std::string, std::string>, 0> DebugPrefixMap;
-
/// Prefix replacement map for source-based code coverage to remap source
/// file paths in coverage mapping.
llvm::SmallVector<std::pair<std::string, std::string>, 0> CoveragePrefixMap;
@@ -214,10 +189,6 @@ class CodeGenOptions : public CodeGenOptionsBase {
/// The ABI to use for passing floating point arguments.
std::string FloatABI;
- /// The file to use for dumping bug report by `Debugify` for original
- /// debug info.
- std::string DIBugsReportFilePath;
-
/// The floating-point denormal mode to use.
llvm::DenormalMode FPDenormalMode = llvm::DenormalMode::getIEEE();
@@ -248,16 +219,6 @@ class CodeGenOptions : public CodeGenOptionsBase {
/// file, for example with -save-temps.
std::string MainFileName;
- /// The name for the split debug info file used for the DW_AT_[GNU_]dwo_name
- /// attribute in the skeleton CU.
- std::string SplitDwarfFile;
-
- /// Output filename for the split debug info, not used in the skeleton CU.
- std::string SplitDwarfOutput;
-
- /// Output filename used in the COFF debug information.
- std::string ObjectFilenameForDebug;
-
/// The name of the relocation model to use.
llvm::Reloc::Model RelocationModel;
@@ -508,16 +469,6 @@ class CodeGenOptions : public CodeGenOptionsBase {
/// Check if CSIR profile use is on.
bool hasProfileCSIRUse() const { return getProfileUse() == ProfileCSIRInstr; }
- /// Check if type and variable info should be emitted.
- bool hasReducedDebugInfo() const {
- return getDebugInfo() >= llvm::codegenoptions::DebugInfoConstructor;
- }
-
- /// Check if maybe unused type info should be emitted.
- bool hasMaybeUnusedDebugInfo() const {
- return getDebugInfo() >= llvm::codegenoptions::UnusedTypeInfo;
- }
-
// Check if any one of SanitizeCoverage* is enabled.
bool hasSanitizeCoverage() const {
return SanitizeCoverageType || SanitizeCoverageIndirectCalls ||
@@ -533,7 +484,7 @@ class CodeGenOptions : public CodeGenOptionsBase {
/// Reset all of the options that are not considered when building a
/// module.
- void resetNonModularOptions(StringRef ModuleFormat);
+ void resetNonModularOptions();
};
} // end namespace clang
diff --git a/clang/include/clang/Basic/DebugOptions.def b/clang/include/clang/Basic/DebugOptions.def
index 7cd3edf08a17ea..7bcbad36873c68 100644
--- a/clang/include/clang/Basic/DebugOptions.def
+++ b/clang/include/clang/Basic/DebugOptions.def
@@ -17,18 +17,17 @@
//
//===----------------------------------------------------------------------===//
#ifndef DEBUGOPT
-#define DEBUGOPT(Name, Bits, Default) \
-CODEGENOPT(Name, Bits, Default)
+# error Define the DEBUGOPT macro to handle debug options
#endif
#ifndef VALUE_DEBUGOPT
# define VALUE_DEBUGOPT(Name, Bits, Default) \
-VALUE_CODEGENOPT(Name, Bits, Default)
+DEBUGOPT(Name, Bits, Default)
#endif
#ifndef ENUM_DEBUGOPT
# define ENUM_DEBUGOPT(Name, Type, Bits, Default) \
-ENUM_CODEGENOPT(Name, Type, Bits, Default)
+DEBUGOPT(Name, Bits, Default)
#endif
#ifndef BENIGN_DEBUGOPT
@@ -94,16 +93,16 @@ DEBUGOPT(DebugFwdTemplateParams, 1, 0) ///< Whether to emit complete
///< forward declarations (versus just
///< including them in the name).
ENUM_DEBUGOPT(DebugSimpleTemplateNames,
- llvm::codegenoptions::DebugTemplateNamesKind, 2,
- llvm::codegenoptions::DebugTemplateNamesKind::Full)
+ llvm::debugoptions::DebugTemplateNamesKind, 2,
+ llvm::debugoptions::DebugTemplateNamesKind::Full)
///< Whether to emit template parameters in the textual names of
///< template specializations.
///< Implies DebugFwdTemplateNames to allow decorated names to be
///< reconstructed when needed.
/// The kind of generated debug info.
-ENUM_DEBUGOPT(DebugInfo, llvm::codegenoptions::DebugInfoKind, 4,
- llvm::codegenoptions::NoDebugInfo)
+ENUM_DEBUGOPT(DebugInfo, llvm::debugoptions::DebugInfoKind, 4,
+ llvm::debugoptions::NoDebugInfo)
/// Whether to generate macro debug info.
DEBUGOPT(MacroDebugInfo, 1, 0)
diff --git a/clang/include/clang/Basic/DebugOptions.h b/clang/include/clang/Basic/DebugOptions.h
new file mode 100644
index 00000000000000..f89e43c862349b
--- /dev/null
+++ b/clang/include/clang/Basic/DebugOptions.h
@@ -0,0 +1,111 @@
+//===--- DebugOptions.h -----------------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the DebugOptions interface.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_BASIC_DEBUGOPTIONS_H
+#define LLVM_CLANG_BASIC_DEBUGOPTIONS_H
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Frontend/Debug/Options.h"
+#include "llvm/MC/MCTargetOptions.h"
+#include "llvm/Support/Compression.h"
+#include "llvm/Target/TargetOptions.h"
+#include <string>
+
+namespace clang {
+
+/// Bitfields of DebugOptions, split out from DebugOptions to ensure
+/// that this large collection of bitfields is a trivial class type.
+class DebugOptionsBase {
+ friend class CompilerInvocation;
+ friend class CompilerInvocationBase;
+
+public:
+#define DEBUGOPT(Name, Bits, Default) unsigned Name : Bits;
+#define ENUM_DEBUGOPT(Name, Type, Bits, Default)
+#include "clang/Basic/DebugOptions.def"
+
+protected:
+#define DEBUGOPT(Name, Bits, Default)
+#define ENUM_DEBUGOPT(Name, Type, Bits, Default) unsigned Name : Bits;
+#include "clang/Basic/DebugOptions.def"
+};
+
+/// DebugOptions - Track various options which control how the debug information
+/// is generated for the backend.
+class DebugOptions : public DebugOptionsBase {
+public:
+ enum DebugSrcHashKind {
+ DSH_MD5,
+ DSH_SHA1,
+ DSH_SHA256,
+ };
+
+ /// Enable additional debugging information.
+ std::string DebugPass;
+
+ /// The string to embed in debug information as the current working directory.
+ std::string DebugCompilationDir;
+
+ /// The string to embed in the debug information for the compile unit, if
+ /// non-empty.
+ std::string DwarfDebugFlags;
+
+ enum AssignmentTrackingOpts {
+ Disabled,
+ Enabled,
+ Forced,
+ };
+
+ llvm::SmallVector<std::pair<std::string, std::string>, 0> DebugPrefixMap;
+
+ /// The file to use for dumping bug report by `Debugify` for original
+ /// debug info.
+ std::string DIBugsReportFilePath;
+
+ /// The name for the split debug info file used for the DW_AT_[GNU_]dwo_name
+ /// attribute in the skeleton CU.
+ std::string SplitDwarfFile;
+
+ /// Output filename for the split debug info, not used in the skeleton CU.
+ std::string SplitDwarfOutput;
+
+ /// Output filename used in the COFF debug information.
+ std::string ObjectFilenameForDebug;
+
+public:
+ // Define accessors/mutators for code generation options of enumeration type.
+#define DEBUGOPT(Name, Bits, Default)
+#define ENUM_DEBUGOPT(Name, Type, Bits, Default) \
+ Type get##Name() const { return static_cast<Type>(Name); } \
+ void set##Name(Type Value) { Name = static_cast<unsigned>(Value); }
+#include "clang/Basic/DebugOptions.def"
+
+ DebugOptions();
+
+ /// Check if type and variable info should be emitted.
+ bool hasReducedDebugInfo() const {
+ return getDebugInfo() >= llvm::debugoptions::DebugInfoConstructor;
+ }
+
+ /// Check if maybe unused type info should be emitted.
+ bool hasMaybeUnusedDebugInfo() const {
+ return getDebugInfo() >= llvm::debugoptions::UnusedTypeInfo;
+ }
+
+ /// Reset all of the options that are not considered when building a
+ /// module.
+ void resetNonModularOptions(llvm::StringRef ModuleFormat);
+};
+
+} // end namespace clang
+
+#endif
diff --git a/clang/include/clang/Basic/TargetInfo.h b/clang/include/clang/Basic/TargetInfo.h
index ec0189627dfbd2..e9661ee660cf06 100644
--- a/clang/include/clang/Basic/TargetInfo.h
+++ b/clang/include/clang/Basic/TargetInfo.h
@@ -16,7 +16,6 @@
#include "clang/Basic/AddressSpaces.h"
#include "clang/Basic/BitmaskEnum.h"
-#include "clang/Basic/CodeGenOptions.h"
#include "clang/Basic/LLVM.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/Specifiers.h"
@@ -48,7 +47,6 @@ struct fltSemantics;
namespace clang {
class DiagnosticsEngine;
class LangOptions;
-class CodeGenOptions;
class MacroBuilder;
/// Contains information gathered from parsing the contents of TargetAttr.
diff --git a/clang/include/clang/CodeGen/BackendUtil.h b/clang/include/clang/CodeGen/BackendUtil.h
index fc8ed4f011f922..9f3fd0b96399a4 100644
--- a/clang/include/clang/CodeGen/BackendUtil.h
+++ b/clang/include/clang/CodeGen/BackendUtil.h
@@ -28,6 +28,7 @@ namespace clang {
class DiagnosticsEngine;
class HeaderSearchOptions;
class CodeGenOptions;
+ class DebugOptions;
class TargetOptions;
class LangOptions;
class BackendConsumer;
@@ -43,8 +44,9 @@ namespace clang {
void EmitBackendOutput(DiagnosticsEngine &Diags, const HeaderSearchOptions &,
const CodeGenOptions &CGOpts,
- const TargetOptions &TOpts, const LangOptions &LOpts,
- StringRef TDesc, llvm::Module *M, BackendAction Action,
+ const DebugOptions &DOpts, const TargetOptions &TOpts,
+ const LangOptions &LOpts, StringRef TDesc,
+ llvm::Module *M, BackendAction Action,
llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
std::unique_ptr<raw_pwrite_stream> OS,
BackendConsumer *BC = nullptr);
diff --git a/clang/include/clang/CodeGen/ModuleBuilder.h b/clang/include/clang/CodeGen/ModuleBuilder.h
index edacd82bf899db..10ce2ecd9bb29b 100644
--- a/clang/include/clang/CodeGen/ModuleBuilder.h
+++ b/clang/include/clang/CodeGen/ModuleBuilder.h
@@ -29,6 +29,7 @@ namespace llvm {
namespace clang {
class CodeGenOptions;
+ class DebugOptions;
class CoverageSourceInfo;
class Decl;
class DiagnosticsEngine;
@@ -107,7 +108,7 @@ CodeGenerator *CreateLLVMCodeGen(DiagnosticsEngine &Diags,
const HeaderSearchOptions &HeaderSearchOpts,
const PreprocessorOptions &PreprocessorOpts,
const CodeGenOptions &CGO,
- llvm::LLVMContext &C,
+ const DebugOptions &DO, llvm::LLVMContext &C,
CoverageSourceInfo *CoverageInfo = nullptr);
} // end namespace clang
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
index 1b02087425b751..647cb873ec8101 100644
--- a/clang/include/clang/Driver/Options.td
+++ b/clang/include/clang/Driver/Options.td
@@ -299,6 +299,8 @@ class DependencyOutputOpts<string base>
: KeyPathAndMacro<"DependencyOutputOpts.", base, "DEPENDENCY_OUTPUT_"> {}
class CodeGenOpts<string base>
: KeyPathAndMacro<"CodeGenOpts.", base, "CODEGEN_"> {}
+class DebugOpts<string base>
+ : KeyPathAndMacro<"DebugOpts.", base, "DEBUG_"> {}
class HeaderSearchOpts<string base>
: KeyPathAndMacro<"HeaderSearchOpts->", base, "HEADER_SEARCH_"> {}
class PreprocessorOpts<string base>
@@ -1656,7 +1658,7 @@ def fdebug_compilation_dir_EQ : Joined<["-"], "fdebug-compilation-dir=">,
Group<f_Group>,
Visibility<[ClangOption, CC1Option, CC1AsOption, CLOption, DXCOption]>,
HelpText<"The compilation directory to embed in the debug info">,
- MarshallingInfoString<CodeGenOpts<"DebugCompilationDir">>;
+ MarshallingInfoString<DebugOpts<"DebugCompilationDir">>;
def fdebug_compilation_dir : Separate<["-"], "fdebug-compilation-dir">,
Group<f_Group>,
Visibility<[ClangOption, CC1Option, CC1AsOption, CLOption, DXCOption]>,
@@ -1669,7 +1671,7 @@ def ffile_compilation_dir_EQ : Joined<["-"], "ffile-compilation-dir=">, Group<f_
Visibility<[ClangOption, CLOption, DXCOption]>,
HelpText<"The compilation directory to embed in the debug info and coverage mapping.">;
defm debug_info_for_profiling : BoolFOption<"debug-info-for-profiling",
- CodeGenOpts<"DebugInfoForProfiling">, DefaultFalse,
+ DebugOpts<"DebugInfoForProfiling">, DefaultFalse,
PosFlag<SetTrue, [], [ClangOption, CC1Option],
"Emit extra debug info to make sample profile more accurate">,
NegFlag<SetFalse>>;
@@ -2005,7 +2007,7 @@ defm dollars_in_identifiers : BoolFOption<"dollars-in-identifiers",
def fdwarf2_cfi_asm : Flag<["-"], "fdwarf2-cfi-asm">, Group<clang_ignored_f_Group>;
def fno_dwarf2_cfi_asm : Flag<["-"], "fno-dwarf2-cfi-asm">, Group<clang_ignored_f_Group>;
defm dwarf_directory_asm : BoolFOption<"dwarf-directory-asm",
- CodeGenOpts<"NoDwarfDirectoryAsm">, DefaultFalse,
+ DebugOpts<"NoDwarfDirectoryAsm">, DefaultFalse,
NegFlag<SetTrue, [], [ClangOption, CC1Option]>,
PosFlag<SetFalse>>;
defm elide_constructors : BoolFOption<"elide-constructors",
@@ -4024,12 +4026,12 @@ def fdebug_types_section: Flag <["-"], "fdebug-types-section">, Group<f_Group>,
HelpText<"Place debug types in their own section (ELF Only)">;
def fno_debug_types_section: Flag<["-"], "fno-debug-types-section">, Group<f_Group>;
defm debug_ranges_base_address : BoolFOption<"debug-ranges-base-address",
- CodeGenOpts<"DebugRangesBaseAddress">, DefaultFalse,
+ DebugOpts<"DebugRangesBaseAddress">, DefaultFalse,
PosFlag<SetTrue, [], [ClangOption, CC1Option],
"Use DWARF base address selection entries in .debug_ranges">,
NegFlag<SetFalse>>;
defm split_dwarf_inlining : BoolFOption<"split-dwarf-inlining",
- CodeGenOpts<"SplitDwarfInlining">, DefaultFalse,
+ DebugOpts<"SplitDwarfInlining">, DefaultFalse,
NegFlag<SetFalse, [], [ClangOption]>,
PosFlag<SetTrue, [], [ClangOption, CC1Option],
"Provide minimal debug info in the object/executable"
@@ -4057,7 +4059,7 @@ def fmacro_prefix_map_EQ
HelpText<"remap file source paths in predefined preprocessor macros and "
"__builtin_FILE(). Implies -ffile-reproducible.">;
defm force_dwarf_frame : BoolFOption<"force-dwarf-frame",
- CodeGenOpts<"ForceDwarfFrameSection">, DefaultFalse,
+ DebugOpts<"ForceDwarfFrameSection">, DefaultFalse,
PosFlag<SetTrue, [], [ClangOption, CC1Option],
"Always emit a debug frame section">,
NegFlag<SetFalse>>;
@@ -4067,7 +4069,7 @@ def femit_dwarf_unwind_EQ : Joined<["-"], "femit-dwarf-unwind=">,
Values<"always,no-compact-unwind,default">,
NormalizedValues<["Always", "NoCompactUnwind", "Default"]>,
NormalizedValuesScope<"llvm::EmitDwarfUnwindType">,
- MarshallingInfoEnum<CodeGenOpts<"EmitDwarfUnwind">, "Default">;
+ MarshallingInfoEnum<DebugOpts<"EmitDwarfUnwind">, "Default">;
defm emit_compact_unwind_non_canonical : BoolFOption<"emit-compact-unwind-non-canonical",
CodeGenOpts<"EmitCompactUnwindNonCanonical">, DefaultFalse,
PosFlag<SetTrue, [], [ClangOption, CC1Option, CC1AsOption],
@@ -4111,7 +4113,7 @@ def gdwarf_5 : Flag<["-"], "gdwarf-5">, Group<g_Group>,
def gdwarf64 : Flag<["-"], "gdwarf64">, Group<g_Group>,
Visibility<[ClangOption, CC1Option, CC1AsOption]>,
HelpText<"Enables DWARF64 format for ELF binaries, if debug information emission is enabled.">,
- MarshallingInfoFlag<CodeGenOpts<"Dwarf64">>;
+ MarshallingInfoFlag<DebugOpts<"Dwarf64">>;
def gdwarf32 : Flag<["-"], "gdwarf32">, Group<g_Group>,
Visibility<[ClangOption, CC1Option, CC1AsOption]>,
HelpText<"Enables DWARF32 format for ELF binaries, if debug information emission is enabled.">;
@@ -4119,19 +4121,19 @@ def gdwarf32 : Flag<["-"], "gdwarf32">, Group<g_Group>,
def gcodeview : Flag<["-"], "gcodeview">,
HelpText<"Generate CodeView debug information">,
Visibility<[ClangOption, CC1Option, CC1AsOption, CLOption, DXCOption]>,
- MarshallingInfoFlag<CodeGenOpts<"EmitCodeView">>;
+ MarshallingInfoFlag<DebugOpts<"EmitCodeView">>;
defm codeview_ghash : BoolOption<"g", "codeview-ghash",
- CodeGenOpts<"CodeViewGHash">, DefaultFalse,
+ DebugOpts<"CodeViewGHash">, DefaultFalse,
PosFlag<SetTrue, [], [ClangOption, CC1Option],
"Emit type record hashes in a .debug$H section">,
NegFlag<SetFalse>, BothFlags<[], [ClangOption, CLOption, DXCOption]>>;
defm codeview_command_line : BoolOption<"g", "codeview-command-line",
- CodeGenOpts<"CodeViewCommandLine">, DefaultTrue,
+ DebugOpts<"CodeViewCommandLine">, DefaultTrue,
PosFlag<SetTrue, [], [ClangOption], "Emit compiler path and command line into CodeView debug information">,
NegFlag<SetFalse, [], [ClangOption], "Don't emit compiler path and command line into CodeView debug information">,
BothFlags<[], [ClangOption, CLOption, DXCOption, CC1Option]>>;
defm inline_line_tables : BoolGOption<"inline-line-tables",
- CodeGenOpts<"NoInlineLineTables">, DefaultFalse,
+ DebugOpts<"NoInlineLineTables">, DefaultFalse,
NegFlag<SetTrue, [], [ClangOption, CC1Option],
"Don't emit inline line tables.">,
PosFlag<SetFalse>, BothFlags<[], [ClangOption, CLOption, DXCOption]>>;
@@ -4150,14 +4152,14 @@ def gno_record_command_line : Flag<["-"], "gno-record-command-line">,
def : Flag<["-"], "grecord-gcc-switches">, Alias<grecord_command_line>;
def : Flag<["-"], "gno-record-gcc-switches">, Alias<gno_record_command_line>;
defm strict_dwarf : BoolOption<"g", "strict-dwarf",
- CodeGenOpts<"DebugStrictDwarf">, DefaultFalse,
+ DebugOpts<"DebugStrictDwarf">, DefaultFalse,
PosFlag<SetTrue, [], [ClangOption, CC1Option],
"Restrict DWARF features to those defined in "
"the specified version, avoiding features from later versions.">,
NegFlag<SetFalse>, BothFlags<[], [ClangOption, CLOption, DXCOption]>>,
Group<g_flags_Group>;
defm column_info : BoolOption<"g", "column-info",
- CodeGenOpts<"DebugColumnInfo">, DefaultTrue,
+ DebugOpts<"DebugColumnInfo">, DefaultTrue,
NegFlag<SetFalse, [], [ClangOption, CC1Option]>,
PosFlag<SetTrue>, BothFlags<[], [ClangOption, CLOption, DXCOption]>>,
Group<g_flags_Group>;
@@ -4179,8 +4181,8 @@ def gsrc_hash_EQ : Joined<["-"], "gsrc-hash=">,
Group<g_flags_Group>, Visibility<[CC1Option]>,
Values<"md5,sha1,sha256">,
NormalizedValues<["DSH_MD5", "DSH_SHA1", "DSH_SHA256"]>,
- NormalizedValuesScope<"CodeGenOptions">,
- MarshallingInfoEnum<CodeGenOpts<"DebugSrcHash">, "DSH_MD5">;
+ NormalizedValuesScope<"DebugOptions">,
+ MarshallingInfoEnum<DebugOpts<"DebugSrcHash">, "DSH_MD5">;
def gno_simple_template_names : Flag<["-"], "gno-simple-template-names">,
Group<g_flags_Group>;
def ggnu_pubnames : Flag<["-"], "ggnu-pubnames">, Group<g_flags_Group>,
@@ -4200,7 +4202,7 @@ def gz : Flag<["-"], "gz">, Alias<gz_EQ>, AliasArgs<["zlib"]>, Group<g_flags_Gro
def gembed_source : Flag<["-"], "gembed-source">, Group<g_flags_Group>,
Visibility<[ClangOption, CC1Option]>,
HelpText<"Embed source text in DWARF debug sections">,
- MarshallingInfoFlag<CodeGenOpts<"EmbedSource">>;
+ MarshallingInfoFlag<DebugOpts<"EmbedSource">>;
def gno_embed_source : Flag<["-"], "gno-embed-source">, Group<g_flags_Group>,
Flags<[NoXarchOption]>,
HelpText<"Restore the default behavior of not embedding source text in DWARF debug sections">;
@@ -5224,7 +5226,7 @@ def o : JoinedOrSeparate<["-"], "o">,
def object_file_name_EQ : Joined<["-"], "object-file-name=">,
Visibility<[ClangOption, CC1Option, CC1AsOption, CLOption, DXCOption]>,
HelpText<"Set the output <file> for debug infos">, MetaVarName<"<file>">,
- MarshallingInfoString<CodeGenOpts<"ObjectFilenameForDebug">>;
+ MarshallingInfoString<DebugOpts<"ObjectFilenameForDebug">>;
def object_file_name : Separate<["-"], "object-file-name">,
Visibility<[ClangOption, CC1Option, CC1AsOption, CLOption, DXCOption]>,
Alias<object_file_name_EQ>;
@@ -6703,26 +6705,26 @@ let Visibility = [CC1Option, CC1AsOption] in {
def debug_info_macro : Flag<["-"], "debug-info-macro">,
HelpText<"Emit macro debug information">,
- MarshallingInfoFlag<CodeGenOpts<"MacroDebugInfo">>;
+ MarshallingInfoFlag<DebugOpts<"MacroDebugInfo">>;
def default_function_attr : Separate<["-"], "default-function-attr">,
HelpText<"Apply given attribute to all functions">,
MarshallingInfoStringVector<CodeGenOpts<"DefaultFunctionAttrs">>;
def dwarf_version_EQ : Joined<["-"], "dwarf-version=">,
- MarshallingInfoInt<CodeGenOpts<"DwarfVersion">>;
+ MarshallingInfoInt<DebugOpts<"DwarfVersion">>;
def debugger_tuning_EQ : Joined<["-"], "debugger-tuning=">,
Values<"gdb,lldb,sce,dbx">,
NormalizedValuesScope<"llvm::DebuggerKind">, NormalizedValues<["GDB", "LLDB", "SCE", "DBX"]>,
- MarshallingInfoEnum<CodeGenOpts<"DebuggerTuning">, "Default">;
+ MarshallingInfoEnum<DebugOpts<"DebuggerTuning">, "Default">;
def dwarf_debug_flags : Separate<["-"], "dwarf-debug-flags">,
HelpText<"The string to embed in the Dwarf debug flags record.">,
- MarshallingInfoString<CodeGenOpts<"DwarfDebugFlags">>;
+ MarshallingInfoString<DebugOpts<"DwarfDebugFlags">>;
def record_command_line : Separate<["-"], "record-command-line">,
HelpText<"The string to embed in the .LLVM.command.line section.">,
MarshallingInfoString<CodeGenOpts<"RecordCommandLine">>;
def compress_debug_sections_EQ : Joined<["-", "--"], "compress-debug-sections=">,
HelpText<"DWARF debug sections compression type">, Values<"none,zlib,zstd">,
NormalizedValuesScope<"llvm::DebugCompressionType">, NormalizedValues<["None", "Zlib", "Zstd"]>,
- MarshallingInfoEnum<CodeGenOpts<"CompressDebugSections">, "None">;
+ MarshallingInfoEnum<DebugOpts<"CompressDebugSections">, "None">;
def compress_debug_sections : Flag<["-", "--"], "compress-debug-sections">,
Alias<compress_debug_sections_EQ>, AliasArgs<["zlib"]>;
def mno_exec_stack : Flag<["-"], "mnoexecstack">,
@@ -6785,15 +6787,15 @@ def disable_red_zone : Flag<["-"], "disable-red-zone">,
def dwarf_ext_refs : Flag<["-"], "dwarf-ext-refs">,
HelpText<"Generate debug info with external references to clang modules"
" or precompiled headers">,
- MarshallingInfoFlag<CodeGenOpts<"DebugTypeExtRefs">>;
+ MarshallingInfoFlag<DebugOpts<"DebugTypeExtRefs">>;
def dwarf_explicit_import : Flag<["-"], "dwarf-explicit-import">,
HelpText<"Generate explicit import from anonymous namespace to containing"
" scope">,
- MarshallingInfoFlag<CodeGenOpts<"DebugExplicitImport">>;
+ MarshallingInfoFlag<DebugOpts<"DebugExplicitImport">>;
def debug_forward_template_params : Flag<["-"], "debug-forward-template-params">,
HelpText<"Emit complete descriptions of template parameters in forward"
" declarations">,
- MarshallingInfoFlag<CodeGenOpts<"DebugFwdTemplateParams">>;
+ MarshallingInfoFlag<DebugOpts<"DebugFwdTemplateParams">>;
def fforbid_guard_variables : Flag<["-"], "fforbid-guard-variables">,
HelpText<"Emit an error if a C++ static local initializer would need a guard variable">,
MarshallingInfoFlag<CodeGenOpts<"ForbidGuardVariables">>;
@@ -6981,14 +6983,14 @@ def fverify_debuginfo_preserve
: Flag<["-"], "fverify-debuginfo-preserve">,
HelpText<"Enable Debug Info Metadata preservation testing in "
"optimizations.">,
- MarshallingInfoFlag<CodeGenOpts<"EnableDIPreservationVerify">>;
+ MarshallingInfoFlag<DebugOpts<"EnableDIPreservationVerify">>;
def fverify_debuginfo_preserve_export
: Joined<["-"], "fverify-debuginfo-preserve-export=">,
MetaVarName<"<file>">,
HelpText<"Export debug info (by testing original Debug Info) failures "
"into specified (JSON) file (should be abs path as we use "
"append mode to insert new JSON objects).">,
- MarshallingInfoString<CodeGenOpts<"DIBugsReportFilePath">>;
+ MarshallingInfoString<DebugOpts<"DIBugsReportFilePath">>;
def fwarn_stack_size_EQ
: Joined<["-"], "fwarn-stack-size=">,
MarshallingInfoInt<CodeGenOpts<"WarnStackSize">, "UINT_MAX">;
@@ -7020,10 +7022,10 @@ def fctor_dtor_return_this : Flag<["-"], "fctor-dtor-return-this">,
MarshallingInfoFlag<CodeGenOpts<"CtorDtorReturnThis">>;
def fexperimental_assignment_tracking_EQ : Joined<["-"], "fexperimental-assignment-tracking=">,
- Group<f_Group>, CodeGenOpts<"EnableAssignmentTracking">,
- NormalizedValuesScope<"CodeGenOptions::AssignmentTrackingOpts">,
+ Group<f_Group>, DebugOpts<"EnableAssignmentTracking">,
+ NormalizedValuesScope<"DebugOptions::AssignmentTrackingOpts">,
Values<"disabled,enabled,forced">, NormalizedValues<["Disabled","Enabled","Forced"]>,
- MarshallingInfoEnum<CodeGenOpts<"AssignmentTrackingMode">, "Enabled">;
+ MarshallingInfoEnum<DebugOpts<"AssignmentTrackingMode">, "Enabled">;
} // let Visibility = [CC1Option]
@@ -7418,7 +7420,7 @@ def main_file_name : Separate<["-"], "main-file-name">,
def split_dwarf_output : Separate<["-"], "split-dwarf-output">,
HelpText<"File name to use for split dwarf debug info output">,
Visibility<[CC1Option, CC1AsOption]>,
- MarshallingInfoString<CodeGenOpts<"SplitDwarfOutput">>;
+ MarshallingInfoString<DebugOpts<"SplitDwarfOutput">>;
let Visibility = [CC1Option, FC1Option] in {
@@ -7461,7 +7463,7 @@ def fexternc_nounwind : Flag<["-"], "fexternc-nounwind">,
MarshallingInfoFlag<LangOpts<"ExternCNoUnwind">>;
def split_dwarf_file : Separate<["-"], "split-dwarf-file">,
HelpText<"Name of the split dwarf debug info file to encode in the object file">,
- MarshallingInfoString<CodeGenOpts<"SplitDwarfFile">>;
+ MarshallingInfoString<DebugOpts<"SplitDwarfFile">>;
def fno_wchar : Flag<["-"], "fno-wchar">,
HelpText<"Disable C++ builtin type wchar_t">,
MarshallingInfoNegativeFlag<LangOpts<"WChar">, cplusplus.KeyPath>,
diff --git a/clang/include/clang/Driver/ToolChain.h b/clang/include/clang/Driver/ToolChain.h
index 2d0c1f826c1728..b210bdb31d3805 100644
--- a/clang/include/clang/Driver/ToolChain.h
+++ b/clang/include/clang/Driver/ToolChain.h
@@ -557,8 +557,8 @@ class ToolChain {
virtual void CheckObjCARC() const {}
/// Get the default debug info format. Typically, this is DWARF.
- virtual llvm::codegenoptions::DebugInfoFormat getDefaultDebugFormat() const {
- return llvm::codegenoptions::DIF_DWARF;
+ virtual llvm::debugoptions::DebugInfoFormat getDefaultDebugFormat() const {
+ return llvm::debugoptions::DIF_DWARF;
}
/// UseDwarfDebugFlags - Embed the compile options to clang into the Dwarf
@@ -595,7 +595,7 @@ class ToolChain {
/// Adjust debug information kind considering all passed options.
virtual void
- adjustDebugInfoKind(llvm::codegenoptions::DebugInfoKind &DebugInfoKind,
+ adjustDebugInfoKind(llvm::debugoptions::DebugInfoKind &DebugInfoKind,
const llvm::opt::ArgList &Args) const {}
/// GetExceptionModel - Return the tool chain exception model.
diff --git a/clang/include/clang/Frontend/CompilerInstance.h b/clang/include/clang/Frontend/CompilerInstance.h
index ac2f940769fbe9..e065ee351af621 100644
--- a/clang/include/clang/Frontend/CompilerInstance.h
+++ b/clang/include/clang/Frontend/CompilerInstance.h
@@ -266,6 +266,11 @@ class CompilerInstance : public ModuleLoader {
return Invocation->getCodeGenOpts();
}
+ DebugOptions &getDebugOpts() { return Invocation->getDebugOpts(); }
+ const DebugOptions &getDebugOpts() const {
+ return Invocation->getDebugOpts();
+ }
+
DependencyOutputOptions &getDependencyOutputOpts() {
return Invocation->getDependencyOutputOpts();
}
@@ -655,15 +660,13 @@ class CompilerInstance : public ModuleLoader {
/// attached to (and, then, owned by) the returned DiagnosticsEngine
/// object.
///
- /// \param CodeGenOpts If non-NULL, the code gen options in use, which may be
+ /// \param DebugOpts If non-NULL, the debug options in use, which may be
/// used by some diagnostics printers (for logging purposes only).
///
/// \return The new object on success, or null on failure.
- static IntrusiveRefCntPtr<DiagnosticsEngine>
- createDiagnostics(DiagnosticOptions *Opts,
- DiagnosticConsumer *Client = nullptr,
- bool ShouldOwnClient = true,
- const CodeGenOptions *CodeGenOpts = nullptr);
+ static IntrusiveRefCntPtr<DiagnosticsEngine> createDiagnostics(
+ DiagnosticOptions *Opts, DiagnosticConsumer *Client = nullptr,
+ bool ShouldOwnClient = true, const DebugOptions *DebugOpts = nullptr);
/// Create the file manager and replace any existing one with it.
///
diff --git a/clang/include/clang/Frontend/CompilerInvocation.h b/clang/include/clang/Frontend/CompilerInvocation.h
index c6528779bde7b2..0969a6bdda067a 100644
--- a/clang/include/clang/Frontend/CompilerInvocation.h
+++ b/clang/include/clang/Frontend/CompilerInvocation.h
@@ -11,6 +11,7 @@
#include "clang/APINotes/APINotesOptions.h"
#include "clang/Basic/CodeGenOptions.h"
+#include "clang/Basic/DebugOptions.h"
#include "clang/Basic/DiagnosticOptions.h"
#include "clang/Basic/FileSystemOptions.h"
#include "clang/Basic/LLVM.h"
@@ -21,8 +22,8 @@
#include "clang/Frontend/MigratorOptions.h"
#include "clang/Frontend/PreprocessorOutputOptions.h"
#include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
-#include "llvm/ADT/IntrusiveRefCntPtr.h"
#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/IntrusiveRefCntPtr.h"
#include <memory>
#include <string>
@@ -99,6 +100,9 @@ class CompilerInvocationBase {
/// Options controlling IRgen and the backend.
std::shared_ptr<CodeGenOptions> CodeGenOpts;
+ /// Options controlling debug generation.
+ std::shared_ptr<DebugOptions> DebugOpts;
+
/// Options controlling file system operations.
std::shared_ptr<FileSystemOptions> FSOpts;
@@ -137,6 +141,7 @@ class CompilerInvocationBase {
const MigratorOptions &getMigratorOpts() const { return *MigratorOpts; }
const APINotesOptions &getAPINotesOpts() const { return *APINotesOpts; }
const CodeGenOptions &getCodeGenOpts() const { return *CodeGenOpts; }
+ const DebugOptions &getDebugOpts() const { return *DebugOpts; }
const FileSystemOptions &getFileSystemOpts() const { return *FSOpts; }
const FrontendOptions &getFrontendOpts() const { return *FrontendOpts; }
const DependencyOutputOptions &getDependencyOutputOpts() const {
@@ -198,6 +203,10 @@ class CompilerInvocationBase {
const llvm::Triple &T,
const std::string &OutputFile,
const LangOptions *LangOpts);
+
+ // Generate command line options from DebugOptions.
+ static void GenerateDebugArgs(const DebugOptions &Opts,
+ ArgumentConsumer Consumer);
/// @}
};
@@ -224,19 +233,20 @@ class CompilerInvocation : public CompilerInvocationBase {
/// @{
// Note: These need to be pulled in manually. Otherwise, they get hidden by
// the mutable getters with the same names.
- using CompilerInvocationBase::getLangOpts;
- using CompilerInvocationBase::getTargetOpts;
- using CompilerInvocationBase::getDiagnosticOpts;
- using CompilerInvocationBase::getHeaderSearchOpts;
- using CompilerInvocationBase::getPreprocessorOpts;
using CompilerInvocationBase::getAnalyzerOpts;
- using CompilerInvocationBase::getMigratorOpts;
using CompilerInvocationBase::getAPINotesOpts;
using CompilerInvocationBase::getCodeGenOpts;
+ using CompilerInvocationBase::getDebugOpts;
+ using CompilerInvocationBase::getDependencyOutputOpts;
+ using CompilerInvocationBase::getDiagnosticOpts;
using CompilerInvocationBase::getFileSystemOpts;
using CompilerInvocationBase::getFrontendOpts;
- using CompilerInvocationBase::getDependencyOutputOpts;
+ using CompilerInvocationBase::getHeaderSearchOpts;
+ using CompilerInvocationBase::getLangOpts;
+ using CompilerInvocationBase::getMigratorOpts;
+ using CompilerInvocationBase::getPreprocessorOpts;
using CompilerInvocationBase::getPreprocessorOutputOpts;
+ using CompilerInvocationBase::getTargetOpts;
/// @}
/// Mutable getters.
@@ -250,6 +260,7 @@ class CompilerInvocation : public CompilerInvocationBase {
MigratorOptions &getMigratorOpts() { return *MigratorOpts; }
APINotesOptions &getAPINotesOpts() { return *APINotesOpts; }
CodeGenOptions &getCodeGenOpts() { return *CodeGenOpts; }
+ DebugOptions &getDebugOpts() { return *DebugOpts; }
FileSystemOptions &getFileSystemOpts() { return *FSOpts; }
FrontendOptions &getFrontendOpts() { return *FrontendOpts; }
DependencyOutputOptions &getDependencyOutputOpts() {
@@ -334,11 +345,18 @@ class CompilerInvocation : public CompilerInvocationBase {
DiagnosticsEngine &Diags);
/// Parse command line options that map to CodeGenOptions.
- static bool ParseCodeGenArgs(CodeGenOptions &Opts, llvm::opt::ArgList &Args,
- InputKind IK, DiagnosticsEngine &Diags,
- const llvm::Triple &T,
+ static bool ParseCodeGenArgs(CodeGenOptions &Opts, DebugOptions &DebugOpts,
+ llvm::opt::ArgList &Args, InputKind IK,
+ DiagnosticsEngine &Diags, const llvm::Triple &T,
const std::string &OutputFile,
const LangOptions &LangOptsRef);
+
+ /// Parse command line options that map to DebugOptions.
+ static bool ParseDebugArgs(DebugOptions &Opts, llvm::opt::ArgList &Args,
+ InputKind IK, DiagnosticsEngine &Diags,
+ const llvm::Triple &T,
+ const std::string &OutputFile,
+ const LangOptions &LangOptsRef);
};
/// Same as \c CompilerInvocation, but with copy-on-write optimization.
@@ -377,6 +395,7 @@ class CowCompilerInvocation : public CompilerInvocationBase {
MigratorOptions &getMutMigratorOpts();
APINotesOptions &getMutAPINotesOpts();
CodeGenOptions &getMutCodeGenOpts();
+ DebugOptions &getMutDebugOpts();
FileSystemOptions &getMutFileSystemOpts();
FrontendOptions &getMutFrontendOpts();
DependencyOutputOptions &getMutDependencyOutputOpts();
diff --git a/clang/lib/Basic/CMakeLists.txt b/clang/lib/Basic/CMakeLists.txt
index 2e218ba7c84cca..b93c1b9cbeb87d 100644
--- a/clang/lib/Basic/CMakeLists.txt
+++ b/clang/lib/Basic/CMakeLists.txt
@@ -62,6 +62,7 @@ add_clang_library(clangBasic
CodeGenOptions.cpp
Cuda.cpp
DarwinSDKInfo.cpp
+ DebugOptions.cpp
Diagnostic.cpp
DiagnosticIDs.cpp
DiagnosticOptions.cpp
diff --git a/clang/lib/Basic/CodeGenOptions.cpp b/clang/lib/Basic/CodeGenOptions.cpp
index 182d0a2fa4d88f..0ed83122afb859 100644
--- a/clang/lib/Basic/CodeGenOptions.cpp
+++ b/clang/lib/Basic/CodeGenOptions.cpp
@@ -11,46 +11,13 @@
namespace clang {
-CodeGenOptions::CodeGenOptions() {
-#define CODEGENOPT(Name, Bits, Default) Name = Default;
-#define ENUM_CODEGENOPT(Name, Type, Bits, Default) set##Name(Default);
-#include "clang/Basic/CodeGenOptions.def"
+CodeGenOptions::CodeGenOptions() { resetNonModularOptions(); }
- RelocationModel = llvm::Reloc::PIC_;
- memcpy(CoverageVersion, "408*", 4);
-}
-
-void CodeGenOptions::resetNonModularOptions(StringRef ModuleFormat) {
- // First reset all CodeGen options only. The Debug options are handled later.
-#define DEBUGOPT(Name, Bits, Default)
-#define VALUE_DEBUGOPT(Name, Bits, Default)
-#define ENUM_DEBUGOPT(Name, Type, Bits, Default)
+void CodeGenOptions::resetNonModularOptions() {
#define CODEGENOPT(Name, Bits, Default) Name = Default;
#define ENUM_CODEGENOPT(Name, Type, Bits, Default) set##Name(Default);
#include "clang/Basic/CodeGenOptions.def"
- // Next reset all debug options that can always be reset, because they never
- // affect the PCM.
-#define DEBUGOPT(Name, Bits, Default)
-#define VALUE_DEBUGOPT(Name, Bits, Default)
-#define ENUM_DEBUGOPT(Name, Type, Bits, Default)
-#define BENIGN_DEBUGOPT(Name, Bits, Default) Name = Default;
-#define BENIGN_VALUE_DEBUGOPT(Name, Bits, Default) Name = Default;
-#define BENIGN_ENUM_DEBUGOPT(Name, Type, Bits, Default) set##Name(Default);
-#include "clang/Basic/DebugOptions.def"
-
- // Conditionally reset debug options that only matter when the debug info is
- // emitted into the PCM (-gmodules).
- if (ModuleFormat == "raw" && !DebugTypeExtRefs) {
-#define DEBUGOPT(Name, Bits, Default) Name = Default;
-#define VALUE_DEBUGOPT(Name, Bits, Default) Name = Default;
-#define ENUM_DEBUGOPT(Name, Type, Bits, Default) set##Name(Default);
-#define BENIGN_DEBUGOPT(Name, Bits, Default)
-#define BENIGN_VALUE_DEBUGOPT(Name, Bits, Default)
-#define BENIGN_ENUM_DEBUGOPT(Name, Type, Bits, Default)
-#include "clang/Basic/DebugOptions.def"
- }
-
RelocationModel = llvm::Reloc::PIC_;
memcpy(CoverageVersion, "408*", 4);
}
diff --git a/clang/lib/Basic/DebugOptions.cpp b/clang/lib/Basic/DebugOptions.cpp
new file mode 100644
index 00000000000000..26c706a3b367ba
--- /dev/null
+++ b/clang/lib/Basic/DebugOptions.cpp
@@ -0,0 +1,40 @@
+//===--- DebugOptions.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
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Basic/DebugOptions.h"
+
+namespace clang {
+
+DebugOptions::DebugOptions() {
+#define DEBUGOPT(Name, Bits, Default) Name = Default;
+#define ENUM_DEBUGOPT(Name, Type, Bits, Default) set##Name(Default);
+#include "clang/Basic/DebugOptions.def"
+}
+
+void DebugOptions::resetNonModularOptions(llvm::StringRef ModuleFormat) {
+ // First reset all debug options that can always be reset, because they never
+ // affect the PCM.
+#define DEBUGOPT(Name, Bits, Default)
+#define BENIGN_DEBUGOPT(Name, Bits, Default) Name = Default;
+#define BENIGN_VALUE_DEBUGOPT(Name, Bits, Default) Name = Default;
+#define BENIGN_ENUM_DEBUGOPT(Name, Type, Bits, Default) set##Name(Default);
+#include "clang/Basic/DebugOptions.def"
+
+ // Conditionally reset debug options that only matter when the debug info is
+ // emitted into the PCM (-gmodules).
+ if (ModuleFormat == "raw" && !DebugTypeExtRefs) {
+#define DEBUGOPT(Name, Bits, Default) Name = Default;
+#define ENUM_DEBUGOPT(Name, Type, Bits, Default) set##Name(Default);
+#define BENIGN_DEBUGOPT(Name, Bits, Default)
+#define BENIGN_VALUE_DEBUGOPT(Name, Bits, Default)
+#define BENIGN_ENUM_DEBUGOPT(Name, Type, Bits, Default)
+#include "clang/Basic/DebugOptions.def"
+ }
+}
+
+} // end namespace clang
diff --git a/clang/lib/CodeGen/BackendConsumer.h b/clang/lib/CodeGen/BackendConsumer.h
index 72a814cd43d738..0b4229c3cd18cd 100644
--- a/clang/lib/CodeGen/BackendConsumer.h
+++ b/clang/lib/CodeGen/BackendConsumer.h
@@ -32,6 +32,7 @@ class BackendConsumer : public ASTConsumer {
BackendAction Action;
const HeaderSearchOptions &HeaderSearchOpts;
const CodeGenOptions &CodeGenOpts;
+ const DebugOptions &DebugOpts;
const TargetOptions &TargetOpts;
const LangOptions &LangOpts;
std::unique_ptr<raw_pwrite_stream> AsmOutStream;
@@ -74,8 +75,9 @@ class BackendConsumer : public ASTConsumer {
const HeaderSearchOptions &HeaderSearchOpts,
const PreprocessorOptions &PPOpts,
const CodeGenOptions &CodeGenOpts,
- const TargetOptions &TargetOpts,
- const LangOptions &LangOpts, const std::string &InFile,
+ const DebugOptions &DebugOpts,
+ const TargetOptions &TargetOpts, const LangOptions &LangOpts,
+ const std::string &InFile,
SmallVector<LinkModule, 4> LinkModules,
std::unique_ptr<raw_pwrite_stream> OS, llvm::LLVMContext &C,
CoverageSourceInfo *CoverageInfo = nullptr);
@@ -88,9 +90,10 @@ class BackendConsumer : public ASTConsumer {
const HeaderSearchOptions &HeaderSearchOpts,
const PreprocessorOptions &PPOpts,
const CodeGenOptions &CodeGenOpts,
- const TargetOptions &TargetOpts,
- const LangOptions &LangOpts, llvm::Module *Module,
- SmallVector<LinkModule, 4> LinkModules, llvm::LLVMContext &C,
+ const DebugOptions &DebugOpts,
+ const TargetOptions &TargetOpts, const LangOptions &LangOpts,
+ llvm::Module *Module, SmallVector<LinkModule, 4> LinkModules,
+ llvm::LLVMContext &C,
CoverageSourceInfo *CoverageInfo = nullptr);
llvm::Module *getModule() const;
diff --git a/clang/lib/CodeGen/BackendUtil.cpp b/clang/lib/CodeGen/BackendUtil.cpp
index 77455c075cab0d..0ee42f51d3fdbc 100644
--- a/clang/lib/CodeGen/BackendUtil.cpp
+++ b/clang/lib/CodeGen/BackendUtil.cpp
@@ -10,6 +10,7 @@
#include "BackendConsumer.h"
#include "LinkInModulesPass.h"
#include "clang/Basic/CodeGenOptions.h"
+#include "clang/Basic/DebugOptions.h"
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/TargetOptions.h"
@@ -119,6 +120,7 @@ class EmitAssemblyHelper {
DiagnosticsEngine &Diags;
const HeaderSearchOptions &HSOpts;
const CodeGenOptions &CodeGenOpts;
+ const DebugOptions &DebugOpts;
const clang::TargetOptions &TargetOpts;
const LangOptions &LangOpts;
llvm::Module *TheModule;
@@ -184,12 +186,13 @@ class EmitAssemblyHelper {
public:
EmitAssemblyHelper(DiagnosticsEngine &_Diags,
const HeaderSearchOptions &HeaderSearchOpts,
- const CodeGenOptions &CGOpts,
+ const CodeGenOptions &CGOpts, const DebugOptions &DOpts,
const clang::TargetOptions &TOpts,
const LangOptions &LOpts, llvm::Module *M,
IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS)
: Diags(_Diags), HSOpts(HeaderSearchOpts), CodeGenOpts(CGOpts),
- TargetOpts(TOpts), LangOpts(LOpts), TheModule(M), VFS(std::move(VFS)),
+ DebugOpts(DOpts), TargetOpts(TOpts), LangOpts(LOpts), TheModule(M),
+ VFS(std::move(VFS)),
CodeGenerationTime("codegen", "Code Generation Time"),
TargetTriple(TheModule->getTargetTriple()) {}
@@ -300,6 +303,7 @@ static bool actionRequiresCodeGen(BackendAction Action) {
static bool initTargetOptions(DiagnosticsEngine &Diags,
llvm::TargetOptions &Options,
const CodeGenOptions &CodeGenOpts,
+ const DebugOptions &DebugOpts,
const clang::TargetOptions &TargetOpts,
const LangOptions &LangOpts,
const HeaderSearchOptions &HSOpts) {
@@ -343,7 +347,7 @@ static bool initTargetOptions(DiagnosticsEngine &Diags,
llvm::TargetMachine::parseBinutilsVersion(CodeGenOpts.BinutilsVersion);
Options.UseInitArray = CodeGenOpts.UseInitArray;
Options.DisableIntegratedAS = CodeGenOpts.DisableIntegratedAS;
- Options.CompressDebugSections = CodeGenOpts.getCompressDebugSections();
+ Options.CompressDebugSections = DebugOpts.getCompressDebugSections();
Options.RelaxELFRelocations = CodeGenOpts.RelaxELFRelocations;
// Set EABI version.
@@ -397,17 +401,17 @@ static bool initTargetOptions(DiagnosticsEngine &Diags,
CodeGenOpts.UniqueBasicBlockSectionNames;
Options.TLSSize = CodeGenOpts.TLSSize;
Options.EmulatedTLS = CodeGenOpts.EmulatedTLS;
- Options.DebuggerTuning = CodeGenOpts.getDebuggerTuning();
+ Options.DebuggerTuning = DebugOpts.getDebuggerTuning();
Options.EmitStackSizeSection = CodeGenOpts.StackSizeSection;
Options.StackUsageOutput = CodeGenOpts.StackUsageOutput;
Options.EmitAddrsig = CodeGenOpts.Addrsig;
- Options.ForceDwarfFrameSection = CodeGenOpts.ForceDwarfFrameSection;
+ Options.ForceDwarfFrameSection = DebugOpts.ForceDwarfFrameSection;
Options.EmitCallSiteInfo = CodeGenOpts.EmitCallSiteInfo;
Options.EnableAIXExtendedAltivecABI = LangOpts.EnableAIXExtendedAltivecABI;
Options.XRayFunctionIndex = CodeGenOpts.XRayFunctionIndex;
Options.LoopAlignment = CodeGenOpts.LoopAlignment;
- Options.DebugStrictDwarf = CodeGenOpts.DebugStrictDwarf;
- Options.ObjectFilenameForDebug = CodeGenOpts.ObjectFilenameForDebug;
+ Options.DebugStrictDwarf = DebugOpts.DebugStrictDwarf;
+ Options.ObjectFilenameForDebug = DebugOpts.ObjectFilenameForDebug;
Options.Hotpatch = CodeGenOpts.HotPatch;
Options.JMCInstrument = CodeGenOpts.JMCInstrument;
Options.XCOFFReadOnlyPointers = CodeGenOpts.XCOFFReadOnlyPointers;
@@ -427,14 +431,14 @@ static bool initTargetOptions(DiagnosticsEngine &Diags,
break;
}
- Options.MCOptions.SplitDwarfFile = CodeGenOpts.SplitDwarfFile;
- Options.MCOptions.EmitDwarfUnwind = CodeGenOpts.getEmitDwarfUnwind();
+ Options.MCOptions.SplitDwarfFile = DebugOpts.SplitDwarfFile;
+ Options.MCOptions.EmitDwarfUnwind = DebugOpts.getEmitDwarfUnwind();
Options.MCOptions.EmitCompactUnwindNonCanonical =
CodeGenOpts.EmitCompactUnwindNonCanonical;
Options.MCOptions.MCRelaxAll = CodeGenOpts.RelaxAll;
Options.MCOptions.MCSaveTempLabels = CodeGenOpts.SaveTempLabels;
Options.MCOptions.MCUseDwarfDirectory =
- CodeGenOpts.NoDwarfDirectoryAsm
+ DebugOpts.NoDwarfDirectoryAsm
? llvm::MCTargetOptions::DisableDwarfDirectory
: llvm::MCTargetOptions::EnableDwarfDirectory;
Options.MCOptions.MCNoExecStack = CodeGenOpts.NoExecStack;
@@ -443,7 +447,7 @@ static bool initTargetOptions(DiagnosticsEngine &Diags,
Options.MCOptions.MCFatalWarnings = CodeGenOpts.FatalWarnings;
Options.MCOptions.MCNoWarn = CodeGenOpts.NoWarn;
Options.MCOptions.AsmVerbose = CodeGenOpts.AsmVerbose;
- Options.MCOptions.Dwarf64 = CodeGenOpts.Dwarf64;
+ Options.MCOptions.Dwarf64 = DebugOpts.Dwarf64;
Options.MCOptions.PreserveAsmComments = CodeGenOpts.PreserveAsmComments;
Options.MCOptions.ABIName = TargetOpts.ABI;
for (const auto &Entry : HSOpts.UserEntries)
@@ -538,8 +542,8 @@ void EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
CodeGenOptLevel OptLevel = *OptLevelOrNone;
llvm::TargetOptions Options;
- if (!initTargetOptions(Diags, Options, CodeGenOpts, TargetOpts, LangOpts,
- HSOpts))
+ if (!initTargetOptions(Diags, Options, CodeGenOpts, DebugOpts, TargetOpts,
+ LangOpts, HSOpts))
return;
TM.reset(TheTarget->createTargetMachine(Triple, TargetOpts.CPU, FeaturesStr,
Options, RM, CM, OptLevel));
@@ -741,7 +745,7 @@ void EmitAssemblyHelper::RunOptimizationPipeline(
CodeGenOpts.InstrProfileOutput.empty() ? getDefaultProfileGenName()
: CodeGenOpts.InstrProfileOutput,
"", "", CodeGenOpts.MemoryProfileUsePath, nullptr, PGOOptions::IRInstr,
- PGOOptions::NoCSAction, CodeGenOpts.DebugInfoForProfiling,
+ PGOOptions::NoCSAction, DebugOpts.DebugInfoForProfiling,
/*PseudoProbeForProfiling=*/false, CodeGenOpts.AtomicProfileUpdate);
else if (CodeGenOpts.hasProfileIRUse()) {
// -fprofile-use.
@@ -750,25 +754,25 @@ void EmitAssemblyHelper::RunOptimizationPipeline(
PGOOpt = PGOOptions(
CodeGenOpts.ProfileInstrumentUsePath, "",
CodeGenOpts.ProfileRemappingFile, CodeGenOpts.MemoryProfileUsePath, VFS,
- PGOOptions::IRUse, CSAction, CodeGenOpts.DebugInfoForProfiling);
+ PGOOptions::IRUse, CSAction, DebugOpts.DebugInfoForProfiling);
} else if (!CodeGenOpts.SampleProfileFile.empty())
// -fprofile-sample-use
PGOOpt = PGOOptions(
CodeGenOpts.SampleProfileFile, "", CodeGenOpts.ProfileRemappingFile,
CodeGenOpts.MemoryProfileUsePath, VFS, PGOOptions::SampleUse,
- PGOOptions::NoCSAction, CodeGenOpts.DebugInfoForProfiling,
+ PGOOptions::NoCSAction, DebugOpts.DebugInfoForProfiling,
CodeGenOpts.PseudoProbeForProfiling);
else if (!CodeGenOpts.MemoryProfileUsePath.empty())
// -fmemory-profile-use (without any of the above options)
PGOOpt = PGOOptions("", "", "", CodeGenOpts.MemoryProfileUsePath, VFS,
PGOOptions::NoAction, PGOOptions::NoCSAction,
- CodeGenOpts.DebugInfoForProfiling);
+ DebugOpts.DebugInfoForProfiling);
else if (CodeGenOpts.PseudoProbeForProfiling)
// -fpseudo-probe-for-profiling
PGOOpt = PGOOptions("", "", "", /*MemoryProfile=*/"", nullptr,
PGOOptions::NoAction, PGOOptions::NoCSAction,
- CodeGenOpts.DebugInfoForProfiling, true);
- else if (CodeGenOpts.DebugInfoForProfiling)
+ DebugOpts.DebugInfoForProfiling, true);
+ else if (DebugOpts.DebugInfoForProfiling)
// -fdebug-info-for-profiling
PGOOpt = PGOOptions("", "", "", /*MemoryProfile=*/"", nullptr,
PGOOptions::NoAction, PGOOptions::NoCSAction, true);
@@ -794,7 +798,7 @@ void EmitAssemblyHelper::RunOptimizationPipeline(
? getDefaultProfileGenName()
: CodeGenOpts.InstrProfileOutput,
"", /*MemoryProfile=*/"", nullptr, PGOOptions::NoAction,
- PGOOptions::CSIRInstr, CodeGenOpts.DebugInfoForProfiling);
+ PGOOptions::CSIRInstr, DebugOpts.DebugInfoForProfiling);
}
if (TM)
TM->setPGOOption(PGOOpt);
@@ -830,18 +834,18 @@ void EmitAssemblyHelper::RunOptimizationPipeline(
PassBuilder PB(TM.get(), PTO, PGOOpt, &PIC);
// Handle the assignment tracking feature options.
- switch (CodeGenOpts.getAssignmentTrackingMode()) {
- case CodeGenOptions::AssignmentTrackingOpts::Forced:
+ switch (DebugOpts.getAssignmentTrackingMode()) {
+ case DebugOptions::AssignmentTrackingOpts::Forced:
PB.registerPipelineStartEPCallback(
[&](ModulePassManager &MPM, OptimizationLevel Level) {
MPM.addPass(AssignmentTrackingPass());
});
break;
- case CodeGenOptions::AssignmentTrackingOpts::Enabled:
+ case DebugOptions::AssignmentTrackingOpts::Enabled:
// Disable assignment tracking in LTO builds for now as the performance
// cost is too high. Disable for LLDB tuning due to llvm.org/PR43126.
if (!CodeGenOpts.PrepareForThinLTO && !CodeGenOpts.PrepareForLTO &&
- CodeGenOpts.getDebuggerTuning() != llvm::DebuggerKind::LLDB) {
+ DebugOpts.getDebuggerTuning() != llvm::DebuggerKind::LLDB) {
PB.registerPipelineStartEPCallback(
[&](ModulePassManager &MPM, OptimizationLevel Level) {
// Only use assignment tracking if optimisations are enabled.
@@ -850,20 +854,20 @@ void EmitAssemblyHelper::RunOptimizationPipeline(
});
}
break;
- case CodeGenOptions::AssignmentTrackingOpts::Disabled:
+ case DebugOptions::AssignmentTrackingOpts::Disabled:
break;
}
// Enable verify-debuginfo-preserve-each for new PM.
DebugifyEachInstrumentation Debugify;
DebugInfoPerPass DebugInfoBeforePass;
- if (CodeGenOpts.EnableDIPreservationVerify) {
+ if (DebugOpts.EnableDIPreservationVerify) {
Debugify.setDebugifyMode(DebugifyMode::OriginalDebugInfo);
Debugify.setDebugInfoBeforePass(DebugInfoBeforePass);
- if (!CodeGenOpts.DIBugsReportFilePath.empty())
+ if (!DebugOpts.DIBugsReportFilePath.empty())
Debugify.setOrigDIVerifyBugsReportFilePath(
- CodeGenOpts.DIBugsReportFilePath);
+ DebugOpts.DIBugsReportFilePath);
Debugify.registerCallbacks(PIC, MAM);
}
// Attempt to load pass plugins and register their callbacks with PB.
@@ -1114,8 +1118,8 @@ void EmitAssemblyHelper::RunCodegenPipeline(
case Backend_EmitObj:
CodeGenPasses.add(
createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
- if (!CodeGenOpts.SplitDwarfOutput.empty()) {
- DwoOS = openOutputFile(CodeGenOpts.SplitDwarfOutput);
+ if (!DebugOpts.SplitDwarfOutput.empty()) {
+ DwoOS = openOutputFile(DebugOpts.SplitDwarfOutput);
if (!DwoOS)
return;
}
@@ -1169,13 +1173,14 @@ void EmitAssemblyHelper::EmitAssembly(BackendAction Action,
DwoOS->keep();
}
-static void runThinLTOBackend(
- DiagnosticsEngine &Diags, ModuleSummaryIndex *CombinedIndex,
- llvm::Module *M, const HeaderSearchOptions &HeaderOpts,
- const CodeGenOptions &CGOpts, const clang::TargetOptions &TOpts,
- const LangOptions &LOpts, std::unique_ptr<raw_pwrite_stream> OS,
- std::string SampleProfile, std::string ProfileRemapping,
- BackendAction Action) {
+static void
+runThinLTOBackend(DiagnosticsEngine &Diags, ModuleSummaryIndex *CombinedIndex,
+ llvm::Module *M, const HeaderSearchOptions &HeaderOpts,
+ const CodeGenOptions &CGOpts, const DebugOptions &DOpts,
+ const clang::TargetOptions &TOpts, const LangOptions &LOpts,
+ std::unique_ptr<raw_pwrite_stream> OS,
+ std::string SampleProfile, std::string ProfileRemapping,
+ BackendAction Action) {
DenseMap<StringRef, DenseMap<GlobalValue::GUID, GlobalValueSummary *>>
ModuleToDefinedGVSummaries;
CombinedIndex->collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
@@ -1191,7 +1196,7 @@ static void runThinLTOBackend(
auto AddStream = [&](size_t Task, const Twine &ModuleName) {
return std::make_unique<CachedFileStream>(std::move(OS),
- CGOpts.ObjectFilenameForDebug);
+ DOpts.ObjectFilenameForDebug);
};
lto::Config Conf;
if (CGOpts.SaveTempsFilePrefix != "") {
@@ -1212,7 +1217,8 @@ static void runThinLTOBackend(
assert(OptLevelOrNone && "Invalid optimization level!");
Conf.CGOptLevel = *OptLevelOrNone;
Conf.OptLevel = CGOpts.OptimizationLevel;
- initTargetOptions(Diags, Conf.Options, CGOpts, TOpts, LOpts, HeaderOpts);
+ initTargetOptions(Diags, Conf.Options, CGOpts, DOpts, TOpts, LOpts,
+ HeaderOpts);
Conf.SampleProfile = std::move(SampleProfile);
Conf.PTO.LoopUnrolling = CGOpts.UnrollLoops;
// For historical reasons, loop interleaving is set to mirror setting for loop
@@ -1240,8 +1246,8 @@ static void runThinLTOBackend(
Conf.RemarksFilename = CGOpts.OptRecordFile;
Conf.RemarksPasses = CGOpts.OptRecordPasses;
Conf.RemarksFormat = CGOpts.OptRecordFormat;
- Conf.SplitDwarfFile = CGOpts.SplitDwarfFile;
- Conf.SplitDwarfOutput = CGOpts.SplitDwarfOutput;
+ Conf.SplitDwarfFile = DOpts.SplitDwarfFile;
+ Conf.SplitDwarfOutput = DOpts.SplitDwarfOutput;
switch (Action) {
case Backend_EmitNothing:
Conf.PreCodeGenModuleHook = [](size_t Task, const llvm::Module &Mod) {
@@ -1276,9 +1282,10 @@ static void runThinLTOBackend(
void clang::EmitBackendOutput(
DiagnosticsEngine &Diags, const HeaderSearchOptions &HeaderOpts,
- const CodeGenOptions &CGOpts, const clang::TargetOptions &TOpts,
- const LangOptions &LOpts, StringRef TDesc, llvm::Module *M,
- BackendAction Action, IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
+ const CodeGenOptions &CGOpts, const DebugOptions &DOpts,
+ const clang::TargetOptions &TOpts, const LangOptions &LOpts,
+ StringRef TDesc, llvm::Module *M, BackendAction Action,
+ IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
std::unique_ptr<raw_pwrite_stream> OS, BackendConsumer *BC) {
llvm::TimeTraceScope TimeScope("Backend");
@@ -1305,8 +1312,9 @@ void clang::EmitBackendOutput(
if (CombinedIndex) {
if (!CombinedIndex->skipModuleByDistributedBackend()) {
runThinLTOBackend(Diags, CombinedIndex.get(), M, HeaderOpts, CGOpts,
- TOpts, LOpts, std::move(OS), CGOpts.SampleProfileFile,
- CGOpts.ProfileRemappingFile, Action);
+ DOpts, TOpts, LOpts, std::move(OS),
+ CGOpts.SampleProfileFile, CGOpts.ProfileRemappingFile,
+ Action);
return;
}
// Distributed indexing detected that nothing from the module is needed
@@ -1321,7 +1329,8 @@ void clang::EmitBackendOutput(
}
}
- EmitAssemblyHelper AsmHelper(Diags, HeaderOpts, CGOpts, TOpts, LOpts, M, VFS);
+ EmitAssemblyHelper AsmHelper(Diags, HeaderOpts, CGOpts, DOpts, TOpts, LOpts,
+ M, VFS);
AsmHelper.EmitAssembly(Action, std::move(OS), BC);
// Verify clang's TargetInfo DataLayout against the LLVM TargetMachine's
diff --git a/clang/lib/CodeGen/CGBlocks.cpp b/clang/lib/CodeGen/CGBlocks.cpp
index 0cbace7b7f7bbd..d88fe8d9b35c9f 100644
--- a/clang/lib/CodeGen/CGBlocks.cpp
+++ b/clang/lib/CodeGen/CGBlocks.cpp
@@ -21,6 +21,7 @@
#include "TargetInfo.h"
#include "clang/AST/Attr.h"
#include "clang/AST/DeclObjC.h"
+#include "clang/Basic/DebugOptions.h"
#include "clang/CodeGen/ConstantInitBuilder.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/IR/DataLayout.h"
@@ -1380,7 +1381,7 @@ void CodeGenFunction::setBlockContextParameter(const ImplicitParamDecl *D,
Address alloc = CreateMemTemp(D->getType(), D->getName() + ".addr");
Builder.CreateStore(arg, alloc);
if (CGDebugInfo *DI = getDebugInfo()) {
- if (CGM.getCodeGenOpts().hasReducedDebugInfo()) {
+ if (CGM.getDebugOpts().hasReducedDebugInfo()) {
DI->setLocation(D->getLocation());
DI->EmitDeclareOfBlockLiteralArgVariable(
*BlockInfo, D->getName(), argNum,
@@ -1550,7 +1551,7 @@ llvm::Function *CodeGenFunction::GenerateBlockFunction(
const VarDecl *variable = CI.getVariable();
DI->EmitLocation(Builder, variable->getLocation());
- if (CGM.getCodeGenOpts().hasReducedDebugInfo()) {
+ if (CGM.getDebugOpts().hasReducedDebugInfo()) {
const CGBlockInfo::Capture &capture = blockInfo.getCapture(variable);
if (capture.isConstant()) {
auto addr = LocalDeclMap.find(variable)->second;
diff --git a/clang/lib/CodeGen/CGDebugInfo.cpp b/clang/lib/CodeGen/CGDebugInfo.cpp
index 236d53bee4e8f1..4dcfdb04d58034 100644
--- a/clang/lib/CodeGen/CGDebugInfo.cpp
+++ b/clang/lib/CodeGen/CGDebugInfo.cpp
@@ -29,6 +29,7 @@
#include "clang/AST/RecursiveASTVisitor.h"
#include "clang/AST/VTableBuilder.h"
#include "clang/Basic/CodeGenOptions.h"
+#include "clang/Basic/DebugOptions.h"
#include "clang/Basic/FileManager.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Basic/Version.h"
@@ -70,8 +71,8 @@ static uint32_t getDeclAlignIfRequired(const Decl *D, const ASTContext &Ctx) {
}
CGDebugInfo::CGDebugInfo(CodeGenModule &CGM)
- : CGM(CGM), DebugKind(CGM.getCodeGenOpts().getDebugInfo()),
- DebugTypeExtRefs(CGM.getCodeGenOpts().DebugTypeExtRefs),
+ : CGM(CGM), DebugKind(CGM.getDebugOpts().getDebugInfo()),
+ DebugTypeExtRefs(CGM.getDebugOpts().DebugTypeExtRefs),
DBuilder(CGM.getModule()) {
CreateCompileUnit();
}
@@ -238,7 +239,7 @@ PrintingPolicy CGDebugInfo::getPrintingPolicy() const {
// particular, we can't have spaces between arguments of standard templates
// like basic_string and vector, but we must have spaces between consecutive
// angle brackets that close nested template argument lists.
- if (CGM.getCodeGenOpts().EmitCodeView) {
+ if (CGM.getDebugOpts().EmitCodeView) {
PP.MSVCFormatting = true;
PP.SplitTemplateClosers = true;
} else {
@@ -304,7 +305,7 @@ StringRef CGDebugInfo::getClassName(const RecordDecl *RD) {
// The CodeView printer in LLVM wants to see the names of unnamed types
// because they need to have a unique identifier.
// These names are used to reconstruct the fully qualified type names.
- if (CGM.getCodeGenOpts().EmitCodeView) {
+ if (CGM.getDebugOpts().EmitCodeView) {
if (const TypedefNameDecl *D = RD->getTypedefNameForAnonDecl()) {
assert(RD->getDeclContext() == D->getDeclContext() &&
"Typedef should not be in another decl context!");
@@ -349,8 +350,7 @@ std::optional<llvm::DIFile::ChecksumKind>
CGDebugInfo::computeChecksum(FileID FID, SmallString<64> &Checksum) const {
Checksum.clear();
- if (!CGM.getCodeGenOpts().EmitCodeView &&
- CGM.getCodeGenOpts().DwarfVersion < 5)
+ if (!CGM.getDebugOpts().EmitCodeView && CGM.getDebugOpts().DwarfVersion < 5)
return std::nullopt;
SourceManager &SM = CGM.getContext().getSourceManager();
@@ -359,14 +359,14 @@ CGDebugInfo::computeChecksum(FileID FID, SmallString<64> &Checksum) const {
return std::nullopt;
auto Data = llvm::arrayRefFromStringRef(MemBuffer->getBuffer());
- switch (CGM.getCodeGenOpts().getDebugSrcHash()) {
- case clang::CodeGenOptions::DSH_MD5:
+ switch (CGM.getDebugOpts().getDebugSrcHash()) {
+ case clang::DebugOptions::DSH_MD5:
llvm::toHex(llvm::MD5::hash(Data), /*LowerCase=*/true, Checksum);
return llvm::DIFile::CSK_MD5;
- case clang::CodeGenOptions::DSH_SHA1:
+ case clang::DebugOptions::DSH_SHA1:
llvm::toHex(llvm::SHA1::hash(Data), /*LowerCase=*/true, Checksum);
return llvm::DIFile::CSK_SHA1;
- case clang::CodeGenOptions::DSH_SHA256:
+ case clang::DebugOptions::DSH_SHA256:
llvm::toHex(llvm::SHA256::hash(Data), /*LowerCase=*/true, Checksum);
return llvm::DIFile::CSK_SHA256;
}
@@ -375,7 +375,7 @@ CGDebugInfo::computeChecksum(FileID FID, SmallString<64> &Checksum) const {
std::optional<StringRef> CGDebugInfo::getSource(const SourceManager &SM,
FileID FID) {
- if (!CGM.getCodeGenOpts().EmbedSource)
+ if (!CGM.getDebugOpts().EmbedSource)
return std::nullopt;
bool SourceInvalid = false;
@@ -472,7 +472,7 @@ llvm::DIFile *CGDebugInfo::createFile(
std::string CGDebugInfo::remapDIPath(StringRef Path) const {
SmallString<256> P = Path;
- for (auto &[From, To] : llvm::reverse(CGM.getCodeGenOpts().DebugPrefixMap))
+ for (auto &[From, To] : llvm::reverse(CGM.getDebugOpts().DebugPrefixMap))
if (llvm::sys::path::replace_path_prefix(P, From, To))
break;
return P.str().str();
@@ -487,7 +487,7 @@ unsigned CGDebugInfo::getLineNumber(SourceLocation Loc) {
unsigned CGDebugInfo::getColumnNumber(SourceLocation Loc, bool Force) {
// We may not want column information at all.
- if (!Force && !CGM.getCodeGenOpts().DebugColumnInfo)
+ if (!Force && !CGM.getDebugOpts().DebugColumnInfo)
return 0;
// If the location is invalid then use the current column.
@@ -499,8 +499,8 @@ unsigned CGDebugInfo::getColumnNumber(SourceLocation Loc, bool Force) {
}
StringRef CGDebugInfo::getCurrentDirname() {
- if (!CGM.getCodeGenOpts().DebugCompilationDir.empty())
- return CGM.getCodeGenOpts().DebugCompilationDir;
+ if (!CGM.getDebugOpts().DebugCompilationDir.empty())
+ return CGM.getDebugOpts().DebugCompilationDir;
if (!CWDName.empty())
return CWDName;
@@ -526,6 +526,7 @@ void CGDebugInfo::CreateCompileUnit() {
// Get absolute path name.
SourceManager &SM = CGM.getContext().getSourceManager();
auto &CGO = CGM.getCodeGenOpts();
+ auto &DO = CGM.getDebugOpts();
const LangOptions &LO = CGM.getLangOpts();
std::string MainFileName = CGO.MainFileName;
if (MainFileName.empty())
@@ -570,7 +571,7 @@ void CGDebugInfo::CreateCompileUnit() {
if (LO.CPlusPlus) {
if (LO.ObjC)
LangTag = llvm::dwarf::DW_LANG_ObjC_plus_plus;
- else if (CGO.DebugStrictDwarf && CGO.DwarfVersion < 5)
+ else if (DO.DebugStrictDwarf && DO.DwarfVersion < 5)
LangTag = llvm::dwarf::DW_LANG_C_plus_plus;
else if (LO.CPlusPlus14)
LangTag = llvm::dwarf::DW_LANG_C_plus_plus_14;
@@ -580,13 +581,12 @@ void CGDebugInfo::CreateCompileUnit() {
LangTag = llvm::dwarf::DW_LANG_C_plus_plus;
} else if (LO.ObjC) {
LangTag = llvm::dwarf::DW_LANG_ObjC;
- } else if (LO.OpenCL && (!CGM.getCodeGenOpts().DebugStrictDwarf ||
- CGM.getCodeGenOpts().DwarfVersion >= 5)) {
+ } else if (LO.OpenCL && (!DO.DebugStrictDwarf || DO.DwarfVersion >= 5)) {
LangTag = llvm::dwarf::DW_LANG_OpenCL;
} else if (LO.RenderScript) {
LangTag = llvm::dwarf::DW_LANG_GOOGLE_RenderScript;
- } else if (LO.C11 && !(CGO.DebugStrictDwarf && CGO.DwarfVersion < 5)) {
- LangTag = llvm::dwarf::DW_LANG_C11;
+ } else if (LO.C11 && !(DO.DebugStrictDwarf && DO.DwarfVersion < 5)) {
+ LangTag = llvm::dwarf::DW_LANG_C11;
} else if (LO.C99) {
LangTag = llvm::dwarf::DW_LANG_C99;
} else {
@@ -602,26 +602,25 @@ void CGDebugInfo::CreateCompileUnit() {
llvm::DICompileUnit::DebugEmissionKind EmissionKind;
switch (DebugKind) {
- case llvm::codegenoptions::NoDebugInfo:
- case llvm::codegenoptions::LocTrackingOnly:
+ case llvm::debugoptions::NoDebugInfo:
+ case llvm::debugoptions::LocTrackingOnly:
EmissionKind = llvm::DICompileUnit::NoDebug;
break;
- case llvm::codegenoptions::DebugLineTablesOnly:
+ case llvm::debugoptions::DebugLineTablesOnly:
EmissionKind = llvm::DICompileUnit::LineTablesOnly;
break;
- case llvm::codegenoptions::DebugDirectivesOnly:
+ case llvm::debugoptions::DebugDirectivesOnly:
EmissionKind = llvm::DICompileUnit::DebugDirectivesOnly;
break;
- case llvm::codegenoptions::DebugInfoConstructor:
- case llvm::codegenoptions::LimitedDebugInfo:
- case llvm::codegenoptions::FullDebugInfo:
- case llvm::codegenoptions::UnusedTypeInfo:
+ case llvm::debugoptions::DebugInfoConstructor:
+ case llvm::debugoptions::LimitedDebugInfo:
+ case llvm::debugoptions::FullDebugInfo:
+ case llvm::debugoptions::UnusedTypeInfo:
EmissionKind = llvm::DICompileUnit::FullDebug;
break;
}
uint64_t DwoId = 0;
- auto &CGOpts = CGM.getCodeGenOpts();
// The DIFile used by the CU is distinct from the main source
// file. Its directory part specifies what becomes the
// DW_AT_comp_dir (the compilation directory), even if the source
@@ -633,7 +632,7 @@ void CGDebugInfo::CreateCompileUnit() {
getSource(SM, SM.getMainFileID()));
StringRef Sysroot, SDK;
- if (CGM.getCodeGenOpts().getDebuggerTuning() == llvm::DebuggerKind::LLDB) {
+ if (DO.getDebuggerTuning() == llvm::DebuggerKind::LLDB) {
Sysroot = CGM.getHeaderSearchOpts().Sysroot;
auto B = llvm::sys::path::rbegin(Sysroot);
auto E = llvm::sys::path::rend(Sysroot);
@@ -644,8 +643,7 @@ void CGDebugInfo::CreateCompileUnit() {
}
llvm::DICompileUnit::DebugNameTableKind NameTableKind =
- static_cast<llvm::DICompileUnit::DebugNameTableKind>(
- CGOpts.DebugNameTable);
+ static_cast<llvm::DICompileUnit::DebugNameTableKind>(DO.DebugNameTable);
if (CGM.getTarget().getTriple().isNVPTX())
NameTableKind = llvm::DICompileUnit::DebugNameTableKind::None;
else if (CGM.getTarget().getTriple().getVendor() == llvm::Triple::Apple)
@@ -653,11 +651,11 @@ void CGDebugInfo::CreateCompileUnit() {
// Create new compile unit.
TheCU = DBuilder.createCompileUnit(
- LangTag, CUFile, CGOpts.EmitVersionIdentMetadata ? Producer : "",
- LO.Optimize || CGOpts.PrepareForLTO || CGOpts.PrepareForThinLTO,
- CGOpts.DwarfDebugFlags, RuntimeVers, CGOpts.SplitDwarfFile, EmissionKind,
- DwoId, CGOpts.SplitDwarfInlining, CGOpts.DebugInfoForProfiling,
- NameTableKind, CGOpts.DebugRangesBaseAddress, remapDIPath(Sysroot), SDK);
+ LangTag, CUFile, CGO.EmitVersionIdentMetadata ? Producer : "",
+ LO.Optimize || CGO.PrepareForLTO || CGO.PrepareForThinLTO,
+ DO.DwarfDebugFlags, RuntimeVers, DO.SplitDwarfFile, EmissionKind, DwoId,
+ DO.SplitDwarfInlining, DO.DebugInfoForProfiling, NameTableKind,
+ DO.DebugRangesBaseAddress, remapDIPath(Sysroot), SDK);
}
llvm::DIType *CGDebugInfo::CreateType(const BuiltinType *BT) {
@@ -1096,7 +1094,7 @@ static bool needsTypeIdentifier(const TagDecl *TD, CodeGenModule &CGM,
return true;
// CodeView types with C++ mangling need a type identifier.
- if (CGM.getCodeGenOpts().EmitCodeView)
+ if (CGM.getDebugOpts().EmitCodeView)
return true;
return false;
@@ -1170,12 +1168,12 @@ CGDebugInfo::getOrCreateRecordFwdDecl(const RecordType *Ty,
// Create the type.
SmallString<256> Identifier;
// Don't include a linkage name in line tables only.
- if (CGM.getCodeGenOpts().hasReducedDebugInfo())
+ if (CGM.getDebugOpts().hasReducedDebugInfo())
Identifier = getTypeIdentifier(Ty, CGM, TheCU);
llvm::DICompositeType *RetTy = DBuilder.createReplaceableCompositeType(
getTagForRecord(RD), RDName, Ctx, DefUnit, Line, 0, Size, Align, Flags,
Identifier);
- if (CGM.getCodeGenOpts().DebugFwdTemplateParams)
+ if (CGM.getDebugOpts().DebugFwdTemplateParams)
if (auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD))
DBuilder.replaceArrays(RetTy, llvm::DINodeArray(),
CollectCXXTemplateParams(TSpecial, DefUnit));
@@ -1660,8 +1658,7 @@ void CGDebugInfo::CollectRecordLambdaFields(
FieldDecl *f = *Field;
llvm::DIFile *VUnit = getOrCreateFile(f->getLocation());
QualType type = f->getType();
- StringRef ThisName =
- CGM.getCodeGenOpts().EmitCodeView ? "__this" : "this";
+ StringRef ThisName = CGM.getDebugOpts().EmitCodeView ? "__this" : "this";
llvm::DIType *fieldType = createFieldType(
ThisName, type, f->getLocation(), f->getAccess(),
layout.getFieldOffset(fieldno), VUnit, RecordTy, CXXDecl);
@@ -1697,9 +1694,8 @@ CGDebugInfo::CreateRecordStaticField(const VarDecl *Var, llvm::DIType *RecordTy,
}
llvm::DINode::DIFlags Flags = getAccessFlag(Var->getAccess(), RD);
- auto Tag = CGM.getCodeGenOpts().DwarfVersion >= 5
- ? llvm::dwarf::DW_TAG_variable
- : llvm::dwarf::DW_TAG_member;
+ auto Tag = CGM.getDebugOpts().DwarfVersion >= 5 ? llvm::dwarf::DW_TAG_variable
+ : llvm::dwarf::DW_TAG_member;
auto Align = getDeclAlignIfRequired(Var, CGM.getContext());
llvm::DIDerivedType *GV = DBuilder.createStaticMemberType(
RecordTy, VName, VUnit, LineNumber, VTy, Flags, C, Tag, Align);
@@ -1770,7 +1766,7 @@ void CGDebugInfo::CollectRecordFields(
// Skip variable template specializations when emitting CodeView. MSVC
// doesn't emit them.
- if (CGM.getCodeGenOpts().EmitCodeView &&
+ if (CGM.getDebugOpts().EmitCodeView &&
isa<VarTemplateSpecializationDecl>(V))
continue;
@@ -1793,7 +1789,7 @@ void CGDebugInfo::CollectRecordFields(
// Bump field number for next field.
++fieldNo;
- } else if (CGM.getCodeGenOpts().EmitCodeView) {
+ } else if (CGM.getDebugOpts().EmitCodeView) {
// Debug info for nested types is included in the member list only for
// CodeView.
if (const auto *nestedType = dyn_cast<TypeDecl>(I)) {
@@ -1994,7 +1990,7 @@ llvm::DISubprogram *CGDebugInfo::CreateCXXMemberFunction(
// In this debug mode, emit type info for a class when its constructor type
// info is emitted.
- if (DebugKind == llvm::codegenoptions::DebugInfoConstructor)
+ if (DebugKind == llvm::debugoptions::DebugInfoConstructor)
if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Method))
completeUnusedClass(*CD->getParent());
@@ -2056,7 +2052,7 @@ void CGDebugInfo::CollectCXXBases(const CXXRecordDecl *RD, llvm::DIFile *Unit,
// If we are generating CodeView debug info, we also need to emit records for
// indirect virtual base classes.
- if (CGM.getCodeGenOpts().EmitCodeView) {
+ if (CGM.getDebugOpts().EmitCodeView) {
CollectCXXBasesAux(RD, Unit, EltTys, RecordTy, RD->vbases(), SeenTypes,
llvm::DINode::FlagIndirectVirtualBase);
}
@@ -2335,7 +2331,7 @@ StringRef CGDebugInfo::getDynamicInitializerName(const VarDecl *VD,
llvm::Function *InitFn) {
// If we're not emitting codeview, use the mangled name. For Itanium, this is
// arbitrary.
- if (!CGM.getCodeGenOpts().EmitCodeView ||
+ if (!CGM.getDebugOpts().EmitCodeView ||
StubKind == DynamicInitKind::GlobalArrayDestructor)
return InitFn->getName();
@@ -2402,7 +2398,7 @@ void CGDebugInfo::CollectVTableInfo(const CXXRecordDecl *RD, llvm::DIFile *Unit,
// emit a special named pointer type into the element list. The vptr type
// points to this type as well.
llvm::DIType *VPtrTy = nullptr;
- bool NeedVTableShape = CGM.getCodeGenOpts().EmitCodeView &&
+ bool NeedVTableShape = CGM.getDebugOpts().EmitCodeView &&
CGM.getTarget().getCXXABI().isMicrosoft();
if (NeedVTableShape) {
uint64_t PtrWidth =
@@ -2441,7 +2437,7 @@ void CGDebugInfo::CollectVTableInfo(const CXXRecordDecl *RD, llvm::DIFile *Unit,
llvm::DIType *CGDebugInfo::getOrCreateRecordType(QualType RTy,
SourceLocation Loc) {
- assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
+ assert(CGM.getDebugOpts().hasReducedDebugInfo());
llvm::DIType *T = getOrCreateType(RTy, getOrCreateFile(Loc));
return T;
}
@@ -2453,7 +2449,7 @@ llvm::DIType *CGDebugInfo::getOrCreateInterfaceType(QualType D,
llvm::DIType *CGDebugInfo::getOrCreateStandaloneType(QualType D,
SourceLocation Loc) {
- assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
+ assert(CGM.getDebugOpts().hasReducedDebugInfo());
assert(!D.isNull() && "null type");
llvm::DIType *T = getOrCreateType(D, getOrCreateFile(Loc));
assert(T && "could not create debug info for type");
@@ -2465,8 +2461,8 @@ llvm::DIType *CGDebugInfo::getOrCreateStandaloneType(QualType D,
void CGDebugInfo::addHeapAllocSiteMetadata(llvm::CallBase *CI,
QualType AllocatedTy,
SourceLocation Loc) {
- if (CGM.getCodeGenOpts().getDebugInfo() <=
- llvm::codegenoptions::DebugLineTablesOnly)
+ if (CGM.getDebugOpts().getDebugInfo() <=
+ llvm::debugoptions::DebugLineTablesOnly)
return;
llvm::MDNode *node;
if (AllocatedTy->isVoidType())
@@ -2478,7 +2474,7 @@ void CGDebugInfo::addHeapAllocSiteMetadata(llvm::CallBase *CI,
}
void CGDebugInfo::completeType(const EnumDecl *ED) {
- if (DebugKind <= llvm::codegenoptions::DebugLineTablesOnly)
+ if (DebugKind <= llvm::debugoptions::DebugLineTablesOnly)
return;
QualType Ty = CGM.getContext().getEnumType(ED);
void *TyPtr = Ty.getAsOpaquePtr();
@@ -2491,7 +2487,7 @@ void CGDebugInfo::completeType(const EnumDecl *ED) {
}
void CGDebugInfo::completeType(const RecordDecl *RD) {
- if (DebugKind > llvm::codegenoptions::LimitedDebugInfo ||
+ if (DebugKind > llvm::debugoptions::LimitedDebugInfo ||
!CGM.getLangOpts().CPlusPlus)
completeRequiredType(RD);
}
@@ -2553,7 +2549,7 @@ void CGDebugInfo::completeClassData(const RecordDecl *RD) {
}
void CGDebugInfo::completeClass(const RecordDecl *RD) {
- if (DebugKind <= llvm::codegenoptions::DebugLineTablesOnly)
+ if (DebugKind <= llvm::debugoptions::DebugLineTablesOnly)
return;
QualType Ty = CGM.getContext().getRecordType(RD);
void *TyPtr = Ty.getAsOpaquePtr();
@@ -2605,7 +2601,7 @@ static bool canUseCtorHoming(const CXXRecordDecl *RD) {
return false;
}
-static bool shouldOmitDefinition(llvm::codegenoptions::DebugInfoKind DebugKind,
+static bool shouldOmitDefinition(llvm::debugoptions::DebugInfoKind DebugKind,
bool DebugTypeExtRefs, const RecordDecl *RD,
const LangOptions &LangOpts) {
if (DebugTypeExtRefs && isDefinedInClangModule(RD->getDefinition()))
@@ -2618,10 +2614,10 @@ static bool shouldOmitDefinition(llvm::codegenoptions::DebugInfoKind DebugKind,
// Only emit forward declarations in line tables only to keep debug info size
// small. This only applies to CodeView, since we don't emit types in DWARF
// line tables only.
- if (DebugKind == llvm::codegenoptions::DebugLineTablesOnly)
+ if (DebugKind == llvm::debugoptions::DebugLineTablesOnly)
return true;
- if (DebugKind > llvm::codegenoptions::LimitedDebugInfo ||
+ if (DebugKind > llvm::debugoptions::LimitedDebugInfo ||
RD->hasAttr<StandaloneDebugAttr>())
return false;
@@ -2657,7 +2653,7 @@ static bool shouldOmitDefinition(llvm::codegenoptions::DebugInfoKind DebugKind,
// In constructor homing mode, only emit complete debug info for a class
// when its constructor is emitted.
- if ((DebugKind == llvm::codegenoptions::DebugInfoConstructor) &&
+ if ((DebugKind == llvm::debugoptions::DebugInfoConstructor) &&
canUseCtorHoming(CXXDecl))
return true;
@@ -2758,7 +2754,7 @@ CGDebugInfo::CreateTypeDefinition(const RecordType *Ty) {
RegionMap[Ty->getDecl()].reset(FwdDecl);
- if (CGM.getCodeGenOpts().getDebuggerTuning() == llvm::DebuggerKind::LLDB)
+ if (CGM.getDebugOpts().getDebuggerTuning() == llvm::DebuggerKind::LLDB)
if (auto *PrefDI = GetPreferredNameType(CXXDecl, DefUnit))
return {FwdDecl, PrefDI};
@@ -3270,8 +3266,8 @@ llvm::DIType *CGDebugInfo::CreateType(const RValueReferenceType *Ty,
llvm::DIFile *Unit) {
llvm::dwarf::Tag Tag = llvm::dwarf::DW_TAG_rvalue_reference_type;
// DW_TAG_rvalue_reference_type was introduced in DWARF 4.
- if (CGM.getCodeGenOpts().DebugStrictDwarf &&
- CGM.getCodeGenOpts().DwarfVersion < 4)
+ if (CGM.getDebugOpts().DebugStrictDwarf &&
+ CGM.getDebugOpts().DwarfVersion < 4)
Tag = llvm::dwarf::DW_TAG_reference_type;
return CreatePointerLikeType(Tag, Ty, Ty->getPointeeType(), Unit);
@@ -3505,7 +3501,7 @@ void CGDebugInfo::completeTemplateDefinition(
}
void CGDebugInfo::completeUnusedClass(const CXXRecordDecl &D) {
- if (DebugKind <= llvm::codegenoptions::DebugLineTablesOnly ||
+ if (DebugKind <= llvm::debugoptions::DebugLineTablesOnly ||
D.isDynamicClass())
return;
@@ -3842,16 +3838,16 @@ void CGDebugInfo::collectFunctionDeclProps(GlobalDecl GD, llvm::DIFile *Unit,
if (LinkageName == Name ||
(CGM.getCodeGenOpts().CoverageNotesFile.empty() &&
CGM.getCodeGenOpts().CoverageDataFile.empty() &&
- !CGM.getCodeGenOpts().DebugInfoForProfiling &&
+ !CGM.getDebugOpts().DebugInfoForProfiling &&
!CGM.getCodeGenOpts().PseudoProbeForProfiling &&
- DebugKind <= llvm::codegenoptions::DebugLineTablesOnly))
+ DebugKind <= llvm::debugoptions::DebugLineTablesOnly))
LinkageName = StringRef();
// Emit the function scope in line tables only mode (if CodeView) to
// differentiate between function names.
- if (CGM.getCodeGenOpts().hasReducedDebugInfo() ||
- (DebugKind == llvm::codegenoptions::DebugLineTablesOnly &&
- CGM.getCodeGenOpts().EmitCodeView)) {
+ if (CGM.getDebugOpts().hasReducedDebugInfo() ||
+ (DebugKind == llvm::debugoptions::DebugLineTablesOnly &&
+ CGM.getDebugOpts().EmitCodeView)) {
if (const NamespaceDecl *NSDecl =
dyn_cast_or_null<NamespaceDecl>(FD->getDeclContext()))
FDContext = getOrCreateNamespace(NSDecl);
@@ -3861,7 +3857,7 @@ void CGDebugInfo::collectFunctionDeclProps(GlobalDecl GD, llvm::DIFile *Unit,
FDContext = getContextDescriptor(RDecl, Mod ? Mod : TheCU);
}
}
- if (CGM.getCodeGenOpts().hasReducedDebugInfo()) {
+ if (CGM.getDebugOpts().hasReducedDebugInfo()) {
// Check if it is a noreturn-marked function
if (FD->isNoReturn())
Flags |= llvm::DINode::FlagNoReturn;
@@ -4042,7 +4038,7 @@ llvm::DINode *CGDebugInfo::getDeclarationOrDefinition(const Decl *D) {
}
llvm::DISubprogram *CGDebugInfo::getFunctionDeclaration(const Decl *D) {
- if (!D || DebugKind <= llvm::codegenoptions::DebugLineTablesOnly)
+ if (!D || DebugKind <= llvm::debugoptions::DebugLineTablesOnly)
return nullptr;
const auto *FD = dyn_cast<FunctionDecl>(D);
@@ -4079,14 +4075,14 @@ llvm::DISubprogram *CGDebugInfo::getFunctionDeclaration(const Decl *D) {
llvm::DISubprogram *CGDebugInfo::getObjCMethodDeclaration(
const Decl *D, llvm::DISubroutineType *FnType, unsigned LineNo,
llvm::DINode::DIFlags Flags, llvm::DISubprogram::DISPFlags SPFlags) {
- if (!D || DebugKind <= llvm::codegenoptions::DebugLineTablesOnly)
+ if (!D || DebugKind <= llvm::debugoptions::DebugLineTablesOnly)
return nullptr;
const auto *OMD = dyn_cast<ObjCMethodDecl>(D);
if (!OMD)
return nullptr;
- if (CGM.getCodeGenOpts().DwarfVersion < 5 && !OMD->isDirectMethod())
+ if (CGM.getDebugOpts().DwarfVersion < 5 && !OMD->isDirectMethod())
return nullptr;
if (OMD->isDirectMethod())
@@ -4119,8 +4115,8 @@ llvm::DISubroutineType *CGDebugInfo::getOrCreateFunctionType(const Decl *D,
llvm::DIFile *F) {
// In CodeView, we emit the function types in line tables only because the
// only way to distinguish between functions is by display name and type.
- if (!D || (DebugKind <= llvm::codegenoptions::DebugLineTablesOnly &&
- !CGM.getCodeGenOpts().EmitCodeView))
+ if (!D || (DebugKind <= llvm::debugoptions::DebugLineTablesOnly &&
+ !CGM.getDebugOpts().EmitCodeView))
// Create fake but valid subroutine type. Otherwise -verify would fail, and
// subprogram DIE will miss DW_AT_decl_file and DW_AT_decl_line fields.
return DBuilder.createSubroutineType(
@@ -4474,7 +4470,7 @@ void CGDebugInfo::EmitLexicalBlockStart(CGBuilderTy &Builder,
CGM.getLLVMContext(), getLineNumber(Loc), getColumnNumber(Loc),
LexicalBlockStack.back(), CurInlinedAt));
- if (DebugKind <= llvm::codegenoptions::DebugLineTablesOnly)
+ if (DebugKind <= llvm::debugoptions::DebugLineTablesOnly)
return;
// Create a new lexical block and push it on the stack.
@@ -4488,7 +4484,7 @@ void CGDebugInfo::EmitLexicalBlockEnd(CGBuilderTy &Builder,
// Provide an entry in the line table for the end of the block.
EmitLocation(Builder, Loc);
- if (DebugKind <= llvm::codegenoptions::DebugLineTablesOnly)
+ if (DebugKind <= llvm::debugoptions::DebugLineTablesOnly)
return;
LexicalBlockStack.pop_back();
@@ -4587,7 +4583,7 @@ llvm::DILocalVariable *CGDebugInfo::EmitDeclare(const VarDecl *VD,
std::optional<unsigned> ArgNo,
CGBuilderTy &Builder,
const bool UsePointerValue) {
- assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
+ assert(CGM.getDebugOpts().hasReducedDebugInfo());
assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
if (VD->hasAttr<NoDebugAttr>())
return nullptr;
@@ -4801,7 +4797,7 @@ llvm::DILocalVariable *CGDebugInfo::EmitDeclare(const BindingDecl *BD,
std::optional<unsigned> ArgNo,
CGBuilderTy &Builder,
const bool UsePointerValue) {
- assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
+ assert(CGM.getDebugOpts().hasReducedDebugInfo());
assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
if (BD->hasAttr<NoDebugAttr>())
return nullptr;
@@ -4890,7 +4886,7 @@ llvm::DILocalVariable *
CGDebugInfo::EmitDeclareOfAutoVariable(const VarDecl *VD, llvm::Value *Storage,
CGBuilderTy &Builder,
const bool UsePointerValue) {
- assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
+ assert(CGM.getDebugOpts().hasReducedDebugInfo());
if (auto *DD = dyn_cast<DecompositionDecl>(VD)) {
for (auto *B : DD->bindings()) {
@@ -4906,7 +4902,7 @@ CGDebugInfo::EmitDeclareOfAutoVariable(const VarDecl *VD, llvm::Value *Storage,
}
void CGDebugInfo::EmitLabel(const LabelDecl *D, CGBuilderTy &Builder) {
- assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
+ assert(CGM.getDebugOpts().hasReducedDebugInfo());
assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
if (D->hasAttr<NoDebugAttr>())
@@ -4943,7 +4939,7 @@ llvm::DIType *CGDebugInfo::CreateSelfType(const QualType &QualTy,
void CGDebugInfo::EmitDeclareOfBlockDeclRefVariable(
const VarDecl *VD, llvm::Value *Storage, CGBuilderTy &Builder,
const CGBlockInfo &blockInfo, llvm::Instruction *InsertPoint) {
- assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
+ assert(CGM.getDebugOpts().hasReducedDebugInfo());
assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
if (Builder.GetInsertBlock() == nullptr)
@@ -5016,7 +5012,7 @@ llvm::DILocalVariable *
CGDebugInfo::EmitDeclareOfArgVariable(const VarDecl *VD, llvm::Value *AI,
unsigned ArgNo, CGBuilderTy &Builder,
bool UsePointerValue) {
- assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
+ assert(CGM.getDebugOpts().hasReducedDebugInfo());
return EmitDeclare(VD, AI, ArgNo, Builder, UsePointerValue);
}
@@ -5073,7 +5069,7 @@ void CGDebugInfo::EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block,
unsigned ArgNo,
llvm::AllocaInst *Alloca,
CGBuilderTy &Builder) {
- assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
+ assert(CGM.getDebugOpts().hasReducedDebugInfo());
ASTContext &C = CGM.getContext();
const BlockDecl *blockDecl = block.getBlockDecl();
@@ -5348,11 +5344,11 @@ std::string CGDebugInfo::GetName(const Decl *D, bool Qualified) const {
const NamedDecl *ND = dyn_cast<NamedDecl>(D);
if (!ND)
return Name;
- llvm::codegenoptions::DebugTemplateNamesKind TemplateNamesKind =
- CGM.getCodeGenOpts().getDebugSimpleTemplateNames();
+ llvm::debugoptions::DebugTemplateNamesKind TemplateNamesKind =
+ CGM.getDebugOpts().getDebugSimpleTemplateNames();
- if (!CGM.getCodeGenOpts().hasReducedDebugInfo())
- TemplateNamesKind = llvm::codegenoptions::DebugTemplateNamesKind::Full;
+ if (!CGM.getDebugOpts().hasReducedDebugInfo())
+ TemplateNamesKind = llvm::debugoptions::DebugTemplateNamesKind::Full;
std::optional<TemplateArgs> Args;
@@ -5435,12 +5431,12 @@ std::string CGDebugInfo::GetName(const Decl *D, bool Qualified) const {
PrintingPolicy PP = getPrintingPolicy();
- if (TemplateNamesKind == llvm::codegenoptions::DebugTemplateNamesKind::Full ||
+ if (TemplateNamesKind == llvm::debugoptions::DebugTemplateNamesKind::Full ||
!Reconstitutable) {
ND->getNameForDiagnostic(OS, PP, Qualified);
} else {
bool Mangled = TemplateNamesKind ==
- llvm::codegenoptions::DebugTemplateNamesKind::Mangled;
+ llvm::debugoptions::DebugTemplateNamesKind::Mangled;
// check if it's a template
if (Mangled)
OS << "_STN|";
@@ -5467,7 +5463,7 @@ std::string CGDebugInfo::GetName(const Decl *D, bool Qualified) const {
void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
const VarDecl *D) {
- assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
+ assert(CGM.getDebugOpts().hasReducedDebugInfo());
if (D->hasAttr<NoDebugAttr>())
return;
@@ -5532,7 +5528,7 @@ void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
}
void CGDebugInfo::EmitGlobalVariable(const ValueDecl *VD, const APValue &Init) {
- assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
+ assert(CGM.getDebugOpts().hasReducedDebugInfo());
if (VD->hasAttr<NoDebugAttr>())
return;
llvm::TimeTraceScope TimeScope("DebugConstGlobalVariable", [&]() {
@@ -5549,7 +5545,7 @@ void CGDebugInfo::EmitGlobalVariable(const ValueDecl *VD, const APValue &Init) {
const auto *ED = cast<EnumDecl>(ECD->getDeclContext());
assert(isa<EnumType>(ED->getTypeForDecl()) && "Enum without EnumType?");
- if (CGM.getCodeGenOpts().EmitCodeView) {
+ if (CGM.getDebugOpts().EmitCodeView) {
// If CodeView, emit enums as global variables, unless they are defined
// inside a class. We do this because MSVC doesn't emit S_CONSTANTs for
// enums in classes, and because it is difficult to attach this scope
@@ -5609,7 +5605,7 @@ void CGDebugInfo::EmitGlobalVariable(const ValueDecl *VD, const APValue &Init) {
void CGDebugInfo::EmitExternalVariable(llvm::GlobalVariable *Var,
const VarDecl *D) {
- assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
+ assert(CGM.getDebugOpts().hasReducedDebugInfo());
if (D->hasAttr<NoDebugAttr>())
return;
@@ -5631,7 +5627,7 @@ void CGDebugInfo::EmitGlobalAlias(const llvm::GlobalValue *GV,
assert(GV);
- if (!CGM.getCodeGenOpts().hasReducedDebugInfo())
+ if (!CGM.getDebugOpts().hasReducedDebugInfo())
return;
const auto *D = cast<ValueDecl>(GD.getDecl());
@@ -5690,11 +5686,11 @@ llvm::DIScope *CGDebugInfo::getCurrentContextDescriptor(const Decl *D) {
}
void CGDebugInfo::EmitUsingDirective(const UsingDirectiveDecl &UD) {
- if (!CGM.getCodeGenOpts().hasReducedDebugInfo())
+ if (!CGM.getDebugOpts().hasReducedDebugInfo())
return;
const NamespaceDecl *NSDecl = UD.getNominatedNamespace();
if (!NSDecl->isAnonymousNamespace() ||
- CGM.getCodeGenOpts().DebugExplicitImport) {
+ CGM.getDebugOpts().DebugExplicitImport) {
auto Loc = UD.getLocation();
if (!Loc.isValid())
Loc = CurLoc;
@@ -5715,7 +5711,7 @@ void CGDebugInfo::EmitUsingShadowDecl(const UsingShadowDecl &USD) {
}
void CGDebugInfo::EmitUsingDecl(const UsingDecl &UD) {
- if (!CGM.getCodeGenOpts().hasReducedDebugInfo())
+ if (!CGM.getDebugOpts().hasReducedDebugInfo())
return;
assert(UD.shadow_size() &&
"We shouldn't be codegening an invalid UsingDecl containing no decls");
@@ -5740,7 +5736,7 @@ void CGDebugInfo::EmitUsingDecl(const UsingDecl &UD) {
}
void CGDebugInfo::EmitUsingEnumDecl(const UsingEnumDecl &UD) {
- if (!CGM.getCodeGenOpts().hasReducedDebugInfo())
+ if (!CGM.getDebugOpts().hasReducedDebugInfo())
return;
assert(UD.shadow_size() &&
"We shouldn't be codegening an invalid UsingEnumDecl"
@@ -5751,7 +5747,7 @@ void CGDebugInfo::EmitUsingEnumDecl(const UsingEnumDecl &UD) {
}
void CGDebugInfo::EmitImportDecl(const ImportDecl &ID) {
- if (CGM.getCodeGenOpts().getDebuggerTuning() != llvm::DebuggerKind::LLDB)
+ if (CGM.getDebugOpts().getDebuggerTuning() != llvm::DebuggerKind::LLDB)
return;
if (Module *M = ID.getImportedModule()) {
auto Info = ASTSourceDescriptor(*M);
@@ -5765,7 +5761,7 @@ void CGDebugInfo::EmitImportDecl(const ImportDecl &ID) {
llvm::DIImportedEntity *
CGDebugInfo::EmitNamespaceAlias(const NamespaceAliasDecl &NA) {
- if (!CGM.getCodeGenOpts().hasReducedDebugInfo())
+ if (!CGM.getDebugOpts().hasReducedDebugInfo())
return nullptr;
auto &VH = NamespaceAliasCache[&NA];
if (VH)
@@ -5838,7 +5834,7 @@ void CGDebugInfo::finalize() {
// For DWARF v4 or earlier, only add objc_direct methods.
for (auto &SubprogramDirect : P.second)
- if (CGM.getCodeGenOpts().DwarfVersion >= 5 || SubprogramDirect.getInt())
+ if (CGM.getDebugOpts().DwarfVersion >= 5 || SubprogramDirect.getInt())
EltTys.push_back(SubprogramDirect.getPointer());
llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
@@ -5888,13 +5884,13 @@ void CGDebugInfo::finalize() {
// Don't ignore in case of explicit cast where it is referenced indirectly.
void CGDebugInfo::EmitExplicitCastType(QualType Ty) {
- if (CGM.getCodeGenOpts().hasReducedDebugInfo())
+ if (CGM.getDebugOpts().hasReducedDebugInfo())
if (auto *DieTy = getOrCreateType(Ty, TheCU->getFile()))
DBuilder.retainType(DieTy);
}
void CGDebugInfo::EmitAndRetainType(QualType Ty) {
- if (CGM.getCodeGenOpts().hasMaybeUnusedDebugInfo())
+ if (CGM.getDebugOpts().hasMaybeUnusedDebugInfo())
if (auto *DieTy = getOrCreateType(Ty, TheCU->getFile()))
DBuilder.retainType(DieTy);
}
@@ -5912,19 +5908,19 @@ llvm::DINode::DIFlags CGDebugInfo::getCallSiteRelatedAttrs() const {
// Call site-related attributes are only useful in optimized programs, and
// when there's a possibility of debugging backtraces.
if (!CGM.getLangOpts().Optimize ||
- DebugKind == llvm::codegenoptions::NoDebugInfo ||
- DebugKind == llvm::codegenoptions::LocTrackingOnly)
+ DebugKind == llvm::debugoptions::NoDebugInfo ||
+ DebugKind == llvm::debugoptions::LocTrackingOnly)
return llvm::DINode::FlagZero;
// Call site-related attributes are available in DWARF v5. Some debuggers,
// while not fully DWARF v5-compliant, may accept these attributes as if they
// were part of DWARF v4.
bool SupportsDWARFv4Ext =
- CGM.getCodeGenOpts().DwarfVersion == 4 &&
- (CGM.getCodeGenOpts().getDebuggerTuning() == llvm::DebuggerKind::LLDB ||
- CGM.getCodeGenOpts().getDebuggerTuning() == llvm::DebuggerKind::GDB);
+ CGM.getDebugOpts().DwarfVersion == 4 &&
+ (CGM.getDebugOpts().getDebuggerTuning() == llvm::DebuggerKind::LLDB ||
+ CGM.getDebugOpts().getDebuggerTuning() == llvm::DebuggerKind::GDB);
- if (!SupportsDWARFv4Ext && CGM.getCodeGenOpts().DwarfVersion < 5)
+ if (!SupportsDWARFv4Ext && CGM.getDebugOpts().DwarfVersion < 5)
return llvm::DINode::FlagZero;
return llvm::DINode::FlagAllCallsDescribed;
diff --git a/clang/lib/CodeGen/CGDebugInfo.h b/clang/lib/CodeGen/CGDebugInfo.h
index 7b60e94555d060..68c3bf8bf7adae 100644
--- a/clang/lib/CodeGen/CGDebugInfo.h
+++ b/clang/lib/CodeGen/CGDebugInfo.h
@@ -20,11 +20,11 @@
#include "clang/AST/PrettyPrinter.h"
#include "clang/AST/Type.h"
#include "clang/AST/TypeOrdering.h"
-#include "clang/Basic/CodeGenOptions.h"
#include "clang/Basic/Module.h"
#include "clang/Basic/SourceLocation.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/DenseSet.h"
+#include "llvm/Frontend/Debug/Options.h"
#include "llvm/IR/DIBuilder.h"
#include "llvm/IR/DebugInfo.h"
#include "llvm/IR/ValueHandle.h"
@@ -56,7 +56,7 @@ class CGDebugInfo {
friend class ApplyDebugLocation;
friend class SaveAndRestoreLocation;
CodeGenModule &CGM;
- const llvm::codegenoptions::DebugInfoKind DebugKind;
+ const llvm::debugoptions::DebugInfoKind DebugKind;
bool DebugTypeExtRefs;
llvm::DIBuilder DBuilder;
llvm::DICompileUnit *TheCU = nullptr;
diff --git a/clang/lib/CodeGen/CGDecl.cpp b/clang/lib/CodeGen/CGDecl.cpp
index a5da0aa2965a00..2e21907731c298 100644
--- a/clang/lib/CodeGen/CGDecl.cpp
+++ b/clang/lib/CodeGen/CGDecl.cpp
@@ -28,6 +28,7 @@
#include "clang/AST/DeclObjC.h"
#include "clang/AST/DeclOpenMP.h"
#include "clang/Basic/CodeGenOptions.h"
+#include "clang/Basic/DebugOptions.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Basic/TargetInfo.h"
#include "clang/CodeGen/CGFunctionInfo.h"
@@ -485,7 +486,7 @@ void CodeGenFunction::EmitStaticVarDecl(const VarDecl &D,
// Emit global variable debug descriptor for static vars.
CGDebugInfo *DI = getDebugInfo();
- if (DI && CGM.getCodeGenOpts().hasReducedDebugInfo()) {
+ if (DI && CGM.getDebugOpts().hasReducedDebugInfo()) {
DI->setLocation(D.getLocation());
DI->EmitGlobalVariable(var, &D);
}
@@ -1446,7 +1447,7 @@ CodeGenFunction::EmitAutoVarAlloca(const VarDecl &D) {
EmitVariablyModifiedType(Ty);
auto *DI = getDebugInfo();
- bool EmitDebugInfo = DI && CGM.getCodeGenOpts().hasReducedDebugInfo();
+ bool EmitDebugInfo = DI && CGM.getDebugOpts().hasReducedDebugInfo();
Address address = Address::invalid();
Address AllocaAddr = Address::invalid();
@@ -2659,7 +2660,7 @@ void CodeGenFunction::EmitParmDecl(const VarDecl &D, ParamValue Arg,
// Emit debug info for param declarations in non-thunk functions.
if (CGDebugInfo *DI = getDebugInfo()) {
- if (CGM.getCodeGenOpts().hasReducedDebugInfo() && !CurFuncIsThunk &&
+ if (CGM.getDebugOpts().hasReducedDebugInfo() && !CurFuncIsThunk &&
!NoDebugInfo) {
llvm::DILocalVariable *DILocalVar = DI->EmitDeclareOfArgVariable(
&D, AllocaPtr.getPointer(), ArgNo, Builder, UseIndirectDebugAddress);
diff --git a/clang/lib/CodeGen/CGHLSLRuntime.cpp b/clang/lib/CodeGen/CGHLSLRuntime.cpp
index 3e8a40e7540bef..7f9ac08034171d 100644
--- a/clang/lib/CodeGen/CGHLSLRuntime.cpp
+++ b/clang/lib/CodeGen/CGHLSLRuntime.cpp
@@ -16,6 +16,7 @@
#include "CGDebugInfo.h"
#include "CodeGenModule.h"
#include "clang/AST/Decl.h"
+#include "clang/Basic/DebugOptions.h"
#include "clang/Basic/TargetOptions.h"
#include "llvm/IR/IntrinsicsDirectX.h"
#include "llvm/IR/Metadata.h"
@@ -127,8 +128,8 @@ void CGHLSLRuntime::addConstant(VarDecl *D, Buffer &CB) {
auto *GV = cast<GlobalVariable>(CGM.GetAddrOfGlobalVar(D));
// Add debug info for constVal.
if (CGDebugInfo *DI = CGM.getModuleDebugInfo())
- if (CGM.getCodeGenOpts().getDebugInfo() >=
- codegenoptions::DebugInfoKind::LimitedDebugInfo)
+ if (CGM.getDebugOpts().getDebugInfo() >=
+ debugoptions::DebugInfoKind::LimitedDebugInfo)
DI->EmitGlobalVariable(cast<GlobalVariable>(GV), D);
// FIXME: support packoffset.
diff --git a/clang/lib/CodeGen/CGOpenMPRuntime.cpp b/clang/lib/CodeGen/CGOpenMPRuntime.cpp
index 7f7e6f53066644..6eda793e869182 100644
--- a/clang/lib/CodeGen/CGOpenMPRuntime.cpp
+++ b/clang/lib/CodeGen/CGOpenMPRuntime.cpp
@@ -23,6 +23,7 @@
#include "clang/AST/StmtOpenMP.h"
#include "clang/AST/StmtVisitor.h"
#include "clang/Basic/BitmaskEnum.h"
+#include "clang/Basic/DebugOptions.h"
#include "clang/Basic/FileManager.h"
#include "clang/Basic/OpenMPKinds.h"
#include "clang/Basic/SourceManager.h"
@@ -1361,8 +1362,8 @@ llvm::Value *CGOpenMPRuntime::emitUpdateLocation(CodeGenFunction &CGF,
unsigned Flags, bool EmitLoc) {
uint32_t SrcLocStrSize;
llvm::Constant *SrcLocStr;
- if ((!EmitLoc && CGM.getCodeGenOpts().getDebugInfo() ==
- llvm::codegenoptions::NoDebugInfo) ||
+ if ((!EmitLoc &&
+ CGM.getDebugOpts().getDebugInfo() == llvm::debugoptions::NoDebugInfo) ||
Loc.isInvalid()) {
SrcLocStr = OMPBuilder.getOrCreateDefaultSrcLocStr(SrcLocStrSize);
} else {
@@ -8746,8 +8747,7 @@ static void emitOffloadingArrays(
auto FillInfoMap = [&](MappableExprsHandler::MappingExprInfo &MapExpr) {
return emitMappingInformation(CGF, OMPBuilder, MapExpr);
};
- if (CGM.getCodeGenOpts().getDebugInfo() !=
- llvm::codegenoptions::NoDebugInfo) {
+ if (CGM.getDebugOpts().getDebugInfo() != llvm::debugoptions::NoDebugInfo) {
CombinedInfo.Names.resize(CombinedInfo.Exprs.size());
llvm::transform(CombinedInfo.Exprs, CombinedInfo.Names.begin(),
FillInfoMap);
@@ -9048,8 +9048,7 @@ void CGOpenMPRuntime::emitUserDefinedMapper(const OMPDeclareMapperDecl *D,
Info.Pointers[I], CGM.getTypes().ConvertTypeForMem(C.VoidPtrTy));
llvm::Value *CurSizeArg = Info.Sizes[I];
llvm::Value *CurNameArg =
- (CGM.getCodeGenOpts().getDebugInfo() ==
- llvm::codegenoptions::NoDebugInfo)
+ (CGM.getDebugOpts().getDebugInfo() == llvm::debugoptions::NoDebugInfo)
? llvm::ConstantPointerNull::get(CGM.VoidPtrTy)
: emitMappingInformation(MapperCGF, OMPBuilder, Info.Exprs[I]);
@@ -9429,8 +9428,8 @@ static void emitTargetCallKernelLaunch(
CGOpenMPRuntime::TargetDataInfo Info;
// Fill up the arrays and create the arguments.
emitOffloadingArrays(CGF, CombinedInfo, Info, OMPBuilder);
- bool EmitDebug = CGF.CGM.getCodeGenOpts().getDebugInfo() !=
- llvm::codegenoptions::NoDebugInfo;
+ bool EmitDebug =
+ CGF.CGM.getDebugOpts().getDebugInfo() != llvm::debugoptions::NoDebugInfo;
OMPBuilder.emitOffloadingArraysArgument(CGF.Builder, Info.RTArgs, Info,
EmitDebug,
/*ForEndCall=*/false);
@@ -10159,8 +10158,7 @@ void CGOpenMPRuntime::emitTargetDataCalls(
auto FillInfoMap = [&](MappableExprsHandler::MappingExprInfo &MapExpr) {
return emitMappingInformation(CGF, OMPBuilder, MapExpr);
};
- if (CGM.getCodeGenOpts().getDebugInfo() !=
- llvm::codegenoptions::NoDebugInfo) {
+ if (CGM.getDebugOpts().getDebugInfo() != llvm::debugoptions::NoDebugInfo) {
CombinedInfo.Names.resize(CombinedInfo.Exprs.size());
llvm::transform(CombinedInfo.Exprs, CombinedInfo.Names.begin(),
FillInfoMap);
@@ -10373,8 +10371,8 @@ void CGOpenMPRuntime::emitTargetDataStandAloneCall(
/*IsNonContiguous=*/true);
bool RequiresOuterTask = D.hasClausesOfKind<OMPDependClause>() ||
D.hasClausesOfKind<OMPNowaitClause>();
- bool EmitDebug = CGF.CGM.getCodeGenOpts().getDebugInfo() !=
- llvm::codegenoptions::NoDebugInfo;
+ bool EmitDebug = CGF.CGM.getDebugOpts().getDebugInfo() !=
+ llvm::debugoptions::NoDebugInfo;
OMPBuilder.emitOffloadingArraysArgument(CGF.Builder, Info.RTArgs, Info,
EmitDebug,
/*ForEndCall=*/false);
diff --git a/clang/lib/CodeGen/CGStmt.cpp b/clang/lib/CodeGen/CGStmt.cpp
index 0f79a2e861d220..9e803c3f75cf24 100644
--- a/clang/lib/CodeGen/CGStmt.cpp
+++ b/clang/lib/CodeGen/CGStmt.cpp
@@ -20,6 +20,7 @@
#include "clang/AST/Stmt.h"
#include "clang/AST/StmtVisitor.h"
#include "clang/Basic/Builtins.h"
+#include "clang/Basic/DebugOptions.h"
#include "clang/Basic/DiagnosticSema.h"
#include "clang/Basic/PrettyStackTrace.h"
#include "clang/Basic/SourceManager.h"
@@ -659,7 +660,7 @@ void CodeGenFunction::EmitLabel(const LabelDecl *D) {
// Emit debug info for labels.
if (CGDebugInfo *DI = getDebugInfo()) {
- if (CGM.getCodeGenOpts().hasReducedDebugInfo()) {
+ if (CGM.getDebugOpts().hasReducedDebugInfo()) {
DI->setLocation(D->getLocation());
DI->EmitLabel(D, Builder);
}
@@ -1536,7 +1537,7 @@ void CodeGenFunction::EmitCaseStmt(const CaseStmt &S,
if (CE) {
if (auto DE = dyn_cast<DeclRefExpr>(CE->getSubExpr()))
if (CGDebugInfo *Dbg = getDebugInfo())
- if (CGM.getCodeGenOpts().hasReducedDebugInfo())
+ if (CGM.getDebugOpts().hasReducedDebugInfo())
Dbg->EmitGlobalVariable(DE->getDecl(),
APValue(llvm::APSInt(CaseVal->getValue())));
}
diff --git a/clang/lib/CodeGen/CGStmtOpenMP.cpp b/clang/lib/CodeGen/CGStmtOpenMP.cpp
index ed426098ac6915..533f728a54737c 100644
--- a/clang/lib/CodeGen/CGStmtOpenMP.cpp
+++ b/clang/lib/CodeGen/CGStmtOpenMP.cpp
@@ -22,6 +22,7 @@
#include "clang/AST/Stmt.h"
#include "clang/AST/StmtOpenMP.h"
#include "clang/AST/StmtVisitor.h"
+#include "clang/Basic/DebugOptions.h"
#include "clang/Basic/OpenMPKinds.h"
#include "clang/Basic/PrettyStackTrace.h"
#include "llvm/ADT/SmallSet.h"
@@ -615,7 +616,7 @@ CodeGenFunction::GenerateOpenMPCapturedStmtFunction(const CapturedStmt &S,
const CapturedDecl *CD = S.getCapturedDecl();
// Build the argument list.
bool NeedWrapperFunction =
- getDebugInfo() && CGM.getCodeGenOpts().hasReducedDebugInfo();
+ getDebugInfo() && CGM.getDebugOpts().hasReducedDebugInfo();
FunctionArgList Args;
llvm::MapVector<const Decl *, std::pair<const VarDecl *, Address>> LocalAddrs;
llvm::DenseMap<const Decl *, std::pair<const Expr *, llvm::Value *>> VLASizes;
@@ -4743,7 +4744,7 @@ void CodeGenFunction::EmitOMPTaskBasedDirective(
CGF.getContext().getASTRecordLayout(CaptureRecord);
unsigned Offset =
Layout.getFieldOffset(It->second->getFieldIndex()) / CharWidth;
- if (CGF.CGM.getCodeGenOpts().hasReducedDebugInfo())
+ if (CGF.CGM.getDebugOpts().hasReducedDebugInfo())
(void)DI->EmitDeclareOfAutoVariable(SharedVar, ContextValue,
CGF.Builder, false);
llvm::Instruction &Last = CGF.Builder.GetInsertBlock()->back();
@@ -4842,7 +4843,7 @@ void CodeGenFunction::EmitOMPTaskBasedDirective(
CGF.getContext().getDeclAlign(Pair.first));
Scope.addPrivate(Pair.first, Replacement);
if (auto *DI = CGF.getDebugInfo())
- if (CGF.CGM.getCodeGenOpts().hasReducedDebugInfo())
+ if (CGF.CGM.getDebugOpts().hasReducedDebugInfo())
(void)DI->EmitDeclareOfAutoVariable(
Pair.first, Pair.second.getPointer(), CGF.Builder,
/*UsePointerValue*/ true);
diff --git a/clang/lib/CodeGen/CGVTables.cpp b/clang/lib/CodeGen/CGVTables.cpp
index 27a2cab4f75319..a8c381de3be69d 100644
--- a/clang/lib/CodeGen/CGVTables.cpp
+++ b/clang/lib/CodeGen/CGVTables.cpp
@@ -17,6 +17,7 @@
#include "clang/AST/CXXInheritance.h"
#include "clang/AST/RecordLayout.h"
#include "clang/Basic/CodeGenOptions.h"
+#include "clang/Basic/DebugOptions.h"
#include "clang/CodeGen/CGFunctionInfo.h"
#include "clang/CodeGen/ConstantInitBuilder.h"
#include "llvm/IR/IntrinsicInst.h"
@@ -1059,20 +1060,19 @@ CodeGenModule::getVTableLinkage(const CXXRecordDecl *RD) {
switch (keyFunction->getTemplateSpecializationKind()) {
case TSK_Undeclared:
case TSK_ExplicitSpecialization:
- assert(
- (def || CodeGenOpts.OptimizationLevel > 0 ||
- CodeGenOpts.getDebugInfo() != llvm::codegenoptions::NoDebugInfo) &&
- "Shouldn't query vtable linkage without key function, "
- "optimizations, or debug info");
- if (!def && CodeGenOpts.OptimizationLevel > 0)
- return llvm::GlobalVariable::AvailableExternallyLinkage;
-
- if (keyFunction->isInlined())
- return !Context.getLangOpts().AppleKext
- ? llvm::GlobalVariable::LinkOnceODRLinkage
- : llvm::Function::InternalLinkage;
-
- return llvm::GlobalVariable::ExternalLinkage;
+ assert((def || CodeGenOpts.OptimizationLevel > 0 ||
+ DebugOpts.getDebugInfo() != llvm::debugoptions::NoDebugInfo) &&
+ "Shouldn't query vtable linkage without key function, "
+ "optimizations, or debug info");
+ if (!def && CodeGenOpts.OptimizationLevel > 0)
+ return llvm::GlobalVariable::AvailableExternallyLinkage;
+
+ if (keyFunction->isInlined())
+ return !Context.getLangOpts().AppleKext
+ ? llvm::GlobalVariable::LinkOnceODRLinkage
+ : llvm::Function::InternalLinkage;
+
+ return llvm::GlobalVariable::ExternalLinkage;
case TSK_ImplicitInstantiation:
return !Context.getLangOpts().AppleKext ?
diff --git a/clang/lib/CodeGen/CodeGenAction.cpp b/clang/lib/CodeGen/CodeGenAction.cpp
index 753a8fd74fa696..8f3ef402ea6a98 100644
--- a/clang/lib/CodeGen/CodeGenAction.cpp
+++ b/clang/lib/CodeGen/CodeGenAction.cpp
@@ -16,6 +16,7 @@
#include "clang/AST/ASTContext.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclGroup.h"
+#include "clang/Basic/DebugOptions.h"
#include "clang/Basic/DiagnosticFrontend.h"
#include "clang/Basic/FileManager.h"
#include "clang/Basic/LangStandard.h"
@@ -109,56 +110,52 @@ static void reportOptRecordError(Error E, DiagnosticsEngine &Diags,
});
}
-BackendConsumer::BackendConsumer(BackendAction Action, DiagnosticsEngine &Diags,
- IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
- const HeaderSearchOptions &HeaderSearchOpts,
- const PreprocessorOptions &PPOpts,
- const CodeGenOptions &CodeGenOpts,
- const TargetOptions &TargetOpts,
- const LangOptions &LangOpts,
- const std::string &InFile,
- SmallVector<LinkModule, 4> LinkModules,
- std::unique_ptr<raw_pwrite_stream> OS,
- LLVMContext &C,
- CoverageSourceInfo *CoverageInfo)
- : Diags(Diags), Action(Action), HeaderSearchOpts(HeaderSearchOpts),
- CodeGenOpts(CodeGenOpts), TargetOpts(TargetOpts), LangOpts(LangOpts),
- AsmOutStream(std::move(OS)), Context(nullptr), FS(VFS),
- LLVMIRGeneration("irgen", "LLVM IR Generation Time"),
- LLVMIRGenerationRefCount(0),
- Gen(CreateLLVMCodeGen(Diags, InFile, std::move(VFS), HeaderSearchOpts,
- PPOpts, CodeGenOpts, C, CoverageInfo)),
- LinkModules(std::move(LinkModules)) {
- TimerIsEnabled = CodeGenOpts.TimePasses;
- llvm::TimePassesIsEnabled = CodeGenOpts.TimePasses;
- llvm::TimePassesPerRun = CodeGenOpts.TimePassesPerRun;
+BackendConsumer::BackendConsumer(
+ BackendAction Action, DiagnosticsEngine &Diags,
+ IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
+ const HeaderSearchOptions &HeaderSearchOpts,
+ const PreprocessorOptions &PPOpts, const CodeGenOptions &CodeGenOpts,
+ const DebugOptions &DebugOpts, const TargetOptions &TargetOpts,
+ const LangOptions &LangOpts, const std::string &InFile,
+ SmallVector<LinkModule, 4> LinkModules,
+ std::unique_ptr<raw_pwrite_stream> OS, LLVMContext &C,
+ CoverageSourceInfo *CoverageInfo)
+ : Diags(Diags), Action(Action), HeaderSearchOpts(HeaderSearchOpts),
+ CodeGenOpts(CodeGenOpts), DebugOpts(DebugOpts), TargetOpts(TargetOpts),
+ LangOpts(LangOpts), AsmOutStream(std::move(OS)), Context(nullptr),
+ FS(VFS), LLVMIRGeneration("irgen", "LLVM IR Generation Time"),
+ LLVMIRGenerationRefCount(0),
+ Gen(CreateLLVMCodeGen(Diags, InFile, std::move(VFS), HeaderSearchOpts,
+ PPOpts, CodeGenOpts, DebugOpts, C, CoverageInfo)),
+ LinkModules(std::move(LinkModules)) {
+ TimerIsEnabled = CodeGenOpts.TimePasses;
+ llvm::TimePassesIsEnabled = CodeGenOpts.TimePasses;
+ llvm::TimePassesPerRun = CodeGenOpts.TimePassesPerRun;
}
// This constructor is used in installing an empty BackendConsumer
// to use the clang diagnostic handler for IR input files. It avoids
// initializing the OS field.
-BackendConsumer::BackendConsumer(BackendAction Action, DiagnosticsEngine &Diags,
- IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
- const HeaderSearchOptions &HeaderSearchOpts,
- const PreprocessorOptions &PPOpts,
- const CodeGenOptions &CodeGenOpts,
- const TargetOptions &TargetOpts,
- const LangOptions &LangOpts,
- llvm::Module *Module,
- SmallVector<LinkModule, 4> LinkModules,
- LLVMContext &C,
- CoverageSourceInfo *CoverageInfo)
- : Diags(Diags), Action(Action), HeaderSearchOpts(HeaderSearchOpts),
- CodeGenOpts(CodeGenOpts), TargetOpts(TargetOpts), LangOpts(LangOpts),
- Context(nullptr), FS(VFS),
- LLVMIRGeneration("irgen", "LLVM IR Generation Time"),
- LLVMIRGenerationRefCount(0),
- Gen(CreateLLVMCodeGen(Diags, "", std::move(VFS), HeaderSearchOpts,
- PPOpts, CodeGenOpts, C, CoverageInfo)),
- LinkModules(std::move(LinkModules)), CurLinkModule(Module) {
- TimerIsEnabled = CodeGenOpts.TimePasses;
- llvm::TimePassesIsEnabled = CodeGenOpts.TimePasses;
- llvm::TimePassesPerRun = CodeGenOpts.TimePassesPerRun;
+BackendConsumer::BackendConsumer(
+ BackendAction Action, DiagnosticsEngine &Diags,
+ IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
+ const HeaderSearchOptions &HeaderSearchOpts,
+ const PreprocessorOptions &PPOpts, const CodeGenOptions &CodeGenOpts,
+ const DebugOptions &DebugOpts, const TargetOptions &TargetOpts,
+ const LangOptions &LangOpts, llvm::Module *Module,
+ SmallVector<LinkModule, 4> LinkModules, LLVMContext &C,
+ CoverageSourceInfo *CoverageInfo)
+ : Diags(Diags), Action(Action), HeaderSearchOpts(HeaderSearchOpts),
+ CodeGenOpts(CodeGenOpts), DebugOpts(DebugOpts), TargetOpts(TargetOpts),
+ LangOpts(LangOpts), Context(nullptr), FS(VFS),
+ LLVMIRGeneration("irgen", "LLVM IR Generation Time"),
+ LLVMIRGenerationRefCount(0),
+ Gen(CreateLLVMCodeGen(Diags, "", std::move(VFS), HeaderSearchOpts, PPOpts,
+ CodeGenOpts, DebugOpts, C, CoverageInfo)),
+ LinkModules(std::move(LinkModules)), CurLinkModule(Module) {
+ TimerIsEnabled = CodeGenOpts.TimePasses;
+ llvm::TimePassesIsEnabled = CodeGenOpts.TimePasses;
+ llvm::TimePassesPerRun = CodeGenOpts.TimePassesPerRun;
}
llvm::Module* BackendConsumer::getModule() const {
@@ -376,9 +373,9 @@ void BackendConsumer::HandleTranslationUnit(ASTContext &C) {
EmbedBitcode(getModule(), CodeGenOpts, llvm::MemoryBufferRef());
- EmitBackendOutput(Diags, HeaderSearchOpts, CodeGenOpts, TargetOpts, LangOpts,
- C.getTargetInfo().getDataLayoutString(), getModule(),
- Action, FS, std::move(AsmOutStream), this);
+ EmitBackendOutput(Diags, HeaderSearchOpts, CodeGenOpts, DebugOpts, TargetOpts,
+ LangOpts, C.getTargetInfo().getDataLayoutString(),
+ getModule(), Action, FS, std::move(AsmOutStream), this);
Ctx.setDiagnosticHandler(std::move(OldDiagnosticHandler));
@@ -1037,14 +1034,15 @@ CodeGenAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
std::unique_ptr<BackendConsumer> Result(new BackendConsumer(
BA, CI.getDiagnostics(), &CI.getVirtualFileSystem(),
CI.getHeaderSearchOpts(), CI.getPreprocessorOpts(), CI.getCodeGenOpts(),
- CI.getTargetOpts(), CI.getLangOpts(), std::string(InFile),
- std::move(LinkModules), std::move(OS), *VMContext, CoverageInfo));
+ CI.getDebugOpts(), CI.getTargetOpts(), CI.getLangOpts(),
+ std::string(InFile), std::move(LinkModules), std::move(OS), *VMContext,
+ CoverageInfo));
BEConsumer = Result.get();
// Enable generating macro debug info only when debug info is not disabled and
// also macro debug info is enabled.
- if (CI.getCodeGenOpts().getDebugInfo() != codegenoptions::NoDebugInfo &&
- CI.getCodeGenOpts().MacroDebugInfo) {
+ if (CI.getDebugOpts().getDebugInfo() != debugoptions::NoDebugInfo &&
+ CI.getDebugOpts().MacroDebugInfo) {
std::unique_ptr<PPCallbacks> Callbacks =
std::make_unique<MacroPPCallbacks>(BEConsumer->getCodeGenerator(),
CI.getPreprocessor());
@@ -1159,6 +1157,7 @@ void CodeGenAction::ExecuteAction() {
BackendAction BA = static_cast<BackendAction>(Act);
CompilerInstance &CI = getCompilerInstance();
auto &CodeGenOpts = CI.getCodeGenOpts();
+ auto &DebugOpts = CI.getDebugOpts();
auto &Diagnostics = CI.getDiagnostics();
std::unique_ptr<raw_pwrite_stream> OS =
GetOutputStream(CI, getCurrentFileOrBufferName(), BA);
@@ -1199,8 +1198,8 @@ void CodeGenAction::ExecuteAction() {
// BackendConsumer.
BackendConsumer Result(BA, CI.getDiagnostics(), &CI.getVirtualFileSystem(),
CI.getHeaderSearchOpts(), CI.getPreprocessorOpts(),
- CI.getCodeGenOpts(), CI.getTargetOpts(),
- CI.getLangOpts(), TheModule.get(),
+ CI.getCodeGenOpts(), CI.getDebugOpts(),
+ CI.getTargetOpts(), CI.getLangOpts(), TheModule.get(),
std::move(LinkModules), *VMContext, nullptr);
// Link in each pending link module.
@@ -1227,7 +1226,7 @@ void CodeGenAction::ExecuteAction() {
std::move(*OptRecordFileOrErr);
EmitBackendOutput(
- Diagnostics, CI.getHeaderSearchOpts(), CodeGenOpts, TargetOpts,
+ Diagnostics, CI.getHeaderSearchOpts(), CodeGenOpts, DebugOpts, TargetOpts,
CI.getLangOpts(), CI.getTarget().getDataLayoutString(), TheModule.get(),
BA, CI.getFileManager().getVirtualFileSystemPtr(), std::move(OS));
if (OptRecordFile)
diff --git a/clang/lib/CodeGen/CodeGenFunction.cpp b/clang/lib/CodeGen/CodeGenFunction.cpp
index 2199d7b58fb96e..c30476c7cd59bd 100644
--- a/clang/lib/CodeGen/CodeGenFunction.cpp
+++ b/clang/lib/CodeGen/CodeGenFunction.cpp
@@ -31,6 +31,7 @@
#include "clang/AST/StmtObjC.h"
#include "clang/Basic/Builtins.h"
#include "clang/Basic/CodeGenOptions.h"
+#include "clang/Basic/DebugOptions.h"
#include "clang/Basic/TargetInfo.h"
#include "clang/CodeGen/CGFunctionInfo.h"
#include "clang/Frontend/FrontendDiagnostic.h"
@@ -921,7 +922,7 @@ void CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy,
Fn->addFnAttr("no-jump-tables", "true");
// Add no-inline-line-tables value.
- if (CGM.getCodeGenOpts().NoInlineLineTables)
+ if (CGM.getDebugOpts().NoInlineLineTables)
Fn->addFnAttr("no-inline-line-tables");
// Add profile-sample-accurate value.
@@ -2396,7 +2397,7 @@ void CodeGenFunction::EmitDeclRefExprDbgValue(const DeclRefExpr *E,
const APValue &Init) {
assert(Init.hasValue() && "Invalid DeclRefExpr initializer!");
if (CGDebugInfo *Dbg = getDebugInfo())
- if (CGM.getCodeGenOpts().hasReducedDebugInfo())
+ if (CGM.getDebugOpts().hasReducedDebugInfo())
Dbg->EmitGlobalVariable(E->getDecl(), Init);
}
diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp
index 7ad26ace328ab2..fc43abdb80f078 100644
--- a/clang/lib/CodeGen/CodeGenModule.cpp
+++ b/clang/lib/CodeGen/CodeGenModule.cpp
@@ -39,6 +39,7 @@
#include "clang/Basic/Builtins.h"
#include "clang/Basic/CharInfo.h"
#include "clang/Basic/CodeGenOptions.h"
+#include "clang/Basic/DebugOptions.h"
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/FileManager.h"
#include "clang/Basic/Module.h"
@@ -328,12 +329,12 @@ CodeGenModule::CodeGenModule(ASTContext &C,
IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS,
const HeaderSearchOptions &HSO,
const PreprocessorOptions &PPO,
- const CodeGenOptions &CGO, llvm::Module &M,
- DiagnosticsEngine &diags,
+ const CodeGenOptions &CGO, const DebugOptions &DO,
+ llvm::Module &M, DiagnosticsEngine &diags,
CoverageSourceInfo *CoverageInfo)
: Context(C), LangOpts(C.getLangOpts()), FS(FS), HeaderSearchOpts(HSO),
- PreprocessorOpts(PPO), CodeGenOpts(CGO), TheModule(M), Diags(diags),
- Target(C.getTargetInfo()), ABI(createCXXABI(*this)),
+ PreprocessorOpts(PPO), CodeGenOpts(CGO), DebugOpts(DO), TheModule(M),
+ Diags(diags), Target(C.getTargetInfo()), ABI(createCXXABI(*this)),
VMContext(M.getContext()), Types(*this), VTables(*this),
SanitizerMD(new SanitizerMetadata(*this)) {
@@ -399,7 +400,7 @@ CodeGenModule::CodeGenModule(ASTContext &C,
// If debug info or coverage generation is enabled, create the CGDebugInfo
// object.
- if (CodeGenOpts.getDebugInfo() != llvm::codegenoptions::NoDebugInfo ||
+ if (DebugOpts.getDebugInfo() != llvm::debugoptions::NoDebugInfo ||
CodeGenOpts.CoverageNotesFile.size() ||
CodeGenOpts.CoverageDataFile.size())
DebugInfo.reset(new CGDebugInfo(*this));
@@ -922,23 +923,23 @@ void CodeGenModule::Release() {
getModule().addModuleFlag(llvm::Module::Error, "NumRegisterParameters",
CodeGenOpts.NumRegisterParameters);
- if (CodeGenOpts.DwarfVersion) {
+ if (DebugOpts.DwarfVersion) {
getModule().addModuleFlag(llvm::Module::Max, "Dwarf Version",
- CodeGenOpts.DwarfVersion);
+ DebugOpts.DwarfVersion);
}
- if (CodeGenOpts.Dwarf64)
+ if (DebugOpts.Dwarf64)
getModule().addModuleFlag(llvm::Module::Max, "DWARF64", 1);
if (Context.getLangOpts().SemanticInterposition)
// Require various optimization to respect semantic interposition.
getModule().setSemanticInterposition(true);
- if (CodeGenOpts.EmitCodeView) {
+ if (DebugOpts.EmitCodeView) {
// Indicate that we want CodeView in the metadata.
getModule().addModuleFlag(llvm::Module::Warning, "CodeView", 1);
}
- if (CodeGenOpts.CodeViewGHash) {
+ if (DebugOpts.CodeViewGHash) {
getModule().addModuleFlag(llvm::Module::Warning, "CodeViewGHash", 1);
}
if (CodeGenOpts.ControlFlowGuard) {
@@ -5471,13 +5472,13 @@ void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D,
// Emit global variable debug information.
if (CGDebugInfo *DI = getModuleDebugInfo())
- if (getCodeGenOpts().hasReducedDebugInfo())
+ if (getDebugOpts().hasReducedDebugInfo())
DI->EmitGlobalVariable(GV, D);
}
void CodeGenModule::EmitExternalVarDeclaration(const VarDecl *D) {
if (CGDebugInfo *DI = getModuleDebugInfo())
- if (getCodeGenOpts().hasReducedDebugInfo()) {
+ if (getDebugOpts().hasReducedDebugInfo()) {
QualType ASTTy = D->getType();
llvm::Type *Ty = getTypes().ConvertTypeForMem(D->getType());
llvm::Constant *GV =
@@ -6199,7 +6200,7 @@ CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) {
}
bool CodeGenModule::getExpressionLocationsEnabled() const {
- return !CodeGenOpts.EmitCodeView || CodeGenOpts.DebugColumnInfo;
+ return !DebugOpts.EmitCodeView || DebugOpts.DebugColumnInfo;
}
QualType CodeGenModule::getObjCFastEnumerationStateType() {
@@ -6337,7 +6338,7 @@ CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S,
auto GV = GenerateStringLiteral(C, LT, *this, GlobalVariableName, Alignment);
CGDebugInfo *DI = getModuleDebugInfo();
- if (DI && getCodeGenOpts().hasReducedDebugInfo())
+ if (DI && getDebugOpts().hasReducedDebugInfo())
DI->AddStringLiteralDebugInfo(GV, S);
if (Entry)
@@ -6812,7 +6813,7 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) {
ObjCRuntime->GenerateClass(OMD);
// Emit global variable debug information.
if (CGDebugInfo *DI = getModuleDebugInfo())
- if (getCodeGenOpts().hasReducedDebugInfo())
+ if (getDebugOpts().hasReducedDebugInfo())
DI->getOrCreateInterfaceType(getContext().getObjCInterfaceType(
OMD->getClassInterface()), OMD->getLocation());
break;
diff --git a/clang/lib/CodeGen/CodeGenModule.h b/clang/lib/CodeGen/CodeGenModule.h
index ec34680fd3f7e6..f1ed2718f65e82 100644
--- a/clang/lib/CodeGen/CodeGenModule.h
+++ b/clang/lib/CodeGen/CodeGenModule.h
@@ -74,6 +74,7 @@ class ValueDecl;
class VarDecl;
class LangOptions;
class CodeGenOptions;
+class DebugOptions;
class HeaderSearchOptions;
class DiagnosticsEngine;
class AnnotateAttr;
@@ -305,6 +306,7 @@ class CodeGenModule : public CodeGenTypeCache {
const HeaderSearchOptions &HeaderSearchOpts; // Only used for debug info.
const PreprocessorOptions &PreprocessorOpts; // Only used for debug info.
const CodeGenOptions &CodeGenOpts;
+ const DebugOptions &DebugOpts;
unsigned NumAutoVarInit = 0;
llvm::Module &TheModule;
DiagnosticsEngine &Diags;
@@ -611,7 +613,8 @@ class CodeGenModule : public CodeGenTypeCache {
CodeGenModule(ASTContext &C, IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS,
const HeaderSearchOptions &headersearchopts,
const PreprocessorOptions &ppopts,
- const CodeGenOptions &CodeGenOpts, llvm::Module &M,
+ const CodeGenOptions &CodeGenOpts,
+ const DebugOptions &DebugOpts, llvm::Module &M,
DiagnosticsEngine &Diags,
CoverageSourceInfo *CoverageInfo = nullptr);
@@ -746,6 +749,7 @@ class CodeGenModule : public CodeGenTypeCache {
const PreprocessorOptions &getPreprocessorOpts()
const { return PreprocessorOpts; }
const CodeGenOptions &getCodeGenOpts() const { return CodeGenOpts; }
+ const DebugOptions &getDebugOpts() const { return DebugOpts; }
llvm::Module &getModule() const { return TheModule; }
DiagnosticsEngine &getDiags() const { return Diags; }
const llvm::DataLayout &getDataLayout() const {
diff --git a/clang/lib/CodeGen/ModuleBuilder.cpp b/clang/lib/CodeGen/ModuleBuilder.cpp
index 3594f4c66e6774..898949e73fc234 100644
--- a/clang/lib/CodeGen/ModuleBuilder.cpp
+++ b/clang/lib/CodeGen/ModuleBuilder.cpp
@@ -37,6 +37,7 @@ namespace {
const HeaderSearchOptions &HeaderSearchOpts; // Only used for debug info.
const PreprocessorOptions &PreprocessorOpts; // Only used for debug info.
const CodeGenOptions &CodeGenOpts;
+ const DebugOptions &DebugOpts;
unsigned HandlingTopLevelDecls;
@@ -79,11 +80,11 @@ namespace {
IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS,
const HeaderSearchOptions &HSO,
const PreprocessorOptions &PPO, const CodeGenOptions &CGO,
- llvm::LLVMContext &C,
+ const DebugOptions &DO, llvm::LLVMContext &C,
CoverageSourceInfo *CoverageInfo = nullptr)
: Diags(diags), Ctx(nullptr), FS(std::move(FS)), HeaderSearchOpts(HSO),
- PreprocessorOpts(PPO), CodeGenOpts(CGO), HandlingTopLevelDecls(0),
- CoverageInfo(CoverageInfo),
+ PreprocessorOpts(PPO), CodeGenOpts(CGO), DebugOpts(DO),
+ HandlingTopLevelDecls(0), CoverageInfo(CoverageInfo),
M(new llvm::Module(ExpandModuleName(ModuleName, CGO), C)) {
C.setDiscardValueNames(CGO.DiscardValueNames);
}
@@ -161,9 +162,9 @@ namespace {
if (auto TVSDKVersion =
Ctx->getTargetInfo().getDarwinTargetVariantSDKVersion())
M->setDarwinTargetVariantSDKVersion(*TVSDKVersion);
- Builder.reset(new CodeGen::CodeGenModule(Context, FS, HeaderSearchOpts,
- PreprocessorOpts, CodeGenOpts,
- *M, Diags, CoverageInfo));
+ Builder.reset(new CodeGen::CodeGenModule(
+ Context, FS, HeaderSearchOpts, PreprocessorOpts, CodeGenOpts,
+ DebugOpts, *M, Diags, CoverageInfo));
for (auto &&Lib : CodeGenOpts.DependentLibraries)
Builder->AddDependentLib(Lib);
@@ -365,9 +366,10 @@ clang::CreateLLVMCodeGen(DiagnosticsEngine &Diags, llvm::StringRef ModuleName,
IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS,
const HeaderSearchOptions &HeaderSearchOpts,
const PreprocessorOptions &PreprocessorOpts,
- const CodeGenOptions &CGO, llvm::LLVMContext &C,
+ const CodeGenOptions &CGO, const DebugOptions &DO,
+ llvm::LLVMContext &C,
CoverageSourceInfo *CoverageInfo) {
return new CodeGeneratorImpl(Diags, ModuleName, std::move(FS),
- HeaderSearchOpts, PreprocessorOpts, CGO, C,
+ HeaderSearchOpts, PreprocessorOpts, CGO, DO, C,
CoverageInfo);
}
diff --git a/clang/lib/CodeGen/ObjectFilePCHContainerOperations.cpp b/clang/lib/CodeGen/ObjectFilePCHContainerOperations.cpp
index ee543e40b46099..cee48f71f1af02 100644
--- a/clang/lib/CodeGen/ObjectFilePCHContainerOperations.cpp
+++ b/clang/lib/CodeGen/ObjectFilePCHContainerOperations.cpp
@@ -49,6 +49,7 @@ class PCHContainerGenerator : public ASTConsumer {
const HeaderSearchOptions &HeaderSearchOpts;
const PreprocessorOptions &PreprocessorOpts;
CodeGenOptions CodeGenOpts;
+ DebugOptions DebugOpts;
const TargetOptions TargetOpts;
LangOptions LangOpts;
std::unique_ptr<llvm::LLVMContext> VMContext;
@@ -154,18 +155,17 @@ class PCHContainerGenerator : public ASTConsumer {
// ThreadModel, but the backend expects them to be nonempty.
CodeGenOpts.CodeModel = "default";
LangOpts.setThreadModel(LangOptions::ThreadModelKind::Single);
- CodeGenOpts.DebugTypeExtRefs = true;
+ DebugOpts.DebugTypeExtRefs = true;
// When building a module MainFileName is the name of the modulemap file.
CodeGenOpts.MainFileName =
LangOpts.CurrentModule.empty() ? MainFileName : LangOpts.CurrentModule;
- CodeGenOpts.setDebugInfo(llvm::codegenoptions::FullDebugInfo);
- CodeGenOpts.setDebuggerTuning(CI.getCodeGenOpts().getDebuggerTuning());
- CodeGenOpts.DwarfVersion = CI.getCodeGenOpts().DwarfVersion;
- CodeGenOpts.DebugCompilationDir =
- CI.getInvocation().getCodeGenOpts().DebugCompilationDir;
- CodeGenOpts.DebugPrefixMap =
- CI.getInvocation().getCodeGenOpts().DebugPrefixMap;
- CodeGenOpts.DebugStrictDwarf = CI.getCodeGenOpts().DebugStrictDwarf;
+ DebugOpts.setDebugInfo(llvm::debugoptions::FullDebugInfo);
+ DebugOpts.setDebuggerTuning(CI.getDebugOpts().getDebuggerTuning());
+ DebugOpts.DwarfVersion = CI.getDebugOpts().DwarfVersion;
+ DebugOpts.DebugCompilationDir =
+ CI.getInvocation().getDebugOpts().DebugCompilationDir;
+ DebugOpts.DebugPrefixMap = CI.getInvocation().getDebugOpts().DebugPrefixMap;
+ DebugOpts.DebugStrictDwarf = CI.getDebugOpts().DebugStrictDwarf;
}
~PCHContainerGenerator() override = default;
@@ -177,8 +177,9 @@ class PCHContainerGenerator : public ASTConsumer {
VMContext.reset(new llvm::LLVMContext());
M.reset(new llvm::Module(MainFileName, *VMContext));
M->setDataLayout(Ctx->getTargetInfo().getDataLayoutString());
- Builder.reset(new CodeGen::CodeGenModule(
- *Ctx, FS, HeaderSearchOpts, PreprocessorOpts, CodeGenOpts, *M, Diags));
+ Builder.reset(new CodeGen::CodeGenModule(*Ctx, FS, HeaderSearchOpts,
+ PreprocessorOpts, CodeGenOpts,
+ DebugOpts, *M, Diags));
// Prepare CGDebugInfo to emit debug info for a clang module.
auto *DI = Builder->getModuleDebugInfo();
@@ -321,7 +322,7 @@ class PCHContainerGenerator : public ASTConsumer {
// Print the IR for the PCH container to the debug output.
llvm::SmallString<0> Buffer;
clang::EmitBackendOutput(
- Diags, HeaderSearchOpts, CodeGenOpts, TargetOpts, LangOpts,
+ Diags, HeaderSearchOpts, CodeGenOpts, DebugOpts, TargetOpts, LangOpts,
Ctx.getTargetInfo().getDataLayoutString(), M.get(),
BackendAction::Backend_EmitLL, FS,
std::make_unique<llvm::raw_svector_ostream>(Buffer));
@@ -329,8 +330,8 @@ class PCHContainerGenerator : public ASTConsumer {
});
// Use the LLVM backend to emit the pch container.
- clang::EmitBackendOutput(Diags, HeaderSearchOpts, CodeGenOpts, TargetOpts,
- LangOpts,
+ clang::EmitBackendOutput(Diags, HeaderSearchOpts, CodeGenOpts, DebugOpts,
+ TargetOpts, LangOpts,
Ctx.getTargetInfo().getDataLayoutString(), M.get(),
BackendAction::Backend_EmitObj, FS, std::move(OS));
diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp
index de9fd5eaa1e020..3d38d0c8418f6d 100644
--- a/clang/lib/Driver/ToolChains/Clang.cpp
+++ b/clang/lib/Driver/ToolChains/Clang.cpp
@@ -847,7 +847,7 @@ static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
static void
RenderDebugEnablingArgs(const ArgList &Args, ArgStringList &CmdArgs,
- llvm::codegenoptions::DebugInfoKind DebugInfoKind,
+ llvm::debugoptions::DebugInfoKind DebugInfoKind,
unsigned DwarfVersion,
llvm::DebuggerKind DebuggerTuning) {
addDebugInfoKind(CmdArgs, DebugInfoKind);
@@ -2594,7 +2594,7 @@ static void CollectArgsForIntegratedAssembler(Compilation &C,
CmdArgs.push_back(Value.data());
} else {
RenderDebugEnablingArgs(Args, CmdArgs,
- llvm::codegenoptions::DebugInfoConstructor,
+ llvm::debugoptions::DebugInfoConstructor,
DwarfVersion, llvm::DebuggerKind::Default);
}
} else if (Value.starts_with("-mcpu") || Value.starts_with("-mfpu") ||
@@ -4178,12 +4178,12 @@ static void renderDwarfFormat(const Driver &D, const llvm::Triple &T,
DwarfFormatArg->render(Args, CmdArgs);
}
-static void
-renderDebugOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T,
- const ArgList &Args, bool IRInput, ArgStringList &CmdArgs,
- const InputInfo &Output,
- llvm::codegenoptions::DebugInfoKind &DebugInfoKind,
- DwarfFissionKind &DwarfFission) {
+static void renderDebugOptions(const ToolChain &TC, const Driver &D,
+ const llvm::Triple &T, const ArgList &Args,
+ bool IRInput, ArgStringList &CmdArgs,
+ const InputInfo &Output,
+ llvm::debugoptions::DebugInfoKind &DebugInfoKind,
+ DwarfFissionKind &DwarfFission) {
if (Args.hasFlag(options::OPT_fdebug_info_for_profiling,
options::OPT_fno_debug_info_for_profiling, false) &&
checkDebugInfoOption(
@@ -4218,7 +4218,7 @@ renderDebugOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T,
}
}
if (const Arg *A = Args.getLastArg(options::OPT_g_Group)) {
- DebugInfoKind = llvm::codegenoptions::DebugInfoConstructor;
+ DebugInfoKind = llvm::debugoptions::DebugInfoConstructor;
// If the last option explicitly specified a debug-info level, use it.
if (checkDebugInfoOption(A, Args, D, TC) &&
@@ -4228,9 +4228,9 @@ renderDebugOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T,
// complicated if you've disabled inline info in the skeleton CUs
// (SplitDWARFInlining) - then there's value in composing split-dwarf and
// line-tables-only, so let those compose naturally in that case.
- if (DebugInfoKind == llvm::codegenoptions::NoDebugInfo ||
- DebugInfoKind == llvm::codegenoptions::DebugDirectivesOnly ||
- (DebugInfoKind == llvm::codegenoptions::DebugLineTablesOnly &&
+ if (DebugInfoKind == llvm::debugoptions::NoDebugInfo ||
+ DebugInfoKind == llvm::debugoptions::DebugDirectivesOnly ||
+ (DebugInfoKind == llvm::debugoptions::DebugLineTablesOnly &&
SplitDWARFInlining))
DwarfFission = DwarfFissionKind::None;
}
@@ -4265,12 +4265,12 @@ renderDebugOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T,
// If the user asked for debug info but did not explicitly specify -gcodeview
// or -gdwarf, ask the toolchain for the default format.
if (!EmitCodeView && !EmitDwarf &&
- DebugInfoKind != llvm::codegenoptions::NoDebugInfo) {
+ DebugInfoKind != llvm::debugoptions::NoDebugInfo) {
switch (TC.getDefaultDebugFormat()) {
- case llvm::codegenoptions::DIF_CodeView:
+ case llvm::debugoptions::DIF_CodeView:
EmitCodeView = true;
break;
- case llvm::codegenoptions::DIF_DWARF:
+ case llvm::debugoptions::DIF_DWARF:
EmitDwarf = true;
break;
}
@@ -4290,8 +4290,8 @@ renderDebugOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T,
// -gline-directives-only supported only for the DWARF debug info.
if (RequestedDWARFVersion == 0 &&
- DebugInfoKind == llvm::codegenoptions::DebugDirectivesOnly)
- DebugInfoKind = llvm::codegenoptions::NoDebugInfo;
+ DebugInfoKind == llvm::debugoptions::DebugDirectivesOnly)
+ DebugInfoKind = llvm::debugoptions::NoDebugInfo;
// strict DWARF is set to false by default. But for DBX, we need it to be set
// as true by default.
@@ -4324,9 +4324,9 @@ renderDebugOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T,
// wins.
if (checkDebugInfoOption(Args.getLastArg(options::OPT_gmodules), Args, D,
TC)) {
- if (DebugInfoKind != llvm::codegenoptions::DebugLineTablesOnly &&
- DebugInfoKind != llvm::codegenoptions::DebugDirectivesOnly) {
- DebugInfoKind = llvm::codegenoptions::DebugInfoConstructor;
+ if (DebugInfoKind != llvm::debugoptions::DebugLineTablesOnly &&
+ DebugInfoKind != llvm::debugoptions::DebugDirectivesOnly) {
+ DebugInfoKind = llvm::debugoptions::DebugInfoConstructor;
CmdArgs.push_back("-dwarf-ext-refs");
CmdArgs.push_back("-fmodule-format=obj");
}
@@ -4348,13 +4348,13 @@ renderDebugOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T,
if (const Arg *A = Args.getLastArg(options::OPT_fstandalone_debug))
(void)checkDebugInfoOption(A, Args, D, TC);
- if (DebugInfoKind == llvm::codegenoptions::LimitedDebugInfo ||
- DebugInfoKind == llvm::codegenoptions::DebugInfoConstructor) {
+ if (DebugInfoKind == llvm::debugoptions::LimitedDebugInfo ||
+ DebugInfoKind == llvm::debugoptions::DebugInfoConstructor) {
if (Args.hasFlag(options::OPT_fno_eliminate_unused_debug_types,
options::OPT_feliminate_unused_debug_types, false))
- DebugInfoKind = llvm::codegenoptions::UnusedTypeInfo;
+ DebugInfoKind = llvm::debugoptions::UnusedTypeInfo;
else if (NeedFullDebug)
- DebugInfoKind = llvm::codegenoptions::FullDebugInfo;
+ DebugInfoKind = llvm::debugoptions::FullDebugInfo;
}
if (Args.hasFlag(options::OPT_gembed_source, options::OPT_gno_embed_source,
@@ -4392,8 +4392,8 @@ renderDebugOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T,
// When emitting remarks, we need at least debug lines in the output.
if (willEmitRemarks(Args) &&
- DebugInfoKind <= llvm::codegenoptions::DebugDirectivesOnly)
- DebugInfoKind = llvm::codegenoptions::DebugLineTablesOnly;
+ DebugInfoKind <= llvm::debugoptions::DebugDirectivesOnly)
+ DebugInfoKind = llvm::debugoptions::DebugLineTablesOnly;
// Adjust the debug info kind for the given toolchain.
TC.adjustDebugInfoKind(DebugInfoKind, Args);
@@ -4499,7 +4499,7 @@ renderDebugOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T,
// This controls whether or not we perform JustMyCode instrumentation.
if (Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc, false)) {
if (TC.getTriple().isOSBinFormatELF() || D.IsCLMode()) {
- if (DebugInfoKind >= llvm::codegenoptions::DebugInfoConstructor)
+ if (DebugInfoKind >= llvm::debugoptions::DebugInfoConstructor)
CmdArgs.push_back("-fjmc");
else if (D.IsCLMode())
D.Diag(clang::diag::warn_drv_jmc_requires_debuginfo) << "/JMC"
@@ -5779,8 +5779,8 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
if (D.IsCLMode())
AddClangCLArgs(Args, InputType, CmdArgs);
- llvm::codegenoptions::DebugInfoKind DebugInfoKind =
- llvm::codegenoptions::NoDebugInfo;
+ llvm::debugoptions::DebugInfoKind DebugInfoKind =
+ llvm::debugoptions::NoDebugInfo;
DwarfFissionKind DwarfFission = DwarfFissionKind::None;
renderDebugOptions(TC, D, RawTriple, Args, types::isLLVMIR(InputType),
CmdArgs, Output, DebugInfoKind, DwarfFission);
@@ -7610,7 +7610,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
if ((Triple.isOSBinFormatELF() || Triple.isOSBinFormatMachO()) &&
(EH || UnwindTables || AsyncUnwindTables ||
- DebugInfoKind != llvm::codegenoptions::NoDebugInfo))
+ DebugInfoKind != llvm::debugoptions::NoDebugInfo))
CmdArgs.push_back("-D__GCC_HAVE_DWARF2_CFI_ASM=1");
if (Arg *A = Args.getLastArg(options::OPT_fsymbol_partition_EQ)) {
@@ -8240,8 +8240,8 @@ void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
WantDebug = !A->getOption().matches(options::OPT_g0) &&
!A->getOption().matches(options::OPT_ggdb0);
- llvm::codegenoptions::DebugInfoKind DebugInfoKind =
- llvm::codegenoptions::NoDebugInfo;
+ llvm::debugoptions::DebugInfoKind DebugInfoKind =
+ llvm::debugoptions::NoDebugInfo;
// Add the -fdebug-compilation-dir flag if needed.
const char *DebugCompilationDir =
@@ -8253,8 +8253,8 @@ void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
// the guard for source type, however there is a test which asserts
// that some assembler invocation receives no -debug-info-kind,
// and it's not clear whether that test is just overly restrictive.
- DebugInfoKind = (WantDebug ? llvm::codegenoptions::DebugInfoConstructor
- : llvm::codegenoptions::NoDebugInfo);
+ DebugInfoKind = (WantDebug ? llvm::debugoptions::DebugInfoConstructor
+ : llvm::debugoptions::NoDebugInfo);
addDebugPrefixMapArg(getToolChain().getDriver(), getToolChain(), Args,
CmdArgs);
@@ -8371,7 +8371,7 @@ void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
- if (DebugInfoKind > llvm::codegenoptions::NoDebugInfo && Output.isFilename())
+ if (DebugInfoKind > llvm::debugoptions::NoDebugInfo && Output.isFilename())
addDebugObjectName(Args, CmdArgs, DebugCompilationDir,
Output.getFilename());
diff --git a/clang/lib/Driver/ToolChains/CommonArgs.cpp b/clang/lib/Driver/ToolChains/CommonArgs.cpp
index 01fb0718b4079d..6b6cc62356272c 100644
--- a/clang/lib/Driver/ToolChains/CommonArgs.cpp
+++ b/clang/lib/Driver/ToolChains/CommonArgs.cpp
@@ -1896,25 +1896,25 @@ unsigned tools::ParseFunctionAlignment(const ToolChain &TC,
return Value ? llvm::Log2_32_Ceil(std::min(Value, 65536u)) : Value;
}
-void tools::addDebugInfoKind(
- ArgStringList &CmdArgs, llvm::codegenoptions::DebugInfoKind DebugInfoKind) {
+void tools::addDebugInfoKind(ArgStringList &CmdArgs,
+ llvm::debugoptions::DebugInfoKind DebugInfoKind) {
switch (DebugInfoKind) {
- case llvm::codegenoptions::DebugDirectivesOnly:
+ case llvm::debugoptions::DebugDirectivesOnly:
CmdArgs.push_back("-debug-info-kind=line-directives-only");
break;
- case llvm::codegenoptions::DebugLineTablesOnly:
+ case llvm::debugoptions::DebugLineTablesOnly:
CmdArgs.push_back("-debug-info-kind=line-tables-only");
break;
- case llvm::codegenoptions::DebugInfoConstructor:
+ case llvm::debugoptions::DebugInfoConstructor:
CmdArgs.push_back("-debug-info-kind=constructor");
break;
- case llvm::codegenoptions::LimitedDebugInfo:
+ case llvm::debugoptions::LimitedDebugInfo:
CmdArgs.push_back("-debug-info-kind=limited");
break;
- case llvm::codegenoptions::FullDebugInfo:
+ case llvm::debugoptions::FullDebugInfo:
CmdArgs.push_back("-debug-info-kind=standalone");
break;
- case llvm::codegenoptions::UnusedTypeInfo:
+ case llvm::debugoptions::UnusedTypeInfo:
CmdArgs.push_back("-debug-info-kind=unused-types");
break;
default:
@@ -1924,18 +1924,18 @@ void tools::addDebugInfoKind(
// Convert an arg of the form "-gN" or "-ggdbN" or one of their aliases
// to the corresponding DebugInfoKind.
-llvm::codegenoptions::DebugInfoKind tools::debugLevelToInfoKind(const Arg &A) {
+llvm::debugoptions::DebugInfoKind tools::debugLevelToInfoKind(const Arg &A) {
assert(A.getOption().matches(options::OPT_gN_Group) &&
"Not a -g option that specifies a debug-info level");
if (A.getOption().matches(options::OPT_g0) ||
A.getOption().matches(options::OPT_ggdb0))
- return llvm::codegenoptions::NoDebugInfo;
+ return llvm::debugoptions::NoDebugInfo;
if (A.getOption().matches(options::OPT_gline_tables_only) ||
A.getOption().matches(options::OPT_ggdb1))
- return llvm::codegenoptions::DebugLineTablesOnly;
+ return llvm::debugoptions::DebugLineTablesOnly;
if (A.getOption().matches(options::OPT_gline_directives_only))
- return llvm::codegenoptions::DebugDirectivesOnly;
- return llvm::codegenoptions::DebugInfoConstructor;
+ return llvm::debugoptions::DebugDirectivesOnly;
+ return llvm::debugoptions::DebugInfoConstructor;
}
static unsigned ParseDebugDefaultVersion(const ToolChain &TC,
diff --git a/clang/lib/Driver/ToolChains/CommonArgs.h b/clang/lib/Driver/ToolChains/CommonArgs.h
index 25d68345a9f9eb..d5aa31a3427f41 100644
--- a/clang/lib/Driver/ToolChains/CommonArgs.h
+++ b/clang/lib/Driver/ToolChains/CommonArgs.h
@@ -87,10 +87,9 @@ unsigned ParseFunctionAlignment(const ToolChain &TC,
const llvm::opt::ArgList &Args);
void addDebugInfoKind(llvm::opt::ArgStringList &CmdArgs,
- llvm::codegenoptions::DebugInfoKind DebugInfoKind);
+ llvm::debugoptions::DebugInfoKind DebugInfoKind);
-llvm::codegenoptions::DebugInfoKind
-debugLevelToInfoKind(const llvm::opt::Arg &A);
+llvm::debugoptions::DebugInfoKind debugLevelToInfoKind(const llvm::opt::Arg &A);
// Extract the integer N from a string spelled "-dwarf-N", returning 0
// on mismatch. The StringRef input (rather than an Arg) allows
diff --git a/clang/lib/Driver/ToolChains/Cuda.cpp b/clang/lib/Driver/ToolChains/Cuda.cpp
index f7a208575cb0cf..053d7facc84397 100644
--- a/clang/lib/Driver/ToolChains/Cuda.cpp
+++ b/clang/lib/Driver/ToolChains/Cuda.cpp
@@ -768,14 +768,14 @@ bool NVPTXToolChain::supportsDebugInfoOption(const llvm::opt::Arg *A) const {
}
void NVPTXToolChain::adjustDebugInfoKind(
- llvm::codegenoptions::DebugInfoKind &DebugInfoKind,
+ llvm::debugoptions::DebugInfoKind &DebugInfoKind,
const ArgList &Args) const {
switch (mustEmitDebugInfo(Args)) {
case DisableDebugInfo:
- DebugInfoKind = llvm::codegenoptions::NoDebugInfo;
+ DebugInfoKind = llvm::debugoptions::NoDebugInfo;
break;
case DebugDirectivesOnly:
- DebugInfoKind = llvm::codegenoptions::DebugDirectivesOnly;
+ DebugInfoKind = llvm::debugoptions::DebugDirectivesOnly;
break;
case EmitSameDebugInfoAsHost:
// Use same debug info level as the host.
diff --git a/clang/lib/Driver/ToolChains/Cuda.h b/clang/lib/Driver/ToolChains/Cuda.h
index 8a053f3393e120..d49438d9d0325e 100644
--- a/clang/lib/Driver/ToolChains/Cuda.h
+++ b/clang/lib/Driver/ToolChains/Cuda.h
@@ -161,7 +161,7 @@ class LLVM_LIBRARY_VISIBILITY NVPTXToolChain : public ToolChain {
bool IsMathErrnoDefault() const override { return false; }
bool supportsDebugInfoOption(const llvm::opt::Arg *A) const override;
- void adjustDebugInfoKind(llvm::codegenoptions::DebugInfoKind &DebugInfoKind,
+ void adjustDebugInfoKind(llvm::debugoptions::DebugInfoKind &DebugInfoKind,
const llvm::opt::ArgList &Args) const override;
// NVPTX supports only DWARF2.
diff --git a/clang/lib/Driver/ToolChains/Flang.cpp b/clang/lib/Driver/ToolChains/Flang.cpp
index 41eaad3bbad0a3..7d5c944dadf2f3 100644
--- a/clang/lib/Driver/ToolChains/Flang.cpp
+++ b/clang/lib/Driver/ToolChains/Flang.cpp
@@ -119,14 +119,14 @@ void Flang::addOtherOptions(const ArgList &Args, ArgStringList &CmdArgs) const {
options::OPT_fconvert_EQ, options::OPT_fpass_plugin_EQ,
options::OPT_funderscoring, options::OPT_fno_underscoring});
- llvm::codegenoptions::DebugInfoKind DebugInfoKind;
+ llvm::debugoptions::DebugInfoKind DebugInfoKind;
if (Args.hasArg(options::OPT_gN_Group)) {
Arg *gNArg = Args.getLastArg(options::OPT_gN_Group);
DebugInfoKind = debugLevelToInfoKind(*gNArg);
} else if (Args.hasArg(options::OPT_g_Flag)) {
- DebugInfoKind = llvm::codegenoptions::DebugLineTablesOnly;
+ DebugInfoKind = llvm::debugoptions::DebugLineTablesOnly;
} else {
- DebugInfoKind = llvm::codegenoptions::NoDebugInfo;
+ DebugInfoKind = llvm::debugoptions::NoDebugInfo;
}
addDebugInfoKind(CmdArgs, DebugInfoKind);
}
diff --git a/clang/lib/Driver/ToolChains/HIPSPV.cpp b/clang/lib/Driver/ToolChains/HIPSPV.cpp
index a144b28057f4c2..8c31475b24e484 100644
--- a/clang/lib/Driver/ToolChains/HIPSPV.cpp
+++ b/clang/lib/Driver/ToolChains/HIPSPV.cpp
@@ -279,10 +279,10 @@ VersionTuple HIPSPVToolChain::computeMSVCVersion(const Driver *D,
}
void HIPSPVToolChain::adjustDebugInfoKind(
- llvm::codegenoptions::DebugInfoKind &DebugInfoKind,
+ llvm::debugoptions::DebugInfoKind &DebugInfoKind,
const llvm::opt::ArgList &Args) const {
// Debug info generation is disabled for SPIRV-LLVM-Translator
// which currently aborts on the presence of DW_OP_LLVM_convert.
// TODO: Enable debug info when the SPIR-V backend arrives.
- DebugInfoKind = llvm::codegenoptions::NoDebugInfo;
+ DebugInfoKind = llvm::debugoptions::NoDebugInfo;
}
diff --git a/clang/lib/Driver/ToolChains/HIPSPV.h b/clang/lib/Driver/ToolChains/HIPSPV.h
index ecd82e7052e48a..781c96ccbf602c 100644
--- a/clang/lib/Driver/ToolChains/HIPSPV.h
+++ b/clang/lib/Driver/ToolChains/HIPSPV.h
@@ -77,7 +77,7 @@ class LLVM_LIBRARY_VISIBILITY HIPSPVToolChain final : public ToolChain {
computeMSVCVersion(const Driver *D,
const llvm::opt::ArgList &Args) const override;
- void adjustDebugInfoKind(llvm::codegenoptions::DebugInfoKind &DebugInfoKind,
+ void adjustDebugInfoKind(llvm::debugoptions::DebugInfoKind &DebugInfoKind,
const llvm::opt::ArgList &Args) const override;
bool IsMathErrnoDefault() const override { return false; }
bool useIntegratedAs() const override { return true; }
diff --git a/clang/lib/Driver/ToolChains/MSVC.h b/clang/lib/Driver/ToolChains/MSVC.h
index fb27c621f2d1fe..11fc59a57029b0 100644
--- a/clang/lib/Driver/ToolChains/MSVC.h
+++ b/clang/lib/Driver/ToolChains/MSVC.h
@@ -59,10 +59,9 @@ class LLVM_LIBRARY_VISIBILITY MSVCToolChain : public ToolChain {
/// Set CodeView as the default debug info format for non-MachO binary
/// formats, and to DWARF otherwise. Users can use -gcodeview and -gdwarf to
/// override the default.
- llvm::codegenoptions::DebugInfoFormat getDefaultDebugFormat() const override {
- return getTriple().isOSBinFormatMachO()
- ? llvm::codegenoptions::DIF_DWARF
- : llvm::codegenoptions::DIF_CodeView;
+ llvm::debugoptions::DebugInfoFormat getDefaultDebugFormat() const override {
+ return getTriple().isOSBinFormatMachO() ? llvm::debugoptions::DIF_DWARF
+ : llvm::debugoptions::DIF_CodeView;
}
/// Set the debugger tuning to "default", since we're definitely not tuning
diff --git a/clang/lib/Frontend/CompilerInstance.cpp b/clang/lib/Frontend/CompilerInstance.cpp
index 56bbef9697b650..cd8df3c1f373ac 100644
--- a/clang/lib/Frontend/CompilerInstance.cpp
+++ b/clang/lib/Frontend/CompilerInstance.cpp
@@ -281,7 +281,7 @@ static void collectVFSEntries(CompilerInstance &CI,
// Diagnostics
static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts,
- const CodeGenOptions *CodeGenOpts,
+ const DebugOptions *DebugOpts,
DiagnosticsEngine &Diags) {
std::error_code EC;
std::unique_ptr<raw_ostream> StreamOwner;
@@ -304,8 +304,8 @@ static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts,
// Chain in the diagnostic client which will log the diagnostics.
auto Logger = std::make_unique<LogDiagnosticPrinter>(*OS, DiagOpts,
std::move(StreamOwner));
- if (CodeGenOpts)
- Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags);
+ if (DebugOpts)
+ Logger->setDwarfDebugFlags(DebugOpts->DwarfDebugFlags);
if (Diags.ownsClient()) {
Diags.setClient(
new ChainedDiagnosticConsumer(Diags.takeClient(), std::move(Logger)));
@@ -332,15 +332,13 @@ static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts,
void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client,
bool ShouldOwnClient) {
- Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client,
- ShouldOwnClient, &getCodeGenOpts());
+ Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client, ShouldOwnClient,
+ &getDebugOpts());
}
-IntrusiveRefCntPtr<DiagnosticsEngine>
-CompilerInstance::createDiagnostics(DiagnosticOptions *Opts,
- DiagnosticConsumer *Client,
- bool ShouldOwnClient,
- const CodeGenOptions *CodeGenOpts) {
+IntrusiveRefCntPtr<DiagnosticsEngine> CompilerInstance::createDiagnostics(
+ DiagnosticOptions *Opts, DiagnosticConsumer *Client, bool ShouldOwnClient,
+ const DebugOptions *DebugOpts) {
IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
IntrusiveRefCntPtr<DiagnosticsEngine>
Diags(new DiagnosticsEngine(DiagID, Opts));
@@ -360,7 +358,7 @@ CompilerInstance::createDiagnostics(DiagnosticOptions *Opts,
// Chain in -diagnostic-log-file dumper, if requested.
if (!Opts->DiagnosticLogFile.empty())
- SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags);
+ SetUpDiagnosticLog(Opts, DebugOpts, *Diags);
if (!Opts->DiagnosticSerializationFile.empty())
SetupSerializedDiagnostics(Opts, *Diags,
diff --git a/clang/lib/Frontend/CompilerInvocation.cpp b/clang/lib/Frontend/CompilerInvocation.cpp
index 11f3f2c2d6425c..d8c297ff268bf0 100644
--- a/clang/lib/Frontend/CompilerInvocation.cpp
+++ b/clang/lib/Frontend/CompilerInvocation.cpp
@@ -146,6 +146,7 @@ CompilerInvocationBase::CompilerInvocationBase()
MigratorOpts(std::make_shared<MigratorOptions>()),
APINotesOpts(std::make_shared<APINotesOptions>()),
CodeGenOpts(std::make_shared<CodeGenOptions>()),
+ DebugOpts(std::make_shared<DebugOptions>()),
FSOpts(std::make_shared<FileSystemOptions>()),
FrontendOpts(std::make_shared<FrontendOptions>()),
DependencyOutputOpts(std::make_shared<DependencyOutputOptions>()),
@@ -163,6 +164,7 @@ CompilerInvocationBase::deep_copy_assign(const CompilerInvocationBase &X) {
MigratorOpts = make_shared_copy(X.getMigratorOpts());
APINotesOpts = make_shared_copy(X.getAPINotesOpts());
CodeGenOpts = make_shared_copy(X.getCodeGenOpts());
+ DebugOpts = make_shared_copy(X.getDebugOpts());
FSOpts = make_shared_copy(X.getFileSystemOpts());
FrontendOpts = make_shared_copy(X.getFrontendOpts());
DependencyOutputOpts = make_shared_copy(X.getDependencyOutputOpts());
@@ -183,6 +185,7 @@ CompilerInvocationBase::shallow_copy_assign(const CompilerInvocationBase &X) {
MigratorOpts = X.MigratorOpts;
APINotesOpts = X.APINotesOpts;
CodeGenOpts = X.CodeGenOpts;
+ DebugOpts = X.DebugOpts;
FSOpts = X.FSOpts;
FrontendOpts = X.FrontendOpts;
DependencyOutputOpts = X.DependencyOutputOpts;
@@ -243,6 +246,10 @@ CodeGenOptions &CowCompilerInvocation::getMutCodeGenOpts() {
return ensureOwned(CodeGenOpts);
}
+DebugOptions &CowCompilerInvocation::getMutDebugOpts() {
+ return ensureOwned(DebugOpts);
+}
+
FileSystemOptions &CowCompilerInvocation::getMutFileSystemOpts() {
return ensureOwned(FSOpts);
}
@@ -1478,40 +1485,6 @@ void CompilerInvocationBase::GenerateCodeGenArgs(const CodeGenOptions &Opts,
else if (!Opts.DirectAccessExternalData && LangOpts->PICLevel == 0)
GenerateArg(Consumer, OPT_fno_direct_access_external_data);
- std::optional<StringRef> DebugInfoVal;
- switch (Opts.DebugInfo) {
- case llvm::codegenoptions::DebugLineTablesOnly:
- DebugInfoVal = "line-tables-only";
- break;
- case llvm::codegenoptions::DebugDirectivesOnly:
- DebugInfoVal = "line-directives-only";
- break;
- case llvm::codegenoptions::DebugInfoConstructor:
- DebugInfoVal = "constructor";
- break;
- case llvm::codegenoptions::LimitedDebugInfo:
- DebugInfoVal = "limited";
- break;
- case llvm::codegenoptions::FullDebugInfo:
- DebugInfoVal = "standalone";
- break;
- case llvm::codegenoptions::UnusedTypeInfo:
- DebugInfoVal = "unused-types";
- break;
- case llvm::codegenoptions::NoDebugInfo: // default value
- DebugInfoVal = std::nullopt;
- break;
- case llvm::codegenoptions::LocTrackingOnly: // implied value
- DebugInfoVal = std::nullopt;
- break;
- }
- if (DebugInfoVal)
- GenerateArg(Consumer, OPT_debug_info_kind_EQ, *DebugInfoVal);
-
- for (const auto &Prefix : Opts.DebugPrefixMap)
- GenerateArg(Consumer, OPT_fdebug_prefix_map_EQ,
- Prefix.first + "=" + Prefix.second);
-
for (const auto &Prefix : Opts.CoveragePrefixMap)
GenerateArg(Consumer, OPT_fcoverage_prefix_map_EQ,
Prefix.first + "=" + Prefix.second);
@@ -1537,21 +1510,6 @@ void CompilerInvocationBase::GenerateCodeGenArgs(const CodeGenOptions &Opts,
if (!Opts.BinutilsVersion.empty())
GenerateArg(Consumer, OPT_fbinutils_version_EQ, Opts.BinutilsVersion);
- if (Opts.DebugNameTable ==
- static_cast<unsigned>(llvm::DICompileUnit::DebugNameTableKind::GNU))
- GenerateArg(Consumer, OPT_ggnu_pubnames);
- else if (Opts.DebugNameTable ==
- static_cast<unsigned>(
- llvm::DICompileUnit::DebugNameTableKind::Default))
- GenerateArg(Consumer, OPT_gpubnames);
-
- auto TNK = Opts.getDebugSimpleTemplateNames();
- if (TNK != llvm::codegenoptions::DebugTemplateNamesKind::Full) {
- if (TNK == llvm::codegenoptions::DebugTemplateNamesKind::Simple)
- GenerateArg(Consumer, OPT_gsimple_template_names_EQ, "simple");
- else if (TNK == llvm::codegenoptions::DebugTemplateNamesKind::Mangled)
- GenerateArg(Consumer, OPT_gsimple_template_names_EQ, "mangled");
- }
// ProfileInstrumentUsePath is marshalled automatically, no need to generate
// it or PGOUseInstrumentor.
@@ -1690,12 +1648,70 @@ void CompilerInvocationBase::GenerateCodeGenArgs(const CodeGenOptions &Opts,
}
}
-bool CompilerInvocation::ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args,
- InputKind IK,
- DiagnosticsEngine &Diags,
- const llvm::Triple &T,
- const std::string &OutputFile,
- const LangOptions &LangOptsRef) {
+void CompilerInvocationBase::GenerateDebugArgs(const DebugOptions &Opts,
+ ArgumentConsumer Consumer) {
+ const DebugOptions &DebugOpts = Opts;
+
+#define DEBUG_OPTION_WITH_MARSHALLING(...) \
+ GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
+#include "clang/Driver/Options.inc"
+#undef DEBUG_OPTION_WITH_MARSHALLING
+
+ std::optional<StringRef> DebugInfoVal;
+ switch (Opts.DebugInfo) {
+ case llvm::debugoptions::DebugLineTablesOnly:
+ DebugInfoVal = "line-tables-only";
+ break;
+ case llvm::debugoptions::DebugDirectivesOnly:
+ DebugInfoVal = "line-directives-only";
+ break;
+ case llvm::debugoptions::DebugInfoConstructor:
+ DebugInfoVal = "constructor";
+ break;
+ case llvm::debugoptions::LimitedDebugInfo:
+ DebugInfoVal = "limited";
+ break;
+ case llvm::debugoptions::FullDebugInfo:
+ DebugInfoVal = "standalone";
+ break;
+ case llvm::debugoptions::UnusedTypeInfo:
+ DebugInfoVal = "unused-types";
+ break;
+ case llvm::debugoptions::NoDebugInfo: // default value
+ DebugInfoVal = std::nullopt;
+ break;
+ case llvm::debugoptions::LocTrackingOnly: // implied value
+ DebugInfoVal = std::nullopt;
+ break;
+ }
+ if (DebugInfoVal)
+ GenerateArg(Consumer, OPT_debug_info_kind_EQ, *DebugInfoVal);
+
+ for (const auto &Prefix : Opts.DebugPrefixMap)
+ GenerateArg(Consumer, OPT_fdebug_prefix_map_EQ,
+ Prefix.first + "=" + Prefix.second);
+
+ if (Opts.DebugNameTable ==
+ static_cast<unsigned>(llvm::DICompileUnit::DebugNameTableKind::GNU))
+ GenerateArg(Consumer, OPT_ggnu_pubnames);
+ else if (Opts.DebugNameTable ==
+ static_cast<unsigned>(
+ llvm::DICompileUnit::DebugNameTableKind::Default))
+ GenerateArg(Consumer, OPT_gpubnames);
+
+ auto TNK = Opts.getDebugSimpleTemplateNames();
+ if (TNK != llvm::debugoptions::DebugTemplateNamesKind::Full) {
+ if (TNK == llvm::debugoptions::DebugTemplateNamesKind::Simple)
+ GenerateArg(Consumer, OPT_gsimple_template_names_EQ, "simple");
+ else if (TNK == llvm::debugoptions::DebugTemplateNamesKind::Mangled)
+ GenerateArg(Consumer, OPT_gsimple_template_names_EQ, "mangled");
+ }
+}
+
+bool CompilerInvocation::ParseCodeGenArgs(
+ CodeGenOptions &Opts, DebugOptions &DebugOpts, ArgList &Args, InputKind IK,
+ DiagnosticsEngine &Diags, const llvm::Triple &T,
+ const std::string &OutputFile, const LangOptions &LangOptsRef) {
unsigned NumErrorsBefore = Diags.getNumErrors();
unsigned OptimizationLevel = getOptimizationLevel(Args, IK, Diags);
@@ -1722,6 +1738,11 @@ bool CompilerInvocation::ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args,
#include "clang/Driver/Options.inc"
#undef CODEGEN_OPTION_WITH_MARSHALLING
+#define DEBUG_OPTION_WITH_MARSHALLING(...) \
+ PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
+#include "clang/Driver/Options.inc"
+#undef DEBUG_OPTION_WITH_MARSHALLING
+
// At O0 we want to fully disable inlining outside of cases marked with
// 'alwaysinline' that are required for correctness.
if (Opts.OptimizationLevel == 0) {
@@ -1752,19 +1773,20 @@ bool CompilerInvocation::ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args,
if (Arg *A = Args.getLastArg(OPT_debug_info_kind_EQ)) {
unsigned Val =
llvm::StringSwitch<unsigned>(A->getValue())
- .Case("line-tables-only", llvm::codegenoptions::DebugLineTablesOnly)
+ .Case("line-tables-only", llvm::debugoptions::DebugLineTablesOnly)
.Case("line-directives-only",
- llvm::codegenoptions::DebugDirectivesOnly)
- .Case("constructor", llvm::codegenoptions::DebugInfoConstructor)
- .Case("limited", llvm::codegenoptions::LimitedDebugInfo)
- .Case("standalone", llvm::codegenoptions::FullDebugInfo)
- .Case("unused-types", llvm::codegenoptions::UnusedTypeInfo)
+ llvm::debugoptions::DebugDirectivesOnly)
+ .Case("constructor", llvm::debugoptions::DebugInfoConstructor)
+ .Case("limited", llvm::debugoptions::LimitedDebugInfo)
+ .Case("standalone", llvm::debugoptions::FullDebugInfo)
+ .Case("unused-types", llvm::debugoptions::UnusedTypeInfo)
.Default(~0U);
if (Val == ~0U)
Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
<< A->getValue();
else
- Opts.setDebugInfo(static_cast<llvm::codegenoptions::DebugInfoKind>(Val));
+ DebugOpts.setDebugInfo(
+ static_cast<llvm::debugoptions::DebugInfoKind>(Val));
}
// If -fuse-ctor-homing is set and limited debug info is already on, then use
@@ -1772,16 +1794,16 @@ bool CompilerInvocation::ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args,
if (const Arg *A =
Args.getLastArg(OPT_fuse_ctor_homing, OPT_fno_use_ctor_homing)) {
if (A->getOption().matches(OPT_fuse_ctor_homing) &&
- Opts.getDebugInfo() == llvm::codegenoptions::LimitedDebugInfo)
- Opts.setDebugInfo(llvm::codegenoptions::DebugInfoConstructor);
+ DebugOpts.getDebugInfo() == llvm::debugoptions::LimitedDebugInfo)
+ DebugOpts.setDebugInfo(llvm::debugoptions::DebugInfoConstructor);
if (A->getOption().matches(OPT_fno_use_ctor_homing) &&
- Opts.getDebugInfo() == llvm::codegenoptions::DebugInfoConstructor)
- Opts.setDebugInfo(llvm::codegenoptions::LimitedDebugInfo);
+ DebugOpts.getDebugInfo() == llvm::debugoptions::DebugInfoConstructor)
+ DebugOpts.setDebugInfo(llvm::debugoptions::LimitedDebugInfo);
}
for (const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) {
auto Split = StringRef(Arg).split('=');
- Opts.DebugPrefixMap.emplace_back(Split.first, Split.second);
+ DebugOpts.DebugPrefixMap.emplace_back(Split.first, Split.second);
}
for (const auto &Arg : Args.getAllArgValues(OPT_fcoverage_prefix_map_EQ)) {
@@ -1794,14 +1816,15 @@ bool CompilerInvocation::ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args,
llvm::Triple::arm, llvm::Triple::armeb, llvm::Triple::mips,
llvm::Triple::mipsel, llvm::Triple::mips64, llvm::Triple::mips64el};
- if (Opts.OptimizationLevel > 0 && Opts.hasReducedDebugInfo() &&
+ if (Opts.OptimizationLevel > 0 && DebugOpts.hasReducedDebugInfo() &&
llvm::is_contained(DebugEntryValueArchs, T.getArch()))
Opts.EmitCallSiteInfo = true;
- if (!Opts.EnableDIPreservationVerify && Opts.DIBugsReportFilePath.size()) {
+ if (!DebugOpts.EnableDIPreservationVerify &&
+ DebugOpts.DIBugsReportFilePath.size()) {
Diags.Report(diag::warn_ignoring_verify_debuginfo_preserve_export)
- << Opts.DIBugsReportFilePath;
- Opts.DIBugsReportFilePath = "";
+ << DebugOpts.DIBugsReportFilePath;
+ DebugOpts.DIBugsReportFilePath = "";
}
Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) &&
@@ -1816,21 +1839,21 @@ bool CompilerInvocation::ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args,
Opts.BinutilsVersion =
std::string(Args.getLastArgValue(OPT_fbinutils_version_EQ));
- Opts.DebugNameTable = static_cast<unsigned>(
+ DebugOpts.DebugNameTable = static_cast<unsigned>(
Args.hasArg(OPT_ggnu_pubnames)
? llvm::DICompileUnit::DebugNameTableKind::GNU
- : Args.hasArg(OPT_gpubnames)
- ? llvm::DICompileUnit::DebugNameTableKind::Default
- : llvm::DICompileUnit::DebugNameTableKind::None);
+ : Args.hasArg(OPT_gpubnames)
+ ? llvm::DICompileUnit::DebugNameTableKind::Default
+ : llvm::DICompileUnit::DebugNameTableKind::None);
if (const Arg *A = Args.getLastArg(OPT_gsimple_template_names_EQ)) {
StringRef Value = A->getValue();
if (Value != "simple" && Value != "mangled")
Diags.Report(diag::err_drv_unsupported_option_argument)
<< A->getSpelling() << A->getValue();
- Opts.setDebugSimpleTemplateNames(
+ DebugOpts.setDebugSimpleTemplateNames(
StringRef(A->getValue()) == "simple"
- ? llvm::codegenoptions::DebugTemplateNamesKind::Simple
- : llvm::codegenoptions::DebugTemplateNamesKind::Mangled);
+ ? llvm::debugoptions::DebugTemplateNamesKind::Simple
+ : llvm::debugoptions::DebugTemplateNamesKind::Mangled);
}
if (const Arg *A = Args.getLastArg(OPT_ftime_report, OPT_ftime_report_EQ)) {
@@ -2145,8 +2168,8 @@ bool CompilerInvocation::ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args,
// If the user requested a flag that requires source locations available in
// the backend, make sure that the backend tracks source location information.
if (NeedLocTracking &&
- Opts.getDebugInfo() == llvm::codegenoptions::NoDebugInfo)
- Opts.setDebugInfo(llvm::codegenoptions::LocTrackingOnly);
+ DebugOpts.getDebugInfo() == llvm::debugoptions::NoDebugInfo)
+ DebugOpts.setDebugInfo(llvm::debugoptions::LocTrackingOnly);
// Parse -fsanitize-recover= arguments.
// FIXME: Report unrecoverable sanitizers incorrectly specified here.
@@ -4626,8 +4649,8 @@ bool CompilerInvocation::CreateFromArgsImpl(
if (LangOpts.OpenMPIsTargetDevice)
Res.getTargetOpts().HostTriple = Res.getFrontendOpts().AuxTriple;
- ParseCodeGenArgs(Res.getCodeGenOpts(), Args, DashX, Diags, T,
- Res.getFrontendOpts().OutputFile, LangOpts);
+ ParseCodeGenArgs(Res.getCodeGenOpts(), Res.getDebugOpts(), Args, DashX, Diags,
+ T, Res.getFrontendOpts().OutputFile, LangOpts);
// FIXME: Override value name discarding when asan or msan is used because the
// backend passes depend on the name of the alloca in order to print out
@@ -4659,7 +4682,7 @@ bool CompilerInvocation::CreateFromArgsImpl(
}
// Store the command-line for using in the CodeView backend.
- if (Res.getCodeGenOpts().CodeViewCommandLine) {
+ if (Res.getDebugOpts().CodeViewCommandLine) {
Res.getCodeGenOpts().Argv0 = Argv0;
append_range(Res.getCodeGenOpts().CommandLineArgs, CommandLineArgs);
}
@@ -4791,15 +4814,14 @@ std::string CompilerInvocation::getModuleHash() const {
// When compiling with -gmodules, also hash -fdebug-prefix-map as it
// affects the debug info in the PCM.
- if (getCodeGenOpts().DebugTypeExtRefs)
- HBuilder.addRange(getCodeGenOpts().DebugPrefixMap);
+ if (getDebugOpts().DebugTypeExtRefs)
+ HBuilder.addRange(getDebugOpts().DebugPrefixMap);
// Extend the signature with the affecting debug options.
if (getHeaderSearchOpts().ModuleFormat == "obj") {
-#define DEBUGOPT(Name, Bits, Default) HBuilder.add(CodeGenOpts->Name);
-#define VALUE_DEBUGOPT(Name, Bits, Default) HBuilder.add(CodeGenOpts->Name);
+#define DEBUGOPT(Name, Bits, Default) HBuilder.add(DebugOpts->Name);
#define ENUM_DEBUGOPT(Name, Type, Bits, Default) \
- HBuilder.add(static_cast<unsigned>(CodeGenOpts->get##Name()));
+ HBuilder.add(static_cast<unsigned>(DebugOpts->get##Name()));
#define BENIGN_DEBUGOPT(Name, Bits, Default)
#define BENIGN_VALUE_DEBUGOPT(Name, Bits, Default)
#define BENIGN_ENUM_DEBUGOPT(Name, Type, Bits, Default)
@@ -4835,6 +4857,7 @@ void CompilerInvocationBase::generateCC1CommandLine(
GenerateLangArgs(getLangOpts(), Consumer, T, getFrontendOpts().DashX);
GenerateCodeGenArgs(getCodeGenOpts(), Consumer, T,
getFrontendOpts().OutputFile, &getLangOpts());
+ GenerateDebugArgs(getDebugOpts(), Consumer);
GeneratePreprocessorArgs(getPreprocessorOpts(), Consumer, getLangOpts(),
getFrontendOpts(), getCodeGenOpts());
GeneratePreprocessorOutputArgs(getPreprocessorOutputOpts(), Consumer,
@@ -4852,7 +4875,8 @@ std::vector<std::string> CompilerInvocationBase::getCC1CommandLine() const {
void CompilerInvocation::resetNonModularOptions() {
getLangOpts().resetNonModularOptions();
getPreprocessorOpts().resetNonModularOptions();
- getCodeGenOpts().resetNonModularOptions(getHeaderSearchOpts().ModuleFormat);
+ getCodeGenOpts().resetNonModularOptions();
+ getDebugOpts().resetNonModularOptions(getHeaderSearchOpts().ModuleFormat);
}
void CompilerInvocation::clearImplicitModuleBuildOptions() {
diff --git a/clang/lib/Frontend/Rewrite/FrontendActions.cpp b/clang/lib/Frontend/Rewrite/FrontendActions.cpp
index 14569013b92ce9..786e1030fc520e 100644
--- a/clang/lib/Frontend/Rewrite/FrontendActions.cpp
+++ b/clang/lib/Frontend/Rewrite/FrontendActions.cpp
@@ -168,8 +168,8 @@ RewriteObjCAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
return CreateModernObjCRewriter(std::string(InFile), std::move(OS),
CI.getDiagnostics(), CI.getLangOpts(),
CI.getDiagnosticOpts().NoRewriteMacros,
- (CI.getCodeGenOpts().getDebugInfo() !=
- llvm::codegenoptions::NoDebugInfo));
+ (CI.getDebugOpts().getDebugInfo() !=
+ llvm::debugoptions::NoDebugInfo));
return CreateObjCRewriter(std::string(InFile), std::move(OS),
CI.getDiagnostics(), CI.getLangOpts(),
CI.getDiagnosticOpts().NoRewriteMacros);
diff --git a/clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp b/clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp
index 4a3cd054f23d92..8c3750ec9c0c44 100644
--- a/clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp
+++ b/clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp
@@ -122,9 +122,9 @@ makeCommonInvocationForModuleBuild(CompilerInvocation CI) {
// TODO: Figure out better way to set options to their default value.
CI.getCodeGenOpts().MainFileName.clear();
- CI.getCodeGenOpts().DwarfDebugFlags.clear();
+ CI.getDebugOpts().DwarfDebugFlags.clear();
if (!CI.getLangOpts().ModulesCodegen) {
- CI.getCodeGenOpts().DebugCompilationDir.clear();
+ CI.getDebugOpts().DebugCompilationDir.clear();
CI.getCodeGenOpts().CoverageCompilationDir.clear();
CI.getCodeGenOpts().CoverageDataFile.clear();
CI.getCodeGenOpts().CoverageNotesFile.clear();
diff --git a/clang/tools/clang-import-test/clang-import-test.cpp b/clang/tools/clang-import-test/clang-import-test.cpp
index 2473e16a546dc0..6e3880dbf337f1 100644
--- a/clang/tools/clang-import-test/clang-import-test.cpp
+++ b/clang/tools/clang-import-test/clang-import-test.cpp
@@ -200,7 +200,7 @@ std::unique_ptr<CompilerInstance> BuildCompilerInstance() {
Inv->getLangOpts().CXXExceptions = true;
// Needed for testing dynamic_cast.
Inv->getLangOpts().RTTI = true;
- Inv->getCodeGenOpts().setDebugInfo(llvm::codegenoptions::FullDebugInfo);
+ Inv->getDebugOpts().setDebugInfo(llvm::debugoptions::FullDebugInfo);
Inv->getTargetOpts().Triple = llvm::sys::getDefaultTargetTriple();
Ins->setInvocation(std::move(Inv));
@@ -232,7 +232,7 @@ std::unique_ptr<CodeGenerator> BuildCodeGen(CompilerInstance &CI,
return std::unique_ptr<CodeGenerator>(CreateLLVMCodeGen(
CI.getDiagnostics(), ModuleName, &CI.getVirtualFileSystem(),
CI.getHeaderSearchOpts(), CI.getPreprocessorOpts(), CI.getCodeGenOpts(),
- LLVMCtx));
+ CI.getDebugOpts(), LLVMCtx));
}
} // namespace init_convenience
diff --git a/clang/unittests/CodeGen/TestCompiler.h b/clang/unittests/CodeGen/TestCompiler.h
index 891489cb511a4f..0b2c3e6040dfa5 100644
--- a/clang/unittests/CodeGen/TestCompiler.h
+++ b/clang/unittests/CodeGen/TestCompiler.h
@@ -59,7 +59,8 @@ struct TestCompiler {
CG.reset(CreateLLVMCodeGen(
compiler.getDiagnostics(), "main-module",
&compiler.getVirtualFileSystem(), compiler.getHeaderSearchOpts(),
- compiler.getPreprocessorOpts(), compiler.getCodeGenOpts(), Context));
+ compiler.getPreprocessorOpts(), compiler.getCodeGenOpts(),
+ compiler.getDebugOpts(), Context));
}
void init(const char *TestProgram,
diff --git a/clang/unittests/Frontend/CodeGenActionTest.cpp b/clang/unittests/Frontend/CodeGenActionTest.cpp
index a6520910c83996..2a6a14b7327173 100644
--- a/clang/unittests/Frontend/CodeGenActionTest.cpp
+++ b/clang/unittests/Frontend/CodeGenActionTest.cpp
@@ -95,7 +95,7 @@ TEST(CodeGenTest, DebugInfoCWDCodeGen) {
FrontendInputFile("test.cpp", Language::CXX));
Invocation->getFrontendOpts().ProgramAction = EmitLLVM;
Invocation->getTargetOpts().Triple = "x86_64-unknown-linux-gnu";
- Invocation->getCodeGenOpts().setDebugInfo(codegenoptions::FullDebugInfo);
+ Invocation->getDebugOpts().setDebugInfo(debugoptions::FullDebugInfo);
CompilerInstance Compiler;
SmallString<256> IRBuffer;
diff --git a/clang/unittests/Frontend/CompilerInvocationTest.cpp b/clang/unittests/Frontend/CompilerInvocationTest.cpp
index 7912253b761e9b..6e6ff7918c7267 100644
--- a/clang/unittests/Frontend/CompilerInvocationTest.cpp
+++ b/clang/unittests/Frontend/CompilerInvocationTest.cpp
@@ -256,7 +256,7 @@ TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNone) {
const char *Args[] = {""};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
- ASSERT_FALSE(Invocation.getCodeGenOpts().NoInlineLineTables);
+ ASSERT_FALSE(Invocation.getDebugOpts().NoInlineLineTables);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-ginline-line-tables"))));
@@ -267,7 +267,7 @@ TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNegChange) {
const char *Args[] = {"-gno-inline-line-tables"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
- ASSERT_TRUE(Invocation.getCodeGenOpts().NoInlineLineTables);
+ ASSERT_TRUE(Invocation.getDebugOpts().NoInlineLineTables);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-gno-inline-line-tables")));
@@ -279,7 +279,7 @@ TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentPosReset) {
// Driver-only flag.
ASSERT_FALSE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
- ASSERT_FALSE(Invocation.getCodeGenOpts().NoInlineLineTables);
+ ASSERT_FALSE(Invocation.getDebugOpts().NoInlineLineTables);
}
// Boolean option with a keypath that defaults to false.
@@ -290,7 +290,7 @@ TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNoneX) {
const char *Args[] = {""};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
- ASSERT_FALSE(Invocation.getCodeGenOpts().CodeViewGHash);
+ ASSERT_FALSE(Invocation.getDebugOpts().CodeViewGHash);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-gcodeview-ghash"))));
@@ -301,7 +301,7 @@ TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentPosChange) {
const char *Args[] = {"-gcodeview-ghash"};
ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
- ASSERT_TRUE(Invocation.getCodeGenOpts().CodeViewGHash);
+ ASSERT_TRUE(Invocation.getDebugOpts().CodeViewGHash);
Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-gcodeview-ghash")));
@@ -313,7 +313,7 @@ TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNegReset) {
// Driver-only flag.
ASSERT_FALSE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
- ASSERT_FALSE(Invocation.getCodeGenOpts().CodeViewGHash);
+ ASSERT_FALSE(Invocation.getDebugOpts().CodeViewGHash);
}
// Boolean option with a keypath that defaults to an arbitrary expression.
@@ -1027,9 +1027,9 @@ TEST_F(CommandLineTest, RoundTrip) {
ASSERT_TRUE(Invocation.getMigratorOpts().NoNSAllocReallocError);
- ASSERT_EQ(Invocation.getCodeGenOpts().getDebugInfo(),
- codegenoptions::DebugInfoKind::LimitedDebugInfo);
- ASSERT_TRUE(Invocation.getCodeGenOpts().MacroDebugInfo);
+ ASSERT_EQ(Invocation.getDebugOpts().getDebugInfo(),
+ debugoptions::DebugInfoKind::LimitedDebugInfo);
+ ASSERT_TRUE(Invocation.getDebugOpts().MacroDebugInfo);
ASSERT_EQ(Invocation.getDependencyOutputOpts().ShowIncludesDest,
ShowIncludesDestination::Stdout);
diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp
index f6856b1a2558cb..80f51844d7e1d1 100644
--- a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp
+++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp
@@ -695,7 +695,7 @@ ClangExpressionParser::ClangExpressionParser(
m_compiler->getDiagnostics(), module_name,
&m_compiler->getVirtualFileSystem(), m_compiler->getHeaderSearchOpts(),
m_compiler->getPreprocessorOpts(), m_compiler->getCodeGenOpts(),
- *m_llvm_context));
+ m_compiler->getDebugOpts(), *m_llvm_context));
}
ClangExpressionParser::~ClangExpressionParser() = default;
diff --git a/llvm/include/llvm/Frontend/Debug/Options.h b/llvm/include/llvm/Frontend/Debug/Options.h
index c490508d3793a3..38dd0627a3da97 100644
--- a/llvm/include/llvm/Frontend/Debug/Options.h
+++ b/llvm/include/llvm/Frontend/Debug/Options.h
@@ -10,7 +10,7 @@
#define LLVM_FRONTEND_DEBUG_OPTIONS_H
namespace llvm {
-namespace codegenoptions {
+namespace debugoptions {
enum DebugInfoFormat {
DIF_DWARF,
@@ -56,7 +56,7 @@ enum DebugInfoKind {
enum class DebugTemplateNamesKind { Full, Simple, Mangled };
-} // end namespace codegenoptions
+} // namespace debugoptions
} // end namespace llvm
#endif
>From dd0ea84da6c5ebd93148b3ff4638ef6803cc8443 Mon Sep 17 00:00:00 2001
From: Juergen Ributzka <juergen at ributzka.de>
Date: Mon, 18 Dec 2023 10:25:59 -0800
Subject: [PATCH 2/3] Fix flang build
---
.../include/flang/Frontend/CodeGenOptions.def | 2 +-
flang/include/flang/Tools/CLOptions.inc | 10 ++++-----
flang/include/flang/Tools/CrossToolHelpers.h | 4 ++--
flang/lib/Frontend/CompilerInvocation.cpp | 22 +++++++++----------
4 files changed, 19 insertions(+), 19 deletions(-)
diff --git a/flang/include/flang/Frontend/CodeGenOptions.def b/flang/include/flang/Frontend/CodeGenOptions.def
index 72e7bdab12a14d..2cee2e3e805399 100644
--- a/flang/include/flang/Frontend/CodeGenOptions.def
+++ b/flang/include/flang/Frontend/CodeGenOptions.def
@@ -36,7 +36,7 @@ CODEGENOPT(AliasAnalysis, 1, 0) ///< Enable alias analysis pass
CODEGENOPT(Underscoring, 1, 1)
ENUM_CODEGENOPT(RelocationModel, llvm::Reloc::Model, 3, llvm::Reloc::PIC_) ///< Name of the relocation model to use.
-ENUM_CODEGENOPT(DebugInfo, llvm::codegenoptions::DebugInfoKind, 4, llvm::codegenoptions::NoDebugInfo) ///< Level of debug info to generate
+ENUM_CODEGENOPT(DebugInfo, llvm::debugoptions::DebugInfoKind, 4, llvm::debugoptions::NoDebugInfo) ///< Level of debug info to generate
ENUM_CODEGENOPT(VecLib, llvm::driver::VectorLibrary, 3, llvm::driver::VectorLibrary::NoLibrary) ///< Vector functions library to use
#undef CODEGENOPT
diff --git a/flang/include/flang/Tools/CLOptions.inc b/flang/include/flang/Tools/CLOptions.inc
index d3e4dc6cd4a243..f4adddf82adde8 100644
--- a/flang/include/flang/Tools/CLOptions.inc
+++ b/flang/include/flang/Tools/CLOptions.inc
@@ -56,8 +56,8 @@ namespace {
const static llvm::OptimizationLevel &defaultOptLevel{
llvm::OptimizationLevel::O0};
-const static llvm::codegenoptions::DebugInfoKind &NoDebugInfo{
- llvm::codegenoptions::NoDebugInfo};
+const static llvm::debugoptions::DebugInfoKind &NoDebugInfo{
+ llvm::debugoptions::NoDebugInfo};
/// Optimizer Passes
DisableOption(CfgConversion, "cfg-conversion", "disable FIR to CFG pass");
@@ -280,13 +280,13 @@ inline void createOpenMPFIRPassPipeline(
#if !defined(FLANG_EXCLUDE_CODEGEN)
inline void createDebugPasses(
- mlir::PassManager &pm, llvm::codegenoptions::DebugInfoKind debugLevel) {
+ mlir::PassManager &pm, llvm::debugoptions::DebugInfoKind debugLevel) {
// Currently only -g1, -g, -gline-tables-only supported
switch (debugLevel) {
- case llvm::codegenoptions::DebugLineTablesOnly:
+ case llvm::debugoptions::DebugLineTablesOnly:
addDebugFoundationPass(pm);
return;
- case llvm::codegenoptions::NoDebugInfo:
+ case llvm::debugoptions::NoDebugInfo:
return;
default:
// TODO: Add cases and passes for other debug options.
diff --git a/flang/include/flang/Tools/CrossToolHelpers.h b/flang/include/flang/Tools/CrossToolHelpers.h
index ddec70fa9824c5..61243cd2b9b021 100644
--- a/flang/include/flang/Tools/CrossToolHelpers.h
+++ b/flang/include/flang/Tools/CrossToolHelpers.h
@@ -42,8 +42,8 @@ struct MLIRToLLVMPassPipelineConfig {
bool Underscoring = true; ///< add underscores to function names.
bool LoopVersioning = false; ///< Run the version loop pass.
bool AliasAnalysis = false; ///< Add TBAA tags to generated LLVMIR
- llvm::codegenoptions::DebugInfoKind DebugInfo =
- llvm::codegenoptions::NoDebugInfo; ///< Debug info generation.
+ llvm::debugoptions::DebugInfoKind DebugInfo =
+ llvm::debugoptions::NoDebugInfo; ///< Debug info generation.
unsigned VScaleMin = 0; ///< SVE vector range minimum.
unsigned VScaleMax = 0; ///< SVE vector range maximum.
};
diff --git a/flang/lib/Frontend/CompilerInvocation.cpp b/flang/lib/Frontend/CompilerInvocation.cpp
index b3f32bb241d068..d8cffdc3cbe544 100644
--- a/flang/lib/Frontend/CompilerInvocation.cpp
+++ b/flang/lib/Frontend/CompilerInvocation.cpp
@@ -125,18 +125,18 @@ bool Fortran::frontend::parseDiagnosticArgs(clang::DiagnosticOptions &opts,
static bool parseDebugArgs(Fortran::frontend::CodeGenOptions &opts,
llvm::opt::ArgList &args,
clang::DiagnosticsEngine &diags) {
- using DebugInfoKind = llvm::codegenoptions::DebugInfoKind;
+ using DebugInfoKind = llvm::debugoptions::DebugInfoKind;
if (llvm::opt::Arg *arg =
args.getLastArg(clang::driver::options::OPT_debug_info_kind_EQ)) {
std::optional<DebugInfoKind> val =
llvm::StringSwitch<std::optional<DebugInfoKind>>(arg->getValue())
- .Case("line-tables-only", llvm::codegenoptions::DebugLineTablesOnly)
+ .Case("line-tables-only", llvm::debugoptions::DebugLineTablesOnly)
.Case("line-directives-only",
- llvm::codegenoptions::DebugDirectivesOnly)
- .Case("constructor", llvm::codegenoptions::DebugInfoConstructor)
- .Case("limited", llvm::codegenoptions::LimitedDebugInfo)
- .Case("standalone", llvm::codegenoptions::FullDebugInfo)
- .Case("unused-types", llvm::codegenoptions::UnusedTypeInfo)
+ llvm::debugoptions::DebugDirectivesOnly)
+ .Case("constructor", llvm::debugoptions::DebugInfoConstructor)
+ .Case("limited", llvm::debugoptions::LimitedDebugInfo)
+ .Case("standalone", llvm::debugoptions::FullDebugInfo)
+ .Case("unused-types", llvm::debugoptions::UnusedTypeInfo)
.Default(std::nullopt);
if (!val.has_value()) {
diags.Report(clang::diag::err_drv_invalid_value)
@@ -144,8 +144,8 @@ static bool parseDebugArgs(Fortran::frontend::CodeGenOptions &opts,
return false;
}
opts.setDebugInfo(val.value());
- if (val != llvm::codegenoptions::DebugLineTablesOnly &&
- val != llvm::codegenoptions::NoDebugInfo) {
+ if (val != llvm::debugoptions::DebugLineTablesOnly &&
+ val != llvm::debugoptions::NoDebugInfo) {
const auto debugWarning = diags.getCustomDiagID(
clang::DiagnosticsEngine::Warning, "Unsupported debug option: %0");
diags.Report(debugWarning) << arg->getValue();
@@ -309,7 +309,7 @@ static void parseCodeGenArgs(Fortran::frontend::CodeGenOptions &opts,
diags, args, clang::driver::options::OPT_Rpass_analysis_EQ,
/*remarkOptName=*/"pass-analysis");
- if (opts.getDebugInfo() == llvm::codegenoptions::NoDebugInfo) {
+ if (opts.getDebugInfo() == llvm::debugoptions::NoDebugInfo) {
// If the user requested a flag that requires source locations available in
// the backend, make sure that the backend tracks source location
// information.
@@ -321,7 +321,7 @@ static void parseCodeGenArgs(Fortran::frontend::CodeGenOptions &opts,
opts.OptimizationRemarkAnalysis.hasValidPattern();
if (needLocTracking)
- opts.setDebugInfo(llvm::codegenoptions::LocTrackingOnly);
+ opts.setDebugInfo(llvm::debugoptions::LocTrackingOnly);
}
if (auto *a = args.getLastArg(clang::driver::options::OPT_save_temps_EQ))
>From 38cf9f856ae137bc6429b6cb8a82e0f9c1d99b48 Mon Sep 17 00:00:00 2001
From: Juergen Ributzka <juergen at ributzka.de>
Date: Mon, 18 Dec 2023 10:37:07 -0800
Subject: [PATCH 3/3] Forward declare *Options in CompilerInvocation.h
---
clang/include/clang/Frontend/CompilerInvocation.h | 6 ++++--
clang/lib/CodeGen/ObjectFilePCHContainerOperations.cpp | 1 +
clang/lib/Frontend/CompilerInstance.cpp | 2 ++
clang/lib/Frontend/CompilerInvocation.cpp | 1 +
clang/lib/Frontend/FrontendAction.cpp | 1 +
clang/lib/Frontend/Rewrite/FrontendActions.cpp | 2 ++
clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp | 1 +
7 files changed, 12 insertions(+), 2 deletions(-)
diff --git a/clang/include/clang/Frontend/CompilerInvocation.h b/clang/include/clang/Frontend/CompilerInvocation.h
index 0969a6bdda067a..f2ccd03e3ce171 100644
--- a/clang/include/clang/Frontend/CompilerInvocation.h
+++ b/clang/include/clang/Frontend/CompilerInvocation.h
@@ -10,8 +10,8 @@
#define LLVM_CLANG_FRONTEND_COMPILERINVOCATION_H
#include "clang/APINotes/APINotesOptions.h"
-#include "clang/Basic/CodeGenOptions.h"
-#include "clang/Basic/DebugOptions.h"
+// #include "clang/Basic/CodeGenOptions.h"
+// #include "clang/Basic/DebugOptions.h"
#include "clang/Basic/DiagnosticOptions.h"
#include "clang/Basic/FileSystemOptions.h"
#include "clang/Basic/LLVM.h"
@@ -47,6 +47,8 @@ class FileSystem;
namespace clang {
+class CodeGenOptions;
+class DebugOptions;
class DiagnosticsEngine;
class HeaderSearchOptions;
class PreprocessorOptions;
diff --git a/clang/lib/CodeGen/ObjectFilePCHContainerOperations.cpp b/clang/lib/CodeGen/ObjectFilePCHContainerOperations.cpp
index cee48f71f1af02..c04b278659cf55 100644
--- a/clang/lib/CodeGen/ObjectFilePCHContainerOperations.cpp
+++ b/clang/lib/CodeGen/ObjectFilePCHContainerOperations.cpp
@@ -14,6 +14,7 @@
#include "clang/AST/Expr.h"
#include "clang/AST/RecursiveASTVisitor.h"
#include "clang/Basic/CodeGenOptions.h"
+#include "clang/Basic/DebugOptions.h"
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/TargetInfo.h"
#include "clang/CodeGen/BackendUtil.h"
diff --git a/clang/lib/Frontend/CompilerInstance.cpp b/clang/lib/Frontend/CompilerInstance.cpp
index cd8df3c1f373ac..ae1135e9bb62ca 100644
--- a/clang/lib/Frontend/CompilerInstance.cpp
+++ b/clang/lib/Frontend/CompilerInstance.cpp
@@ -11,6 +11,8 @@
#include "clang/AST/ASTContext.h"
#include "clang/AST/Decl.h"
#include "clang/Basic/CharInfo.h"
+#include "clang/Basic/CodeGenOptions.h"
+#include "clang/Basic/DebugOptions.h"
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/DiagnosticOptions.h"
#include "clang/Basic/FileManager.h"
diff --git a/clang/lib/Frontend/CompilerInvocation.cpp b/clang/lib/Frontend/CompilerInvocation.cpp
index d8c297ff268bf0..de6dd15bd6dde7 100644
--- a/clang/lib/Frontend/CompilerInvocation.cpp
+++ b/clang/lib/Frontend/CompilerInvocation.cpp
@@ -12,6 +12,7 @@
#include "clang/Basic/CharInfo.h"
#include "clang/Basic/CodeGenOptions.h"
#include "clang/Basic/CommentOptions.h"
+#include "clang/Basic/DebugOptions.h"
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/DiagnosticDriver.h"
#include "clang/Basic/DiagnosticOptions.h"
diff --git a/clang/lib/Frontend/FrontendAction.cpp b/clang/lib/Frontend/FrontendAction.cpp
index eff785b99a09a4..7dbf41b613ee53 100644
--- a/clang/lib/Frontend/FrontendAction.cpp
+++ b/clang/lib/Frontend/FrontendAction.cpp
@@ -11,6 +11,7 @@
#include "clang/AST/ASTContext.h"
#include "clang/AST/DeclGroup.h"
#include "clang/Basic/Builtins.h"
+#include "clang/Basic/CodeGenOptions.h"
#include "clang/Basic/DiagnosticOptions.h"
#include "clang/Basic/FileEntry.h"
#include "clang/Basic/LangStandard.h"
diff --git a/clang/lib/Frontend/Rewrite/FrontendActions.cpp b/clang/lib/Frontend/Rewrite/FrontendActions.cpp
index 786e1030fc520e..dd66ee52bddeb0 100644
--- a/clang/lib/Frontend/Rewrite/FrontendActions.cpp
+++ b/clang/lib/Frontend/Rewrite/FrontendActions.cpp
@@ -9,6 +9,7 @@
#include "clang/Rewrite/Frontend/FrontendActions.h"
#include "clang/AST/ASTConsumer.h"
#include "clang/Basic/CharInfo.h"
+#include "clang/Basic/DebugOptions.h"
#include "clang/Basic/LangStandard.h"
#include "clang/Config/config.h"
#include "clang/Frontend/CompilerInstance.h"
@@ -24,6 +25,7 @@
#include "clang/Serialization/ModuleFile.h"
#include "clang/Serialization/ModuleManager.h"
#include "llvm/ADT/DenseSet.h"
+#include "llvm/Frontend/Debug/Options.h"
#include "llvm/Support/CrashRecoveryContext.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/Path.h"
diff --git a/clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp b/clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp
index b280a1359d2f27..c5ebc2a31dafd7 100644
--- a/clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp
+++ b/clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp
@@ -12,6 +12,7 @@
//===----------------------------------------------------------------------===//
#include "clang/ARCMigrate/ARCMTActions.h"
+#include "clang/Basic/CodeGenOptions.h"
#include "clang/CodeGen/CodeGenAction.h"
#include "clang/Config/config.h"
#include "clang/Driver/Options.h"
More information about the lldb-commits
mailing list