This is an archive of the discontinued LLVM Phabricator instance.

Differential D13221

Make CompilerInvocation's use of the debug options more understandable.
ClosedPublic

Authored by dougk on Sep 28 2015, 12:18 PM.

Details

Reviewers
jyknight
chandlerc
dblaikie
Commits
rG3459ce2e5ebb: Stop messing with the 'g' group of options in CompilerInvocation.
rC249655: Stop messing with the 'g' group of options in CompilerInvocation.
rL249655: Stop messing with the 'g' group of options in CompilerInvocation.
Summary

Stop mucking with the semantics of debug options in CompilerInvocation.

This changes causes most of the 'g' group options to be rejected by CompilerInvocation. They remain only as Driver options.
The new way to tell cc1 what kind of debug info to emit is with "-di-kind={full|limited|line-tables}" "-dwarf-version={2|3|4}".




In the absence of any command-line option to specify Dwarf version, there is a new virtual method in the Toolchain rather than hiding Toolchain-specific logic in CompilerInvocation. This is important when the default depends on complicating factors that cc1 is not aware of.



Also fix a bug in the Windows compatibility argument parsing in which the "rightmost argument wins" principle failed.
Diff Detail
Event Timeline
dougk updated this revision to Diff 35899.Sep 28 2015, 12:18 PM
dougk retitled this revision from  to Make CompilerInvocation's use of the debug options more understandable..
dougk updated this object.
dougk added reviewers: chandlerc, jyknight.
dougk added a subscriber: cfe-commits.
dougk added a comment.Sep 28 2015, 12:38 PM
I think the best thing to do is introduce new cc1 arguments that control the Opts explicitly, and cease accepting the equivalent driver arguments in cc1.

I would propose '-gdwarf-version={2|3|4}' and '-gdebug-info-kind={line-tables|limited|full}'
dougk updated this revision to Diff 35988.Sep 29 2015, 9:23 AM
dougk updated this object.
Replaced the cc1 arguments with two three-valued options. Fixed all the tests.



Reviewers: the "important" tests to review are:

test/Driver/clang-g-opts.c

test/Driver/debug-options.c

test/Driver/split-debug.c

test/Driver/cl-options.c



The rest are all mechanical and pretty much the minimally obvious change to avoid putting "-g" to in the cc1 invocation.
dougk updated this revision to Diff 36140.Sep 30 2015, 12:55 PM
dougk updated this object.
Fix CollectArgsForIntegratedAs and make sure that no other tests talk about "-g" after the Driver has produced the command invocation, except for xcore in which apparently xcc does accept -g.
aprantl added a subscriber: aprantl.Oct 2 2015, 3:23 PM
dougk added a comment.Oct 2 2015, 4:31 PM
A few more remarks:



    

  • The code which emits line-tables-only seems to understand dwarf2 versus dwarf4, but due solely to the way that arguments were parsed, the dwarf version did not propagate through to the compiler invocation if you also specified line-tables-only.  The new pair of arguments does not have that issue.
    • 




So as mentioned on cfe-dev, this is another case of "yeah, I fixed that but wasn't really the intent".  [All I want is MyriadToolchain to default to dwarf 2. That's it!]



    

  • It was suggested to me that it ought to have been possible to pull out all of the g group argument processing so that ClangAs::ConstructJob can share a little bit more code with Clang::ConstructJob but I'd really prefer not to do that in this change. It's possible that another small cleanup can be done, but the governing factor is that somehow or another you also have to deal with the case where the integrated-as tool has to parse '-gdwarf-N' flags (because people can pass those with -Xassembler,-gdwarf-). So you've got to be able to parse plain old StringRefs, as opposed to "Arg", which, absent that requirement, you'd just do with getOption().matches(). As it is, I think the code is well factored for this purpose.
    • 

jyknight edited edge metadata.Oct 2 2015, 6:43 PM
This certainly seems a big improvement.



However, I don't think that you actually fixed specifying both -gline-tables-only and a Dwarf version, because that requires actually handling multiple options from g_group, instead of just the last one. E.g. "-gdwarf-2 -g1" should cause the dwarf level to be set to 2, and enable line-tables. I expect the correct thing for Driver to do is to process *all* the args and apply them one at a time to the state variables, rather than just take the last arg.



(Not that I'm recommending that you fix that also in this commit, just not to claim it now works unless it does)
include/clang/Driver/CC1Options.td


135
I'd suggest to keep the name of thevar and the string the same for easy searching.


lib/Driver/Tools.cpp


2353
How about:



if (DwarfVersion > 0) CmdArgs.push_back("-dwarf-version=" + DwarfVersion);
aprantl added a comment.Oct 5 2015, 8:37 AM
Some bikeshedding about -di-kind={full|limited|line-tables}:



    

  1. Is there a good reason not to spell out -debug-info-kind?
    2. 

  2. "full" is misleading as it will still only emit debug info for types actually used by the program. I think "standalone" would be more descriptive.
    3. 

  3. Why not "line-tables-only" like in -gline-tables-only?
    4. 

dougk marked an inline comment as done.Oct 7 2015, 8:03 AM
James, you're right, 'gdwarf-2' followed by 'line-tables-only' works, but the opposite order doesn't.

So it halfway works, which is better than not working at all.
lib/Driver/Tools.cpp


2353
minor point: the "+" syntax you've used is actually pointer arithmetic, but giving the benefit of doubt there, and writing it as to_string(DwarfVersion), the annoying thing is that CmdArgs wants a 'const char*'.

To get one, you have to call MakeArgString which is a method on Args, not CmdArgs, so you have to pass both.

I did that in the latest patch, see what you think.
dougk updated this revision to Diff 36748.Oct 7 2015, 8:09 AM
dougk updated this object.
dougk edited edge metadata.
spell 'di-kind=' as 'debug-info-kind=', spell 'full' as 'standalone', spell 'line-tables' as 'line-tables-only', spell internal option name as debug_info_kind_EQ
dblaikie accepted this revision.Oct 7 2015, 9:13 AM
dblaikie added a reviewer: dblaikie.
dblaikie added a subscriber: dblaikie.
dblaikie added inline comments.
test/Driver/clang-g-opts.c


33–36
Should this be -debug-info-kind instead?
This revision is now accepted and ready to land.Oct 7 2015, 9:13 AM
dougk marked an inline comment as done.Oct 7 2015, 10:59 AM
Closed by commit rL249655: Stop messing with the 'g' group of options in CompilerInvocation. (authored by dougk).  ·  Explain WhyOct 7 2015, 9:27 PM
This revision was automatically updated to reflect the committed changes.
thakis added a subscriber: thakis.Dec 3 2015, 10:08 AM
thakis added inline comments.
cfe/trunk/lib/Frontend/CompilerInvocation.cpp


401 ↗(On Diff #36825)
This lets cc1 crash if you pass -debug-info-kind=foo for any foo not explicitly handled in the stringswitch. (I don't see a nice and obvious fix, so leaving this to you.)
dougk mentioned this in rL256897: Avoid assert failure on some invalid cc1 options..Jan 5 2016, 5:41 PM
Revision Contents
PathSize
include/
clang/
Driver/
2 lines
14 lines
10 lines
lib/
Driver/
13 lines
5 lines
162 lines
Frontend/
38 lines
test/
CodeGen/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
CodeGenCXX/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
6 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
3 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
CodeGenObjC/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 lines
2 lines
CodeGenObjCXX/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Coverage/
2 lines
4 lines
32 lines
Driver/
18 lines
18 lines
9 lines
35 lines
15 lines
8 lines
Frontend/
2 lines
2 lines
Misc/
2 lines
Modules/
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
2 lines
6 lines
OpenMP/
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
2 lines
4 lines
PCH/
2 lines
2 lines
Rewriter/
2 lines
VFS/
4 lines
tools/
driver/
11 lines
Diff 36140
include/clang/Driver/CC1Options.td
Show First 20 Lines • Show All 126 Lines • ▼ Show 20 Linesdef migrator_no_finalize_removal : Flag<["-"], "no-finalize-removal">,

  HelpText<"Do not remove finalize method in gc mode">;
  HelpText<"Do not remove finalize method in gc mode">;




//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//

// CodeGen Options
// CodeGen Options

//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//




let Flags = [CC1Option, CC1AsOption, NoDriverOption] in {
let Flags = [CC1Option, CC1AsOption, NoDriverOption] in {




def debug_info_kind_EQ : Joined<["-"], "di-kind=">;

jyknightUnsubmitted
Done
ReplyInline Actions
I'd suggest to keep the name of thevar and the string the same for easy searching.
jyknight: I'd suggest to keep the name of thevar and the string the same for easy searching.
def dwarf_version_EQ : Joined<["-"], "dwarf-version=">;

def fdebug_compilation_dir : Separate<["-"], "fdebug-compilation-dir">,
def fdebug_compilation_dir : Separate<["-"], "fdebug-compilation-dir">,

  HelpText<"The compilation directory to embed in the debug info.">;
  HelpText<"The compilation directory to embed in the debug info.">;

def dwarf_debug_flags : Separate<["-"], "dwarf-debug-flags">,
def dwarf_debug_flags : Separate<["-"], "dwarf-debug-flags">,

  HelpText<"The string to embed in the Dwarf debug flags record.">;
  HelpText<"The string to embed in the Dwarf debug flags record.">;

def mno_exec_stack : Flag<["-"], "mnoexecstack">,
def mno_exec_stack : Flag<["-"], "mnoexecstack">,

  HelpText<"Mark the file as not needing an executable stack">;
  HelpText<"Mark the file as not needing an executable stack">;

def massembler_fatal_warnings : Flag<["-"], "massembler-fatal-warnings">,
def massembler_fatal_warnings : Flag<["-"], "massembler-fatal-warnings">,

  HelpText<"Make assembler warnings fatal">;
  HelpText<"Make assembler warnings fatal">;

▲ Show 20 Lines • Show All 556 Lines • Show Last 20 Lines
include/clang/Driver/Options.td
Show First 20 Lines • Show All 979 Lines • ▼ Show 20 Linesdef fno_signed_char : Flag<["-"], "fno-signed-char">, Group<f_Group>,

    Flags<[CC1Option]>, HelpText<"Char is unsigned">;
    Flags<[CC1Option]>, HelpText<"Char is unsigned">;

def fsplit_stack : Flag<["-"], "fsplit-stack">, Group<f_Group>;
def fsplit_stack : Flag<["-"], "fsplit-stack">, Group<f_Group>;

def fstack_protector_all : Flag<["-"], "fstack-protector-all">, Group<f_Group>,
def fstack_protector_all : Flag<["-"], "fstack-protector-all">, Group<f_Group>,

  HelpText<"Force the usage of stack protectors for all functions">;
  HelpText<"Force the usage of stack protectors for all functions">;

def fstack_protector_strong : Flag<["-"], "fstack-protector-strong">, Group<f_Group>,
def fstack_protector_strong : Flag<["-"], "fstack-protector-strong">, Group<f_Group>,

  HelpText<"Use a strong heuristic to apply stack protectors to functions">;
  HelpText<"Use a strong heuristic to apply stack protectors to functions">;

def fstack_protector : Flag<["-"], "fstack-protector">, Group<f_Group>,
def fstack_protector : Flag<["-"], "fstack-protector">, Group<f_Group>,

  HelpText<"Enable stack protectors for functions potentially vulnerable to stack smashing">;
  HelpText<"Enable stack protectors for functions potentially vulnerable to stack smashing">;

def fstandalone_debug : Flag<["-"], "fstandalone-debug">, Group<f_Group>, Flags<[CC1Option]>,
def fstandalone_debug : Flag<["-"], "fstandalone-debug">, Group<f_Group>,

  HelpText<"Emit full debug info for all types used by the program">;
  HelpText<"Emit full debug info for all types used by the program">;

def fno_standalone_debug : Flag<["-"], "fno-standalone-debug">, Group<f_Group>, Flags<[CC1Option]>,
def fno_standalone_debug : Flag<["-"], "fno-standalone-debug">, Group<f_Group>,

  HelpText<"Limit debug information produced to reduce size of debug binary">;
  HelpText<"Limit debug information produced to reduce size of debug binary">;

def flimit_debug_info : Flag<["-"], "flimit-debug-info">, Alias<fno_standalone_debug>;
def flimit_debug_info : Flag<["-"], "flimit-debug-info">, Alias<fno_standalone_debug>;

def fno_limit_debug_info : Flag<["-"], "fno-limit-debug-info">, Alias<fstandalone_debug>;
def fno_limit_debug_info : Flag<["-"], "fno-limit-debug-info">, Alias<fstandalone_debug>;

def fstrict_aliasing : Flag<["-"], "fstrict-aliasing">, Group<f_Group>,
def fstrict_aliasing : Flag<["-"], "fstrict-aliasing">, Group<f_Group>,

  Flags<[DriverOption, CoreOption]>;
  Flags<[DriverOption, CoreOption]>;

def fstrict_enums : Flag<["-"], "fstrict-enums">, Group<f_Group>, Flags<[CC1Option]>,
def fstrict_enums : Flag<["-"], "fstrict-enums">, Group<f_Group>, Flags<[CC1Option]>,

  HelpText<"Enable optimizations based on the strict definition of an enum's "
  HelpText<"Enable optimizations based on the strict definition of an enum's "

           "value range">;
           "value range">;

▲ Show 20 Lines • Show All 100 Lines • ▼ Show 20 Linesdef fno_unique_section_names : Flag <["-"], "fno-unique-section-names">,

  Group<f_Group>, Flags<[CC1Option]>;
  Group<f_Group>, Flags<[CC1Option]>;







def fdebug_types_section: Flag <["-"], "fdebug-types-section">, Group<f_Group>,
def fdebug_types_section: Flag <["-"], "fdebug-types-section">, Group<f_Group>,

  Flags<[CC1Option]>, HelpText<"Place debug types in their own section (ELF Only)">;
  Flags<[CC1Option]>, HelpText<"Place debug types in their own section (ELF Only)">;

def fno_debug_types_section: Flag<["-"], "fno-debug-types-section">, Group<f_Group>,
def fno_debug_types_section: Flag<["-"], "fno-debug-types-section">, Group<f_Group>,

  Flags<[CC1Option]>;
  Flags<[CC1Option]>;

def g_Flag : Flag<["-"], "g">, Group<g_Group>,
def g_Flag : Flag<["-"], "g">, Group<g_Group>,

  HelpText<"Generate source-level debug information">, Flags<[CC1Option,CC1AsOption]>;
  HelpText<"Generate source-level debug information">;

def gline_tables_only : Flag<["-"], "gline-tables-only">, Group<g_Group>,
def gline_tables_only : Flag<["-"], "gline-tables-only">, Group<g_Group>,

  HelpText<"Emit debug line number tables only">, Flags<[CC1Option]>;
  HelpText<"Emit debug line number tables only">;

def gmlt : Flag<["-"], "gmlt">, Alias<gline_tables_only>;
def gmlt : Flag<["-"], "gmlt">, Alias<gline_tables_only>;

def g0 : Flag<["-"], "g0">, Group<g_Group>;
def g0 : Flag<["-"], "g0">, Group<g_Group>;

def g1 : Flag<["-"], "g1">, Group<g_Group>, Alias<gline_tables_only>;
def g1 : Flag<["-"], "g1">, Group<g_Group>, Alias<gline_tables_only>;

def g2 : Flag<["-"], "g2">, Group<g_Group>;
def g2 : Flag<["-"], "g2">, Group<g_Group>;

def g3 : Flag<["-"], "g3">, Group<g_Group>;
def g3 : Flag<["-"], "g3">, Group<g_Group>;

def ggdb : Flag<["-"], "ggdb">, Group<g_Group>;
def ggdb : Flag<["-"], "ggdb">, Group<g_Group>;

def ggdb0 : Flag<["-"], "ggdb0">, Alias<g0>;
def ggdb0 : Flag<["-"], "ggdb0">, Alias<g0>;

// Redirect ggdb1 to <gline_tables_only>, not <g1>,
// Redirect ggdb1 to <gline_tables_only>, not <g1>,

// because aliases of aliases aren't allowed.
// because aliases of aliases aren't allowed.

def ggdb1 : Flag<["-"], "ggdb1">, Alias<gline_tables_only>;
def ggdb1 : Flag<["-"], "ggdb1">, Alias<gline_tables_only>;

def ggdb2 : Flag<["-"], "ggdb2">, Alias<g2>;
def ggdb2 : Flag<["-"], "ggdb2">, Alias<g2>;

def ggdb3 : Flag<["-"], "ggdb3">, Alias<g3>;
def ggdb3 : Flag<["-"], "ggdb3">, Alias<g3>;

def gdwarf_2 : Flag<["-"], "gdwarf-2">, Group<g_Group>,
def gdwarf_2 : Flag<["-"], "gdwarf-2">, Group<g_Group>,

  HelpText<"Generate source-level debug information with dwarf version 2">, Flags<[CC1Option,CC1AsOption]>;
  HelpText<"Generate source-level debug information with dwarf version 2">;

def gdwarf_3 : Flag<["-"], "gdwarf-3">, Group<g_Group>,
def gdwarf_3 : Flag<["-"], "gdwarf-3">, Group<g_Group>,

  HelpText<"Generate source-level debug information with dwarf version 3">, Flags<[CC1Option,CC1AsOption]>;
  HelpText<"Generate source-level debug information with dwarf version 3">;

def gdwarf_4 : Flag<["-"], "gdwarf-4">, Group<g_Group>,
def gdwarf_4 : Flag<["-"], "gdwarf-4">, Group<g_Group>,

  HelpText<"Generate source-level debug information with dwarf version 4">, Flags<[CC1Option,CC1AsOption]>;
  HelpText<"Generate source-level debug information with dwarf version 4">;

def gcodeview : Flag<["-"], "gcodeview">,
def gcodeview : Flag<["-"], "gcodeview">,

  HelpText<"Generate CodeView debug information">,
  HelpText<"Generate CodeView debug information">,

  Flags<[CC1Option, CC1AsOption, CoreOption]>;
  Flags<[CC1Option, CC1AsOption, CoreOption]>;

// Equivalent to our default dwarf version. Forces usual dwarf emission when
// Equivalent to our default dwarf version. Forces usual dwarf emission when

// CodeView is enabled.
// CodeView is enabled.

def gdwarf : Flag<["-"], "gdwarf">, Alias<gdwarf_4>, Flags<[CoreOption]>;
def gdwarf : Flag<["-"], "gdwarf">, Alias<gdwarf_4>, Flags<[CoreOption]>;




def gfull : Flag<["-"], "gfull">, Group<g_Group>;
def gfull : Flag<["-"], "gfull">, Group<g_Group>;

▲ Show 20 Lines • Show All 915 Lines • Show Last 20 Lines
include/clang/Driver/ToolChain.h
Show First 20 Lines • Show All 273 Lines • ▼ Show 20 Linespublic:




  /// Complain if this tool chain doesn't support Objective-C ARC.
  /// Complain if this tool chain doesn't support Objective-C ARC.

  virtual void CheckObjCARC() const {}
  virtual void CheckObjCARC() const {}




  /// UseDwarfDebugFlags - Embed the compile options to clang into the Dwarf
  /// UseDwarfDebugFlags - Embed the compile options to clang into the Dwarf

  /// compile unit information.
  /// compile unit information.

  virtual bool UseDwarfDebugFlags() const { return false; }
  virtual bool UseDwarfDebugFlags() const { return false; }




  // Return the DWARF version to emit, in the absence of arguments

  // to the contrary.

  virtual unsigned GetDefaultDwarfVersion() const { return 4; }



  // True if the driver should assume "-fstandalone-debug"

  // in the absence of an option specifying otherwise,

  // provided that debugging was requested in the first place.

  // i.e. a value of 'true' does not imply that debugging is wanted.

  virtual bool GetDefaultStandaloneDebug() const { return false; }



  /// UseSjLjExceptions - Does this tool chain use SjLj exceptions.
  /// UseSjLjExceptions - Does this tool chain use SjLj exceptions.

  virtual bool UseSjLjExceptions() const { return false; }
  virtual bool UseSjLjExceptions() const { return false; }




  /// getThreadModel() - Which thread model does this target use?
  /// getThreadModel() - Which thread model does this target use?

  virtual std::string getThreadModel() const { return "posix"; }
  virtual std::string getThreadModel() const { return "posix"; }




  /// isThreadModelSupported() - Does this target support a thread model?
  /// isThreadModelSupported() - Does this target support a thread model?

  virtual bool isThreadModelSupported(const StringRef Model) const;
  virtual bool isThreadModelSupported(const StringRef Model) const;

▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines
lib/Driver/ToolChains.h
Show First 20 Lines • Show All 502 Lines • ▼ Show 20 Linespublic:




  void AddCCKextLibArgs(const llvm::opt::ArgList &Args,
  void AddCCKextLibArgs(const llvm::opt::ArgList &Args,

                        llvm::opt::ArgStringList &CmdArgs) const override;
                        llvm::opt::ArgStringList &CmdArgs) const override;




  void addClangWarningOptions(llvm::opt::ArgStringList &CC1Args) const override;
  void addClangWarningOptions(llvm::opt::ArgStringList &CC1Args) const override;




  void AddLinkARCArgs(const llvm::opt::ArgList &Args,
  void AddLinkARCArgs(const llvm::opt::ArgList &Args,

                      llvm::opt::ArgStringList &CmdArgs) const override;
                      llvm::opt::ArgStringList &CmdArgs) const override;



  unsigned GetDefaultDwarfVersion() const override { return 2; }

  // Until dtrace (via CTF) and LLDB can deal with distributed debug info,

  // Darwin defaults to standalone/full debug info.

  bool GetDefaultStandaloneDebug() const override { return true; }



  /// }
  /// }




private:
private:

  void AddLinkSanitizerLibArgs(const llvm::opt::ArgList &Args,
  void AddLinkSanitizerLibArgs(const llvm::opt::ArgList &Args,

                               llvm::opt::ArgStringList &CmdArgs,
                               llvm::opt::ArgStringList &CmdArgs,

                               StringRef Sanitizer) const;
                               StringRef Sanitizer) const;

};
};




Show All 40 Lines  Solaris(const Driver &D, const llvm::Triple &Triple,

          const llvm::opt::ArgList &Args);
          const llvm::opt::ArgList &Args);




  bool IsIntegratedAssemblerDefault() const override { return true; }
  bool IsIntegratedAssemblerDefault() const override { return true; }




  void AddClangCXXStdlibIncludeArgs(
  void AddClangCXXStdlibIncludeArgs(

      const llvm::opt::ArgList &DriverArgs,
      const llvm::opt::ArgList &DriverArgs,

      llvm::opt::ArgStringList &CC1Args) const override;
      llvm::opt::ArgStringList &CC1Args) const override;




  unsigned GetDefaultDwarfVersion() const override { return 2; }



protected:
protected:

  Tool *buildAssembler() const override;
  Tool *buildAssembler() const override;

  Tool *buildLinker() const override;
  Tool *buildLinker() const override;

};
};




class LLVM_LIBRARY_VISIBILITY MinGW : public ToolChain {
class LLVM_LIBRARY_VISIBILITY MinGW : public ToolChain {

public:
public:

  MinGW(const Driver &D, const llvm::Triple &Triple,
  MinGW(const Driver &D, const llvm::Triple &Triple,

Show All 35 Linespublic:




  bool IsMathErrnoDefault() const override { return false; }
  bool IsMathErrnoDefault() const override { return false; }

  bool IsObjCNonFragileABIDefault() const override { return true; }
  bool IsObjCNonFragileABIDefault() const override { return true; }

  bool isPIEDefault() const override { return true; }
  bool isPIEDefault() const override { return true; }




  unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const override {
  unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const override {

    return 2;
    return 2;

  }
  }

  unsigned GetDefaultDwarfVersion() const override { return 2; }




protected:
protected:

  Tool *buildAssembler() const override;
  Tool *buildAssembler() const override;

  Tool *buildLinker() const override;
  Tool *buildLinker() const override;

};
};




class LLVM_LIBRARY_VISIBILITY Bitrig : public Generic_ELF {
class LLVM_LIBRARY_VISIBILITY Bitrig : public Generic_ELF {

public:
public:

Show All 30 Linespublic:

  CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override;
  CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override;

  void AddClangCXXStdlibIncludeArgs(
  void AddClangCXXStdlibIncludeArgs(

      const llvm::opt::ArgList &DriverArgs,
      const llvm::opt::ArgList &DriverArgs,

      llvm::opt::ArgStringList &CC1Args) const override;
      llvm::opt::ArgStringList &CC1Args) const override;




  bool UseSjLjExceptions() const override;
  bool UseSjLjExceptions() const override;

  bool isPIEDefault() const override;
  bool isPIEDefault() const override;

  SanitizerMask getSupportedSanitizers() const override;
  SanitizerMask getSupportedSanitizers() const override;

  unsigned GetDefaultDwarfVersion() const override { return 2; }

  // Until dtrace (via CTF) and LLDB can deal with distributed debug info,

  // FreeBSD defaults to standalone/full debug info.

  bool GetDefaultStandaloneDebug() const override { return true; }




protected:
protected:

  Tool *buildAssembler() const override;
  Tool *buildAssembler() const override;

  Tool *buildLinker() const override;
  Tool *buildLinker() const override;

};
};




class LLVM_LIBRARY_VISIBILITY NetBSD : public Generic_ELF {
class LLVM_LIBRARY_VISIBILITY NetBSD : public Generic_ELF {

public:
public:

▲ Show 20 Lines • Show All 338 Lines • Show Last 20 Lines
lib/Driver/Tools.h
//===--- Tools.h - Tool Implementations -------------------------*- C++ -*-===//
//===--- Tools.h - Tool Implementations -------------------------*- C++ -*-===//

//
//

//                     The LLVM Compiler Infrastructure
//                     The LLVM Compiler Infrastructure

//
//

// This file is distributed under the University of Illinois Open Source
// This file is distributed under the University of Illinois Open Source

// License. See LICENSE.TXT for details.
// License. See LICENSE.TXT for details.

//
//

//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//




#ifndef LLVM_CLANG_LIB_DRIVER_TOOLS_H
#ifndef LLVM_CLANG_LIB_DRIVER_TOOLS_H

#define LLVM_CLANG_LIB_DRIVER_TOOLS_H
#define LLVM_CLANG_LIB_DRIVER_TOOLS_H




#include "clang/Basic/VersionTuple.h"
#include "clang/Basic/VersionTuple.h"

#include "clang/Driver/Tool.h"
#include "clang/Driver/Tool.h"

#include "clang/Driver/Types.h"
#include "clang/Driver/Types.h"

#include "clang/Driver/Util.h"
#include "clang/Driver/Util.h"

#include "clang/Frontend/CodeGenOptions.h"

#include "llvm/ADT/Triple.h"
#include "llvm/ADT/Triple.h"

#include "llvm/Option/Option.h"
#include "llvm/Option/Option.h"

#include "llvm/Support/Compiler.h"
#include "llvm/Support/Compiler.h"




namespace clang {
namespace clang {

class ObjCRuntime;
class ObjCRuntime;




namespace driver {
namespace driver {

▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Linesprivate:




  enum RewriteKind { RK_None, RK_Fragile, RK_NonFragile };
  enum RewriteKind { RK_None, RK_Fragile, RK_NonFragile };




  ObjCRuntime AddObjCRuntimeArgs(const llvm::opt::ArgList &args,
  ObjCRuntime AddObjCRuntimeArgs(const llvm::opt::ArgList &args,

                                 llvm::opt::ArgStringList &cmdArgs,
                                 llvm::opt::ArgStringList &cmdArgs,

                                 RewriteKind rewrite) const;
                                 RewriteKind rewrite) const;




  void AddClangCLArgs(const llvm::opt::ArgList &Args,
  void AddClangCLArgs(const llvm::opt::ArgList &Args,

                      llvm::opt::ArgStringList &CmdArgs) const;
                      llvm::opt::ArgStringList &CmdArgs,

                      enum CodeGenOptions::DebugInfoKind *DebugInfoKind,

                      bool *EmitCodeView) const;




  visualstudio::Compiler *getCLFallback() const;
  visualstudio::Compiler *getCLFallback() const;




  mutable std::unique_ptr<visualstudio::Compiler> CLFallback;
  mutable std::unique_ptr<visualstudio::Compiler> CLFallback;




public:
public:

  // CAUTION! The first constructor argument ("clang") is not arbitrary,
  // CAUTION! The first constructor argument ("clang") is not arbitrary,

  // as it is for other tools. Some operations on a Tool actually test
  // as it is for other tools. Some operations on a Tool actually test

▲ Show 20 Lines • Show All 736 Lines • Show Last 20 Lines
lib/Driver/Tools.cpp
  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 2,317 Lines • ▼ Show 20 Lines    for (const auto &Act : C.getActions()) {

      }
      }

    }
    }

  }
  }




  return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
  return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,

                      RelaxDefault);
                      RelaxDefault);

}
}




// Extract the integer N from a string spelled "-dwarf-N", returning 0

// on mismatch. The StringRef input (rather than an Arg) allows

// for use by the "-Xassembler" option parser.

static unsigned DwarfVersionNum(StringRef ArgValue) {

  return llvm::StringSwitch<unsigned>(ArgValue)

      .Case("-gdwarf-2", 2)

      .Case("-gdwarf-3", 3)

      .Case("-gdwarf-4", 4)

      .Default(0);

}



static void RenderDebugEnablingArgs(ArgStringList &CmdArgs,

                                    CodeGenOptions::DebugInfoKind DebugInfoKind,

                                    unsigned DwarfVersion) {

  switch (DebugInfoKind) {

  case CodeGenOptions::DebugLineTablesOnly:

    CmdArgs.push_back("-di-kind=line-tables");

    break;

  case CodeGenOptions::LimitedDebugInfo:

    CmdArgs.push_back("-di-kind=limited");

    break;

  case CodeGenOptions::FullDebugInfo:

    CmdArgs.push_back("-di-kind=full");

    break;

  default:

    break;

  }

  switch (DwarfVersion) {

jyknightUnsubmitted
Not Done
ReplyInline Actions
How about:



if (DwarfVersion > 0) CmdArgs.push_back("-dwarf-version=" + DwarfVersion);
jyknight: How about:
  if (DwarfVersion > 0) CmdArgs.push_back("-dwarf-version=" + DwarfVersion);
dougkAuthorUnsubmitted
Not Done
ReplyInline Actions
minor point: the "+" syntax you've used is actually pointer arithmetic, but giving the benefit of doubt there, and writing it as to_string(DwarfVersion), the annoying thing is that CmdArgs wants a 'const char*'.

To get one, you have to call MakeArgString which is a method on Args, not CmdArgs, so you have to pass both.

I did that in the latest patch, see what you think.
dougk: minor point: the "+" syntax you've used is actually pointer arithmetic, but giving the benefit…
  case 2:

    CmdArgs.push_back("-dwarf-version=2");

    break;

  case 3:

    CmdArgs.push_back("-dwarf-version=3");

    break;

  case 4:

    CmdArgs.push_back("-dwarf-version=4");

    break;

  default:

    break;

  }

}



static void CollectArgsForIntegratedAssembler(Compilation &C,
static void CollectArgsForIntegratedAssembler(Compilation &C,

                                              const ArgList &Args,
                                              const ArgList &Args,

                                              ArgStringList &CmdArgs,
                                              ArgStringList &CmdArgs,

                                              const Driver &D) {
                                              const Driver &D) {

  if (UseRelaxAll(C, Args))
  if (UseRelaxAll(C, Args))

    CmdArgs.push_back("-mrelax-all");
    CmdArgs.push_back("-mrelax-all");




  // When passing -I arguments to the assembler we sometimes need to
  // When passing -I arguments to the assembler we sometimes need to

Show All 33 Lines    for (StringRef Value : A->getValues()) {

        CompressDebugSections = false;
        CompressDebugSections = false;

      } else if (Value.startswith("-I")) {
      } else if (Value.startswith("-I")) {

        CmdArgs.push_back(Value.data());
        CmdArgs.push_back(Value.data());

        // We need to consume the next argument if the current arg is a plain
        // We need to consume the next argument if the current arg is a plain

        // -I. The next arg will be the include directory.
        // -I. The next arg will be the include directory.

        if (Value == "-I")
        if (Value == "-I")

          TakeNextArg = true;
          TakeNextArg = true;

      } else if (Value.startswith("-gdwarf-")) {
      } else if (Value.startswith("-gdwarf-")) {

        // "-gdwarf-N" options are not cc1as options.

        unsigned DwarfVersion = DwarfVersionNum(Value);

        if (DwarfVersion == 0) { // Send it onward, and let cc1as complain.

        CmdArgs.push_back(Value.data());
          CmdArgs.push_back(Value.data());

        } else {

          RenderDebugEnablingArgs(CmdArgs, CodeGenOptions::LimitedDebugInfo,

                                  DwarfVersion);

        }

      } else if (Value.startswith("-mcpu") || Value.startswith("-mfpu") ||
      } else if (Value.startswith("-mcpu") || Value.startswith("-mfpu") ||

                 Value.startswith("-mhwdiv") || Value.startswith("-march")) {
                 Value.startswith("-mhwdiv") || Value.startswith("-march")) {

        // Do nothing, we'll validate it later.
        // Do nothing, we'll validate it later.

      } else if (Value == "--trap") {
      } else if (Value == "--trap") {

        CmdArgs.push_back("-target-feature");
        CmdArgs.push_back("-target-feature");

        CmdArgs.push_back("+use-tcc-in-div");
        CmdArgs.push_back("+use-tcc-in-div");

      } else if (Value == "--break") {
      } else if (Value == "--break") {

        CmdArgs.push_back("-target-feature");
        CmdArgs.push_back("-target-feature");

▲ Show 20 Lines • Show All 1,365 Lines • ▼ Show 20 Lines  case llvm::Triple::x86_64:

    AddX86TargetArgs(Args, CmdArgs);
    AddX86TargetArgs(Args, CmdArgs);

    break;
    break;




  case llvm::Triple::hexagon:
  case llvm::Triple::hexagon:

    AddHexagonTargetArgs(Args, CmdArgs);
    AddHexagonTargetArgs(Args, CmdArgs);

    break;
    break;

  }
  }




  // The 'g' groups options involve a somewhat intricate sequence of decisions

  // about what to pass from the driver to the frontend, but by the time they

  // reach cc1 they've been factored into two well-defined orthogonal choices:

  //  * what level of debug info to generate

  //  * what dwarf version to write

  // This avoids having to monkey around further in cc1 other than to disable

  // codeview if not running in a Windows environment. Perhaps even that

  // decision should be made in the driver as well though.

  enum CodeGenOptions::DebugInfoKind DebugInfoKind =

      CodeGenOptions::NoDebugInfo;

  // These two are potentially updated by AddClangCLArgs.

  unsigned DwarfVersion = 0;

  bool EmitCodeView = false;



  // Add clang-cl arguments.
  // Add clang-cl arguments.

  if (getToolChain().getDriver().IsCLMode())
  if (getToolChain().getDriver().IsCLMode())

    AddClangCLArgs(Args, CmdArgs);
    AddClangCLArgs(Args, CmdArgs, &DebugInfoKind, &EmitCodeView);




  // Pass the linker version in use.
  // Pass the linker version in use.

  if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
  if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {

    CmdArgs.push_back("-target-linker-version");
    CmdArgs.push_back("-target-linker-version");

    CmdArgs.push_back(A->getValue());
    CmdArgs.push_back(A->getValue());

  }
  }




  if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
  if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))

Show All 24 Lines#endif

  Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
  Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);




  if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
  if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {

    CmdArgs.push_back("-diagnostic-log-file");
    CmdArgs.push_back("-diagnostic-log-file");

    CmdArgs.push_back(D.CCLogDiagnosticsFilename ? D.CCLogDiagnosticsFilename
    CmdArgs.push_back(D.CCLogDiagnosticsFilename ? D.CCLogDiagnosticsFilename

                                                 : "-");
                                                 : "-");

  }
  }




  // Use the last option from "-g" group. "-gline-tables-only" and "-gdwarf-x"

  // are preserved, all other debug options are substituted with "-g".

  Args.ClaimAllArgs(options::OPT_g_Group);
  Args.ClaimAllArgs(options::OPT_g_Group);

  Arg *SplitDwarfArg = Args.getLastArg(options::OPT_gsplit_dwarf);
  Arg *SplitDwarfArg = Args.getLastArg(options::OPT_gsplit_dwarf);

  if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
  if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {

    // If you say "-gline-tables-only -gsplit-dwarf", split-dwarf wins,

    // which mandates turning on "-g". But -split-dwarf is not a g_group option,

    // hence it takes a nontrivial test to decide about line-tables-only.

    if (A->getOption().matches(options::OPT_gline_tables_only) &&
    if (A->getOption().matches(options::OPT_gline_tables_only) &&

        (!SplitDwarfArg || A->getIndex() > SplitDwarfArg->getIndex())) {
        (!SplitDwarfArg || A->getIndex() > SplitDwarfArg->getIndex())) {

      // FIXME: we should support specifying dwarf version with
      DebugInfoKind = CodeGenOptions::DebugLineTablesOnly;

      // -gline-tables-only.

      CmdArgs.push_back("-gline-tables-only");

      // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.

      const llvm::Triple &Triple = getToolChain().getTriple();

      if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||

          Triple.getOS() == llvm::Triple::FreeBSD ||

          Triple.getOS() == llvm::Triple::Solaris)

        CmdArgs.push_back("-gdwarf-2");

      SplitDwarfArg = nullptr;
      SplitDwarfArg = nullptr;

    } else if (A->getOption().matches(options::OPT_gdwarf_2) ||

               A->getOption().matches(options::OPT_gdwarf_3) ||

               A->getOption().matches(options::OPT_gdwarf_4)) {

      A->render(Args, CmdArgs);

    } else if (!A->getOption().matches(options::OPT_g0)) {
    } else if (!A->getOption().matches(options::OPT_g0)) {

      // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.
      // Some 'g' group option other than one expressly disabling debug info

      const llvm::Triple &Triple = getToolChain().getTriple();
      // must have been the final (winning) one. They're all equivalent.

      if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
      DebugInfoKind = CodeGenOptions::LimitedDebugInfo;

          Triple.getOS() == llvm::Triple::FreeBSD ||

          Triple.getOS() == llvm::Triple::Solaris)

        CmdArgs.push_back("-gdwarf-2");

      else

        CmdArgs.push_back("-g");

    }
    }

  }
  }




  // If a -gdwarf argument appeared, use it, unless DebugInfoKind is None

  // (because that would mean that "-g0" was the rightmost 'g' group option).

  if (Arg *A = Args.getLastArg(options::OPT_gdwarf_2, options::OPT_gdwarf_3,

                               options::OPT_gdwarf_4))

    DwarfVersion = DwarfVersionNum(A->getSpelling());



  // Forward -gcodeview.
  // Forward -gcodeview.

  Args.AddLastArg(CmdArgs, options::OPT_gcodeview);
  // 'EmitCodeView might have been set by CL-compatibility argument parsing.

  if (Args.hasArg(options::OPT_gcodeview) || EmitCodeView) {

    // DwarfVersion remains at 0 if no explicit choice was made.

    CmdArgs.push_back("-gcodeview");

  } else if (DwarfVersion == 0 &&

             DebugInfoKind != CodeGenOptions::NoDebugInfo) {

    DwarfVersion = getToolChain().GetDefaultDwarfVersion();

  }




  // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
  // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.

  Args.ClaimAllArgs(options::OPT_g_flags_Group);
  Args.ClaimAllArgs(options::OPT_g_flags_Group);

  if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
  if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,

                   /*Default*/ true))
                   /*Default*/ true))

    CmdArgs.push_back("-dwarf-column-info");
    CmdArgs.push_back("-dwarf-column-info");




  // FIXME: Move backend command line options to the module.
  // FIXME: Move backend command line options to the module.

  if (Args.hasArg(options::OPT_gmodules)) {
  if (Args.hasArg(options::OPT_gmodules)) {

    CmdArgs.push_back("-g");
    DebugInfoKind = CodeGenOptions::LimitedDebugInfo;

    CmdArgs.push_back("-dwarf-ext-refs");
    CmdArgs.push_back("-dwarf-ext-refs");

    CmdArgs.push_back("-fmodule-format=obj");
    CmdArgs.push_back("-fmodule-format=obj");

  }
  }




  // -gsplit-dwarf should turn on -g and enable the backend dwarf
  // -gsplit-dwarf should turn on -g and enable the backend dwarf

  // splitting and extraction.
  // splitting and extraction.

  // FIXME: Currently only works on Linux.
  // FIXME: Currently only works on Linux.

  if (getToolChain().getTriple().isOSLinux() && SplitDwarfArg) {
  if (getToolChain().getTriple().isOSLinux() && SplitDwarfArg) {

    CmdArgs.push_back("-g");
    DebugInfoKind = CodeGenOptions::LimitedDebugInfo;

    CmdArgs.push_back("-backend-option");
    CmdArgs.push_back("-backend-option");

    CmdArgs.push_back("-split-dwarf=Enable");
    CmdArgs.push_back("-split-dwarf=Enable");

  }
  }




  // After we've dealt with all combinations of things that could

  // make DebugInfoKind be other than None or DebugLineTablesOnly,

  // figure out if we need to "upgrade" it to standalone debug info.

  // We parse these two '-f' options whether or not they will be used,

  // to claim them even if you wrote "-fstandalone-debug -gline-tables-only"

  bool NeedFullDebug = Args.hasFlag(options::OPT_fstandalone_debug,

                                    options::OPT_fno_standalone_debug,

                                    getToolChain().GetDefaultStandaloneDebug());

  if (DebugInfoKind == CodeGenOptions::LimitedDebugInfo && NeedFullDebug)

    DebugInfoKind = CodeGenOptions::FullDebugInfo;

  RenderDebugEnablingArgs(CmdArgs, DebugInfoKind, DwarfVersion);



  // -ggnu-pubnames turns on gnu style pubnames in the backend.
  // -ggnu-pubnames turns on gnu style pubnames in the backend.

  if (Args.hasArg(options::OPT_ggnu_pubnames)) {
  if (Args.hasArg(options::OPT_ggnu_pubnames)) {

    CmdArgs.push_back("-backend-option");
    CmdArgs.push_back("-backend-option");

    CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
    CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");

  }
  }




  // -gdwarf-aranges turns on the emission of the aranges section in the
  // -gdwarf-aranges turns on the emission of the aranges section in the

  // backend.
  // backend.

▲ Show 20 Lines • Show All 346 Lines • ▼ Show 20 Lines#endif

  // -fhosted is default.
  // -fhosted is default.

  if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
  if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||

      KernelOrKext)
      KernelOrKext)

    CmdArgs.push_back("-ffreestanding");
    CmdArgs.push_back("-ffreestanding");




  // Forward -f (flag) options which we can pass directly.
  // Forward -f (flag) options which we can pass directly.

  Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
  Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);

  Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
  Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);

  Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);

  Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);

  Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
  Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);

  // Emulated TLS is enabled by default on Android, and can be enabled manually
  // Emulated TLS is enabled by default on Android, and can be enabled manually

  // with -femulated-tls.
  // with -femulated-tls.

  bool EmulatedTLSDefault = Triple.getEnvironment() == llvm::Triple::Android;
  bool EmulatedTLSDefault = Triple.getEnvironment() == llvm::Triple::Android;

  if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,
  if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,

                   EmulatedTLSDefault))
                   EmulatedTLSDefault))

    CmdArgs.push_back("-femulated-tls");
    CmdArgs.push_back("-femulated-tls");

  // AltiVec-like language extensions aren't relevant for assembling.
  // AltiVec-like language extensions aren't relevant for assembling.

▲ Show 20 Lines • Show All 1,138 Lines • ▼ Show 20 Linesstatic EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) {




  // FIXME: Disable C++ EH completely, until it becomes more reliable. Users
  // FIXME: Disable C++ EH completely, until it becomes more reliable. Users

  // can use -Xclang to manually enable C++ EH until then.
  // can use -Xclang to manually enable C++ EH until then.

  EH = EHFlags();
  EH = EHFlags();




  return EH;
  return EH;

}
}




void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs,

                           enum CodeGenOptions::DebugInfoKind *DebugInfoKind,

                           bool *EmitCodeView) const {

  unsigned RTOptionID = options::OPT__SLASH_MT;
  unsigned RTOptionID = options::OPT__SLASH_MT;




  if (Args.hasArg(options::OPT__SLASH_LDd))
  if (Args.hasArg(options::OPT__SLASH_LDd))

    // The /LDd option implies /MTd. The dependent lib part can be overridden,
    // The /LDd option implies /MTd. The dependent lib part can be overridden,

    // but defining _DEBUG is sticky.
    // but defining _DEBUG is sticky.

    RTOptionID = options::OPT__SLASH_MTd;
    RTOptionID = options::OPT__SLASH_MTd;




  if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
  if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))

▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines    if (Arg *A = Args.getLastArg(options::OPT_show_includes))

      A->render(Args, CmdArgs);
      A->render(Args, CmdArgs);




  // This controls whether or not we emit RTTI data for polymorphic types.
  // This controls whether or not we emit RTTI data for polymorphic types.

  if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
  if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,

                   /*default=*/false))
                   /*default=*/false))

    CmdArgs.push_back("-fno-rtti-data");
    CmdArgs.push_back("-fno-rtti-data");




  // Emit CodeView if -Z7 is present.
  // Emit CodeView if -Z7 is present.

  bool EmitCodeView = Args.hasArg(options::OPT__SLASH_Z7);
  *EmitCodeView = Args.hasArg(options::OPT__SLASH_Z7);

  bool EmitDwarf = Args.hasArg(options::OPT_gdwarf);
  bool EmitDwarf = Args.hasArg(options::OPT_gdwarf);

  // If we are emitting CV but not DWARF, don't build information that LLVM
  // If we are emitting CV but not DWARF, don't build information that LLVM

  // can't yet process.
  // can't yet process.

  if (EmitCodeView && !EmitDwarf)
  if (*EmitCodeView && !EmitDwarf)

    CmdArgs.push_back("-gline-tables-only");
    *DebugInfoKind = CodeGenOptions::DebugLineTablesOnly;

  if (EmitCodeView)
  if (*EmitCodeView)

    CmdArgs.push_back("-gcodeview");
    CmdArgs.push_back("-gcodeview");




  const Driver &D = getToolChain().getDriver();
  const Driver &D = getToolChain().getDriver();

  EHFlags EH = parseClangCLEHFlags(D, Args);
  EHFlags EH = parseClangCLEHFlags(D, Args);

  // FIXME: Do something with NoExceptC.
  // FIXME: Do something with NoExceptC.

  if (EH.Synch || EH.Asynch) {
  if (EH.Synch || EH.Asynch) {

    CmdArgs.push_back("-fcxx-exceptions");
    CmdArgs.push_back("-fcxx-exceptions");

    CmdArgs.push_back("-fexceptions");
    CmdArgs.push_back("-fexceptions");

▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 Lines  while (SourceAction->getKind() != Action::InputClass) {

    assert(!SourceAction->getInputs().empty() && "unexpected root action!");
    assert(!SourceAction->getInputs().empty() && "unexpected root action!");

    SourceAction = SourceAction->getInputs()[0];
    SourceAction = SourceAction->getInputs()[0];

  }
  }




  // Forward -g and handle debug info related flags, assuming we are dealing
  // Forward -g and handle debug info related flags, assuming we are dealing

  // with an actual assembly file.
  // with an actual assembly file.

  if (SourceAction->getType() == types::TY_Asm ||
  if (SourceAction->getType() == types::TY_Asm ||

      SourceAction->getType() == types::TY_PP_Asm) {
      SourceAction->getType() == types::TY_PP_Asm) {

    bool WantDebug = false;

    unsigned DwarfVersion = 0;

    Args.ClaimAllArgs(options::OPT_g_Group);
    Args.ClaimAllArgs(options::OPT_g_Group);

    if (Arg *A = Args.getLastArg(options::OPT_g_Group))
    if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {

      if (!A->getOption().matches(options::OPT_g0))
      WantDebug = !A->getOption().matches(options::OPT_g0);

        CmdArgs.push_back("-g");
      if (WantDebug) {


        if ((DwarfVersion = DwarfVersionNum(A->getSpelling())) == 0)

    if (Arg *A = Args.getLastArg(options::OPT_gdwarf_2, options::OPT_gdwarf_3,
          DwarfVersion = getToolChain().GetDefaultDwarfVersion();

                                 options::OPT_gdwarf_4))
      }

      A->render(Args, CmdArgs);
    }

    RenderDebugEnablingArgs(CmdArgs,

                            (WantDebug ? CodeGenOptions::LimitedDebugInfo

                                       : CodeGenOptions::NoDebugInfo),

                            DwarfVersion);




    // Add the -fdebug-compilation-dir flag if needed.
    // Add the -fdebug-compilation-dir flag if needed.

    addDebugCompDirArg(Args, CmdArgs);
    addDebugCompDirArg(Args, CmdArgs);




    // Set the AT_producer to the clang version when using the integrated
    // Set the AT_producer to the clang version when using the integrated

    // assembler on assembly source files.
    // assembler on assembly source files.

    CmdArgs.push_back("-dwarf-debug-producer");
    CmdArgs.push_back("-dwarf-debug-producer");

    CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
    CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));

▲ Show 20 Lines • Show All 4,247 Lines • Show Last 20 Lines
lib/Frontend/CompilerInvocation.cpp
Show First 20 Lines • Show All 387 Lines • ▼ Show 20 Lines  if (Arg *A = Args.getLastArg(OPT_fveclib)) {

    if (Name == "Accelerate")
    if (Name == "Accelerate")

      Opts.setVecLib(CodeGenOptions::Accelerate);
      Opts.setVecLib(CodeGenOptions::Accelerate);

    else if (Name == "none")
    else if (Name == "none")

      Opts.setVecLib(CodeGenOptions::NoLibrary);
      Opts.setVecLib(CodeGenOptions::NoLibrary);

    else
    else

      Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
      Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;

  }
  }




  if (Args.hasArg(OPT_gline_tables_only)) {
  if (Arg *A = Args.getLastArg(OPT_debug_info_kind_EQ)) {

    Opts.setDebugInfo(CodeGenOptions::DebugLineTablesOnly);
    Opts.setDebugInfo(

  } else if (Args.hasArg(OPT_g_Flag) || Args.hasArg(OPT_gdwarf_2) ||
        llvm::StringSwitch<CodeGenOptions::DebugInfoKind>(A->getValue())

             Args.hasArg(OPT_gdwarf_3) || Args.hasArg(OPT_gdwarf_4)) {
            .Case("line-tables", CodeGenOptions::DebugLineTablesOnly)

    bool Default = false;
            .Case("limited", CodeGenOptions::LimitedDebugInfo)

    // Until dtrace (via CTF) and LLDB can deal with distributed debug info,
            .Case("full", CodeGenOptions::FullDebugInfo));

    // Darwin and FreeBSD default to standalone/full debug info.

    if (llvm::Triple(TargetOpts.Triple).isOSDarwin() ||

        llvm::Triple(TargetOpts.Triple).isOSFreeBSD())

      Default = true;



    if (Args.hasFlag(OPT_fstandalone_debug, OPT_fno_standalone_debug, Default))

      Opts.setDebugInfo(CodeGenOptions::FullDebugInfo);

    else

      Opts.setDebugInfo(CodeGenOptions::LimitedDebugInfo);

  }
  }

  Opts.DwarfVersion = getLastArgIntValue(Args, OPT_dwarf_version_EQ, 0, Diags);

  Opts.DebugColumnInfo = Args.hasArg(OPT_dwarf_column_info);
  Opts.DebugColumnInfo = Args.hasArg(OPT_dwarf_column_info);

  if (Args.hasArg(OPT_gcodeview)) {
  Opts.EmitCodeView = Args.hasArg(OPT_gcodeview);

    Opts.EmitCodeView = true;

    Opts.DwarfVersion = 0;

  } else if (Opts.getDebugInfo() != CodeGenOptions::NoDebugInfo) {

    // Default Dwarf version is 4 if we are generating debug information.

    Opts.DwarfVersion = 4;

  }

  Opts.SplitDwarfFile = Args.getLastArgValue(OPT_split_dwarf_file);
  Opts.SplitDwarfFile = Args.getLastArgValue(OPT_split_dwarf_file);

  if (Args.hasArg(OPT_gdwarf_2))

    Opts.DwarfVersion = 2;

  else if (Args.hasArg(OPT_gdwarf_3))

    Opts.DwarfVersion = 3;

  else if (Args.hasArg(OPT_gdwarf_4))

    Opts.DwarfVersion = 4;

  Opts.DebugTypeExtRefs = Args.hasArg(OPT_dwarf_ext_refs);
  Opts.DebugTypeExtRefs = Args.hasArg(OPT_dwarf_ext_refs);




  if (const Arg *A =
  if (const Arg *A =

          Args.getLastArg(OPT_emit_llvm_uselists, OPT_no_emit_llvm_uselists))
          Args.getLastArg(OPT_emit_llvm_uselists, OPT_no_emit_llvm_uselists))

    Opts.EmitLLVMUseLists = A->getOption().getID() == OPT_emit_llvm_uselists;
    Opts.EmitLLVMUseLists = A->getOption().getID() == OPT_emit_llvm_uselists;




  Opts.DisableLLVMOpts = Args.hasArg(OPT_disable_llvm_optzns);
  Opts.DisableLLVMOpts = Args.hasArg(OPT_disable_llvm_optzns);

  Opts.DisableLLVMPasses = Args.hasArg(OPT_disable_llvm_passes);
  Opts.DisableLLVMPasses = Args.hasArg(OPT_disable_llvm_passes);

▲ Show 20 Lines • Show All 1,724 Lines • Show Last 20 Lines
test/CodeGen/2006-01-13-Includes.c
// RUN: %clang_cc1 %s -g -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 %s -di-kind=limited -emit-llvm -o - | FileCheck %s

// PR676
// PR676




int printf(const char * restrict format, ...);
int printf(const char * restrict format, ...);




void test() {
void test() {

  printf("Hello World\n");
  printf("Hello World\n");

}
}




// CHECK: test{{[\\/]}}CodeGen
// CHECK: test{{[\\/]}}CodeGen

test/CodeGen/2007-05-11-str-const.c
// RUN: %clang_cc1 -emit-llvm -g %s  -o /dev/null
// RUN: %clang_cc1 -emit-llvm -di-kind=limited %s  -o /dev/null




static unsigned char out[]={0,1};
static unsigned char out[]={0,1};

static const unsigned char str1[]="1";
static const unsigned char str1[]="1";




test/CodeGen/2009-01-21-InvalidIterator.c
// RUN: %clang_cc1 %s -emit-llvm -g -o /dev/null
// RUN: %clang_cc1 %s -emit-llvm -di-kind=limited -o /dev/null




typedef long unsigned int size_t;
typedef long unsigned int size_t;

typedef unsigned short int uint16_t;
typedef unsigned short int uint16_t;

typedef unsigned int uint32_t;
typedef unsigned int uint32_t;

typedef unsigned long int uint64_t;
typedef unsigned long int uint64_t;

typedef uint16_t Elf64_Half;
typedef uint16_t Elf64_Half;

typedef uint32_t Elf64_Word;
typedef uint32_t Elf64_Word;

typedef uint64_t Elf64_Xword;
typedef uint64_t Elf64_Xword;

▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines
test/CodeGen/2009-03-13-dbg.c
// RUN: %clang_cc1 %s -emit-llvm -g -o /dev/null
// RUN: %clang_cc1 %s -emit-llvm -di-kind=limited -o /dev/null

void foo() {}
void foo() {}

test/CodeGen/2009-04-23-dbg.c
// RUN: %clang_cc1 -S -g -o %t %s
// RUN: %clang_cc1 -S -di-kind=limited -o %t %s

# 1 "a.c"
# 1 "a.c"

# 1 "a.c" 1
# 1 "a.c" 1

# 1 "<built-in>" 1
# 1 "<built-in>" 1

# 103 "<built-in>"
# 103 "<built-in>"

# 103 "<command line>" 1
# 103 "<command line>" 1




# 1 "/private/tmp/a.h" 1
# 1 "/private/tmp/a.h" 1

int bar;
int bar;

Show All 11 Lines
test/CodeGen/2009-07-31-DbgDeclare.c
// RUN: %clang_cc1 -S -g -o %t.s %s
// RUN: %clang_cc1 -S -di-kind=limited -o %t.s %s

void foo() {
void foo() {

     int i = 0;
     int i = 0;

     i = 42;
     i = 42;

}
}

test/CodeGen/2010-01-14-FnType-DebugInfo.c
// RUN: %clang_cc1 %s -emit-llvm -g -o /dev/null
// RUN: %clang_cc1 %s -emit-llvm -di-kind=limited -o /dev/null

typedef void (*sigcatch_t)( struct sigcontext *);
typedef void (*sigcatch_t)( struct sigcontext *);

sigcatch_t sigcatch[50] = {(sigcatch_t) 0};
sigcatch_t sigcatch[50] = {(sigcatch_t) 0};




test/CodeGen/2010-01-18-Inlined-Debug.c
// PR: 6058
// PR: 6058

// RUN: %clang_cc1 -g -emit-llvm %s -o /dev/null
// RUN: %clang_cc1 -di-kind=limited -emit-llvm %s -o /dev/null




static inline int foo(double) __attribute__ ((always_inline));
static inline int foo(double) __attribute__ ((always_inline));

static inline int foo(double __x) { return __x; }
static inline int foo(double __x) { return __x; }




void bar(double x) {
void bar(double x) {

  foo(x);
  foo(x);

}
}










test/CodeGen/2010-02-10-PointerName.c
// RUN: %clang_cc1 %s -emit-llvm -g -o - | FileCheck %s
// RUN: %clang_cc1 %s -emit-llvm -di-kind=limited -o - | FileCheck %s

// CHECK: DW_TAG_pointer_type
// CHECK: DW_TAG_pointer_type

// CHECK-NOT: {"char"}
// CHECK-NOT: {"char"}




char i = 1;
char i = 1;

void foo() {
void foo() {

  char *cp = &i;
  char *cp = &i;

}
}




test/CodeGen/2010-02-15-DbgStaticVar.c
// RUN: %clang_cc1 -g -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -di-kind=limited -emit-llvm %s -o - | FileCheck %s

// Test to check intentionally empty linkage name for a static variable.
// Test to check intentionally empty linkage name for a static variable.

// Radar 7651244.
// Radar 7651244.

static int foo(int a)
static int foo(int a)

{
{

  static int b = 1;
  static int b = 1;

  return b+a;
  return b+a;

}
}




int main() {
int main() {

  int j = foo(1);
  int j = foo(1);

  return 0;
  return 0;

}
}

// CHECK: !DIGlobalVariable(name: "b",
// CHECK: !DIGlobalVariable(name: "b",

// CHECK-NOT:               linkageName:
// CHECK-NOT:               linkageName:

// CHECK-SAME:              ){{$}}
// CHECK-SAME:              ){{$}}

test/CodeGen/2010-02-16-DbgScopes.c
// RUN: %clang_cc1 -emit-llvm -g < %s | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited < %s | FileCheck %s

// Test to check number of lexical scope identified in debug info.
// Test to check number of lexical scope identified in debug info.

// CHECK: !DILexicalBlock(
// CHECK: !DILexicalBlock(

// CHECK: !DILexicalBlock(
// CHECK: !DILexicalBlock(

// CHECK: !DILexicalBlock(
// CHECK: !DILexicalBlock(

// CHECK: !DILexicalBlock(
// CHECK: !DILexicalBlock(




extern int bar();
extern int bar();

extern void foobar();
extern void foobar();

Show All 13 Lines
test/CodeGen/2010-03-5-LexicalScope.c
// RUN: %clang_cc1 -emit-llvm -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited %s -o - | FileCheck %s

// CHECK: !DILexicalBlock(
// CHECK: !DILexicalBlock(

// CHECK: !DILexicalBlock(
// CHECK: !DILexicalBlock(

int foo(int i) {
int foo(int i) {

  if (i) {
  if (i) {

    int j = 2;
    int j = 2;

  }
  }

  else {
  else {

    int j = 3;
    int j = 3;

  }
  }

  return i;
  return i;

}
}

test/CodeGen/2010-07-08-DeclDebugLineNo.c
// RUN: %clang_cc1 -emit-llvm -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited %s -o - | FileCheck %s

// Insure that dbg.declare lines for locals refer to correct line number records.
// Insure that dbg.declare lines for locals refer to correct line number records.

// Radar 8152866.
// Radar 8152866.

void foo() {
void foo() {

  int l = 0;    // line #4: CHECK: {{call.*llvm.dbg.declare.*%l.*\!dbg }}[[variable_l:![0-9]+]]
  int l = 0;    // line #4: CHECK: {{call.*llvm.dbg.declare.*%l.*\!dbg }}[[variable_l:![0-9]+]]

  int p = 0;    // line #5: CHECK: {{call.*llvm.dbg.declare.*%p.*\!dbg }}[[variable_p:![0-9]+]]
  int p = 0;    // line #5: CHECK: {{call.*llvm.dbg.declare.*%p.*\!dbg }}[[variable_p:![0-9]+]]

}
}

// Now match the line number records:
// Now match the line number records:

// CHECK: {{^}}[[variable_l]] = !DILocation(line: 5,
// CHECK: {{^}}[[variable_l]] = !DILocation(line: 5,

// CHECK: {{^}}[[variable_p]] = !DILocation(line: 6,
// CHECK: {{^}}[[variable_p]] = !DILocation(line: 6,

test/CodeGen/2010-08-10-DbgConstant.c
// RUN: %clang_cc1 -S -emit-llvm -g  %s -o - | FileCheck %s
// RUN: %clang_cc1 -S -emit-llvm -di-kind=limited  %s -o - | FileCheck %s

// CHECK: !DIGlobalVariable(
// CHECK: !DIGlobalVariable(




static const unsigned int ro = 201;
static const unsigned int ro = 201;

void bar(int);
void bar(int);

void foo() { bar(ro); }
void foo() { bar(ro); }

test/CodeGen/attr-nodebug.c
// RUN: %clang_cc1 -g -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -di-kind=limited -emit-llvm -o - %s | FileCheck %s




void t1() __attribute__((nodebug));
void t1() __attribute__((nodebug));




void t1()
void t1()

{
{

  int a = 10;
  int a = 10;

  a++;
  a++;

}
}

Show All 23 Lines
test/CodeGen/attr-noinline.c
// RUN: %clang_cc1 -g -emit-llvm -o %t %s
// RUN: %clang_cc1 -di-kind=limited -emit-llvm -o %t %s

// RUN: grep 'noinline' %t
// RUN: grep 'noinline' %t




void t1() __attribute__((noinline));
void t1() __attribute__((noinline));




void t1()
void t1()

{
{

}
}




test/CodeGen/cleanup-destslot-simple.c
// RUN: %clang_cc1 -O1 -triple x86_64-none-linux-gnu -emit-llvm -gline-tables-only %s -o - | FileCheck %s --check-prefix=CHECK --check-prefix=LIFETIME
// RUN: %clang_cc1 -O1 -triple x86_64-none-linux-gnu -emit-llvm -di-kind=line-tables %s -o - | FileCheck %s --check-prefix=CHECK --check-prefix=LIFETIME




// We shouldn't have markers at -O0 or with msan.
// We shouldn't have markers at -O0 or with msan.

// RUN: %clang_cc1 -O0 -triple x86_64-none-linux-gnu -emit-llvm -gline-tables-only %s -o - | FileCheck %s --check-prefix=CHECK
// RUN: %clang_cc1 -O0 -triple x86_64-none-linux-gnu -emit-llvm -di-kind=line-tables %s -o - | FileCheck %s --check-prefix=CHECK

// RUN: %clang_cc1 -O1 -triple x86_64-none-linux-gnu -emit-llvm -gline-tables-only %s -o - -fsanitize=memory | FileCheck %s --check-prefix=CHECK
// RUN: %clang_cc1 -O1 -triple x86_64-none-linux-gnu -emit-llvm -di-kind=line-tables %s -o - -fsanitize=memory | FileCheck %s --check-prefix=CHECK




// There is no exception to handle here, lifetime.end is not a destructor,
// There is no exception to handle here, lifetime.end is not a destructor,

// so there is no need have cleanup dest slot related code
// so there is no need have cleanup dest slot related code

// CHECK-LABEL: define i32 @test
// CHECK-LABEL: define i32 @test

int test() {
int test() {

  int x = 3;
  int x = 3;

  int *volatile p = &x;
  int *volatile p = &x;

  return *p;
  return *p;

// CHECK: [[X:%.*]] = alloca i32
// CHECK: [[X:%.*]] = alloca i32

// CHECK: [[P:%.*]] = alloca i32*
// CHECK: [[P:%.*]] = alloca i32*

// LIFETIME: call void @llvm.lifetime.start(i64 4, i8* %{{.*}}){{( #[0-9]+)?}}, !dbg
// LIFETIME: call void @llvm.lifetime.start(i64 4, i8* %{{.*}}){{( #[0-9]+)?}}, !dbg

// LIFETIME: call void @llvm.lifetime.start(i64 8, i8* %{{.*}}){{( #[0-9]+)?}}, !dbg
// LIFETIME: call void @llvm.lifetime.start(i64 8, i8* %{{.*}}){{( #[0-9]+)?}}, !dbg

// CHECK-NOT: store i32 %{{.*}}, i32* %cleanup.dest.slot
// CHECK-NOT: store i32 %{{.*}}, i32* %cleanup.dest.slot

// LIFETIME: call void @llvm.lifetime.end(i64 8, {{.*}}){{( #[0-9]+)?}}, !dbg
// LIFETIME: call void @llvm.lifetime.end(i64 8, {{.*}}){{( #[0-9]+)?}}, !dbg

// LIFETIME: call void @llvm.lifetime.end(i64 4, {{.*}}){{( #[0-9]+)?}}, !dbg
// LIFETIME: call void @llvm.lifetime.end(i64 4, {{.*}}){{( #[0-9]+)?}}, !dbg

}
}

test/CodeGen/debug-info-257-args.c
// RUN: %clang_cc1 -x c++ -g -emit-llvm -triple x86_64-linux-gnu -o - %s | FileCheck %s
// RUN: %clang_cc1 -x c++ -di-kind=limited -emit-llvm -triple x86_64-linux-gnu -o - %s | FileCheck %s

// PR23332
// PR23332




// CHECK: DILocalVariable(arg: 255
// CHECK: DILocalVariable(arg: 255

// CHECK: DILocalVariable(arg: 256
// CHECK: DILocalVariable(arg: 256

// CHECK: DILocalVariable(arg: 257
// CHECK: DILocalVariable(arg: 257

void fn1(int, int, int, int, int, int, int, int, int, int, int, int, int, int,
void fn1(int, int, int, int, int, int, int, int, int, int, int, int, int, int,

         int, int, int, int, int, int, int, int, int, int, int, int, int, int,
         int, int, int, int, int, int, int, int, int, int, int, int, int, int,

         int, int, int, int, int, int, int, int, int, int, int, int, int, int,
         int, int, int, int, int, int, int, int, int, int, int, int, int, int,

Show All 16 Lines
test/CodeGen/debug-info-args.c
// RUN: %clang_cc1 -triple x86_64-unk-unk -o - -emit-llvm -g %s | FileCheck %s
// RUN: %clang_cc1 -triple x86_64-unk-unk -o - -emit-llvm -di-kind=limited %s | FileCheck %s




int somefunc(char *x, int y, double z) {
int somefunc(char *x, int y, double z) {

  
  

  // CHECK: !DISubroutineType(types: ![[NUM:[0-9]+]])
  // CHECK: !DISubroutineType(types: ![[NUM:[0-9]+]])

  // CHECK: ![[NUM]] = {{!{![^,]*, ![^,]*, ![^,]*, ![^,]*}}}
  // CHECK: ![[NUM]] = {{!{![^,]*, ![^,]*, ![^,]*, ![^,]*}}}

  
  

  return y;
  return y;

}
}

test/CodeGen/debug-info-block-decl.c
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -g -fblocks -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -di-kind=limited -fblocks -emit-llvm -o - %s | FileCheck %s

// Assignment and block entry should point to the same line.
// Assignment and block entry should point to the same line.

// rdar://problem/14039866
// rdar://problem/14039866




// CHECK: define{{.*}}@main()
// CHECK: define{{.*}}@main()

// CHECK: store{{.*}}bitcast{{.*}}, !dbg ![[ASSIGNMENT:[0-9]+]]
// CHECK: store{{.*}}bitcast{{.*}}, !dbg ![[ASSIGNMENT:[0-9]+]]

// CHECK: define {{.*}} @__main_block_invoke
// CHECK: define {{.*}} @__main_block_invoke

// CHECK: dbg ![[BLOCK_ENTRY:[0-9]+]]
// CHECK: dbg ![[BLOCK_ENTRY:[0-9]+]]




Show All 10 Lines
test/CodeGen/debug-info-block-out-return.c
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -g -fblocks -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -di-kind=limited -fblocks -emit-llvm -o - %s | FileCheck %s




// Check that arg numbering is not affected by LLVM IR argument numbering -
// Check that arg numbering is not affected by LLVM IR argument numbering -

// since the latter is affected by return-by-out-parameter ABI requirements
// since the latter is affected by return-by-out-parameter ABI requirements




// 1 for the argument number (1 indexed), 2 for the line number
// 1 for the argument number (1 indexed), 2 for the line number

// 16777218 == 1 << 24 | 2
// 16777218 == 1 << 24 | 2

// 33554434 == 2 << 24 | 2
// 33554434 == 2 << 24 | 2

// This explains the two magic numbers below, testing that these two arguments
// This explains the two magic numbers below, testing that these two arguments

Show All 16 Lines
test/CodeGen/debug-info-block.c
// RUN: %clang_cc1 -fblocks -g -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -fblocks -di-kind=limited -emit-llvm -o - %s | FileCheck %s

// Verify that the desired debugging type is generated for a structure
// Verify that the desired debugging type is generated for a structure

// member that is a pointer to a block.
// member that is a pointer to a block.




// CHECK: !DICompositeType(tag: DW_TAG_structure_type, scope
// CHECK: !DICompositeType(tag: DW_TAG_structure_type, scope

// CHECK-NOT:              line
// CHECK-NOT:              line

// CHECK-SAME:             elements: ![[ELEMS1:.*]])
// CHECK-SAME:             elements: ![[ELEMS1:.*]])

// CHECK: ![[ELEMS1]] = {{.*, .*, .*,}} ![[FPEL1:.*]], {{.*}}
// CHECK: ![[ELEMS1]] = {{.*, .*, .*,}} ![[FPEL1:.*]], {{.*}}

// CHECK: ![[INT:.*]] = !DIBasicType(name: "int"
// CHECK: ![[INT:.*]] = !DIBasicType(name: "int"

Show All 20 Lines
test/CodeGen/debug-info-compilation-dir.c
// RUN: %clang_cc1 -fdebug-compilation-dir /nonsense -emit-llvm -g %s -o - | FileCheck -check-prefix=CHECK-NONSENSE %s
// RUN: %clang_cc1 -fdebug-compilation-dir /nonsense -emit-llvm -di-kind=limited %s -o - | FileCheck -check-prefix=CHECK-NONSENSE %s

// CHECK-NONSENSE: nonsense
// CHECK-NONSENSE: nonsense




// RUN: %clang_cc1 -emit-llvm -g %s -o - | FileCheck -check-prefix=CHECK-DIR %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited %s -o - | FileCheck -check-prefix=CHECK-DIR %s

// CHECK-DIR: CodeGen
// CHECK-DIR: CodeGen




test/CodeGen/debug-info-crash.c
// REQUIRES: x86-registered-target
// REQUIRES: x86-registered-target

// RUN: %clang_cc1 -triple i386-apple-darwin10 -fblocks -g -S %s -o -
// RUN: %clang_cc1 -triple i386-apple-darwin10 -fblocks -di-kind=limited -S %s -o -




// rdar://7590323
// rdar://7590323

typedef struct dispatch_queue_s *dispatch_queue_t;
typedef struct dispatch_queue_s *dispatch_queue_t;

__attribute__((visibility("default")))
__attribute__((visibility("default")))

extern struct dispatch_queue_s _dispatch_main_q;
extern struct dispatch_queue_s _dispatch_main_q;

typedef struct dispatch_item_s *dispatch_item_t;
typedef struct dispatch_item_s *dispatch_item_t;

typedef void (^dispatch_legacy_block_t)(dispatch_item_t);
typedef void (^dispatch_legacy_block_t)(dispatch_item_t);

dispatch_item_t LEGACY_dispatch_call(dispatch_queue_t dq,
dispatch_item_t LEGACY_dispatch_call(dispatch_queue_t dq,

Show All 21 Lines
test/CodeGen/debug-info-enum.c
// RUN: %clang_cc1 -emit-llvm -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited %s -o - | FileCheck %s




// CHECK: !DICompositeType(tag: DW_TAG_enumeration_type, name: "e"
// CHECK: !DICompositeType(tag: DW_TAG_enumeration_type, name: "e"

// CHECK-SAME:             elements: [[TEST3_ENUMS:![0-9]*]]
// CHECK-SAME:             elements: [[TEST3_ENUMS:![0-9]*]]

// CHECK: [[TEST3_ENUMS]] = !{[[TEST3_E:![0-9]*]]}
// CHECK: [[TEST3_ENUMS]] = !{[[TEST3_E:![0-9]*]]}

// CHECK: [[TEST3_E]] = !DIEnumerator(name: "E", value: -1)
// CHECK: [[TEST3_E]] = !DIEnumerator(name: "E", value: -1)




enum e;
enum e;

void func(enum e *p) {
void func(enum e *p) {

}
}

enum e { E = -1 };
enum e { E = -1 };

test/CodeGen/debug-info-gline-tables-only.c
// RUN: %clang_cc1 %s -gline-tables-only -S -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 %s -di-kind=line-tables -S -emit-llvm -o - | FileCheck %s

// Checks that clang with "-gline-tables-only" doesn't emit debug info
// Checks that clang with "-gline-tables-only" doesn't emit debug info

// for variables and types.
// for variables and types.




// CHECK-NOT: DW_TAG_variable
// CHECK-NOT: DW_TAG_variable

int global = 42;
int global = 42;




// CHECK-NOT: DW_TAG_typedef
// CHECK-NOT: DW_TAG_typedef

// CHECK-NOT: DW_TAG_const_type
// CHECK-NOT: DW_TAG_const_type

Show All 23 Lines
test/CodeGen/debug-info-gline-tables-only2.c
// RUN: %clang_cc1 %s -gline-tables-only -S -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 %s -di-kind=line-tables -S -emit-llvm -o - | FileCheck %s

// Checks that clang with "-gline-tables-only" emits metadata for
// Checks that clang with "-gline-tables-only" emits metadata for

// compile unit, subprogram and file.
// compile unit, subprogram and file.




int main() {
int main() {

  // CHECK: ret i32 0, !dbg
  // CHECK: ret i32 0, !dbg

  return 0;
  return 0;

}
}




// CHECK: !llvm.dbg.cu = !{!0}
// CHECK: !llvm.dbg.cu = !{!0}

// CHECK: !DICompileUnit(
// CHECK: !DICompileUnit(

// CHECK: !DISubprogram(
// CHECK: !DISubprogram(

// CHECK: !DIFile(
// CHECK: !DIFile(

test/CodeGen/debug-info-line.c
// RUN: %clang_cc1 -w -gline-tables-only -fexceptions -fcxx-exceptions -S -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -w -di-kind=line-tables -fexceptions -fcxx-exceptions -S -emit-llvm %s -o - | FileCheck %s




int f1(int a, int b) {
int f1(int a, int b) {

  // CHECK: icmp {{.*}}, !dbg [[DBG_F1:!.*]]
  // CHECK: icmp {{.*}}, !dbg [[DBG_F1:!.*]]

#line 100
#line 100

  return a  //
  return a  //

         && //
         && //

         b;
         b;

}
}




// CHECK: [[DBG_F1]] = !DILocation(line: 100,
// CHECK: [[DBG_F1]] = !DILocation(line: 100,

test/CodeGen/debug-info-line2.c
// RUN: %clang_cc1 -triple x86_64-darwin-apple -g -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -triple x86_64-darwin-apple -di-kind=limited -emit-llvm -o - %s | FileCheck %s

// Radar 9199234
// Radar 9199234




int bar();
int bar();

int foo(int i) {
int foo(int i) {

  int j = 0;
  int j = 0;

  if (i) {
  if (i) {

    j = bar();
    j = bar();

  } 
  } 

Show All 9 Lines
test/CodeGen/debug-info-line3.c
// RUN: %clang_cc1 -g -S -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -di-kind=limited -S -emit-llvm %s -o - | FileCheck %s




void func(char c, char* d)
void func(char c, char* d)

{
{

  *d = c + 1;
  *d = c + 1;

  return;
  return;

  
  




  
  

  
  

  
  

  
  

}
}




// CHECK: ret void, !dbg [[LINE:.*]]
// CHECK: ret void, !dbg [[LINE:.*]]

// CHECK: [[LINE]] = !DILocation(line: 6,
// CHECK: [[LINE]] = !DILocation(line: 6,

test/CodeGen/debug-info-member.c
// RUN: %clang_cc1 -emit-llvm -g < %s | grep DW_TAG_member 
// RUN: %clang_cc1 -emit-llvm -di-kind=limited < %s | grep DW_TAG_member 




struct A { int x; } a;
struct A { int x; } a;

test/CodeGen/debug-info-packed-struct.c
// RUN: %clang_cc1 -x c -g -emit-llvm -triple x86_64-apple-darwin -o - %s | FileCheck %s
// RUN: %clang_cc1 -x c -di-kind=limited -emit-llvm -triple x86_64-apple-darwin -o - %s | FileCheck %s




// CHECK: %struct.layout0 = type { i8, %struct.size8, i8 }
// CHECK: %struct.layout0 = type { i8, %struct.size8, i8 }

// CHECK: %struct.layout1 = type <{ i8, %struct.size8_anon, i8, [2 x i8] }>
// CHECK: %struct.layout1 = type <{ i8, %struct.size8_anon, i8, [2 x i8] }>

// CHECK: %struct.layout2 = type <{ i8, %struct.size8_pack1, i8 }>
// CHECK: %struct.layout2 = type <{ i8, %struct.size8_pack1, i8 }>

// CHECK: %struct.layout3 = type <{ i8, [3 x i8], %struct.size8_pack4, i8, [3 x i8] }>
// CHECK: %struct.layout3 = type <{ i8, [3 x i8], %struct.size8_pack4, i8, [3 x i8] }>




// ---------------------------------------------------------------------
// ---------------------------------------------------------------------

// Not packed.
// Not packed.

▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines
test/CodeGen/debug-info-same-line.c
// RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm %s -g -o - | FileCheck %s
// RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm %s -di-kind=limited -o - | FileCheck %s

// Here two temporary nodes are identical (but should not get uniqued) while
// Here two temporary nodes are identical (but should not get uniqued) while

// building the full debug type.
// building the full debug type.

typedef struct { long x; } foo; typedef struct {  foo *x; } bar;
typedef struct { long x; } foo; typedef struct {  foo *x; } bar;

// CHECK: !DICompositeType(tag: DW_TAG_structure_type,{{.*}} line: 4, size: 64,
// CHECK: !DICompositeType(tag: DW_TAG_structure_type,{{.*}} line: 4, size: 64,

// CHECK: !DICompositeType(tag: DW_TAG_structure_type,{{.*}} line: 4, size: 64,
// CHECK: !DICompositeType(tag: DW_TAG_structure_type,{{.*}} line: 4, size: 64,

bar b;
bar b;

test/CodeGen/debug-info-scope-file.c
// RUN: %clang_cc1 -g -emit-llvm < %s | FileCheck %s
// RUN: %clang_cc1 -di-kind=limited -emit-llvm < %s | FileCheck %s




// Check that, just because we emitted a function from a different file doesn't
// Check that, just because we emitted a function from a different file doesn't

// mean we insert a file-change inside the next function.
// mean we insert a file-change inside the next function.




// CHECK: ret void, !dbg [[F1_LINE:![0-9]*]]
// CHECK: ret void, !dbg [[F1_LINE:![0-9]*]]

// CHECK: ret void, !dbg [[F2_LINE:![0-9]*]]
// CHECK: ret void, !dbg [[F2_LINE:![0-9]*]]

// CHECK: [[F1:![0-9]*]] = distinct !DISubprogram(name: "f1",{{.*}} isDefinition: true
// CHECK: [[F1:![0-9]*]] = distinct !DISubprogram(name: "f1",{{.*}} isDefinition: true

// CHECK: [[F2:![0-9]*]] = distinct !DISubprogram(name: "f2",{{.*}} isDefinition: true
// CHECK: [[F2:![0-9]*]] = distinct !DISubprogram(name: "f2",{{.*}} isDefinition: true

Show All 11 Lines
test/CodeGen/debug-info-scope.c
// RUN: %clang_cc1 -g -emit-llvm < %s | FileCheck %s
// RUN: %clang_cc1 -dwarf-version=4 -di-kind=limited -emit-llvm < %s | FileCheck %s

// RUN: %clang_cc1 -gline-tables-only -emit-llvm < %s | FileCheck --check-prefix=GMLT %s
// RUN: %clang_cc1 -dwarf-version=4 -di-kind=line-tables -emit-llvm < %s | FileCheck --check-prefix=GMLT %s

// Two variables with same name in separate scope.
// Two variables with same name in separate scope.

// Radar 8330217.
// Radar 8330217.

int main() {
int main() {

  int j = 0;
  int j = 0;

  int k = 0;
  int k = 0;

// CHECK: !DILocalVariable(name: "i"
// CHECK: !DILocalVariable(name: "i"

// CHECK-NEXT: !DILexicalBlock(
// CHECK-NEXT: !DILexicalBlock(




Show All 18 Lines
test/CodeGen/debug-info-static.c
// RUN: %clang_cc1  -g -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1  -di-kind=limited -emit-llvm -o - %s | FileCheck %s




// CHECK: !DIGlobalVariable({{.*}}variable: i32* @f.xyzzy
// CHECK: !DIGlobalVariable({{.*}}variable: i32* @f.xyzzy

void f(void)
void f(void)

{
{

   static int xyzzy;
   static int xyzzy;

   xyzzy += 3;
   xyzzy += 3;

}
}

test/CodeGen/debug-info-typedef.c
// RUN: %clang_cc1 -emit-llvm -g -I%p %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -I%p %s -o - | FileCheck %s

// Test that the location of the typedef points to the header file.
// Test that the location of the typedef points to the header file.

#line 1 "a.c"
#line 1 "a.c"

#line 2 "b.h"
#line 2 "b.h"

typedef int MyType;
typedef int MyType;

#line 2 "a.c"
#line 2 "a.c"




MyType a;
MyType a;




// CHECK: !DIDerivedType(tag: DW_TAG_typedef, name: "MyType", file: ![[HEADER:[0-9]+]], line: 2,
// CHECK: !DIDerivedType(tag: DW_TAG_typedef, name: "MyType", file: ![[HEADER:[0-9]+]], line: 2,

// CHECK: ![[HEADER]] = !DIFile(filename: "b.h",
// CHECK: ![[HEADER]] = !DIFile(filename: "b.h",

test/CodeGen/debug-info-vector.c
// RUN: %clang_cc1 -emit-llvm -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited %s -o - | FileCheck %s

typedef int v4si __attribute__((__vector_size__(16)));
typedef int v4si __attribute__((__vector_size__(16)));




v4si a;
v4si a;




// Test that we get an array type that's also a vector out of debug.
// Test that we get an array type that's also a vector out of debug.

// CHECK: !DICompositeType(tag: DW_TAG_array_type,
// CHECK: !DICompositeType(tag: DW_TAG_array_type,

// CHECK-SAME:             baseType: ![[INT:[0-9]+]]
// CHECK-SAME:             baseType: ![[INT:[0-9]+]]

// CHECK-SAME:             size: 128, align: 128
// CHECK-SAME:             size: 128, align: 128

// CHECK-SAME:             DIFlagVector
// CHECK-SAME:             DIFlagVector

// CHECK: ![[INT]] = !DIBasicType(name: "int"
// CHECK: ![[INT]] = !DIBasicType(name: "int"

test/CodeGen/debug-info-vla.c
// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -triple x86_64-apple-darwin %s -o - | FileCheck %s




void testVLAwithSize(int s)
void testVLAwithSize(int s)

{
{

// CHECK: dbg.declare
// CHECK: dbg.declare

// CHECK: dbg.declare({{.*}}, metadata ![[VAR:.*]], metadata ![[EXPR:.*]])
// CHECK: dbg.declare({{.*}}, metadata ![[VAR:.*]], metadata ![[EXPR:.*]])

// CHECK: ![[VAR]] = !DILocalVariable(name: "vla",{{.*}} line: [[@LINE+2]]
// CHECK: ![[VAR]] = !DILocalVariable(name: "vla",{{.*}} line: [[@LINE+2]]

// CHECK: ![[EXPR]] = !DIExpression(DW_OP_deref)
// CHECK: ![[EXPR]] = !DIExpression(DW_OP_deref)

  int vla[s];
  int vla[s];

  int i;
  int i;

  for (i = 0; i < s; i++) {
  for (i = 0; i < s; i++) {

    vla[i] = i*i;
    vla[i] = i*i;

  }
  }

}
}

test/CodeGen/debug-info.c
// RUN: %clang_cc1 -triple x86_64-unk-unk -o - -emit-llvm -g %s | FileCheck %s
// RUN: %clang_cc1 -triple x86_64-unk-unk -o - -emit-llvm -di-kind=limited %s | FileCheck %s




// PR3023
// PR3023

void convert(void) {
void convert(void) {

  struct { typeof(0) f0; } v0;
  struct { typeof(0) f0; } v0;

}
}







// PR2784
// PR2784

▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines
test/CodeGen/debug-line-1.c
// RUN: %clang_cc1 -triple x86_64-apple-darwin -o - -emit-llvm -g %s | FileCheck %s
// RUN: %clang_cc1 -triple x86_64-apple-darwin -o - -emit-llvm -di-kind=limited %s | FileCheck %s

// REQUIRES: asserts
// REQUIRES: asserts

// PR9796
// PR9796




// Check to make sure that we emit the block for the break so that we can count the line.
// Check to make sure that we emit the block for the break so that we can count the line.

// CHECK: sw.bb:                                            ; preds = %entry
// CHECK: sw.bb:                                            ; preds = %entry

// CHECK: br label %sw.epilog, !dbg !
// CHECK: br label %sw.epilog, !dbg !

  
  

extern int atoi(const char *);
extern int atoi(const char *);

Show All 11 Lines
test/CodeGen/enum2.c
// RUN: %clang_cc1 -triple i386-unknown-unknown %s -g -emit-llvm -o /dev/null
// RUN: %clang_cc1 -triple i386-unknown-unknown %s -di-kind=limited -emit-llvm -o /dev/null

int v;
int v;

enum e { MAX };
enum e { MAX };




void foo (void)
void foo (void)

{
{

  v = MAX;
  v = MAX;

}
}

test/CodeGen/global-blocks-lines.c
// RUN: %clang_cc1 -fblocks -g -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -fblocks -di-kind=limited -emit-llvm %s -o - | FileCheck %s

// Make sure we do not generate line info for debugging-related frame setup.
// Make sure we do not generate line info for debugging-related frame setup.

// CHECK: define {{.*}}block_invoke
// CHECK: define {{.*}}block_invoke

// CHECK-NOT: store {{.*}}%struct.__block_descriptor*{{.*}}dbg
// CHECK-NOT: store {{.*}}%struct.__block_descriptor*{{.*}}dbg

// CHECK: store {{.*}}%struct.__block_descriptor*{{.*}}, align
// CHECK: store {{.*}}%struct.__block_descriptor*{{.*}}, align

// CHECK: ret
// CHECK: ret

// CHECK: define {{.*}}block_invoke
// CHECK: define {{.*}}block_invoke

// CHECK-NOT: store {{.*}}%struct.__block_descriptor*{{.*}}dbg
// CHECK-NOT: store {{.*}}%struct.__block_descriptor*{{.*}}dbg

// CHECK: store {{.*}}%struct.__block_descriptor*{{.*}}, align
// CHECK: store {{.*}}%struct.__block_descriptor*{{.*}}, align

Show All 36 Lines
test/CodeGen/lifetime-debuginfo-1.c
// RUN: %clang_cc1 -O1 -triple x86_64-none-linux-gnu -emit-llvm -gline-tables-only %s -o - | FileCheck %s
// RUN: %clang_cc1 -O1 -triple x86_64-none-linux-gnu -emit-llvm -di-kind=line-tables %s -o - | FileCheck %s




// Inserting lifetime markers should not affect debuginfo
// Inserting lifetime markers should not affect debuginfo




extern int x;
extern int x;




// CHECK-LABEL: define i32 @f
// CHECK-LABEL: define i32 @f

int f() {
int f() {

  int *p = &x;
  int *p = &x;

// CHECK: ret i32 %{{.*}}, !dbg [[DI:![0-9]*]]
// CHECK: ret i32 %{{.*}}, !dbg [[DI:![0-9]*]]

// CHECK: [[DI]] = !DILocation(line: [[@LINE+1]]
// CHECK: [[DI]] = !DILocation(line: [[@LINE+1]]

  return *p;
  return *p;

}
}

test/CodeGen/lifetime-debuginfo-2.c
// RUN: %clang_cc1 -O1 -triple x86_64-none-linux-gnu -emit-llvm -gline-tables-only %s -o - | FileCheck %s
// RUN: %clang_cc1 -O1 -triple x86_64-none-linux-gnu -emit-llvm -di-kind=line-tables %s -o - | FileCheck %s




// Inserting lifetime markers should not affect debuginfo: lifetime.end is not
// Inserting lifetime markers should not affect debuginfo: lifetime.end is not

// a destructor, but instrumentation for the compiler. Ensure the debug info for
// a destructor, but instrumentation for the compiler. Ensure the debug info for

// the return statement (in the IR) does not point to the function closing '}'
// the return statement (in the IR) does not point to the function closing '}'

// which is used to show some destructors have been called before leaving the
// which is used to show some destructors have been called before leaving the

// function.
// function.




extern int f(int);
extern int f(int);

Show All 20 Lines
test/CodeGen/lineno-dbginfo.c
// RUN: echo "#include <stddef.h>" > %t.h
// RUN: echo "#include <stddef.h>" > %t.h

// RUN: %clang_cc1 -S -g -include %t.h %s -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 -S -di-kind=limited -include %t.h %s -emit-llvm -o - | FileCheck %s




// CHECK: !DIGlobalVariable(name: "outer",
// CHECK: !DIGlobalVariable(name: "outer",

// CHECK-NOT:               linkageName:
// CHECK-NOT:               linkageName:

// CHECK-SAME:              line: [[@LINE+2]]
// CHECK-SAME:              line: [[@LINE+2]]

// CHECK-SAME:              isDefinition: true
// CHECK-SAME:              isDefinition: true

int outer = 42;
int outer = 42;




test/CodeGen/linetable-endscope.c
// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin10 %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -triple x86_64-apple-darwin10 %s -o - | FileCheck %s




// Check the line numbers for the ret instruction. We expect it to be
// Check the line numbers for the ret instruction. We expect it to be

// at the closing of the lexical scope in this case. See the comments in
// at the closing of the lexical scope in this case. See the comments in

// CodeGenFunction::FinishFunction() for more details.
// CodeGenFunction::FinishFunction() for more details.




// CHECK: define {{.*}}foo
// CHECK: define {{.*}}foo

// CHECK: store {{.*}}, !dbg ![[CONV:[0-9]+]]
// CHECK: store {{.*}}, !dbg ![[CONV:[0-9]+]]

// CHECK: ret {{.*}}, !dbg ![[RET:[0-9]+]]
// CHECK: ret {{.*}}, !dbg ![[RET:[0-9]+]]




void foo(char c)
void foo(char c)

{
{

  int i;
  int i;

  // CHECK: ![[CONV]] = !DILocation(line: [[@LINE+1]], scope: !{{.*}})
  // CHECK: ![[CONV]] = !DILocation(line: [[@LINE+1]], scope: !{{.*}})

  i = c;
  i = c;

  // CHECK: ![[RET]] = !DILocation(line: [[@LINE+1]], scope: !{{.*}})
  // CHECK: ![[RET]] = !DILocation(line: [[@LINE+1]], scope: !{{.*}})

}
}

test/CodeGen/sse-builtins-dbg.c
// RUN: %clang_cc1 -ffreestanding -triple x86_64-apple-macosx10.8.0 -target-feature +sse4.1 -g -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -ffreestanding -triple x86_64-apple-macosx10.8.0 -target-feature +sse4.1 -di-kind=limited -emit-llvm %s -o - | FileCheck %s




// Test that intrinsic calls inlined from _mm_* wrappers have debug metadata.
// Test that intrinsic calls inlined from _mm_* wrappers have debug metadata.




#include <xmmintrin.h>
#include <xmmintrin.h>




__m128 test_rsqrt_ss(__m128 x) {
__m128 test_rsqrt_ss(__m128 x) {

  // CHECK: define {{.*}} @test_rsqrt_ss
  // CHECK: define {{.*}} @test_rsqrt_ss

  // CHECK: call <4 x float> @llvm.x86.sse.rsqrt.ss({{.*}}, !dbg !{{.*}}
  // CHECK: call <4 x float> @llvm.x86.sse.rsqrt.ss({{.*}}, !dbg !{{.*}}

  // CHECK: ret <4 x float>
  // CHECK: ret <4 x float>

  return _mm_rsqrt_ss(x);
  return _mm_rsqrt_ss(x);

}
}

test/CodeGen/vector.c
// RUN: %clang_cc1 -triple i386-apple-darwin9 -O1 -target-cpu pentium4 -target-feature +sse4.1 -g -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple i386-apple-darwin9 -O1 -target-cpu pentium4 -target-feature +sse4.1 -di-kind=limited -emit-llvm %s -o - | FileCheck %s

typedef short __v4hi __attribute__ ((__vector_size__ (8)));
typedef short __v4hi __attribute__ ((__vector_size__ (8)));




void test1() {
void test1() {

  __v4hi A = (__v4hi)0LL;
  __v4hi A = (__v4hi)0LL;

}
}




__v4hi x = {1,2,3};
__v4hi x = {1,2,3};

__v4hi y = {1,2,3,4};
__v4hi y = {1,2,3,4};

▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines
test/CodeGenCXX/2006-11-20-GlobalSymbols.cpp
// PR1013
// PR1013

// Check to make sure debug symbols use the correct name for globals and
// Check to make sure debug symbols use the correct name for globals and

// functions.  Will not assemble if it fails to.
// functions.  Will not assemble if it fails to.

// RUN: %clang_cc1 -emit-llvm -g -o - %s | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -o - %s | FileCheck %s




// CHECK: f\01oo"
// CHECK: f\01oo"

int foo __asm__("f\001oo");
int foo __asm__("f\001oo");




int bar() {
int bar() {

  return foo;
  return foo;

}
}

test/CodeGenCXX/2007-01-02-UnboundedArray.cpp
// Make sure unbounded arrays compile with debug information.
// Make sure unbounded arrays compile with debug information.

//
//

// RUN: %clang_cc1 -emit-llvm -g %s -o -
// RUN: %clang_cc1 -emit-llvm -di-kind=limited %s -o -




// PR1068
// PR1068




struct Object {
struct Object {

  char buffer[];
  char buffer[];

};
};




int main(int argc, char** argv) {
int main(int argc, char** argv) {

  new Object;
  new Object;

  return 0;
  return 0;

}
}

test/CodeGenCXX/2009-03-17-dbg.cpp
// RUN: %clang_cc1 -emit-llvm %s -o /dev/null -g
// RUN: %clang_cc1 -emit-llvm %s -o /dev/null -di-kind=limited




template <typename T1,typename T2>
template <typename T1,typename T2>

inline void f(const T1&,const T2&) { }
inline void f(const T1&,const T2&) { }




template <typename T1,typename T2,void F(const T1&,const T2&)>
template <typename T1,typename T2,void F(const T1&,const T2&)>

struct A {
struct A {

    template <typename T> void g(T& i) { }
    template <typename T> void g(T& i) { }

};
};




int main() {
int main() {

    int i;
    int i;

    A<int,int,f> a;
    A<int,int,f> a;

    a.g(i);
    a.g(i);

}
}

test/CodeGenCXX/2009-06-16-DebugInfoCrash.cpp
// RUN: %clang_cc1 -emit-llvm %s -o /dev/null -g
// RUN: %clang_cc1 -emit-llvm %s -o /dev/null -di-kind=limited

// This crashes if we try to emit debug info for TEMPLATE_DECL members.
// This crashes if we try to emit debug info for TEMPLATE_DECL members.

template <class T> class K2PtrVectorBase {};
template <class T> class K2PtrVectorBase {};

template <class T> class K2Vector {};
template <class T> class K2Vector {};

template <class U > class K2Vector<U*> : public K2PtrVectorBase<U*> {};
template <class U > class K2Vector<U*> : public K2PtrVectorBase<U*> {};

class ScriptInfoManager {
class ScriptInfoManager {

  void PostRegister() ;
  void PostRegister() ;

  template <class SI> short ReplaceExistingElement(K2Vector<SI*>& v);
  template <class SI> short ReplaceExistingElement(K2Vector<SI*>& v);

};
};

void ScriptInfoManager::PostRegister() {}
void ScriptInfoManager::PostRegister() {}

test/CodeGenCXX/2010-03-09-AnonAggregate.cpp
// RUN: %clang_cc1 -g -S -o %t %s
// RUN: %clang_cc1 -di-kind=limited -S -o %t %s

// PR: 6554
// PR: 6554

// More then one anonymous aggregates on one line creates chaos when MDNode uniquness is 
// More then one anonymous aggregates on one line creates chaos when MDNode uniquness is 

// combined with RAUW operation.
// combined with RAUW operation.

// This test case causes crashes if malloc is configured to trip buffer overruns.
// This test case causes crashes if malloc is configured to trip buffer overruns.

class MO {
class MO {




  union {       struct {       union {    int BA;       } Val;       int Offset;     } OffsetedInfo;   } Contents; 
  union {       struct {       union {    int BA;       } Val;       int Offset;     } OffsetedInfo;   } Contents; 




};
};




class MO m;
class MO m;

test/CodeGenCXX/2010-05-10-Var-DbgInfo.cpp
// RUN: %clang_cc1 -emit-llvm -g %s -o /dev/null
// RUN: %clang_cc1 -emit-llvm -di-kind=limited %s -o /dev/null

// PR 7104
// PR 7104




struct A {
struct A {

  int Ai;
  int Ai;

};
};




struct B : public A {};
struct B : public A {};

struct C : public B {};
struct C : public B {};

Show All 33 Lines
test/CodeGenCXX/2010-05-12-PtrToMember-Dbg.cpp
//RUN: %clang_cc1 -emit-llvm -g -o - %s | FileCheck %s
//RUN: %clang_cc1 -emit-llvm -di-kind=limited -o - %s | FileCheck %s

//CHECK: DILocalVariable(
//CHECK: DILocalVariable(

class Foo
class Foo

{
{

 public:
 public:

  int x;
  int x;

  int y;
  int y;

  Foo (int i, int j) { x = i; y = j; }
  Foo (int i, int j) { x = i; y = j; }

};
};







Foo foo(10, 11);
Foo foo(10, 11);




int main() {
int main() {

  int Foo::* pmi = &Foo::y;
  int Foo::* pmi = &Foo::y;

  return foo.*pmi;
  return foo.*pmi;

}
}

test/CodeGenCXX/2010-06-21-LocalVarDbg.cpp
// RUN: %clang_cc1 -g -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -di-kind=limited -emit-llvm %s -o - | FileCheck %s

// Do not use function name to create named metadata used to hold
// Do not use function name to create named metadata used to hold

// local variable info. For example. llvm.dbg.lv.~A is an invalid name.
// local variable info. For example. llvm.dbg.lv.~A is an invalid name.




// CHECK-NOT: llvm.dbg.lv.~A
// CHECK-NOT: llvm.dbg.lv.~A

class A {
class A {

public:
public:

  ~A() { int i = 0; i++; }
  ~A() { int i = 0; i++; }

};
};




int foo(int i) {
int foo(int i) {

  A a;
  A a;

  return 0;
  return 0;

}
}

test/CodeGenCXX/2010-06-22-BitfieldInit.cpp
// RUN: %clang_cc1 -emit-llvm -g %s -o -
// RUN: %clang_cc1 -emit-llvm -di-kind=limited %s -o -

struct TEST2
struct TEST2

{
{

  int subid:32;
  int subid:32;

  int :0;
  int :0;

};
};




typedef struct _TEST3
typedef struct _TEST3

{
{

Show All 11 Lines
test/CodeGenCXX/2010-06-22-ZeroBitfield.cpp
// RUN: %clang_cc1 -emit-llvm -g %s -o -
// RUN: %clang_cc1 -emit-llvm -di-kind=limited %s -o -

struct s8_0 { unsigned : 0; };
struct s8_0 { unsigned : 0; };

struct s8_1 { double x; };
struct s8_1 { double x; };

struct s8 { s8_0 a; s8_1 b; };
struct s8 { s8_0 a; s8_1 b; };

s8 f8() { return s8(); }
s8 f8() { return s8(); }

test/CodeGenCXX/2010-07-23-DeclLoc.cpp
// RUN: %clang_cc1 -emit-llvm -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited %s -o - | FileCheck %s

// Require the template function declaration refer to the correct filename.
// Require the template function declaration refer to the correct filename.

// First, locate the function decl in metadata, and pluck out the file handle:
// First, locate the function decl in metadata, and pluck out the file handle:

// CHECK: !DISubprogram(name: "extract_dwarf_data_from_header
// CHECK: !DISubprogram(name: "extract_dwarf_data_from_header

// CHECK-SAME:          file: [[FILE:![0-9]+]]
// CHECK-SAME:          file: [[FILE:![0-9]+]]

// Second: Require that filehandle refer to the correct filename:
// Second: Require that filehandle refer to the correct filename:

// CHECK: [[FILE]] = !DIFile(filename: "decl_should_be_here.hpp"
// CHECK: [[FILE]] = !DIFile(filename: "decl_should_be_here.hpp"

typedef long unsigned int __darwin_size_t;
typedef long unsigned int __darwin_size_t;

typedef __darwin_size_t size_t;
typedef __darwin_size_t size_t;

▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines
test/CodeGenCXX/PR20038.cpp
// RUN: %clang_cc1 -triple %itanium_abi_triple -g -mllvm -no-discriminators -emit-llvm  %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple %itanium_abi_triple -di-kind=limited -mllvm -no-discriminators -emit-llvm  %s -o - | FileCheck %s




struct C {
struct C {

  ~C();
  ~C();

};
};

extern bool b;
extern bool b;

// CHECK: call {{.*}}, !dbg [[DTOR_CALL1_LOC:![0-9]*]]
// CHECK: call {{.*}}, !dbg [[DTOR_CALL1_LOC:![0-9]*]]

// CHECK: call {{.*}}, !dbg [[DTOR_CALL2_LOC:![0-9]*]]
// CHECK: call {{.*}}, !dbg [[DTOR_CALL2_LOC:![0-9]*]]

// CHECK: [[FUN1:.*]] = distinct !DISubprogram(name: "fun1",{{.*}} isDefinition: true
// CHECK: [[FUN1:.*]] = distinct !DISubprogram(name: "fun1",{{.*}} isDefinition: true

// CHECK: [[FUN2:.*]] = distinct !DISubprogram(name: "fun2",{{.*}} isDefinition: true
// CHECK: [[FUN2:.*]] = distinct !DISubprogram(name: "fun2",{{.*}} isDefinition: true

// CHECK: [[DTOR_CALL1_LOC]] = !DILocation(line: [[@LINE+1]], scope: [[FUN1]])
// CHECK: [[DTOR_CALL1_LOC]] = !DILocation(line: [[@LINE+1]], scope: [[FUN1]])

void fun1() { b && (C(), 1); }
void fun1() { b && (C(), 1); }

// CHECK: [[DTOR_CALL2_LOC]] = !DILocation(line: [[@LINE+1]], scope: [[FUN2]])
// CHECK: [[DTOR_CALL2_LOC]] = !DILocation(line: [[@LINE+1]], scope: [[FUN2]])

bool fun2() { return (C(), b) && 0; }
bool fun2() { return (C(), b) && 0; }

test/CodeGenCXX/cp-blocks-linetables.cpp
// RUN: %clang_cc1 -fblocks -g -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -fblocks -di-kind=limited -emit-llvm %s -o - | FileCheck %s

// Ensure that we generate a line table entry for the block cleanup.
// Ensure that we generate a line table entry for the block cleanup.

// CHECK: define {{.*}} @__main_block_invoke
// CHECK: define {{.*}} @__main_block_invoke

// CHECK: _NSConcreteStackBlock
// CHECK: _NSConcreteStackBlock

// CHECK: = bitcast {{.*}}, !dbg ![[L1:[0-9]+]]
// CHECK: = bitcast {{.*}}, !dbg ![[L1:[0-9]+]]

// CHECK-NOT:  call {{.*}} @_Block_object_dispose{{.*}}, !dbg ![[L1]]
// CHECK-NOT:  call {{.*}} @_Block_object_dispose{{.*}}, !dbg ![[L1]]

// CHECK: ret
// CHECK: ret




void * _NSConcreteStackBlock;
void * _NSConcreteStackBlock;

▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines
test/CodeGenCXX/crash.cpp
// XFAIL: hexagon
// XFAIL: hexagon

// RUN: %clang_cc1 %s -std=c++11 -emit-llvm-only
// RUN: %clang_cc1 %s -std=c++11 -emit-llvm-only

// RUN: %clang_cc1 -emit-obj -o %t -gline-tables-only -std=c++11 %s
// RUN: %clang_cc1 -emit-obj -o %t -di-kind=line-tables -std=c++11 %s

// CHECK that we don't crash.
// CHECK that we don't crash.




// PR11676's example is ill-formed:
// PR11676's example is ill-formed:

/*
/*

union _XEvent {
union _XEvent {

};
};

void ProcessEvent() {
void ProcessEvent() {

  _XEvent pluginEvent = _XEvent();
  _XEvent pluginEvent = _XEvent();

Show All 26 Lines
test/CodeGenCXX/debug-info-access.cpp
// RUN: %clang_cc1 -emit-llvm -g -triple %itanium_abi_triple %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -triple %itanium_abi_triple %s -o - | FileCheck %s

// Test the various accessibility flags in the debug info.
// Test the various accessibility flags in the debug info.

struct A {
struct A {

  // CHECK-DAG: !DISubprogram(name: "pub_default",{{.*}} line: [[@LINE+1]],{{.*}} flags: DIFlagPrototyped,
  // CHECK-DAG: !DISubprogram(name: "pub_default",{{.*}} line: [[@LINE+1]],{{.*}} flags: DIFlagPrototyped,

  void pub_default();
  void pub_default();

  // CHECK-DAG: !DIDerivedType(tag: DW_TAG_member, name: "pub_default_static",{{.*}} line: [[@LINE+1]],{{.*}} flags: DIFlagStaticMember)
  // CHECK-DAG: !DIDerivedType(tag: DW_TAG_member, name: "pub_default_static",{{.*}} line: [[@LINE+1]],{{.*}} flags: DIFlagStaticMember)

  static int pub_default_static;
  static int pub_default_static;

};
};




Show All 32 Lines
test/CodeGenCXX/debug-info-anon-union-vars.cpp
// RUN: %clang_cc1 -emit-llvm -gdwarf-4 -triple x86_64-linux-gnu %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -triple x86_64-linux-gnu %s -o - | FileCheck %s




// Make sure that we emit a global variable for each of the members of the
// Make sure that we emit a global variable for each of the members of the

// anonymous union.
// anonymous union.




static union {
static union {

  int c;
  int c;

  int d;
  int d;

  union {
  union {

Show All 37 Lines
test/CodeGenCXX/debug-info-artificial-arg.cpp
// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -triple x86_64-apple-darwin %s -o - | FileCheck %s




template<class X> class B {
template<class X> class B {

public:
public:

  explicit B(X* p = 0);
  explicit B(X* p = 0);

};
};




class A
class A

{
{

Show All 24 Lines
test/CodeGenCXX/debug-info-blocks.cpp
// RUN: %clang_cc1 %s -gline-tables-only -fblocks -S -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 %s -di-kind=line-tables -fblocks -S -emit-llvm -o - | FileCheck %s




struct A {
struct A {

  A();
  A();

  A(const A &);
  A(const A &);

  ~A();
  ~A();

};
};




void test() {
void test() {

Show All 9 Lines
test/CodeGenCXX/debug-info-char16.cpp
// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -std=c++11 -g %s -o -| FileCheck %s
// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -std=c++11 -di-kind=limited %s -o -| FileCheck %s




// 16 is DW_ATE_UTF (0x10) encoding attribute.
// 16 is DW_ATE_UTF (0x10) encoding attribute.

char16_t char_a = u'h';
char16_t char_a = u'h';




// CHECK: !{{.*}} = !DIBasicType(name: "char16_t"
// CHECK: !{{.*}} = !DIBasicType(name: "char16_t"

// CHECK-SAME:                   encoding: DW_ATE_UTF)
// CHECK-SAME:                   encoding: DW_ATE_UTF)

test/CodeGenCXX/debug-info-class-nolimit.cpp
// RUN: %clang_cc1 -triple x86_64-unk-unk -fstandalone-debug -o - -emit-llvm -g %s | FileCheck %s
// RUN: %clang_cc1 -triple x86_64-unk-unk -di-kind=full -o - -emit-llvm %s | FileCheck %s

// On Darwin, this should be the default:
// On Darwin, "full" debug info is the default, so really these tests are

// RUN: %clang_cc1 -triple x86_64-apple-darwin -o - -emit-llvm -g %s | FileCheck %s
// identical, as cc1 no longer chooses the effective value of DebugInfoKind.

// RUN: %clang_cc1 -triple x86_64-apple-darwin -di-kind=full -o - -emit-llvm %s | FileCheck %s




namespace rdar14101097_1 { // see also PR16214
namespace rdar14101097_1 { // see also PR16214

// Check that we emit debug info for the definition of a struct if the
// Check that we emit debug info for the definition of a struct if the

// definition is available, even if it's used via a pointer wrapped in a
// definition is available, even if it's used via a pointer wrapped in a

// typedef.
// typedef.

// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "foo"
// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "foo"

// CHECK-NOT:              DIFlagFwdDecl
// CHECK-NOT:              DIFlagFwdDecl

// CHECK-SAME:             ){{$}}
// CHECK-SAME:             ){{$}}

Show All 16 Lines
// CHECK-SAME:             ){{$}}
// CHECK-SAME:             ){{$}}

struct foo;
struct foo;

void bar() {
void bar() {

  foo *f;
  foo *f;

}
}

struct foo {
struct foo {

};
};

}
}



test/CodeGenCXX/debug-info-context.cpp
// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -triple x86_64-apple-darwin %s -o - | FileCheck %s

// PR11345
// PR11345




class locale {
class locale {

private:
private:

  void _M_add_reference() const throw() {
  void _M_add_reference() const throw() {

  }
  }

};
};

class ios_base {
class ios_base {

  locale _M_ios_locale;
  locale _M_ios_locale;

public:
public:

  class Init {
  class Init {

  };
  };

};
};

static ios_base::Init __ioinit;
static ios_base::Init __ioinit;




// CHECK-NOT: _M_ios_locale
// CHECK-NOT: _M_ios_locale

test/CodeGenCXX/debug-info-cxx0x.cpp
// RUN: %clang_cc1 -emit-llvm-only -std=c++11 -g %s
// RUN: %clang_cc1 -emit-llvm-only -std=c++11 -di-kind=limited %s




namespace PR9414 {
namespace PR9414 {

  int f() {
  int f() {

    auto x = 0;
    auto x = 0;

    return x;
    return x;

  }
  }

}
}




Show All 9 Lines
test/CodeGenCXX/debug-info-cxx1y.cpp
// RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm-only -std=c++14 -emit-llvm -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm-only -std=c++14 -emit-llvm -di-kind=limited %s -o - | FileCheck %s




// CHECK: [[EMPTY:![0-9]*]] = !{}
// CHECK: [[EMPTY:![0-9]*]] = !{}

// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "foo",
// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "foo",

// CHECK-SAME:             elements: [[EMPTY]]
// CHECK-SAME:             elements: [[EMPTY]]

// FIXME: The context of this definition should be the CU/file scope, not the class.
// FIXME: The context of this definition should be the CU/file scope, not the class.

// CHECK: !DISubprogram(name: "func", {{.*}} scope: !"_ZTS3foo"
// CHECK: !DISubprogram(name: "func", {{.*}} scope: !"_ZTS3foo"

// CHECK-SAME:          type: [[SUBROUTINE_TYPE:![0-9]*]]
// CHECK-SAME:          type: [[SUBROUTINE_TYPE:![0-9]*]]

// CHECK-SAME:          isDefinition: true
// CHECK-SAME:          isDefinition: true

Show All 18 Lines
test/CodeGenCXX/debug-info-decl-nested.cpp
// RUN: %clang_cc1 -std=c++11 -g -emit-llvm -g -triple x86_64-apple-darwin %s -o %t
// RUN: %clang_cc1 -std=c++11 -di-kind=full -emit-llvm -triple x86_64-apple-darwin %s -o %t

// RUN: cat %t | FileCheck %s -check-prefix=CHECK0
// RUN: cat %t | FileCheck %s -check-prefix=CHECK0

// RUN: cat %t | FileCheck %s -check-prefix=CHECK1
// RUN: cat %t | FileCheck %s -check-prefix=CHECK1

// RUN: cat %t | FileCheck %s -check-prefix=CHECK2
// RUN: cat %t | FileCheck %s -check-prefix=CHECK2

//
//

// This test ensures that we associate a declaration with the
// This test ensures that we associate a declaration with the

// definition of the constructor for OuterClass. The declaration is
// definition of the constructor for OuterClass. The declaration is

// necessary so the backend can emit the DW_AT_specification attribute
// necessary so the backend can emit the DW_AT_specification attribute

// for the definition.
// for the definition.

▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines
test/CodeGenCXX/debug-info-determinism.cpp
// RUN: %clang_cc1 -S -emit-llvm -g -o %t1.ll %s
// RUN: %clang_cc1 -S -emit-llvm -di-kind=limited -o %t1.ll %s

// RUN: %clang_cc1 -S -emit-llvm -g -o %t2.ll %s
// RUN: %clang_cc1 -S -emit-llvm -di-kind=limited -o %t2.ll %s

// RUN: diff %t1.ll %t2.ll
// RUN: diff %t1.ll %t2.ll




template <int N> struct C {
template <int N> struct C {

  template <int M> int f() {
  template <int M> int f() {

    int arr[M] = {};
    int arr[M] = {};

    return arr[M/2] + C<M/2>().template f<M-1>();
    return arr[M/2] + C<M/2>().template f<M-1>();

  }
  }

};
};

template <> template <> int C<0>::f<0>() { return 0; }
template <> template <> int C<0>::f<0>() { return 0; }

template <> template <> int C<0>::f<1>() { return 0; }
template <> template <> int C<0>::f<1>() { return 0; }

template <> template <> int C<1>::f<0>() { return 0; }
template <> template <> int C<1>::f<0>() { return 0; }

template <> template <> int C<1>::f<1>() { return 0; }
template <> template <> int C<1>::f<1>() { return 0; }




int x = C<0>().f<64>();
int x = C<0>().f<64>();

test/CodeGenCXX/debug-info-dup-fwd-decl.cpp
// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin -fstandalone-debug %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=full -triple x86_64-apple-darwin %s -o - | FileCheck %s




class Test
class Test

{
{

public:
public:

    Test () : reserved (new data()) {}
    Test () : reserved (new data()) {}




    unsigned
    unsigned

    getID() const
    getID() const

Show All 15 Lines
test/CodeGenCXX/debug-info-enum-class.cpp
// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin -std=c++11 %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -triple x86_64-apple-darwin -std=c++11 %s -o - | FileCheck %s




enum class A { A1=1 };                 // underlying type is int by default
enum class A { A1=1 };                 // underlying type is int by default

enum class B: unsigned long { B1=1 };  // underlying type is unsigned long
enum class B: unsigned long { B1=1 };  // underlying type is unsigned long

enum C { C1 = 1 };
enum C { C1 = 1 };

enum D : short; // enum forward declaration
enum D : short; // enum forward declaration

A a;
A a;

B b;
B b;

C c;
C c;

▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines
test/CodeGenCXX/debug-info-enum.cpp
// RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -di-kind=limited %s -o - | FileCheck %s




// CHECK: !DICompileUnit(
// CHECK: !DICompileUnit(

// CHECK-SAME:           enums: [[ENUMS:![0-9]*]]
// CHECK-SAME:           enums: [[ENUMS:![0-9]*]]

// CHECK: [[ENUMS]] = !{[[E1:![0-9]*]], [[E2:![0-9]*]], [[E3:![0-9]*]]}
// CHECK: [[ENUMS]] = !{[[E1:![0-9]*]], [[E2:![0-9]*]], [[E3:![0-9]*]]}




namespace test1 {
namespace test1 {

// CHECK: [[E1]] = !DICompositeType(tag: DW_TAG_enumeration_type, name: "e"
// CHECK: [[E1]] = !DICompositeType(tag: DW_TAG_enumeration_type, name: "e"

// CHECK-SAME:                      scope: [[TEST1:![0-9]*]]
// CHECK-SAME:                      scope: [[TEST1:![0-9]*]]

▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines
test/CodeGenCXX/debug-info-flex-member.cpp
// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -triple x86_64-apple-darwin %s -o - | FileCheck %s




// CHECK: !DISubrange(count: -1)
// CHECK: !DISubrange(count: -1)




struct StructName {
struct StructName {

  int member[];
  int member[];

};
};




struct StructName SN;
struct StructName SN;

test/CodeGenCXX/debug-info-function-context.cpp
// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-pc-linux-gnu %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -triple x86_64-pc-linux-gnu %s -o - | FileCheck %s




struct C {
struct C {

  void member_function();
  void member_function();

  static int static_member_function();
  static int static_member_function();

  static int static_member_variable;
  static int static_member_variable;

};
};




int C::static_member_variable = 0;
int C::static_member_variable = 0;

Show All 27 Lines
test/CodeGenCXX/debug-info-fwd-ref.cpp
// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -triple x86_64-apple-darwin %s -o - | FileCheck %s




struct baz {
struct baz {

    int h;
    int h;

    baz(int a) : h(a) {}
    baz(int a) : h(a) {}

};
};




struct bar {
struct bar {

    baz b;
    baz b;

Show All 16 Lines
test/CodeGenCXX/debug-info-gline-tables-only.cpp
// RUN: %clang_cc1 %s -fno-rtti -gline-tables-only -S -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 %s -fno-rtti -di-kind=line-tables -S -emit-llvm -o - | FileCheck %s

// Checks that clang with "-gline-tables-only" doesn't emit debug info
// Checks that clang with "-gline-tables-only" doesn't emit debug info

// for variables and types.
// for variables and types.




// CHECK-NOT: DW_TAG_namespace
// CHECK-NOT: DW_TAG_namespace

namespace NS {
namespace NS {

// CHECK-NOT: DW_TAG_class_type
// CHECK-NOT: DW_TAG_class_type

// CHECK-NOT: DW_TAG_friend
// CHECK-NOT: DW_TAG_friend

class C { friend class D; };
class C { friend class D; };

Show All 20 Lines
test/CodeGenCXX/debug-info-global-ctor-dtor.cpp
// RUN: %clang_cc1 %s -g -triple %itanium_abi_triple -fno-use-cxa-atexit -S -emit-llvm -o - \
// RUN: %clang_cc1 %s -di-kind=limited -triple %itanium_abi_triple -fno-use-cxa-atexit -S -emit-llvm -o - \

// RUN:     | FileCheck %s --check-prefix=CHECK-NOKEXT
// RUN:     | FileCheck %s --check-prefix=CHECK-NOKEXT

// RUN: %clang_cc1 %s -g -triple %itanium_abi_triple -fno-use-cxa-atexit -fapple-kext -S -emit-llvm -o - \
// RUN: %clang_cc1 %s -di-kind=limited -triple %itanium_abi_triple -fno-use-cxa-atexit -fapple-kext -S -emit-llvm -o - \

// RUN:     | FileCheck %s --check-prefix=CHECK-KEXT
// RUN:     | FileCheck %s --check-prefix=CHECK-KEXT




class A {
class A {

 public:
 public:

  A() {}
  A() {}

  virtual ~A() {}
  virtual ~A() {}

};
};




Show All 16 Lines
test/CodeGenCXX/debug-info-global.cpp
// RUN: %clang_cc1 -triple x86_64-none-linux-gnu -emit-llvm -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple x86_64-none-linux-gnu -emit-llvm -di-kind=limited %s -o - | FileCheck %s




// Multiple references to the same constant should result in only one entry in
// Multiple references to the same constant should result in only one entry in

// the globals list.
// the globals list.




namespace ns {
namespace ns {

const int cnst = 42;
const int cnst = 42;

}
}

int f1() {
int f1() {

Show All 12 Lines
test/CodeGenCXX/debug-info-globalinit.cpp
// RUN: %clang_cc1 -triple x86_64-apple-darwin10.0.0 -emit-llvm -o - %s -std=c++11 -g | FileCheck %s
// RUN: %clang_cc1 -triple x86_64-apple-darwin10.0.0 -emit-llvm -o - %s -std=c++11 -di-kind=limited | FileCheck %s




void crash() {
void crash() {

  volatile char *ptr = 0;
  volatile char *ptr = 0;

  char x = *ptr;
  char x = *ptr;

}
}




int test() {
int test() {

  crash();
  crash();

Show All 29 Lines
test/CodeGenCXX/debug-info-indirect-field-decl.cpp
// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -triple x86_64-apple-darwin %s -o - | FileCheck %s

//
//

// Test that indirect field decls are handled gracefully.
// Test that indirect field decls are handled gracefully.

// rdar://problem/16348575
// rdar://problem/16348575

//
//

template <class T, int T::*ptr> class Foo {  };
template <class T, int T::*ptr> class Foo {  };




struct Bar {
struct Bar {

  int i1;
  int i1;

Show All 17 Lines
test/CodeGenCXX/debug-info-large-constant.cpp
// RUN: %clang_cc1 -g -triple=x86_64-apple-darwin %s -o /dev/null
// RUN: %clang_cc1 -di-kind=limited -triple=x86_64-apple-darwin %s -o /dev/null

// PR 8913
// PR 8913




typedef __uint128_t word128;
typedef __uint128_t word128;

static const word128 m126 = 0xffffffffffffffffULL;
static const word128 m126 = 0xffffffffffffffffULL;

word128 foo() {
word128 foo() {

  return m126;
  return m126;

}
}

test/CodeGenCXX/debug-info-line-if.cpp
// RUN: %clang_cc1 -g -std=c++11 -S -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -di-kind=limited -std=c++11 -S -emit-llvm %s -o - | FileCheck %s

// PR19864
// PR19864

extern int v[2];
extern int v[2];

int a = 0, b = 0;
int a = 0, b = 0;

int main() {
int main() {

#line 100
#line 100

  for (int x : v)
  for (int x : v)

    if (x)
    if (x)

      ++b; // CHECK: add nsw{{.*}}, 1
      ++b; // CHECK: add nsw{{.*}}, 1

▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines
test/CodeGenCXX/debug-info-line.cpp
// RUN: %clang_cc1 -w -gline-tables-only -std=c++11 -fexceptions -fcxx-exceptions -S -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -w -di-kind=line-tables -std=c++11 -fexceptions -fcxx-exceptions -S -emit-llvm %s -o - | FileCheck %s

// RUN: %clang_cc1 -w -gline-tables-only -std=c++11 -fexceptions -fcxx-exceptions -S -emit-llvm %s -o - -triple i686-linux-gnu | FileCheck %s
// RUN: %clang_cc1 -w -di-kind=line-tables -std=c++11 -fexceptions -fcxx-exceptions -S -emit-llvm %s -o - -triple i686-linux-gnu | FileCheck %s




// XFAIL: win32
// XFAIL: win32




int &src();
int &src();

int *sink();
int *sink();

extern "C" __complex float complex_src();
extern "C" __complex float complex_src();

extern "C" __complex float *complex_sink();
extern "C" __complex float *complex_sink();




▲ Show 20 Lines • Show All 314 Lines • Show Last 20 Lines
test/CodeGenCXX/debug-info-method-nodebug.cpp
// RUN: %clang_cc1 -emit-llvm -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited %s -o - | FileCheck %s




class C {
class C {

  void present();
  void present();

  void absent() __attribute__((nodebug));
  void absent() __attribute__((nodebug));

};
};




C c;
C c;




// CHECK-NOT: name: "absent"
// CHECK-NOT: name: "absent"

// CHECK:     name: "present"
// CHECK:     name: "present"

// CHECK-NOT: name: "absent"
// CHECK-NOT: name: "absent"

test/CodeGenCXX/debug-info-method.cpp
// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -std=c++11 -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -std=c++11 -di-kind=limited %s -o - | FileCheck %s

// CHECK: !DICompositeType(tag: DW_TAG_class_type, name: "A",{{.*}} identifier: "_ZTS1A")
// CHECK: !DICompositeType(tag: DW_TAG_class_type, name: "A",{{.*}} identifier: "_ZTS1A")

// CHECK: !DISubprogram(name: "foo", linkageName: "_ZN1A3fooEiS_3$_0"
// CHECK: !DISubprogram(name: "foo", linkageName: "_ZN1A3fooEiS_3$_0"

// CHECK-SAME:          DIFlagProtected
// CHECK-SAME:          DIFlagProtected

// CHECK: ![[THISTYPE:[0-9]+]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !"_ZTS1A"
// CHECK: ![[THISTYPE:[0-9]+]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !"_ZTS1A"

// CHECK-SAME:                                  DIFlagArtificial
// CHECK-SAME:                                  DIFlagArtificial

// CHECK: !DIDerivedType(tag: DW_TAG_ptr_to_member_type
// CHECK: !DIDerivedType(tag: DW_TAG_ptr_to_member_type

// CHECK: !DIDerivedType(tag: DW_TAG_ptr_to_member_type, baseType: ![[MEMFUNTYPE:[0-9]+]]
// CHECK: !DIDerivedType(tag: DW_TAG_ptr_to_member_type, baseType: ![[MEMFUNTYPE:[0-9]+]]

// CHECK: ![[MEMFUNTYPE]] = !DISubroutineType(types: ![[MEMFUNARGS:[0-9]+]])
// CHECK: ![[MEMFUNTYPE]] = !DISubroutineType(types: ![[MEMFUNARGS:[0-9]+]])

Show All 22 Lines
test/CodeGenCXX/debug-info-method2.cpp
// RUN: %clang_cc1 -fno-standalone-debug -x c++ -g -S -emit-llvm < %s | FileCheck %s
// RUN: %clang_cc1 -x c++ -di-kind=limited -S -emit-llvm < %s | FileCheck %s

// rdar://10336845
// rdar://10336845

// Preserve type qualifiers in -flimit-debug-info mode.
// Preserve type qualifiers in -flimit-debug-info mode.




// CHECK:  DW_TAG_const_type
// CHECK:  DW_TAG_const_type

class A {
class A {

public:
public:

  int bar(int arg) const;
  int bar(int arg) const;

};
};

Show All 10 Lines
test/CodeGenCXX/debug-info-namespace.cpp
// RUN: %clang_cc1 -g -fno-standalone-debug -S -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -di-kind=limited -S -emit-llvm %s -o - | FileCheck %s

// RUN: %clang_cc1 -g -gline-tables-only    -S -emit-llvm %s -o - | FileCheck -check-prefix=CHECK-GMLT %s
// RUN: %clang_cc1 -di-kind=line-tables -S -emit-llvm %s -o - | FileCheck -check-prefix=CHECK-GMLT %s

// RUN: %clang_cc1 -g -fstandalone-debug    -S -emit-llvm %s -o - | FileCheck -check-prefix=CHECK-NOLIMIT %s
// RUN: %clang_cc1 -di-kind=full -S -emit-llvm %s -o - | FileCheck -check-prefix=CHECK-NOLIMIT %s




namespace A {
namespace A {

#line 1 "foo.cpp"
#line 1 "foo.cpp"

namespace B {
namespace B {

extern int i;
extern int i;

int f1() { return 0; }
int f1() { return 0; }

void f1(int) { }
void f1(int) { }

struct foo;
struct foo;

▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines
test/CodeGenCXX/debug-info-nullptr.cpp
// RUN: %clang_cc1 -emit-llvm -std=c++11 -g %s -o -| FileCheck %s
// RUN: %clang_cc1 -emit-llvm -std=c++11 -di-kind=limited %s -o -| FileCheck %s




void foo() {
void foo() {

  decltype(nullptr) t = 0;
  decltype(nullptr) t = 0;

}
}




// CHECK: !DIBasicType(tag: DW_TAG_unspecified_type, name: "decltype(nullptr)")
// CHECK: !DIBasicType(tag: DW_TAG_unspecified_type, name: "decltype(nullptr)")

test/CodeGenCXX/debug-info-ptr-to-member-function.cpp
// RUN: %clang_cc1 %s -triple x86_64-apple-darwin -g -emit-llvm -o - | FileCheck -check-prefix=CHECK -check-prefix=DARWIN-X64 %s
// RUN: %clang_cc1 %s -triple x86_64-apple-darwin -di-kind=limited -emit-llvm -o - | FileCheck -check-prefix=CHECK -check-prefix=DARWIN-X64 %s

// RUN: %clang_cc1 %s -triple x86_64-pc-win32     -g -emit-llvm -o - | FileCheck -check-prefix=CHECK -check-prefix=WIN32-X64 %s
// RUN: %clang_cc1 %s -triple x86_64-pc-win32     -di-kind=limited -emit-llvm -o - | FileCheck -check-prefix=CHECK -check-prefix=WIN32-X64 %s




struct T {
struct T {

  int method();
  int method();

};
};




void foo(int (T::*method)()) {}
void foo(int (T::*method)()) {}




// A pointer to a member function is a pair of function- and this-pointer.
// A pointer to a member function is a pair of function- and this-pointer.

Show All 11 Lines
test/CodeGenCXX/debug-info-qualifiers.cpp
// RUN: %clang_cc1 -std=c++11 -emit-llvm -g -triple x86_64-apple-darwin %s -o - | FileCheck %s
// RUN: %clang_cc1 -std=c++11 -emit-llvm -di-kind=limited -triple x86_64-apple-darwin %s -o - | FileCheck %s

// Test (r)value and CVR qualifiers on C++11 non-static member functions.
// Test (r)value and CVR qualifiers on C++11 non-static member functions.

class A {
class A {

public:
public:

  // CHECK: !DISubprogram(name: "l",
  // CHECK: !DISubprogram(name: "l",

  // CHECK-SAME:          line: [[@LINE+4]]
  // CHECK-SAME:          line: [[@LINE+4]]

  // CHECK-SAME:          type: ![[PLSR:[0-9]+]]
  // CHECK-SAME:          type: ![[PLSR:[0-9]+]]

  // CHECK-SAME:          flags: DIFlagPublic | DIFlagPrototyped | DIFlagLValueReference,
  // CHECK-SAME:          flags: DIFlagPublic | DIFlagPrototyped | DIFlagLValueReference,

  // CHECK: ![[PLSR]] = !DISubroutineType(flags: DIFlagLValueReference, types: ![[ARGS:[0-9]+]])
  // CHECK: ![[PLSR]] = !DISubroutineType(flags: DIFlagLValueReference, types: ![[ARGS:[0-9]+]])

Show All 27 Lines
test/CodeGenCXX/debug-info-rvalue-ref.cpp
// RUN: %clang_cc1 -std=c++11 -emit-llvm -g -triple x86_64-apple-darwin %s -o - | FileCheck %s
// RUN: %clang_cc1 -std=c++11 -emit-llvm -di-kind=limited -triple x86_64-apple-darwin %s -o - | FileCheck %s




extern "C" {
extern "C" {

extern int printf(const char * format, ...);
extern int printf(const char * format, ...);

}
}

void foo (int &&i)
void foo (int &&i)

{
{

  printf("%d\n", i);
  printf("%d\n", i);

}
}




// CHECK: !DIDerivedType(tag: DW_TAG_rvalue_reference_type, baseType: ![[INT:[0-9]+]])
// CHECK: !DIDerivedType(tag: DW_TAG_rvalue_reference_type, baseType: ![[INT:[0-9]+]])

// CHECK: ![[INT]] = !DIBasicType(name: "int"
// CHECK: ![[INT]] = !DIBasicType(name: "int"

test/CodeGenCXX/debug-info-scope.cpp
// RUN: %clang_cc1 -g -std=c++11 -emit-llvm %s -o -| FileCheck %s
// RUN: %clang_cc1 -di-kind=limited -std=c++11 -emit-llvm %s -o -| FileCheck %s

//
//

// Two variables with the same name in subsequent if staments need to be in separate scopes.
// Two variables with the same name in subsequent if staments need to be in separate scopes.

//
//

// rdar://problem/14024005
// rdar://problem/14024005




int src();
int src();




void f();
void f();

▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines
test/CodeGenCXX/debug-info-static-fns.cpp
// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -triple x86_64-apple-darwin %s -o - | FileCheck %s




namespace A {
namespace A {

  static int a(int b) { return b + 4; }
  static int a(int b) { return b + 4; }




  int b(int c) { return c + a(c); }
  int b(int c) { return c + a(c); }

}
}




// Verify that a is present and mangled.
// Verify that a is present and mangled.

// CHECK: !DISubprogram(name: "a", linkageName: "_ZN1AL1aEi",
// CHECK: !DISubprogram(name: "a", linkageName: "_ZN1AL1aEi",

// CHECK-SAME:          line: 4
// CHECK-SAME:          line: 4

// CHECK-SAME:          isDefinition: true
// CHECK-SAME:          isDefinition: true

// CHECK-SAME:          function: i32 (i32)* @_ZN1AL1aEi
// CHECK-SAME:          function: i32 (i32)* @_ZN1AL1aEi

test/CodeGenCXX/debug-info-template-explicit-specialization.cpp
// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -g %s -o - -fno-standalone-debug | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -di-kind=limited %s -o - | FileCheck %s




// Run again with -gline-tables-only and verify we don't crash.  We won't output
// Run again with -gline-tables-only and verify we don't crash.  We won't output

// type info at all.
// type info at all.

// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -g %s -o - -gline-tables-only | FileCheck %s -check-prefix LINES-ONLY
// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -di-kind=limited %s -o - -di-kind=line-tables | FileCheck %s -check-prefix LINES-ONLY




// LINES-ONLY-NOT: !DICompositeType(tag: DW_TAG_structure_type
// LINES-ONLY-NOT: !DICompositeType(tag: DW_TAG_structure_type




template <typename T>
template <typename T>

struct a {
struct a {

};
};

extern template class a<int>;
extern template class a<int>;

// CHECK-NOT: DICompositeType(tag: DW_TAG_structure_type, name: "a<int>"
// CHECK-NOT: DICompositeType(tag: DW_TAG_structure_type, name: "a<int>"

▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines
test/CodeGenCXX/debug-info-template-fwd.cpp
// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -g -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -di-kind=limited -emit-llvm -o - | FileCheck %s

// This test is for a crash when emitting debug info for not-yet-completed
// This test is for a crash when emitting debug info for not-yet-completed

// types.
// types.

// Test that we don't actually emit a forward decl for the offending class:
// Test that we don't actually emit a forward decl for the offending class:

// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "Derived<int>"
// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "Derived<int>"

// CHECK-NOT:              DIFlagFwdDecl
// CHECK-NOT:              DIFlagFwdDecl

// CHECK-SAME:             ){{$}}
// CHECK-SAME:             ){{$}}

// rdar://problem/15931354
// rdar://problem/15931354

template <class A> class Derived;
template <class A> class Derived;

Show All 20 Lines
test/CodeGenCXX/debug-info-template-limit.cpp
// RUN: %clang_cc1 -emit-llvm -fno-standalone-debug -triple %itanium_abi_triple -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -triple %itanium_abi_triple %s -o - | FileCheck %s




// Check that this pointer type is TC<int>
// Check that this pointer type is TC<int>

// CHECK: ![[LINE:[0-9]+]] = !DICompositeType(tag: DW_TAG_class_type, name: "TC<int>"{{.*}}, identifier: "_ZTS2TCIiE")
// CHECK: ![[LINE:[0-9]+]] = !DICompositeType(tag: DW_TAG_class_type, name: "TC<int>"{{.*}}, identifier: "_ZTS2TCIiE")

// CHECK: !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !"_ZTS2TCIiE"
// CHECK: !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !"_ZTS2TCIiE"




template<typename T>
template<typename T>

class TC {
class TC {

public:
public:

  TC(const TC &) {}
  TC(const TC &) {}

  TC() {}
  TC() {}

};
};




TC<int> tci;
TC<int> tci;

test/CodeGenCXX/debug-info-template-member.cpp
// RUN: %clang_cc1 -emit-llvm -g -fno-standalone-debug -triple x86_64-apple-darwin %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -triple x86_64-apple-darwin %s -o - | FileCheck %s




struct MyClass {
struct MyClass {

  template <int i> int add(int j) {
  template <int i> int add(int j) {

    return i + j;
    return i + j;

  }
  }

  virtual void func() {
  virtual void func() {

  }
  }

};
};

▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Linesstruct elem {

  static virt<elem> x; // ensure that completing 'elem' will require/completing 'virt<elem>'
  static virt<elem> x; // ensure that completing 'elem' will require/completing 'virt<elem>'

};
};

inline void f1() {
inline void f1() {

  elem e; // ensure 'elem' is required to be complete when it is emitted as a template argument for 'virt<elem>'
  elem e; // ensure 'elem' is required to be complete when it is emitted as a template argument for 'virt<elem>'

};
};

void f2() {
void f2() {

  virt<elem> d; // emit 'virt<elem>'
  virt<elem> d; // emit 'virt<elem>'

}
}



test/CodeGenCXX/debug-info-template-partial-specialization.cpp
// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -g %s -o - -fstandalone-debug | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple %s -o - -di-kind=full | FileCheck %s

namespace __pointer_type_imp
namespace __pointer_type_imp

{
{

  template <class _Tp, class _Dp, bool > struct __pointer_type1 {};
  template <class _Tp, class _Dp, bool > struct __pointer_type1 {};




  // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "__pointer_type1<C, default_delete<C>, false>",
  // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "__pointer_type1<C, default_delete<C>, false>",

  // CHECK-SAME:             templateParams: ![[PARAMS:[0-9]+]]
  // CHECK-SAME:             templateParams: ![[PARAMS:[0-9]+]]

  // CHECK-SAME:             identifier: "_ZTSN18__pointer_type_imp15__pointer_type1I1C14default_deleteIS1_ELb0EEE"
  // CHECK-SAME:             identifier: "_ZTSN18__pointer_type_imp15__pointer_type1I1C14default_deleteIS1_ELb0EEE"

  template <class _Tp, class _Dp> struct __pointer_type1<_Tp, _Dp, false>
  template <class _Tp, class _Dp> struct __pointer_type1<_Tp, _Dp, false>

Show All 24 Lines
test/CodeGenCXX/debug-info-template-quals.cpp
// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -triple x86_64-apple-darwin %s -o - | FileCheck %s




template<typename _CharT>
template<typename _CharT>

struct basic_string {
struct basic_string {




  basic_string&
  basic_string&

  assign(const _CharT* __s, const basic_string<_CharT> &x)
  assign(const _CharT* __s, const basic_string<_CharT> &x)

  {
  {

    return *this;
    return *this;

Show All 22 Lines
test/CodeGenCXX/debug-info-template-recursive.cpp
// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -triple x86_64-apple-darwin %s -o - | FileCheck %s




class base { };
class base { };




template <class T> class foo : public base  {
template <class T> class foo : public base  {

  void operator=(const foo r) { }
  void operator=(const foo r) { }

};
};




class bar : public foo<void> { };
class bar : public foo<void> { };

bar filters;
bar filters;




// For now check that it simply doesn't crash.
// For now check that it simply doesn't crash.

// CHECK: {{.*}}
// CHECK: {{.*}}

test/CodeGenCXX/debug-info-thunk.cpp
// RUN: %clang_cc1 %s -triple %itanium_abi_triple -g -S -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 %s -triple %itanium_abi_triple -di-kind=limited -S -emit-llvm -o - | FileCheck %s




struct A {
struct A {

  virtual void f();
  virtual void f();

};
};




struct B {
struct B {

  virtual void f();
  virtual void f();

};
};

Show All 11 Lines
test/CodeGenCXX/debug-info-union-template.cpp
// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-linux-gnu  %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -triple x86_64-linux-gnu  %s -o - | FileCheck %s




// Make sure that the union type has template parameters.
// Make sure that the union type has template parameters.




namespace PR15637 {
namespace PR15637 {

  template <typename T> union Value { int a; };
  template <typename T> union Value { int a; };

  void g(float value) {
  void g(float value) {

    Value<float> tempValue;
    Value<float> tempValue;

  }
  }

  Value<float> f;
  Value<float> f;

}
}




// CHECK: !DICompositeType(tag: DW_TAG_union_type, name: "Value<float>",
// CHECK: !DICompositeType(tag: DW_TAG_union_type, name: "Value<float>",

// CHECK-SAME:             templateParams: [[TTPARAM:![0-9]+]]
// CHECK-SAME:             templateParams: [[TTPARAM:![0-9]+]]

// CHECK-SAME:             identifier: "_ZTSN7PR156375ValueIfEE"
// CHECK-SAME:             identifier: "_ZTSN7PR156375ValueIfEE"

// CHECK: [[TTPARAM]] = !{[[PARAMS:.*]]}
// CHECK: [[TTPARAM]] = !{[[PARAMS:.*]]}

// CHECK: [[PARAMS]] = !DITemplateTypeParameter(name: "T"
// CHECK: [[PARAMS]] = !DITemplateTypeParameter(name: "T"

test/CodeGenCXX/debug-info-union.cpp
// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin -std=c++11 %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -triple x86_64-apple-darwin -std=c++11 %s -o - | FileCheck %s




union E {
union E {

  int a;
  int a;

  float b;
  float b;

  int bb() { return a;}
  int bb() { return a;}

  float aa() { return b;}
  float aa() { return b;}

  E() { a = 0; }
  E() { a = 0; }

};
};

Show All 11 Lines
test/CodeGenCXX/debug-info-use-after-free.cpp
// RUN: %clang_cc1 -g -triple %itanium_abi_triple -emit-llvm-only %s
// RUN: %clang_cc1 -di-kind=limited -triple %itanium_abi_triple -emit-llvm-only %s

// Check that we don't crash.
// Check that we don't crash.

// PR12305, PR12315
// PR12305, PR12315




# 1 "a.h"  3
# 1 "a.h"  3

template < typename T1 > struct Types1
template < typename T1 > struct Types1

{
{

  typedef T1 Head;
  typedef T1 Head;

};
};

▲ Show 20 Lines • Show All 304 Lines • Show Last 20 Lines
test/CodeGenCXX/debug-info-uuid.cpp
// RUN: %clang_cc1 -emit-llvm -fms-extensions -triple=x86_64-pc-win32 -g %s -o - -std=c++11 | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -fms-extensions -triple=x86_64-pc-win32 -di-kind=limited %s -o - -std=c++11 | FileCheck %s

// RUN: %clang_cc1 -emit-llvm -fms-extensions -triple=x86_64-unknown-unknown -g %s -o - -std=c++11 2>&1 | FileCheck %s --check-prefix=CHECK-ITANIUM
// RUN: %clang_cc1 -emit-llvm -fms-extensions -triple=x86_64-unknown-unknown -di-kind=limited %s -o - -std=c++11 2>&1 | FileCheck %s --check-prefix=CHECK-ITANIUM




// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "tmpl_guid<&__uuidof(uuid)>"
// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "tmpl_guid<&__uuidof(uuid)>"

// CHECK-SAME:             templateParams: [[TGIARGS:![0-9]*]]
// CHECK-SAME:             templateParams: [[TGIARGS:![0-9]*]]

// CHECK: [[TGIARGS]] = !{[[TGIARG1:![0-9]*]]}
// CHECK: [[TGIARGS]] = !{[[TGIARG1:![0-9]*]]}

// CHECK: [[TGIARG1]] = !DITemplateValueParameter(
// CHECK: [[TGIARG1]] = !DITemplateValueParameter(

// CHECK-SAME:                                    type: [[CONST_GUID_PTR:![0-9]*]]
// CHECK-SAME:                                    type: [[CONST_GUID_PTR:![0-9]*]]

// CHECK-SAME:                                    value: { i32, i16, i16, [8 x i8] }* @_GUID_12345678_1234_1234_1234_1234567890ab
// CHECK-SAME:                                    value: { i32, i16, i16, [8 x i8] }* @_GUID_12345678_1234_1234_1234_1234567890ab

// CHECK: [[CONST_GUID_PTR]] = !DIDerivedType(tag: DW_TAG_pointer_type
// CHECK: [[CONST_GUID_PTR]] = !DIDerivedType(tag: DW_TAG_pointer_type

Show All 32 Lines
test/CodeGenCXX/debug-info-varargs.cpp
// RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -di-kind=limited %s -o - | FileCheck %s




struct A
struct A

{
{

  // CHECK: !DISubprogram(name: "a", linkageName: "_ZN1A1aEiz"
  // CHECK: !DISubprogram(name: "a", linkageName: "_ZN1A1aEiz"

  // CHECK-SAME:          line: [[@LINE+2]]
  // CHECK-SAME:          line: [[@LINE+2]]

  // CHECK-SAME:          type: ![[ATY:[0-9]+]]
  // CHECK-SAME:          type: ![[ATY:[0-9]+]]

  void a(int c, ...) {}
  void a(int c, ...) {}

  // CHECK: ![[ATY]] = !DISubroutineType(types: ![[AARGS:[0-9]+]])
  // CHECK: ![[ATY]] = !DISubroutineType(types: ![[AARGS:[0-9]+]])

Show All 19 Lines
test/CodeGenCXX/debug-info-vtable-optzn.cpp
// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=full -triple x86_64-apple-darwin %s -o - | FileCheck %s

// RUN: %clang_cc1 -emit-llvm -g -triple amd64-unknown-freebsd %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=full -triple amd64-unknown-freebsd %s -o - | FileCheck %s

//
//

// This tests that the "emit debug info for a C++ class only in the
// This tests that the "emit debug info for a C++ class only in the

// module that has its vtable" optimization is disabled by default on
// module that has its vtable" optimization is disabled by default on

// Darwin and FreeBSD.
// Darwin and FreeBSD.

//
//

// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "lost"
// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "lost"

class A
class A

{
{

Show All 12 Lines
test/CodeGenCXX/debug-info-wchar.cpp
// RUN: %clang_cc1 -emit-llvm -g %s -o -| FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited %s -o -| FileCheck %s

void foo() {
void foo() {

// CHECK: !DIBasicType(name: "wchar_t"
// CHECK: !DIBasicType(name: "wchar_t"

  const wchar_t w = L'x';
  const wchar_t w = L'x';

}
}

test/CodeGenCXX/debug-info-windows-dtor.cpp
// RUN: %clang_cc1 -triple i386-unknown-windows-msvc -std=c++11 -emit-llvm -gline-tables-only %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple i386-unknown-windows-msvc -std=c++11 -emit-llvm -di-kind=line-tables %s -o - | FileCheck %s




struct A {
struct A {

  virtual ~A() {}
  virtual ~A() {}

};
};




struct B {
struct B {

  virtual ~B() {}
  virtual ~B() {}

};
};

Show All 13 Lines
test/CodeGenCXX/debug-info.cpp
// RUN: %clang_cc1 -triple x86_64-none-linux-gnu -emit-llvm -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple x86_64-none-linux-gnu -emit-llvm -di-kind=limited %s -o - | FileCheck %s

// RUN: %clang_cc1 -triple i686-pc-windows-msvc -emit-llvm -g %s -o - | FileCheck %s --check-prefix=MSVC
// RUN: %clang_cc1 -triple i686-pc-windows-msvc -emit-llvm -di-kind=limited %s -o - | FileCheck %s --check-prefix=MSVC




template<typename T> struct Identity {
template<typename T> struct Identity {

  typedef T Type;
  typedef T Type;

};
};




void f(Identity<int>::Type a) {}
void f(Identity<int>::Type a) {}

void f(Identity<int> a) {}
void f(Identity<int> a) {}

void f(int& a) { }
void f(int& a) { }

▲ Show 20 Lines • Show All 161 Lines • Show Last 20 Lines
test/CodeGenCXX/debug-lambda-expressions.cpp
// RUN: %clang_cc1 -triple x86_64-apple-darwin10.0.0 -emit-llvm -o - %s -fexceptions -std=c++11 -g | FileCheck %s
// RUN: %clang_cc1 -triple x86_64-apple-darwin10.0.0 -emit-llvm -o - %s -fexceptions -std=c++11 -di-kind=limited | FileCheck %s




auto var = [](int i) { return i+1; };
auto var = [](int i) { return i+1; };

void *use = &var;
void *use = &var;




extern "C" auto cvar = []{};
extern "C" auto cvar = []{};




int a() { return []{ return 1; }(); }
int a() { return []{ return 1; }(); }




▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines
test/CodeGenCXX/debug-lambda-this.cpp
// RUN: %clang_cc1 -triple x86_64-apple-darwin10.0.0 -emit-llvm -o - %s -fexceptions -std=c++11 -g | FileCheck %s
// RUN: %clang_cc1 -triple x86_64-apple-darwin10.0.0 -emit-llvm -o - %s -fexceptions -std=c++11 -di-kind=limited | FileCheck %s




struct D {
struct D {

  D();
  D();

  D(const D&);
  D(const D&);

  int x;
  int x;

  int d(int x);
  int d(int x);

};
};

int D::d(int x) {
int D::d(int x) {

Show All 12 Lines
test/CodeGenCXX/destructor-debug-info.cpp
// RUN: %clang_cc1 -g -S -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -di-kind=limited -S -emit-llvm %s -o - | FileCheck %s




class A { int a; };
class A { int a; };

class B {
class B {

public:
public:

  B() { a = new A; }
  B() { a = new A; }

  ~B() { delete a; }
  ~B() { delete a; }

private:
private:

  A *a;
  A *a;

Show All 13 Lines
test/CodeGenCXX/globalinit-loc.cpp
// RUN: %clang_cc1 -emit-llvm -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited %s -o - | FileCheck %s

// rdar://problem/14985269.
// rdar://problem/14985269.

//
//

// Verify that the global init helper function does not get associated
// Verify that the global init helper function does not get associated

// with any source location.
// with any source location.

//
//

// CHECK: define internal {{.*}}void @_GLOBAL__sub_I_globalinit_loc.cpp
// CHECK: define internal {{.*}}void @_GLOBAL__sub_I_globalinit_loc.cpp

// CHECK: !dbg ![[DBG:.*]]
// CHECK: !dbg ![[DBG:.*]]

// CHECK: !DISubprogram(linkageName: "_GLOBAL__sub_I_globalinit_loc.cpp"
// CHECK: !DISubprogram(linkageName: "_GLOBAL__sub_I_globalinit_loc.cpp"

Show All 17 Lines
test/CodeGenCXX/inline-dllexport-member.cpp
// RUN: %clang_cc1 -triple i686-windows-gnu -fms-compatibility -g -emit-llvm %s -o - \
// RUN: %clang_cc1 -triple i686-windows-gnu -fms-compatibility -di-kind=limited -emit-llvm %s -o - \

// RUN:    | FileCheck %s
// RUN:    | FileCheck %s




struct __declspec(dllexport) s {
struct __declspec(dllexport) s {

  static const unsigned int ui = 0;
  static const unsigned int ui = 0;

};
};




// CHECK: ![[SCOPE:[0-9]+]] = distinct !DICompileUnit(
// CHECK: ![[SCOPE:[0-9]+]] = distinct !DICompileUnit(

// CHECK: !DIGlobalVariable(name: "ui", linkageName: "_ZN1s2uiE", scope: ![[SCOPE]],
// CHECK: !DIGlobalVariable(name: "ui", linkageName: "_ZN1s2uiE", scope: ![[SCOPE]],

// CHECK-SAME:              variable: i32* @_ZN1s2uiE
// CHECK-SAME:              variable: i32* @_ZN1s2uiE




test/CodeGenCXX/linetable-cleanup.cpp
// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin10 %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -triple x86_64-apple-darwin10 %s -o - | FileCheck %s




// Check the line numbers for cleanup code with EH in combination with
// Check the line numbers for cleanup code with EH in combination with

// simple return expressions.
// simple return expressions.




// CHECK: define {{.*}}foo
// CHECK: define {{.*}}foo

// CHECK: call void @_ZN1CD1Ev(%class.C* {{.*}}), !dbg ![[RET:[0-9]+]]
// CHECK: call void @_ZN1CD1Ev(%class.C* {{.*}}), !dbg ![[RET:[0-9]+]]

// CHECK: ret i32 0, !dbg ![[RET]]
// CHECK: ret i32 0, !dbg ![[RET]]




▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines
test/CodeGenCXX/linetable-eh.cpp
// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-macosx10.9.0 -munwind-tables -std=c++11 -fcxx-exceptions -fexceptions %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -triple x86_64-apple-macosx10.9.0 -munwind-tables -std=c++11 -fcxx-exceptions -fexceptions %s -o - | FileCheck %s




// Test that emitting a landing pad does not affect the line table
// Test that emitting a landing pad does not affect the line table

// entries for the code that triggered it.
// entries for the code that triggered it.




// CHECK: call void @llvm.dbg.declare
// CHECK: call void @llvm.dbg.declare

// CHECK: call void @llvm.dbg.declare(metadata {{.*}}, metadata ![[CURRENT_ADDR:.*]], metadata !{{.*}}), !dbg ![[DBG1:.*]]
// CHECK: call void @llvm.dbg.declare(metadata {{.*}}, metadata ![[CURRENT_ADDR:.*]], metadata !{{.*}}), !dbg ![[DBG1:.*]]

// CHECK: unwind label %{{.*}}, !dbg ![[DBG1]]
// CHECK: unwind label %{{.*}}, !dbg ![[DBG1]]

// CHECK: store i64 %{{.*}}, i64* %current_address, align 8, !dbg ![[DBG4:.*]]
// CHECK: store i64 %{{.*}}, i64* %current_address, align 8, !dbg ![[DBG4:.*]]

Show All 35 Lines
test/CodeGenCXX/linetable-fnbegin.cpp
// RUN: %clang_cc1 -emit-llvm -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited %s -o - | FileCheck %s

// Test that the line table info for Foo<T>::bar() is pointing to the
// Test that the line table info for Foo<T>::bar() is pointing to the

// right header file.
// right header file.

// CHECK: define{{.*}}bar
// CHECK: define{{.*}}bar

// CHECK-NOT: define
// CHECK-NOT: define

// CHECK: ret {{.*}}, !dbg [[DBG:.*]]
// CHECK: ret {{.*}}, !dbg [[DBG:.*]]

// CHECK: [[HPP:.*]] = !DIFile(filename: "./template.hpp",
// CHECK: [[HPP:.*]] = !DIFile(filename: "./template.hpp",

// CHECK: [[SP:.*]] = distinct !DISubprogram(name: "bar",
// CHECK: [[SP:.*]] = distinct !DISubprogram(name: "bar",

// CHECK-SAME:                               file: [[HPP]], line: 22
// CHECK-SAME:                               file: [[HPP]], line: 22

Show All 21 Lines
test/CodeGenCXX/linetable-virtual-variadic.cpp
// RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm -gline-tables-only %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm -di-kind=line-tables %s -o - | FileCheck %s

// Crasher for PR22929.
// Crasher for PR22929.

class Base {
class Base {

  virtual void VariadicFunction(...);
  virtual void VariadicFunction(...);

};
};




class Derived : public virtual Base {
class Derived : public virtual Base {

  virtual void VariadicFunction(...);
  virtual void VariadicFunction(...);

};
};

Show All 14 Lines
test/CodeGenCXX/lpad-linetable.cpp
// RUN: %clang_cc1  -fcxx-exceptions -fexceptions -emit-llvm -g -triple x86_64-apple-darwin10 %s -o - | FileCheck %s
// RUN: %clang_cc1  -fcxx-exceptions -fexceptions -emit-llvm -di-kind=limited -triple x86_64-apple-darwin10 %s -o - | FileCheck %s

// The landing pad should have the line number of the closing brace of the function.
// The landing pad should have the line number of the closing brace of the function.

// rdar://problem/13888152
// rdar://problem/13888152

// CHECK: ret i32
// CHECK: ret i32

// CHECK: landingpad {{.*}}
// CHECK: landingpad {{.*}}

// CHECK-NEXT: !dbg ![[LPAD:[0-9]+]]
// CHECK-NEXT: !dbg ![[LPAD:[0-9]+]]

// CHECK: ![[LPAD]] = !DILocation(line: 24, scope: !{{.*}})
// CHECK: ![[LPAD]] = !DILocation(line: 24, scope: !{{.*}})




# 1 "/usr/include/c++/4.2.1/vector" 1 3
# 1 "/usr/include/c++/4.2.1/vector" 1 3

▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines
test/CodeGenCXX/scoped-enums-debug-info.cpp
// RUN: %clang_cc1 -std=c++11 -emit-llvm -g -o - %s | FileCheck %s
// RUN: %clang_cc1 -std=c++11 -emit-llvm -di-kind=limited -o - %s | FileCheck %s

// Test that we are emitting debug info and base types for scoped enums.
// Test that we are emitting debug info and base types for scoped enums.




// CHECK: !DICompositeType(tag: DW_TAG_enumeration_type, name: "Color"
// CHECK: !DICompositeType(tag: DW_TAG_enumeration_type, name: "Color"

// CHECK-SAME:             baseType: ![[INT:[0-9]+]]
// CHECK-SAME:             baseType: ![[INT:[0-9]+]]

// CHECK: ![[INT]] = !DIBasicType(name: "int"
// CHECK: ![[INT]] = !DIBasicType(name: "int"

enum class Color { gray };
enum class Color { gray };




void f(Color);
void f(Color);

Show All 22 Lines
test/CodeGenCXX/vtable-holder-self-reference.cpp
// RUN: %clang_cc1 -emit-llvm -gdwarf-2 -x c++ -o - %s | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -dwarf-version=2 -di-kind=limited -x c++ -o - %s | FileCheck %s

//
//

// PR21941: crasher for self-referencing DW_TAG_structure_type node.  If we get
// PR21941: crasher for self-referencing DW_TAG_structure_type node.  If we get

// rid of self-referenceing structure_types (PR21902), then it should be safe
// rid of self-referenceing structure_types (PR21902), then it should be safe

// to just kill this test.
// to just kill this test.

//
//

// CHECK: ![[SELF:[0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "B",
// CHECK: ![[SELF:[0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "B",

// CHECK-SAME:                                         vtableHolder: ![[SELF]]
// CHECK-SAME:                                         vtableHolder: ![[SELF]]




void foo() {
void foo() {

  struct V {
  struct V {

    int vi;
    int vi;

  };
  };

  struct B : virtual V {};
  struct B : virtual V {};

  B b;
  B b;

}
}

test/CodeGenObjC/2009-01-21-invalid-debug-info.m
// RUN: %clang_cc1 -S -g -o %t.s %s
// RUN: %clang_cc1 -S -di-kind=limited -o %t.s %s




// FIXME: This test case can be removed at some point (since it will
// FIXME: This test case can be removed at some point (since it will

// no longer effectively test anything). The reason it was causing
// no longer effectively test anything). The reason it was causing

// trouble was the synthesized self decl in im1 was causing the debug
// trouble was the synthesized self decl in im1 was causing the debug

// info for I1* to be generated, but referring to an invalid compile
// info for I1* to be generated, but referring to an invalid compile

// unit. This was later referred to by f1 and created ill formed debug
// unit. This was later referred to by f1 and created ill formed debug

// information.
// information.




@interface I1 @end
@interface I1 @end




@implementation I1
@implementation I1

-im0 { return 0; }
-im0 { return 0; }

@end
@end




I1 *f1(void) { return 0; }
I1 *f1(void) { return 0; }

test/CodeGenObjC/2010-02-09-DbgSelf.m
// RUN: %clang_cc1 -x objective-c -emit-llvm -g < %s | FileCheck %s
// RUN: %clang_cc1 -x objective-c -emit-llvm -di-kind=limited < %s | FileCheck %s

// Test to check that "self" argument is assigned a location.
// Test to check that "self" argument is assigned a location.

// CHECK: call void @llvm.dbg.declare(metadata %0** %{{[^,]+}}, metadata [[SELF:![0-9]*]], metadata !{{.*}})
// CHECK: call void @llvm.dbg.declare(metadata %0** %{{[^,]+}}, metadata [[SELF:![0-9]*]], metadata !{{.*}})

// CHECK: [[SELF]] = !DILocalVariable(name: "self", arg: 1,
// CHECK: [[SELF]] = !DILocalVariable(name: "self", arg: 1,




@interface Foo 
@interface Foo 

-(void) Bar: (int)x ;
-(void) Bar: (int)x ;

@end
@end







@implementation Foo
@implementation Foo

-(void) Bar: (int)x 
-(void) Bar: (int)x 

{
{

}
}

@end
@end




test/CodeGenObjC/2010-02-15-Dbg-MethodStart.m
// RUN: %clang_cc1 -x objective-c -emit-llvm -g < %s | FileCheck "%s"
// RUN: %clang_cc1 -x objective-c -emit-llvm -di-kind=limited < %s | FileCheck "%s"

// Test to check that subprogram start location.
// Test to check that subprogram start location.




@interface Foo
@interface Foo

-(int) barMethod;
-(int) barMethod;

@end
@end




@implementation Foo
@implementation Foo

-(int) barMethod {
-(int) barMethod {

  // CHECK: !DISubprogram({{.*}}line: [[@LINE-1]]
  // CHECK: !DISubprogram({{.*}}line: [[@LINE-1]]

  int i = 0;
  int i = 0;

  int j = 1;
  int j = 1;

  int k = 1;
  int k = 1;

  return i + j + k;
  return i + j + k;

}
}

@end
@end

test/CodeGenObjC/2010-02-23-DbgInheritance.m
// RUN: %clang_cc1 -emit-llvm %s -g -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm %s -di-kind=limited -o - | FileCheck %s

// CHECK-NOT: DW_TAG_member
// CHECK-NOT: DW_TAG_member

// Interface P should not be a member of interface I in debug info.
// Interface P should not be a member of interface I in debug info.

@interface P 
@interface P 

@end
@end




@interface I : P 
@interface I : P 

@end
@end




void fn(I *iptr) {}
void fn(I *iptr) {}

test/CodeGenObjC/arc-linetable-autorelease.m
// RUN: %clang_cc1 -emit-llvm -fobjc-arc -g -triple x86_64-apple-darwin10 %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -fobjc-arc -di-kind=limited -triple x86_64-apple-darwin10 %s -o - | FileCheck %s

// Ensure that the line info is making sense:
// Ensure that the line info is making sense:

// ARC cleanups should be at the closing '}'.
// ARC cleanups should be at the closing '}'.

@protocol NSObject
@protocol NSObject

@end
@end




@interface NSObject <NSObject> {}
@interface NSObject <NSObject> {}

@end
@end




Show All 30 Lines
test/CodeGenObjC/arc-linetable.m
// RUN: %clang_cc1 -emit-llvm -fblocks -fobjc-arc -g -triple x86_64-apple-darwin10 %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -fblocks -fobjc-arc -di-kind=full -dwarf-version=4 -triple x86_64-apple-darwin10 %s -o - | FileCheck %s




// Legend: EXP = Return expression, RET = ret instruction
// Legend: EXP = Return expression, RET = ret instruction




// CHECK: define {{.*}}testNoSideEffect
// CHECK: define {{.*}}testNoSideEffect

// CHECK: call void @objc_storeStrong{{.*}}
// CHECK: call void @objc_storeStrong{{.*}}

// CHECK: call void @objc_storeStrong{{.*}} !dbg ![[RET1:[0-9]+]]
// CHECK: call void @objc_storeStrong{{.*}} !dbg ![[RET1:[0-9]+]]

// CHECK: ret {{.*}} !dbg ![[RET1]]
// CHECK: ret {{.*}} !dbg ![[RET1]]




▲ Show 20 Lines • Show All 117 Lines • Show Last 20 Lines
test/CodeGenObjC/block-byref-debuginfo.m
// RUN: %clang_cc1 -fblocks -fobjc-arc -fobjc-runtime-has-weak -g -triple x86_64-apple-darwin -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -fblocks -fobjc-arc -fobjc-runtime-has-weak -di-kind=limited -triple x86_64-apple-darwin -emit-llvm %s -o - | FileCheck %s




// rdar://problem/14386148
// rdar://problem/14386148

// Test that the foo is aligned at an 8 byte boundary in the DWARF
// Test that the foo is aligned at an 8 byte boundary in the DWARF

// expression (256) that locates it inside of the byref descriptor:
// expression (256) that locates it inside of the byref descriptor:

// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "foo",
// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "foo",

// CHECK-NOT:            line:
// CHECK-NOT:            line:

// CHECK-SAME:           align: 64
// CHECK-SAME:           align: 64

// CHECK-SAME:           offset: 256
// CHECK-SAME:           offset: 256




struct Foo {
struct Foo {

  unsigned char *data;
  unsigned char *data;

};
};

int func() {
int func() {

  __attribute__((__blocks__(byref))) struct Foo foo;
  __attribute__((__blocks__(byref))) struct Foo foo;

  return 0;
  return 0;

}
}

test/CodeGenObjC/blocks-ivar-debug.m
// RUN: %clang_cc1 -g %s -fblocks -S -o %t
// RUN: %clang_cc1 -di-kind=limited %s -fblocks -S -o %t

// Radar 7959934
// Radar 7959934




@interface NSObject {
@interface NSObject {

  struct objc_object *isa;
  struct objc_object *isa;

}
}

@end
@end

@interface Foo : NSObject {
@interface Foo : NSObject {

  int _prop;
  int _prop;

Show All 11 Lines
test/CodeGenObjC/catch-lexical-block.m
// RUN: %clang_cc1 -g -fobjc-exceptions -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -di-kind=limited -fobjc-exceptions -emit-llvm %s -o - | FileCheck %s

@interface Foo @end
@interface Foo @end

void f0() {
void f0() {

  @try {
  @try {

    @throw @"a";
    @throw @"a";

  } @catch(Foo *e) {
  } @catch(Foo *e) {

  }
  }

}
}




// We should have 3 lexical blocks here at the moment, including one
// We should have 3 lexical blocks here at the moment, including one

// for the catch block.
// for the catch block.

// CHECK: !DILexicalBlock(
// CHECK: !DILexicalBlock(

// CHECK: !DILocalVariable(
// CHECK: !DILocalVariable(

// CHECK: !DILexicalBlock(
// CHECK: !DILexicalBlock(

// CHECK: !DILexicalBlock(
// CHECK: !DILexicalBlock(

test/CodeGenObjC/debug-info-block-captured-self.m
// RUN: %clang_cc1 -fblocks -g -emit-llvm -triple x86_64-apple-darwin -o - %s | FileCheck %s
// RUN: %clang_cc1 -fblocks -di-kind=limited -emit-llvm -triple x86_64-apple-darwin -o - %s | FileCheck %s

//
//

// Test that debug location is generated for a captured "self" inside
// Test that debug location is generated for a captured "self" inside

// a block.
// a block.

//
//

// This test is split into two parts, this one for the frontend, and
// This test is split into two parts, this one for the frontend, and

// then llvm/test/DebugInfo/debug-info-block-captured-self.ll to
// then llvm/test/DebugInfo/debug-info-block-captured-self.ll to

// ensure that DW_AT_location is generated for the captured self.
// ensure that DW_AT_location is generated for the captured self.

@class T;
@class T;

▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines
test/CodeGenObjC/debug-info-block-helper.m
// REQUIRES: x86-registered-target
// REQUIRES: x86-registered-target

// RUN: %clang_cc1 -emit-llvm -fblocks -g -triple x86_64-apple-darwin10 -fobjc-runtime=macosx-fragile-10.5 %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -fblocks -di-kind=limited -triple x86_64-apple-darwin10 -fobjc-runtime=macosx-fragile-10.5 %s -o - | FileCheck %s

extern void foo(void(^)(void));
extern void foo(void(^)(void));




// CHECK: !DISubprogram(name: "__destroy_helper_block_"
// CHECK: !DISubprogram(name: "__destroy_helper_block_"




@interface NSObject {
@interface NSObject {

  struct objc_object *isa;
  struct objc_object *isa;

}
}

@end
@end

Show All 20 Lines
test/CodeGenObjC/debug-info-block-line.m
// REQUIRES: x86-registered-target
// REQUIRES: x86-registered-target

// RUN: %clang_cc1 -emit-llvm -fblocks -fobjc-arc -g -triple x86_64-apple-darwin10 %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -fblocks -fobjc-arc -di-kind=limited -triple x86_64-apple-darwin10 %s -o - | FileCheck %s




// rdar://11562117
// rdar://11562117

typedef unsigned int NSUInteger;
typedef unsigned int NSUInteger;

typedef long NSInteger;
typedef long NSInteger;

typedef signed char BOOL;
typedef signed char BOOL;




#define nil ((void*) 0)
#define nil ((void*) 0)

#define YES             ((BOOL)1)
#define YES             ((BOOL)1)

▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines
test/CodeGenObjC/debug-info-block-type.m
// RUN: %clang_cc1 -emit-llvm -fblocks -g  -triple x86_64-apple-darwin14 -x objective-c < %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -fblocks -di-kind=limited  -triple x86_64-apple-darwin14 -x objective-c < %s -o - | FileCheck %s

#define nil ((void*) 0)
#define nil ((void*) 0)

typedef signed char BOOL;
typedef signed char BOOL;

// CHECK: ![[BOOL:[0-9]+]] = !DIDerivedType(tag: DW_TAG_typedef, name: "BOOL"
// CHECK: ![[BOOL:[0-9]+]] = !DIDerivedType(tag: DW_TAG_typedef, name: "BOOL"

// CHECK-SAME:                              line: [[@LINE-2]]
// CHECK-SAME:                              line: [[@LINE-2]]

// CHECK: ![[ID:[0-9]+]] = !DIDerivedType(tag: DW_TAG_typedef, name: "id"
// CHECK: ![[ID:[0-9]+]] = !DIDerivedType(tag: DW_TAG_typedef, name: "id"




typedef BOOL (^SomeKindOfPredicate)(id obj);
typedef BOOL (^SomeKindOfPredicate)(id obj);

// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "__FuncPtr"
// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "__FuncPtr"

Show All 14 Lines
test/CodeGenObjC/debug-info-blocks.m
// RUN: %clang_cc1 -emit-llvm -fblocks -g  -triple x86_64-apple-darwin10 -fobjc-dispatch-method=mixed -x objective-c < %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -fblocks -di-kind=limited  -triple x86_64-apple-darwin10 -fobjc-dispatch-method=mixed -x objective-c < %s -o - | FileCheck %s




// rdar://problem/9279956
// rdar://problem/9279956

// Test that we generate the proper debug location for a captured self.
// Test that we generate the proper debug location for a captured self.

// The second half of this test is in llvm/tests/DebugInfo/debug-info-blocks.ll
// The second half of this test is in llvm/tests/DebugInfo/debug-info-blocks.ll




// CHECK: define {{.*}}_block_invoke
// CHECK: define {{.*}}_block_invoke

// CHECK: %[[BLOCK:.*]] = bitcast i8* %.block_descriptor to <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, %0* }>*, !dbg
// CHECK: %[[BLOCK:.*]] = bitcast i8* %.block_descriptor to <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, %0* }>*, !dbg

// CHECK-NEXT: store <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, %0* }>* %[[BLOCK]], <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, %0* }>** %[[ALLOCA:.*]], align
// CHECK-NEXT: store <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, %0* }>* %[[BLOCK]], <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, %0* }>** %[[ALLOCA:.*]], align

▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines
test/CodeGenObjC/debug-info-class-extension.m
// FIXME: Check IR rather than asm, then triple is not needed.
// FIXME: Check IR rather than asm, then triple is not needed.

// RUN: %clang_cc1 -triple %itanium_abi_triple -masm-verbose -S -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple %itanium_abi_triple -masm-verbose -S -di-kind=limited %s -o - | FileCheck %s




// CHECK: AT_APPLE_objc_complete_type
// CHECK: AT_APPLE_objc_complete_type




@interface I1
@interface I1

@end
@end




@implementation I1 {
@implementation I1 {

int myi2;
int myi2;

}
}

int myi;
int myi;

@end
@end




void foo(I1 *iptr) {}
void foo(I1 *iptr) {}




test/CodeGenObjC/debug-info-class-extension2.m
// FIXME: Check IR rather than asm, then triple is not needed.
// FIXME: Check IR rather than asm, then triple is not needed.

// RUN: %clang_cc1 -triple %itanium_abi_triple -masm-verbose -S -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple %itanium_abi_triple -masm-verbose -S -di-kind=limited %s -o - | FileCheck %s

// CHECK: AT_APPLE_objc_complete_type
// CHECK: AT_APPLE_objc_complete_type




@interface Foo {} @end
@interface Foo {} @end




@interface Foo () {
@interface Foo () {

    int *bar;
    int *bar;

}
}

@end
@end




@implementation Foo
@implementation Foo

@end
@end




void bar(Foo *fptr) {}
void bar(Foo *fptr) {}

test/CodeGenObjC/debug-info-class-extension3.m
// RUN: %clang_cc1 -masm-verbose -S -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -masm-verbose -S -di-kind=limited %s -o - | FileCheck %s




// CHECK-NOT: AT_APPLE_objc_complete_type
// CHECK-NOT: AT_APPLE_objc_complete_type




@interface Foo {} @end
@interface Foo {} @end




@interface Foo () {
@interface Foo () {

    int *bar;
    int *bar;

}
}

@end
@end




void bar(Foo *fptr) {}
void bar(Foo *fptr) {}

test/CodeGenObjC/debug-info-crash-2.m
// RUN: %clang_cc1 -triple x86_64-apple-darwin11 -g -S %s -o -
// RUN: %clang_cc1 -triple x86_64-apple-darwin11 -di-kind=limited -S %s -o -

// REQUIRES: x86-registered-target
// REQUIRES: x86-registered-target




@class Bar;
@class Bar;

@interface Foo
@interface Foo

@property (strong, nonatomic) Bar *window;
@property (strong, nonatomic) Bar *window;

@end
@end




@interface Foo__ : Foo
@interface Foo__ : Foo

@end
@end

@implementation Foo__
@implementation Foo__

@end
@end




@implementation Foo
@implementation Foo

@synthesize window = _window;
@synthesize window = _window;

@end
@end




test/CodeGenObjC/debug-info-crash.m
// REQUIRES: x86-registered-target
// REQUIRES: x86-registered-target

// RUN: %clang_cc1 -triple i386-apple-darwin10 -fobjc-runtime=macosx-fragile-10.5 -fblocks -g -S %s -o -
// RUN: %clang_cc1 -triple i386-apple-darwin10 -fobjc-runtime=macosx-fragile-10.5 -fblocks -di-kind=limited -S %s -o -




// rdar://7556129
// rdar://7556129

@implementation test
@implementation test

- (void)wait {
- (void)wait {

  ^{};
  ^{};

}
}

@end
@end




Show All 31 Lines
test/CodeGenObjC/debug-info-default-synth-ivar.m
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -g %s -o %t 
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -di-kind=limited %s -o %t 

// RUN: grep DW_TAG_member %t | count 5
// RUN: grep DW_TAG_member %t | count 5

// rdar://8493239
// rdar://8493239




@class NSString;
@class NSString;




@interface InstanceVariablesEverywhereButTheInterface 
@interface InstanceVariablesEverywhereButTheInterface 

@end
@end




Show All 26 Lines
test/CodeGenObjC/debug-info-getter-name.m
// REQUIRES: x86-registered-target
// REQUIRES: x86-registered-target

// RUN: %clang_cc1 -emit-llvm -triple x86_64-apple-darwin10 -fexceptions -fobjc-exceptions -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -triple x86_64-apple-darwin10 -fexceptions -fobjc-exceptions -di-kind=limited %s -o - | FileCheck %s




// CHECK:  !DISubprogram(name: "-[InstanceVariablesEverywhereButTheInterface someString]"
// CHECK:  !DISubprogram(name: "-[InstanceVariablesEverywhereButTheInterface someString]"




//rdar: //8498026
//rdar: //8498026




@class NSString;
@class NSString;




@interface InstanceVariablesEverywhereButTheInterface 
@interface InstanceVariablesEverywhereButTheInterface 

▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines
test/CodeGenObjC/debug-info-id-with-protocol.m
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -di-kind=limited %s -o - | FileCheck %s

__attribute((objc_root_class)) @interface NSObject {
__attribute((objc_root_class)) @interface NSObject {

  id isa;
  id isa;

}
}

+ (id)alloc;
+ (id)alloc;

- (id)init;
- (id)init;

- (id)retain;
- (id)retain;

@end
@end




Show All 38 Lines
test/CodeGenObjC/debug-info-impl.m
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -g -S -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -di-kind=limited -S -emit-llvm %s -o - | FileCheck %s

@interface NSObject {
@interface NSObject {

  struct objc_object *isa;
  struct objc_object *isa;

}
}

@end
@end




@interface Shape : NSObject
@interface Shape : NSObject




@end
@end

// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "Circle"
// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "Circle"

// CHECK-SAME:             line: [[@LINE+1]],
// CHECK-SAME:             line: [[@LINE+1]],

@interface Circle : Shape
@interface Circle : Shape




@end
@end

@implementation Circle
@implementation Circle




@end
@end

test/CodeGenObjC/debug-info-instancetype.m
// RUN: %clang_cc1 -emit-llvm -g -triple x86_64-apple-darwin10 %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -triple x86_64-apple-darwin10 %s -o - | FileCheck %s

// rdar://problem/13359718
// rdar://problem/13359718

// Substitute the actual type for a method returning instancetype.
// Substitute the actual type for a method returning instancetype.

@interface NSObject
@interface NSObject

+ (id)alloc;
+ (id)alloc;

- (id)init;
- (id)init;

- (id)retain;
- (id)retain;

@end
@end




Show All 22 Lines
test/CodeGenObjC/debug-info-ivars-extension.m
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -di-kind=limited %s -o - | FileCheck %s




// Make sure we generate debug symbols for ivars added by a class extension.
// Make sure we generate debug symbols for ivars added by a class extension.




@interface I
@interface I

{
{

    @public int a;
    @public int a;

}
}

@end
@end

Show All 38 Lines
test/CodeGenObjC/debug-info-ivars-indirect.m
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -di-kind=limited %s -o - | FileCheck %s




// Make sure we generate debug symbols for an indirectly referenced
// Make sure we generate debug symbols for an indirectly referenced

// extension to an interface.
// extension to an interface.




// This happens to be the order the members are emitted in... I'm assuming it's
// This happens to be the order the members are emitted in... I'm assuming it's

// not meaningful/important, so if something causes the order to change, feel
// not meaningful/important, so if something causes the order to change, feel

// free to update the test to reflect the new order.
// free to update the test to reflect the new order.

// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "a"
// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "a"

▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines
test/CodeGenObjC/debug-info-ivars-private.m
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -di-kind=limited %s -o - | FileCheck %s




// Debug symbols for private ivars. This test ensures that we are
// Debug symbols for private ivars. This test ensures that we are

// generating debug info for ivars added by the implementation.
// generating debug info for ivars added by the implementation.

__attribute((objc_root_class)) @interface NSObject {
__attribute((objc_root_class)) @interface NSObject {

  id isa;
  id isa;

}
}

@end
@end




Show All 38 Lines
test/CodeGenObjC/debug-info-ivars.m
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -di-kind=limited %s -o - | FileCheck %s




__attribute((objc_root_class)) @interface NSObject {
__attribute((objc_root_class)) @interface NSObject {

    id isa;
    id isa;

}
}

@end
@end




@interface BaseClass : NSObject
@interface BaseClass : NSObject

{
{

Show All 35 Lines
test/CodeGenObjC/debug-info-lifetime-crash.m
// RUN: %clang_cc1 -triple arm-apple-ios -emit-llvm -g -fblocks -fobjc-runtime=ios-7.0.0 -fobjc-arc %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple arm-apple-ios -emit-llvm -di-kind=limited -fblocks -fobjc-runtime=ios-7.0.0 -fobjc-arc %s -o - | FileCheck %s

// rdar://problem/14990656
// rdar://problem/14990656

@protocol NSObject
@protocol NSObject

- (id)copy;
- (id)copy;

@end
@end

@class W;
@class W;

@interface View1
@interface View1

@end
@end

@implementation Controller {
@implementation Controller {

Show All 18 Lines
test/CodeGenObjC/debug-info-linkagename.m
// RUN: %clang_cc1  -g -S -o %t %s
// RUN: %clang_cc1  -di-kind=limited -S -o %t %s

// RUN: not grep "001-[F bar" %t
// RUN: not grep "001-[F bar" %t

// Linkage name should not use 001 prefix in debug info.
// Linkage name should not use 001 prefix in debug info.




@interface F 
@interface F 

-(int) bar;
-(int) bar;

@end
@end




@implementation F
@implementation F

Show All 9 Lines
test/CodeGenObjC/debug-info-nested-blocks.m
// RUN: %clang_cc1 -emit-llvm -gdwarf-2 -fblocks -o - -x objective-c %s| FileCheck %s
// RUN: %clang_cc1 -emit-llvm -dwarf-version=2 -di-kind=limited -fblocks -o - -x objective-c %s| FileCheck %s

// This code triggered a bug where a dbg.declare intrinsic ended up with the
// This code triggered a bug where a dbg.declare intrinsic ended up with the

// wrong parent and subsequently failed the Verifier.
// wrong parent and subsequently failed the Verifier.

void baz(id b);
void baz(id b);

void fub(id block);
void fub(id block);

int foo(void);
int foo(void);

void bar(void) {
void bar(void) {

  fub(^() {
  fub(^() {

      id a;
      id a;

Show All 17 Lines
test/CodeGenObjC/debug-info-property-accessors.m
// RUN: %clang_cc1 -emit-llvm -x objective-c -g -triple x86_64-apple-macosx10.8.0 %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -x objective-c -di-kind=limited -triple x86_64-apple-macosx10.8.0 %s -o - | FileCheck %s

//
//

// rdar://problem/14035789
// rdar://problem/14035789

//
//

// Ensure we emit the names of explicit/renamed accessors even if they
// Ensure we emit the names of explicit/renamed accessors even if they

// are defined later in the implementation section.
// are defined later in the implementation section.

//
//

// CHECK:  !DIObjCProperty(name: "blah"
// CHECK:  !DIObjCProperty(name: "blah"

// CHECK-SAME:             getter: "isBlah"
// CHECK-SAME:             getter: "isBlah"

▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines
test/CodeGenObjC/debug-info-property.m
// FIXME: Check IR rather than asm, then triple is not needed.
// FIXME: Check IR rather than asm, then triple is not needed.

// RUN: %clang_cc1 -triple %itanium_abi_triple -masm-verbose -S -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple %itanium_abi_triple -masm-verbose -S -di-kind=limited %s -o - | FileCheck %s




// CHECK: AT_APPLE_property_name
// CHECK: AT_APPLE_property_name

// CHECK: AT_APPLE_property_attribute
// CHECK: AT_APPLE_property_attribute

// CHECK: AT_APPLE_property
// CHECK: AT_APPLE_property

@interface I1 {
@interface I1 {

int p1;
int p1;

}
}

@property int p1;
@property int p1;

@end
@end




@implementation I1
@implementation I1

@synthesize p1;
@synthesize p1;

@end
@end

test/CodeGenObjC/debug-info-property2.m
// FIXME: Check IR rather than asm, then triple is not needed.
// FIXME: Check IR rather than asm, then triple is not needed.

// RUN: %clang_cc1 -triple %itanium_abi_triple -masm-verbose -S -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple %itanium_abi_triple -masm-verbose -S -di-kind=limited %s -o - | FileCheck %s




// CHECK: AT_APPLE_property_name
// CHECK: AT_APPLE_property_name

@interface C {
@interface C {

  int _base;
  int _base;

}
}

@property int base;
@property int base;

@end
@end




@implementation C
@implementation C

@synthesize base = _base;
@synthesize base = _base;

@end
@end




void foo(C *cptr) {}
void foo(C *cptr) {}

test/CodeGenObjC/debug-info-property3.m
// RUN: %clang_cc1 -S -emit-llvm -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -S -emit-llvm -di-kind=limited %s -o - | FileCheck %s




@interface I1
@interface I1

// CHECK: !DIObjCProperty(name: "p1"
// CHECK: !DIObjCProperty(name: "p1"

// CHECK-SAME:            line: [[@LINE+2]]
// CHECK-SAME:            line: [[@LINE+2]]

// CHECK-SAME:            attributes: 2316
// CHECK-SAME:            attributes: 2316

@property int p1;
@property int p1;

@end
@end




@implementation I1
@implementation I1

@synthesize p1;
@synthesize p1;

@end
@end




void foo(I1 *iptr) {}
void foo(I1 *iptr) {}

test/CodeGenObjC/debug-info-property4.m
// FIXME: Check IR rather than asm, then triple is not needed.
// FIXME: Check IR rather than asm, then triple is not needed.

// RUN: %clang_cc1 -triple %itanium_abi_triple -masm-verbose -S -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple %itanium_abi_triple -masm-verbose -S -di-kind=limited %s -o - | FileCheck %s




// CHECK: AT_APPLE_property_name
// CHECK: AT_APPLE_property_name

// CHECK-NOT: AT_APPLE_property_getter
// CHECK-NOT: AT_APPLE_property_getter

// CHECK-NOT: AT_APPLE_property_setter
// CHECK-NOT: AT_APPLE_property_setter

// CHECK: AT_APPLE_property_attribute
// CHECK: AT_APPLE_property_attribute

// CHECK: AT_APPLE_property
// CHECK: AT_APPLE_property







@interface I1
@interface I1

@property int p1;
@property int p1;

@end
@end




@implementation I1
@implementation I1

@end
@end




void foo(I1 *ptr) {}
void foo(I1 *ptr) {}

test/CodeGenObjC/debug-info-property5.m
// FIXME: Check IR rather than asm, then triple is not needed.
// FIXME: Check IR rather than asm, then triple is not needed.

// RUN: %clang_cc1 -triple %itanium_abi_triple -masm-verbose -S -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple %itanium_abi_triple -masm-verbose -S -di-kind=limited %s -o - | FileCheck %s




// CHECK: AT_APPLE_property_name
// CHECK: AT_APPLE_property_name

// CHECK: AT_APPLE_property_getter
// CHECK: AT_APPLE_property_getter

// CHECK: AT_APPLE_property_setter
// CHECK: AT_APPLE_property_setter

// CHECK: AT_APPLE_property_attribute
// CHECK: AT_APPLE_property_attribute

// CHECK: AT_APPLE_property
// CHECK: AT_APPLE_property




@interface BaseClass2 
@interface BaseClass2 

Show All 23 Lines
test/CodeGenObjC/debug-info-pubtypes.m
// REQUIRES: x86-registered-target
// REQUIRES: x86-registered-target

// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -g -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -di-kind=limited -emit-llvm %s -o - | FileCheck %s




// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "H"
// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "H"

// CHECK-SAME:             line: [[@LINE+1]],
// CHECK-SAME:             line: [[@LINE+1]],

@interface H
@interface H

-(void) foo;
-(void) foo;

@end
@end




@implementation H
@implementation H

-(void) foo {
-(void) foo {

}
}

@end
@end




test/CodeGenObjC/debug-info-selector.m
// RUN: %clang_cc1 -emit-llvm  -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm  -di-kind=limited %s -o - | FileCheck %s

// Radar 8494540
// Radar 8494540




// CHECK: objc_selector
// CHECK: objc_selector

@interface MyClass {
@interface MyClass {

}
}

- (id)init;
- (id)init;

@end
@end




@implementation MyClass
@implementation MyClass

- (id) init
- (id) init

{
{

  return self;
  return self;

}
}

@end
@end

test/CodeGenObjC/debug-info-self.m
// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -di-kind=limited %s -o - | FileCheck %s

// self and _cmd are marked as DW_AT_artificial. 
// self and _cmd are marked as DW_AT_artificial. 

// myarg is not marked as DW_AT_artificial.
// myarg is not marked as DW_AT_artificial.




@interface MyClass {
@interface MyClass {

}
}

- (id)init:(int) myarg;
- (id)init:(int) myarg;

@end
@end




Show All 20 Lines
test/CodeGenObjC/debug-info-static-var.m
// RUN: %clang_cc1 -g -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -di-kind=limited -emit-llvm -o - %s | FileCheck %s

// Radar 8801045
// Radar 8801045

// Do not emit AT_MIPS_linkage_name for static variable i
// Do not emit AT_MIPS_linkage_name for static variable i




// CHECK: !DIGlobalVariable(name: "i"
// CHECK: !DIGlobalVariable(name: "i"

// CHECK-NOT:               linkageName:
// CHECK-NOT:               linkageName:

// CHECK-SAME:              ){{$}}
// CHECK-SAME:              ){{$}}




@interface A {
@interface A {

Show All 10 Lines
test/CodeGenObjC/debug-info-synthesis.m
// RUN: %clang_cc1 -emit-llvm -g -w -triple x86_64-apple-darwin10 %s -o - | FileCheck %s
// RUN: %clang_cc1 -emit-llvm -di-kind=limited -w -triple x86_64-apple-darwin10 %s -o - | FileCheck %s

# 1 "foo.m" 1
# 1 "foo.m" 1

# 1 "foo.m" 2
# 1 "foo.m" 2

# 1 "./foo.h" 1
# 1 "./foo.h" 1

@interface NSObject {
@interface NSObject {

  struct objc_object *isa;
  struct objc_object *isa;

}
}

@end
@end

@class NSDictionary;
@class NSDictionary;

Show All 28 Lines
test/CodeGenObjC/debug-info-variadic-method.m
// RUN: %clang_cc1 -o - -emit-llvm -g %s | FileCheck %s
// RUN: %clang_cc1 -o - -emit-llvm -di-kind=limited %s | FileCheck %s




// This test verifies that variadic ObjC methods get the
// This test verifies that variadic ObjC methods get the

// DW_TAG_unspecified_parameter marker.
// DW_TAG_unspecified_parameter marker.




@interface Foo
@interface Foo

- (void) Bar: (int) n, ...;
- (void) Bar: (int) n, ...;

@end
@end




@implementation Foo
@implementation Foo

- (void) Bar: (int) n, ...
- (void) Bar: (int) n, ...

{
{

  // CHECK: !DISubroutineType(types: ![[NUM:[0-9]+]])
  // CHECK: !DISubroutineType(types: ![[NUM:[0-9]+]])

  // CHECK: ![[NUM]] = {{!{null, ![^,]*, ![^,]*, ![^,]*, null}}}
  // CHECK: ![[NUM]] = {{!{null, ![^,]*, ![^,]*, ![^,]*, null}}}

}
}

@end
@end

test/CodeGenObjC/debug-property-synth.m
// RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -g %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm -di-kind=limited %s -o - | FileCheck %s

// rdar://problem/9468526
// rdar://problem/9468526

//
//

// Setting a breakpoint on a property should create breakpoints in
// Setting a breakpoint on a property should create breakpoints in

// synthesized getters/setters.
// synthesized getters/setters.

//
//

@interface I {
@interface I {

  int _p1;
  int _p1;

}
}

Show All 27 Lines
test/CodeGenObjC/debuginfo-properties.m
// RUN: %clang_cc1 -g -emit-llvm -triple x86_64-apple-darwin -o - %s | FileCheck %s
// RUN: %clang_cc1 -di-kind=limited -emit-llvm -triple x86_64-apple-darwin -o - %s | FileCheck %s

// Check that we emit the correct method names for properties from a protocol.
// Check that we emit the correct method names for properties from a protocol.

// rdar://problem/13798000
// rdar://problem/13798000

@protocol NSObject
@protocol NSObject

- (id)init;
- (id)init;

@end
@end

@interface NSObject <NSObject> {}
@interface NSObject <NSObject> {}

@end
@end




Show All 35 Lines
test/CodeGenObjC/layout-bitfield-crash.m
// RUN: %clang_cc1 -triple x86_64-apple-darwin11 -fobjc-gc -emit-llvm -g -o - %s
// RUN: %clang_cc1 -triple x86_64-apple-darwin11 -fobjc-gc -emit-llvm -di-kind=limited -o - %s

// Check that this doesn't crash when compiled with debugging on.
// Check that this doesn't crash when compiled with debugging on.

@class Foo;
@class Foo;

typedef struct Bar *BarRef;
typedef struct Bar *BarRef;




@interface Baz
@interface Baz

@end
@end




@interface Foo
@interface Foo

Show All 26 Lines
test/CodeGenObjC/objc-fixed-enum.m
// RUN: %clang_cc1 -g -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -di-kind=limited -emit-llvm -o - %s | FileCheck %s

// The DWARF standard says the underlying data type of an enum may be
// The DWARF standard says the underlying data type of an enum may be

// stored in an DW_AT_type entry in the enum DIE. This is useful to have
// stored in an DW_AT_type entry in the enum DIE. This is useful to have

// so the debugger knows about the signedness of the underlying type.
// so the debugger knows about the signedness of the underlying type.




typedef long NSInteger;
typedef long NSInteger;

#define NS_ENUM(_type, _name) enum _name : _type _name; enum _name : _type
#define NS_ENUM(_type, _name) enum _name : _type _name; enum _name : _type




// Enum with no specified underlying type
// Enum with no specified underlying type

▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines
test/CodeGenObjC/objc2-weak-ivar-debug.m
// RUN: %clang_cc1 -triple x86_64-apple-darwin9 -fobjc-runtime=macosx-fragile-10.5 -fobjc-gc -g -emit-llvm -o - %s
// RUN: %clang_cc1 -triple x86_64-apple-darwin9 -fobjc-runtime=macosx-fragile-10.5 -fobjc-gc -di-kind=limited -emit-llvm -o - %s

// RUN: %clang_cc1 -triple i386-apple-darwin9 -fobjc-runtime=macosx-fragile-10.5 -fobjc-gc -g -emit-llvm -o - %s
// RUN: %clang_cc1 -triple i386-apple-darwin9 -fobjc-runtime=macosx-fragile-10.5 -fobjc-gc -di-kind=limited -emit-llvm -o - %s

// RUN: %clang_cc1 -x objective-c++ -triple x86_64-apple-darwin9 -fobjc-runtime=macosx-fragile-10.5 -fobjc-gc -g -emit-llvm -o - %s
// RUN: %clang_cc1 -x objective-c++ -triple x86_64-apple-darwin9 -fobjc-runtime=macosx-fragile-10.5 -fobjc-gc -di-kind=limited -emit-llvm -o - %s

// RUN: %clang_cc1 -x objective-c++ -triple i386-apple-darwin9 -fobjc-runtime=macosx-fragile-10.5 -fobjc-gc -g -emit-llvm -o - %s
// RUN: %clang_cc1 -x objective-c++ -triple i386-apple-darwin9 -fobjc-runtime=macosx-fragile-10.5 -fobjc-gc -di-kind=limited -emit-llvm -o - %s




// rdar://7252252
// rdar://7252252

@interface Loop {
@interface Loop {

@public
@public

  __weak Loop *_loop;
  __weak Loop *_loop;

}
}

@end
@end




@implementation Loop @end
@implementation Loop @end




void loop(Loop *L) {
void loop(Loop *L) {

  L->_loop = 0;
  L->_loop = 0;

}
}

test/CodeGenObjC/property-dbg.m
// FIXME: Check IR rather than asm, then triple is not needed.
// FIXME: Check IR rather than asm, then triple is not needed.

// RUN: %clang_cc1 -triple %itanium_abi_triple -S -g -masm-verbose -x objective-c < %s | grep DW_AT_name
// RUN: %clang_cc1 -triple %itanium_abi_triple -S -di-kind=limited -masm-verbose -x objective-c < %s | grep DW_AT_name

@interface Foo {
@interface Foo {

  int i;
  int i;

}
}

@property int i;
@property int i;

@end
@end




@implementation Foo
@implementation Foo

@synthesize i;
@synthesize i;

@end
@end




int bar(Foo *f) {
int bar(Foo *f) {

  int i = 1;
  int i = 1;

  f.i = 2;
  f.i = 2;

  i = f.i;
  i = f.i;

  return i;
  return i;

}
}

test/CodeGenObjCXX/debug-info-cyclic.mm
// RUN: %clang_cc1 -triple x86_64-apple-darwin -g -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple x86_64-apple-darwin -di-kind=full -emit-llvm %s -o - | FileCheck %s




struct B {
struct B {

// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "B"
// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "B"

// CHECK-SAME:                             line: [[@LINE-2]],
// CHECK-SAME:                             line: [[@LINE-2]],

// CHECK-SAME:                             size: 8, align: 8,
// CHECK-SAME:                             size: 8, align: 8,

// CHECK-NOT:                              offset:
// CHECK-NOT:                              offset:

// CHECK-NOT:                              DIFlagFwdDecl
// CHECK-NOT:                              DIFlagFwdDecl

// CHECK-SAME:                             elements: ![[BMEMBERS:[0-9]+]]
// CHECK-SAME:                             elements: ![[BMEMBERS:[0-9]+]]

Show All 21 Lines
test/CodeGenObjCXX/debug-info-line.mm
// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -gline-tables-only -fblocks -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -di-kind=line-tables -fblocks -emit-llvm %s -o - | FileCheck %s




void fn();
void fn();




struct foo {
struct foo {

  ~foo();
  ~foo();

};
};




void f1() {
void f1() {

Show All 21 Lines
test/CodeGenObjCXX/debug-info.mm
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -g -emit-llvm %s -o /dev/null
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -di-kind=limited -emit-llvm %s -o /dev/null




// This test passes if clang doesn't crash.
// This test passes if clang doesn't crash.




template <class C> class scoped_ptr {
template <class C> class scoped_ptr {

public:
public:

  C* operator->() const { return 0; }
  C* operator->() const { return 0; }

};
};




Show All 32 Lines
test/CodeGenObjCXX/nested-ehlocation.mm
// RUN: %clang_cc1  -triple x86_64-apple-macosx -emit-llvm -g -stdlib=libc++ -fblocks -fexceptions -x objective-c++ -o - %s | FileCheck %s
// RUN: %clang_cc1  -triple x86_64-apple-macosx -emit-llvm -di-kind=limited -stdlib=libc++ -fblocks -fexceptions -x objective-c++ -o - %s | FileCheck %s




// Verify that all invoke instructions have a debug location.
// Verify that all invoke instructions have a debug location.

// Literally: There are no unwind lines that don't end with ", (!dbg 123)".
// Literally: There are no unwind lines that don't end with ", (!dbg 123)".

// CHECK-NOT: {{to label %.* unwind label [^,]+$}}
// CHECK-NOT: {{to label %.* unwind label [^,]+$}}




void block(void (^)(void));
void block(void (^)(void));

extern void foo();
extern void foo();

struct A {
struct A {

Show All 15 Lines
test/CodeGenObjCXX/pr14474-gline-tables-only.mm
// PR 14474
// PR 14474

// RUN: %clang_cc1 -triple i386-apple-macosx10.6.0 -emit-llvm \
// RUN: %clang_cc1 -triple i386-apple-macosx10.6.0 -emit-llvm \

// RUN:   -gline-tables-only -x objective-c++ -o /dev/null %s
// RUN:   -di-kind=line-tables -x objective-c++ -o /dev/null %s




typedef signed char BOOL;
typedef signed char BOOL;

@class NSInvocation, NSMethodSignature, NSCoder, NSString, NSEnumerator;
@class NSInvocation, NSMethodSignature, NSCoder, NSString, NSEnumerator;

@protocol NSObject - (BOOL)isEqual:(id)object;
@protocol NSObject - (BOOL)isEqual:(id)object;

@end
@end

@protocol NSCoding - (void)encodeWithCoder:(NSCoder *)aCoder;
@protocol NSCoding - (void)encodeWithCoder:(NSCoder *)aCoder;

@end 
@end 

@interface NSObject <NSObject> { }
@interface NSObject <NSObject> { }

Show All 14 Lines
test/CodeGenObjCXX/property-objects.mm
// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin10 -std=c++11 -emit-llvm -g -o - | FileCheck %s
// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin10 -std=c++11 -emit-llvm -di-kind=limited -o - | FileCheck %s




class S {
class S {

public:
public:

  S& operator = (const S&);
  S& operator = (const S&);

  S (const S&);
  S (const S&);

  S ();
  S ();

};
};




▲ Show 20 Lines • Show All 214 Lines • Show Last 20 Lines
test/Coverage/codegen-next.m
// RUN: %clang_cc1 -emit-llvm -fobjc-exceptions -triple x86_64-apple-darwin -o %t %s
// RUN: %clang_cc1 -emit-llvm -fobjc-exceptions -triple x86_64-apple-darwin -o %t %s

// RUN: %clang_cc1 -g -emit-llvm -fobjc-exceptions -triple x86_64-apple-darwin -o %t %s
// RUN: %clang_cc1 -di-kind=limited -emit-llvm -fobjc-exceptions -triple x86_64-apple-darwin -o %t %s




// An error could be seen for targeting x86_64-win32;
// An error could be seen for targeting x86_64-win32;

//
//

//     Bitcast requires types of same width
//     Bitcast requires types of same width

//       %7 = bitcast i32 %6 to i64
//       %7 = bitcast i32 %6 to i64

//
//

// Then, This test should be excluded on x86_64-win32.
// Then, This test should be excluded on x86_64-win32.

// REQUIRES: LP64
// REQUIRES: LP64




#include "objc-language-features.inc"
#include "objc-language-features.inc"

test/Coverage/codegen.c
// RUN: %clang_cc1 -triple i386-unknown-unknown -emit-llvm -o %t %s
// RUN: %clang_cc1 -triple i386-unknown-unknown -emit-llvm -o %t %s

// RUN: %clang_cc1 -triple i386-unknown-unknown -emit-llvm-bc -o %t %s
// RUN: %clang_cc1 -triple i386-unknown-unknown -emit-llvm-bc -o %t %s

// RUN: %clang_cc1 -triple i386-unknown-unknown -g -emit-llvm-bc -o %t %s
// RUN: %clang_cc1 -triple i386-unknown-unknown -di-kind=limited -emit-llvm-bc -o %t %s

// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm-bc -o %t %s
// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm-bc -o %t %s

// RUN: %clang_cc1 -triple x86_64-unknown-unknown -g -emit-llvm-bc -o %t %s
// RUN: %clang_cc1 -triple x86_64-unknown-unknown -di-kind=limited -emit-llvm-bc -o %t %s




#include "c-language-features.inc"
#include "c-language-features.inc"

test/Coverage/targets.c
// RUN: %clang_cc1 -g -triple armv6-apple-darwin9 -emit-llvm -o %t %s
// RUN: %clang_cc1 -di-kind=limited -triple armv6-apple-darwin9 -emit-llvm -o %t %s

// RUN: %clang_cc1 -g -triple armv6-unknown-unknown -emit-llvm -o %t %s
// RUN: %clang_cc1 -di-kind=limited -triple armv6-unknown-unknown -emit-llvm -o %t %s

// RUN: %clang_cc1 -g -triple i686-apple-darwin9 -emit-llvm -o %t %s
// RUN: %clang_cc1 -di-kind=limited -triple i686-apple-darwin9 -emit-llvm -o %t %s

// RUN: %clang_cc1 -g -triple i686-pc-linux-gnu -emit-llvm -o %t %s
// RUN: %clang_cc1 -di-kind=limited -triple i686-pc-linux-gnu -emit-llvm -o %t %s

// RUN: %clang_cc1 -g -triple i686-unknown-dragonfly -emit-llvm -o %t %s
// RUN: %clang_cc1 -di-kind=limited -triple i686-unknown-dragonfly -emit-llvm -o %t %s

// RUN: %clang_cc1 -g -triple i686-unknown-unknown -emit-llvm -o %t %s
// RUN: %clang_cc1 -di-kind=limited -triple i686-unknown-unknown -emit-llvm -o %t %s

// RUN: %clang_cc1 -g -triple i686-unknown-win32 -emit-llvm -o %t %s
// RUN: %clang_cc1 -di-kind=limited -triple i686-unknown-win32 -emit-llvm -o %t %s

// RUN: %clang_cc1 -g -triple powerpc-apple-darwin9 -emit-llvm -o %t %s
// RUN: %clang_cc1 -di-kind=limited -triple powerpc-apple-darwin9 -emit-llvm -o %t %s

// RUN: %clang_cc1 -g -triple powerpc-unknown-unknown -emit-llvm -o %t %s
// RUN: %clang_cc1 -di-kind=limited -triple powerpc-unknown-unknown -emit-llvm -o %t %s

// RUN: %clang_cc1 -g -triple powerpc64-apple-darwin9 -emit-llvm -o %t %s
// RUN: %clang_cc1 -di-kind=limited -triple powerpc64-apple-darwin9 -emit-llvm -o %t %s

// RUN: %clang_cc1 -g -triple powerpc64-unknown-unknown -emit-llvm -o %t %s
// RUN: %clang_cc1 -di-kind=limited -triple powerpc64-unknown-unknown -emit-llvm -o %t %s

// RUN: %clang_cc1 -g -triple sparc-unknown-solaris -emit-llvm -o %t %s
// RUN: %clang_cc1 -di-kind=limited -triple sparc-unknown-solaris -emit-llvm -o %t %s

// RUN: %clang_cc1 -g -triple sparc-unknown-unknown -emit-llvm -o %t %s
// RUN: %clang_cc1 -di-kind=limited -triple sparc-unknown-unknown -emit-llvm -o %t %s

// RUN: %clang_cc1 -g -triple x86_64-apple-darwin9 -emit-llvm -o %t %s
// RUN: %clang_cc1 -di-kind=limited -triple x86_64-apple-darwin9 -emit-llvm -o %t %s

// RUN: %clang_cc1 -g -triple x86_64-pc-linux-gnu -emit-llvm -o %t %s
// RUN: %clang_cc1 -di-kind=limited -triple x86_64-pc-linux-gnu -emit-llvm -o %t %s

// RUN: %clang_cc1 -g -triple x86_64-unknown-unknown -emit-llvm -o %t %s
// RUN: %clang_cc1 -di-kind=limited -triple x86_64-unknown-unknown -emit-llvm -o %t %s




// <rdar://problem/7181838> clang 1.0 fails to compile Python 2.6
// <rdar://problem/7181838> clang 1.0 fails to compile Python 2.6

// RUN: %clang -target x86_64-apple-darwin9 -### -S %s -mmacosx-version-min=10.4
// RUN: %clang -target x86_64-apple-darwin9 -### -S %s -mmacosx-version-min=10.4

test/Driver/cl-options.c
Show First 20 Lines • Show All 356 Lines • ▼ Show 20 Lines
// RUN: %clang_cl /c -### -- %s 2>&1 | FileCheck -check-prefix=NoThreadSafeStatics %s
// RUN: %clang_cl /c -### -- %s 2>&1 | FileCheck -check-prefix=NoThreadSafeStatics %s

// RUN: %clang_cl /Zc:threadSafeInit /Zc:threadSafeInit- /c -### -- %s 2>&1 | FileCheck -check-prefix=NoThreadSafeStatics %s
// RUN: %clang_cl /Zc:threadSafeInit /Zc:threadSafeInit- /c -### -- %s 2>&1 | FileCheck -check-prefix=NoThreadSafeStatics %s

// NoThreadSafeStatics: "-fno-threadsafe-statics"
// NoThreadSafeStatics: "-fno-threadsafe-statics"




// RUN: %clang_cl /Zc:threadSafeInit /c -### -- %s 2>&1 | FileCheck -check-prefix=ThreadSafeStatics %s
// RUN: %clang_cl /Zc:threadSafeInit /c -### -- %s 2>&1 | FileCheck -check-prefix=ThreadSafeStatics %s

// ThreadSafeStatics-NOT: "-fno-threadsafe-statics"
// ThreadSafeStatics-NOT: "-fno-threadsafe-statics"




// RUN: %clang_cl /Zi /c -### -- %s 2>&1 | FileCheck -check-prefix=Zi %s
// RUN: %clang_cl /Zi /c -### -- %s 2>&1 | FileCheck -check-prefix=Zi %s

// Zi: "-gline-tables-only"

// Zi: "-gcodeview"
// Zi: "-gcodeview"

// Zi: "-di-kind=line-tables"




// RUN: %clang_cl /Z7 /c -### -- %s 2>&1 | FileCheck -check-prefix=Z7 %s
// RUN: %clang_cl /Z7 /c -### -- %s 2>&1 | FileCheck -check-prefix=Z7 %s

// Z7: "-gline-tables-only"

// Z7: "-gcodeview"
// Z7: "-gcodeview"

// Z7: "-di-kind=line-tables"




// This test was super sneaky: "/Z7" means "line-tables", but "-gdwarf" occurs

// later on the command line, so it should win. Interestingly the cc1 arguments

// came out right, but had wrong semantics, because an invariant assumed by

// CompilerInvocation was violated: it expects that at most one of {gdwarfN,

// line-tables-only} appear. If you assume that, then you can safely use

// Args.hasArg to test whether a boolean flag is present without caring

// where it appeared. And for this test, it appeared to the left of -gdwarf

// which made it "win". This test could not detect that bug.

// RUN: %clang_cl /Z7 -gdwarf /c -### -- %s 2>&1 | FileCheck -check-prefix=Z7_gdwarf %s
// RUN: %clang_cl /Z7 -gdwarf /c -### -- %s 2>&1 | FileCheck -check-prefix=Z7_gdwarf %s

// Z7_gdwarf: "-gline-tables-only"

// Z7_gdwarf: "-gcodeview"
// Z7_gdwarf: "-gcodeview"

// Z7_gdwarf: "-gdwarf-4"
// Z7_gdwarf: "-di-kind=limited"

// Z7_gdwarf: "-dwarf-version=4"




// RUN: %clang_cl -fmsc-version=1800 -TP -### -- %s 2>&1 | FileCheck -check-prefix=CXX11 %s
// RUN: %clang_cl -fmsc-version=1800 -TP -### -- %s 2>&1 | FileCheck -check-prefix=CXX11 %s

// CXX11: -std=c++11
// CXX11: -std=c++11




// RUN: %clang_cl -fmsc-version=1900 -TP -### -- %s 2>&1 | FileCheck -check-prefix=CXX14 %s
// RUN: %clang_cl -fmsc-version=1900 -TP -### -- %s 2>&1 | FileCheck -check-prefix=CXX14 %s

// CXX14: -std=c++14
// CXX14: -std=c++14




// RUN: env CL="/Gy" %clang_cl -### -- %s 2>&1 | FileCheck -check-prefix=ENV-CL %s
// RUN: env CL="/Gy" %clang_cl -### -- %s 2>&1 | FileCheck -check-prefix=ENV-CL %s

Show All 26 Lines
test/Driver/clang-g-opts.c
// RUN: %clang -### -S %s        2>&1 | FileCheck --check-prefix=CHECK-WITHOUT-G %s
// RUN: %clang -### -S %s        2>&1 | FileCheck --check-prefix=CHECK-WITHOUT-G %s

// RUN: %clang -### -S %s -g -target x86_64-linux-gnu 2>&1 \
// RUN: %clang -### -S %s -g -target x86_64-linux-gnu 2>&1 \

// RUN:             | FileCheck --check-prefix=CHECK-WITH-G %s
// RUN:             | FileCheck --check-prefix=CHECK-WITH-G %s



// Assert that the toolchains which should default to a lower Dwarf version do so.

// RUN: %clang -### -S %s -g -target x86_64-apple-darwin 2>&1 \
// RUN: %clang -### -S %s -g -target x86_64-apple-darwin 2>&1 \

// RUN:             | FileCheck --check-prefix=CHECK-WITH-G-DWARF2 %s
// RUN:             | FileCheck --check-prefix=CHECK-WITH-G-DWARF2 %s

// RUN: %clang -### -S %s -g -target i686-pc-openbsd 2>&1 \
// RUN: %clang -### -S %s -g -target i686-pc-openbsd 2>&1 \

// RUN:             | FileCheck --check-prefix=CHECK-WITH-G-DWARF2 %s
// RUN:             | FileCheck --check-prefix=CHECK-WITH-G-DWARF2 %s

// RUN: %clang -### -S %s -g -target x86_64-pc-freebsd10.0 2>&1 \
// RUN: %clang -### -S %s -g -target x86_64-pc-freebsd10.0 2>&1 \

// RUN:             | FileCheck --check-prefix=CHECK-WITH-G-DWARF2 %s
// RUN:             | FileCheck --check-prefix=CHECK-WITH-G-DWARF2 %s



// 'g0' is the default. Just sanity-test that it does nothing

// RUN: %clang -### -S %s -g0    2>&1 | FileCheck --check-prefix=CHECK-WITHOUT-G %s
// RUN: %clang -### -S %s -g0    2>&1 | FileCheck --check-prefix=CHECK-WITHOUT-G %s



// And check that the last of -g or -g0 wins.

// RUN: %clang -### -S %s -g -g0 2>&1 | FileCheck --check-prefix=CHECK-WITHOUT-G %s
// RUN: %clang -### -S %s -g -g0 2>&1 | FileCheck --check-prefix=CHECK-WITHOUT-G %s



// These should be semantically the same as not having given 'g0'

// as the last 'g' option wins. Nothing interesting to see here.

//

// RUN: %clang -### -S %s -g0 -g -target x86_64-linux-gnu 2>&1 \
// RUN: %clang -### -S %s -g0 -g -target x86_64-linux-gnu 2>&1 \

// RUN:             | FileCheck --check-prefix=CHECK-WITH-G %s
// RUN:             | FileCheck --check-prefix=CHECK-WITH-G %s

// RUN: %clang -### -S %s -g0 -g -target x86_64-apple-darwin 2>&1 \
// RUN: %clang -### -S %s -g0 -g -target x86_64-apple-darwin 2>&1 \

// RUN:             | FileCheck --check-prefix=CHECK-WITH-G-DWARF2 %s
// RUN:             | FileCheck --check-prefix=CHECK-WITH-G-DWARF2 %s

// RUN: %clang -### -S %s -g0 -g -target i686-pc-openbsd 2>&1 \
// RUN: %clang -### -S %s -g0 -g -target i686-pc-openbsd 2>&1 \

// RUN:             | FileCheck --check-prefix=CHECK-WITH-G-DWARF2 %s
// RUN:             | FileCheck --check-prefix=CHECK-WITH-G-DWARF2 %s

// RUN: %clang -### -S %s -g0 -g -target x86_64-pc-freebsd10.0 2>&1 \
// RUN: %clang -### -S %s -g0 -g -target x86_64-pc-freebsd10.0 2>&1 \

// RUN:             | FileCheck --check-prefix=CHECK-WITH-G-DWARF2 %s
// RUN:             | FileCheck --check-prefix=CHECK-WITH-G-DWARF2 %s

// RUN: %clang -### -S %s -g0 -g -target i386-pc-solaris 2>&1 \
// RUN: %clang -### -S %s -g0 -g -target i386-pc-solaris 2>&1 \

// RUN:             | FileCheck --check-prefix=CHECK-WITH-G-DWARF2 %s
// RUN:             | FileCheck --check-prefix=CHECK-WITH-G-DWARF2 %s




// CHECK-WITHOUT-G-NOT: "-g"
// CHECK-WITHOUT-G-NOT: -di-kind

// CHECK-WITH-G: "-g"
// CHECK-WITH-G: "-di-kind=limited"

// CHECK-WITH-G-DWARF2: "-gdwarf-2"
// CHECK-WITH-G: "-dwarf-version=4"


// CHECK-WITH-G-DWARF2: "-dwarf-version=2"

dblaikieUnsubmitted
Done
ReplyInline Actions
Should this be -debug-info-kind instead?
dblaikie: Should this be -debug-info-kind instead?
test/Driver/debug-options-as.c
// Check to make sure clang is somewhat picky about -g options.
// Check to make sure clang is somewhat picky about -g options.

// (Delived from debug-options.c)
// (Delived from debug-options.c)

// rdar://10383444
// rdar://10383444

// RUN: %clang -### -c -save-temps -integrated-as -g %s 2>&1 \
// RUN: %clang -### -c -save-temps -integrated-as -g %s 2>&1 \

// RUN:   | FileCheck -check-prefix=SAVE %s
// RUN:   | FileCheck -check-prefix=SAVE %s

//
//

// SAVE: "-cc1"{{.*}}"-E"{{.*}}"-di-kind=

// SAVE: "-cc1"{{.*}}"-emit-llvm-bc"{{.*}}"-di-kind=

// SAVE: "-cc1"{{.*}}"-S"{{.*}}"-di-kind=

// SAVE: "-cc1as"
// SAVE: "-cc1as"

// SAVE-NOT: "-g"
// SAVE-NOT: -di-kind=




// Make sure that '-ggdb0' is not accidentally mistaken for '-g'
// Make sure that '-ggdb0' is not accidentally mistaken for '-g'

// RUN: %clang -### -ggdb0 -c -integrated-as -x assembler %s 2>&1 \
// RUN: %clang -### -ggdb0 -c -integrated-as -x assembler %s 2>&1 \

// RUN:   | FileCheck -check-prefix=GGDB0 %s
// RUN:   | FileCheck -check-prefix=GGDB0 %s

//
//

// GGDB0: "-cc1as"
// GGDB0: "-cc1as"

// GGDB0-NOT: "-g"
// GGDB0-NOT: -di-kind=




// Check to make sure clang with -g on a .s file gets passed.
// Check to make sure clang with -g on a .s file gets passed.

// rdar://9275556
// rdar://9275556

// RUN: %clang -### -c -integrated-as -g -x assembler %s 2>&1 \
// RUN: %clang -### -c -integrated-as -g -x assembler %s 2>&1 \

// RUN:   | FileCheck %s
// RUN:   | FileCheck %s

//
//

// CHECK: "-cc1as"
// CHECK: "-cc1as"

// CHECK: "-g"
// CHECK: "-di-kind=limited"




// Check to make sure clang with -g on a .s file gets passed -dwarf-debug-producer.
// Check to make sure clang with -g on a .s file gets passed -dwarf-debug-producer.

// rdar://12955296
// rdar://12955296

// RUN: %clang -### -c -integrated-as -g -x assembler %s 2>&1 \
// RUN: %clang -### -c -integrated-as -g -x assembler %s 2>&1 \

// RUN:   | FileCheck -check-prefix=P %s
// RUN:   | FileCheck -check-prefix=P %s

//
//

// P: "-cc1as"
// P: "-cc1as"

// P: "-dwarf-debug-producer"
// P: "-dwarf-debug-producer"

test/Driver/debug-options.c
Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Lines
// RUN:        | FileCheck -check-prefix=NOCI %s
// RUN:        | FileCheck -check-prefix=NOCI %s

//
//

// RUN: %clang -### -g %s 2>&1 | FileCheck -check-prefix=CI %s
// RUN: %clang -### -g %s 2>&1 | FileCheck -check-prefix=CI %s

//
//

// RUN: %clang -### -gmodules %s 2>&1 \
// RUN: %clang -### -gmodules %s 2>&1 \

// RUN:        | FileCheck -check-prefix=GEXTREFS %s
// RUN:        | FileCheck -check-prefix=GEXTREFS %s

//
//

// G: "-cc1"
// G: "-cc1"

// G: "-g"
// G: "-di-kind=limited"

//
//

// G_DARWIN: "-cc1"
// G_DARWIN: "-cc1"

// G_DARWIN: "-gdwarf-2"
// G_DARWIN: "-dwarf-version=2"

//
//

// G_D2: "-cc1"
// G_D2: "-cc1"

// G_D2: "-gdwarf-2"
// G_D2: "-dwarf-version=2"

//
//

// G_NO: "-cc1"
// G_NO: "-cc1"

// G_NO-NOT: "-g"
// G_NO-NOT: -di-kind=

//
//

// GLTO_ONLY: "-cc1"
// GLTO_ONLY: "-cc1"

// GLTO_ONLY-NOT: "-g"
// GLTO_ONLY: "-di-kind=line-tables"

// GLTO_ONLY: "-gline-tables-only"

// GLTO_ONLY-NOT: "-g"

//
//

// GLTO_ONLY_DWARF2: "-cc1"
// GLTO_ONLY_DWARF2: "-cc1"

// GLTO_ONLY_DWARF2-NOT: "-g"
// GLTO_ONLY_DWARF2: "-di-kind=line-tables"

// GLTO_ONLY_DWARF2: "-gline-tables-only"
// GLTO_ONLY_DWARF2: "-dwarf-version=2"

// GLTO_ONLY_DWARF2: "-gdwarf-2"

// GLTO_ONLY_DWARF2-NOT: "-g"

//
//

// G_ONLY: "-cc1"
// G_ONLY: "-cc1"

// G_ONLY-NOT: "-gline-tables-only"
// G_ONLY: "-di-kind=limited"

// G_ONLY: "-g"

// G_ONLY-NOT: "-gline-tables-only"

//
//

// These tests assert that "-gline-tables-only" "-g" uses the latter,

// but otherwise not caring about the DebugInfoKind (of which the BSD

// derivatives favor dwarf-2, with only Solaris using Dwarf-4).

// G_ONLY_DWARF2: "-cc1"
// G_ONLY_DWARF2: "-cc1"

// G_ONLY_DWARF2-NOT: "-gline-tables-only"
// G_ONLY_DWARF2: "-di-kind={{full|limited}}"

// G_ONLY_DWARF2: "-gdwarf-2"
// G_ONLY_DWARF2: "-dwarf-version=2"

// G_ONLY_DWARF2-NOT: "-gline-tables-only"

//
//

// This tests asserts that "-gline-tables-only" "-g0" disables debug info.

// GLTO_NO: "-cc1"
// GLTO_NO: "-cc1"

// GLTO_NO-NOT: "-gline-tables-only"
// GLTO_NO-NOT: -di-kind=

//
//

// GIGNORE-NOT: "argument unused during compilation"
// GIGNORE-NOT: "argument unused during compilation"

//
//

// GOPT: -generate-gnu-dwarf-pub-sections
// GOPT: -generate-gnu-dwarf-pub-sections

//
//

// GARANGE: -generate-arange-section
// GARANGE: -generate-arange-section

//
//

// FDTS: "-backend-option" "-generate-type-units"
// FDTS: "-backend-option" "-generate-type-units"

//
//

// NOFDTS-NOT: "-backend-option" "-generate-type-units"
// NOFDTS-NOT: "-backend-option" "-generate-type-units"

//
//

// CI: "-dwarf-column-info"
// CI: "-dwarf-column-info"

//
//

// NOCI-NOT: "-dwarf-column-info"
// NOCI-NOT: "-dwarf-column-info"

//
//

// GEXTREFS: "-g" "-dwarf-ext-refs" "-fmodule-format=obj"
// GEXTREFS: "-dwarf-ext-refs" "-fmodule-format=obj" "-di-kind=limited"

test/Driver/integrated-as.s
Show All 21 Lines
// XA_INCLUDE1: cc1as
// XA_INCLUDE1: cc1as

// XA_INCLUDE1: "-I" "foo_dir"
// XA_INCLUDE1: "-I" "foo_dir"




// RUN: %clang -### -c -integrated-as %s -Xassembler -Ifoo_dir 2>&1 | FileCheck --check-prefix=XA_INCLUDE2 %s
// RUN: %clang -### -c -integrated-as %s -Xassembler -Ifoo_dir 2>&1 | FileCheck --check-prefix=XA_INCLUDE2 %s

// XA_INCLUDE2: cc1as
// XA_INCLUDE2: cc1as

// XA_INCLUDE2: "-Ifoo_dir"
// XA_INCLUDE2: "-Ifoo_dir"




// RUN: %clang -### -c -integrated-as %s -gdwarf-4 -gdwarf-2 2>&1 | FileCheck --check-prefix=DWARF2 %s
// RUN: %clang -### -c -integrated-as %s -gdwarf-4 -gdwarf-2 2>&1 | FileCheck --check-prefix=DWARF2 %s

// DWARF2: "-g" "-gdwarf-2"
// DWARF2: "-di-kind=limited" "-dwarf-version=2"

// DWARF2-NOT: "-gdwarf-4"




// RUN: %clang -### -c -integrated-as %s -gdwarf-3 2>&1 | FileCheck --check-prefix=DWARF3 %s
// RUN: %clang -### -c -integrated-as %s -gdwarf-3 2>&1 | FileCheck --check-prefix=DWARF3 %s

// DWARF3: "-g" "-gdwarf-3"
// DWARF3: "-di-kind=limited" "-dwarf-version=3"




// RUN: %clang -### -c -integrated-as %s -gdwarf-4 2>&1 | FileCheck --check-prefix=DWARF4 %s
// RUN: %clang -### -c -integrated-as %s -gdwarf-4 2>&1 | FileCheck --check-prefix=DWARF4 %s

// DWARF4: "-g" "-gdwarf-4"
// DWARF4: "-di-kind=limited" "-dwarf-version=4"




// RUN: %clang -### -c -integrated-as %s -Xassembler -gdwarf-2 2>&1 | FileCheck --check-prefix=DWARF2XASSEMBLER %s
// RUN: %clang -### -c -integrated-as %s -Xassembler -gdwarf-2 2>&1 | FileCheck --check-prefix=DWARF2XASSEMBLER %s

// DWARF2XASSEMBLER: "-gdwarf-2"
// DWARF2XASSEMBLER: "-di-kind=limited" "-dwarf-version=2"




// RUN: %clang -### -c -integrated-as %s -Wa,-gdwarf-2 2>&1 | FileCheck --check-prefix=DWARF2WA %s
// RUN: %clang -### -c -integrated-as %s -Wa,-gdwarf-2 2>&1 | FileCheck --check-prefix=DWARF2WA %s

// DWARF2WA: "-gdwarf-2"
// DWARF2WA: "-di-kind=limited" "-dwarf-version=2"



// A dwarf version number that driver can't parse is just stuffed in.

// RUN: %clang -### -c -integrated-as %s -Wa,-gdwarf-huh 2>&1 | FileCheck --check-prefix=BOGODWARF %s

// BOGODWARF: "-gdwarf-huh"




// RUN: %clang -### -x assembler -c -integrated-as %s -I myincludedir 2>&1 | FileCheck --check-prefix=INCLUDEPATH %s
// RUN: %clang -### -x assembler -c -integrated-as %s -I myincludedir 2>&1 | FileCheck --check-prefix=INCLUDEPATH %s

// INCLUDEPATH: "-I" "myincludedir"
// INCLUDEPATH: "-I" "myincludedir"




// RUN: %clang -### -x assembler -c -fPIC -integrated-as %s 2>&1 | FileCheck --check-prefix=PIC %s
// RUN: %clang -### -x assembler -c -fPIC -integrated-as %s 2>&1 | FileCheck --check-prefix=PIC %s

// PIC: "-mrelocation-model" "pic"
// PIC: "-mrelocation-model" "pic"

test/Driver/split-debug.c
Show All 30 Lines
// RUN: %clang -target x86_64-unknown-linux-gnu -no-integrated-as -gsplit-dwarf -c -### %s 2> %t
// RUN: %clang -target x86_64-unknown-linux-gnu -no-integrated-as -gsplit-dwarf -c -### %s 2> %t

// RUN: FileCheck -check-prefix=CHECK-IAS < %t %s
// RUN: FileCheck -check-prefix=CHECK-IAS < %t %s

//
//

// CHECK-IAS: objcopy
// CHECK-IAS: objcopy




// RUN: %clang -target x86_64-unknown-linux-gnu -gsplit-dwarf -gmlt -S -### %s 2> %t
// RUN: %clang -target x86_64-unknown-linux-gnu -gsplit-dwarf -gmlt -S -### %s 2> %t

// RUN: FileCheck -check-prefix=CHECK-GMLT-OVER-SPLIT < %t %s
// RUN: FileCheck -check-prefix=CHECK-GMLT-OVER-SPLIT < %t %s

//
//

// CHECK-GMLT-OVER-SPLIT: "-gline-tables-only"
// CHECK-GMLT-OVER-SPLIT: "-di-kind=line-tables"

// CHECK-GMLT-OVER-SPLIT-NOT: "-g"

// CHECK-GMLT-OVER-SPLIT-NOT: "-split-dwarf=Enable"
// CHECK-GMLT-OVER-SPLIT-NOT: "-split-dwarf=Enable"

// CHECK-GMLT-OVER-SPLIT-NOT: "-split-dwarf-file"
// CHECK-GMLT-OVER-SPLIT-NOT: "-split-dwarf-file"




// RUN: %clang -target x86_64-unknown-linux-gnu -gmlt -gsplit-dwarf -S -### %s 2> %t
// RUN: %clang -target x86_64-unknown-linux-gnu -gmlt -gsplit-dwarf -S -### %s 2> %t

// RUN: FileCheck -check-prefix=CHECK-SPLIT-OVER-GMLT < %t %s
// RUN: FileCheck -check-prefix=CHECK-SPLIT-OVER-GMLT < %t %s

//
//

// CHECK-SPLIT-OVER-GMLT-NOT: "-gline-tables-only"
// CHECK-SPLIT-OVER-GMLT: "-split-dwarf=Enable" "-di-kind=limited"

// CHECK-SPLIT-OVER-GMLT: "-g"

// CHECK-SPLIT-OVER-GMLT: "-split-dwarf=Enable"

// CHECK-SPLIT-OVER-GMLT: "-split-dwarf-file"
// CHECK-SPLIT-OVER-GMLT: "-split-dwarf-file"

// CHECK-SPLIT-OVER-GMLT-NOT: "-gline-tables-only"

test/Frontend/optimization-remark-line-directive.c
// This file tests -Rpass diagnostics together with #line
// This file tests -Rpass diagnostics together with #line

// directives. We cannot map #line directives back to
// directives. We cannot map #line directives back to

// a SourceLocation.
// a SourceLocation.




// RUN: %clang_cc1 %s -Rpass=inline -gline-tables-only -dwarf-column-info -emit-llvm-only -verify
// RUN: %clang_cc1 %s -Rpass=inline -di-kind=line-tables -dwarf-column-info -emit-llvm-only -verify




int foo(int x, int y) __attribute__((always_inline));
int foo(int x, int y) __attribute__((always_inline));

int foo(int x, int y) { return x + y; }
int foo(int x, int y) { return x + y; }




// expected-remark@+2 {{foo inlined into bar}} expected-note@+2 {{could not determine the original source location for /bad/path/to/original.c:1230:25}}
// expected-remark@+2 {{foo inlined into bar}} expected-note@+2 {{could not determine the original source location for /bad/path/to/original.c:1230:25}}

#line 1230 "/bad/path/to/original.c"
#line 1230 "/bad/path/to/original.c"

int bar(int j) { return foo(j, j - 2); }
int bar(int j) { return foo(j, j - 2); }

test/Frontend/optimization-remark.c
// This file tests the -Rpass family of flags (-Rpass, -Rpass-missed
// This file tests the -Rpass family of flags (-Rpass, -Rpass-missed

// and -Rpass-analysis) with the inliner. The test is designed to
// and -Rpass-analysis) with the inliner. The test is designed to

// always trigger the inliner, so it should be independent of the
// always trigger the inliner, so it should be independent of the

// optimization level.
// optimization level.




// RUN: %clang_cc1 %s -Rpass=inline -Rpass-analysis=inline -Rpass-missed=inline -O0 -emit-llvm-only -verify
// RUN: %clang_cc1 %s -Rpass=inline -Rpass-analysis=inline -Rpass-missed=inline -O0 -emit-llvm-only -verify

// RUN: %clang_cc1 %s -Rpass=inline -Rpass-analysis=inline -Rpass-missed=inline -O0 -emit-llvm-only -gline-tables-only -verify
// RUN: %clang_cc1 %s -Rpass=inline -Rpass-analysis=inline -Rpass-missed=inline -O0 -emit-llvm-only -di-kind=line-tables -verify

// RUN: %clang_cc1 %s -Rpass=inline -emit-llvm -o - 2>/dev/null | FileCheck %s
// RUN: %clang_cc1 %s -Rpass=inline -emit-llvm -o - 2>/dev/null | FileCheck %s

//
//

// Check that we can override -Rpass= with -Rno-pass.
// Check that we can override -Rpass= with -Rno-pass.

// RUN: %clang_cc1 %s -Rpass=inline -emit-llvm -o - 2>&1 | FileCheck %s --check-prefix=CHECK-REMARKS
// RUN: %clang_cc1 %s -Rpass=inline -emit-llvm -o - 2>&1 | FileCheck %s --check-prefix=CHECK-REMARKS

// RUN: %clang_cc1 %s -Rpass=inline -Rno-pass -emit-llvm -o - 2>&1 | FileCheck %s --check-prefix=CHECK-NO-REMARKS
// RUN: %clang_cc1 %s -Rpass=inline -Rno-pass -emit-llvm -o - 2>&1 | FileCheck %s --check-prefix=CHECK-NO-REMARKS

// RUN: %clang_cc1 %s -Rpass=inline -Rno-everything -emit-llvm -o - 2>&1 | FileCheck %s --check-prefix=CHECK-NO-REMARKS
// RUN: %clang_cc1 %s -Rpass=inline -Rno-everything -emit-llvm -o - 2>&1 | FileCheck %s --check-prefix=CHECK-NO-REMARKS

// RUN: %clang_cc1 %s -Rpass=inline -Rno-everything -Reverything -emit-llvm -o - 2>&1 | FileCheck %s --check-prefix=CHECK-REMARKS
// RUN: %clang_cc1 %s -Rpass=inline -Rno-everything -Reverything -emit-llvm -o - 2>&1 | FileCheck %s --check-prefix=CHECK-REMARKS

//
//

Show All 36 Lines
test/Misc/backend-optimization-failure.cpp
// RUN: %clang_cc1 -triple x86_64-unknown-unknown %s -O3 -emit-llvm -gline-tables-only -S -verify -o /dev/null
// RUN: %clang_cc1 -triple x86_64-unknown-unknown %s -O3 -emit-llvm -di-kind=line-tables -S -verify -o /dev/null

// REQUIRES: x86-registered-target
// REQUIRES: x86-registered-target




// Test verifies optimization failures generated by the backend are handled
// Test verifies optimization failures generated by the backend are handled

// correctly by clang. LLVM tests verify all of the failure conditions.
// correctly by clang. LLVM tests verify all of the failure conditions.




void test_switch(int *A, int *B, int Length) {
void test_switch(int *A, int *B, int Length) {

#pragma clang loop vectorize(enable) unroll(disable)
#pragma clang loop vectorize(enable) unroll(disable)

  for (int i = 0; i < Length; i++) {
  for (int i = 0; i < Length; i++) {

Show All 12 Lines
test/Modules/DebugInfoSubmoduleImport.c
// RUN: rm -rf %t
// RUN: rm -rf %t

// RUN: %clang_cc1 -fmodules -fmodule-format=obj -g -dwarf-ext-refs \
// RUN: %clang_cc1 -fmodules -fmodule-format=obj -di-kind=limited -dwarf-ext-refs \

// RUN:     -fimplicit-module-maps -x c -fmodules-cache-path=%t -I %S/Inputs \
// RUN:     -fimplicit-module-maps -x c -fmodules-cache-path=%t -I %S/Inputs \

// RUN:     %s -emit-llvm -o - | FileCheck %s
// RUN:     %s -emit-llvm -o - | FileCheck %s

#include "DebugSubmoduleA.h"
#include "DebugSubmoduleA.h"

#include "DebugSubmoduleB.h"
#include "DebugSubmoduleB.h"




// CHECK: !DICompileUnit
// CHECK: !DICompileUnit

// CHECK-NOT: !DICompileUnit
// CHECK-NOT: !DICompileUnit

// CHECK: !DIModule(scope: ![[PARENT:.*]], name: "DebugSubmoduleA"
// CHECK: !DIModule(scope: ![[PARENT:.*]], name: "DebugSubmoduleA"

// CHECK: [[PARENT]] = !DIModule(scope: null, name: "DebugSubmodules"
// CHECK: [[PARENT]] = !DIModule(scope: null, name: "DebugSubmodules"

// CHECK: !DIModule(scope: ![[PARENT]], name: "DebugSubmoduleB"
// CHECK: !DIModule(scope: ![[PARENT]], name: "DebugSubmoduleB"

// CHECK: !DICompileUnit({{.*}}splitDebugFilename: {{.*}}DebugSubmodules
// CHECK: !DICompileUnit({{.*}}splitDebugFilename: {{.*}}DebugSubmodules

// CHECK-SAME:                 dwoId:
// CHECK-SAME:                 dwoId:

// CHECK-NOT: !DICompileUnit
// CHECK-NOT: !DICompileUnit

test/Modules/DebugInfoSubmodules.c
// RUN: rm -rf %t
// RUN: rm -rf %t

// RUN: %clang_cc1 -fmodules -fmodule-format=obj -g -dwarf-ext-refs \
// RUN: %clang_cc1 -fmodules -fmodule-format=obj -di-kind=limited -dwarf-ext-refs \

// RUN:     -fimplicit-module-maps -x c -fmodules-cache-path=%t -I %S/Inputs \
// RUN:     -fimplicit-module-maps -x c -fmodules-cache-path=%t -I %S/Inputs \

// RUN:     %s -mllvm -debug-only=pchcontainer -emit-llvm -o %t.ll \
// RUN:     %s -mllvm -debug-only=pchcontainer -emit-llvm -o %t.ll \

// RUN:     2>&1 | FileCheck %s
// RUN:     2>&1 | FileCheck %s

// REQUIRES: asserts
// REQUIRES: asserts

#include "DebugSubmoduleA.h"
#include "DebugSubmoduleA.h"




// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "A",
// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "A",

// CHECK-SAME:             scope: ![[SUBMODULEA:[0-9]+]]
// CHECK-SAME:             scope: ![[SUBMODULEA:[0-9]+]]

// CHECK: ![[SUBMODULEA]] = !DIModule(scope: ![[PARENT:[0-9]+]],
// CHECK: ![[SUBMODULEA]] = !DIModule(scope: ![[PARENT:[0-9]+]],

// CHECK-SAME:                        name: "DebugSubmoduleA",
// CHECK-SAME:                        name: "DebugSubmoduleA",

// CHECK: ![[PARENT]] = !DIModule(scope: null, name: "DebugSubmodules"
// CHECK: ![[PARENT]] = !DIModule(scope: null, name: "DebugSubmodules"




// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "B",
// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "B",

// CHECK-SAME:             scope: ![[SUBMODULEB:[0-9]+]]
// CHECK-SAME:             scope: ![[SUBMODULEB:[0-9]+]]

// CHECK: ![[SUBMODULEB]] = !DIModule(scope: ![[PARENT]],
// CHECK: ![[SUBMODULEB]] = !DIModule(scope: ![[PARENT]],

// CHECK-SAME:                        name: "DebugSubmoduleB",
// CHECK-SAME:                        name: "DebugSubmoduleB",

test/Modules/DebugInfoTransitiveImport.m
// RUN: rm -rf %t
// RUN: rm -rf %t

// RUN: %clang_cc1 -fmodules -fmodule-format=obj -g -dwarf-ext-refs \
// RUN: %clang_cc1 -fmodules -fmodule-format=obj -di-kind=limited -dwarf-ext-refs \

// RUN:     -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs \
// RUN:     -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs \

// RUN:     %s -mllvm -debug-only=pchcontainer 2>&1 | FileCheck %s
// RUN:     %s -mllvm -debug-only=pchcontainer 2>&1 | FileCheck %s

// REQUIRES: asserts
// REQUIRES: asserts




@import diamond_left;
@import diamond_left;




// Definition of top:
// Definition of top:

// CHECK: !DICompileUnit({{.*}}dwoId:
// CHECK: !DICompileUnit({{.*}}dwoId:

Show All 12 Lines
test/Modules/ExtDebugInfo.cpp
// RUN: rm -rf %t
// RUN: rm -rf %t

// Test that only forward declarations are emitted for types dfined in modules.
// Test that only forward declarations are emitted for types dfined in modules.




// Modules:
// Modules:

// RUN: %clang_cc1 -x objective-c++ -std=c++11 -g -dwarf-ext-refs -fmodules \
// RUN: %clang_cc1 -x objective-c++ -std=c++11 -di-kind=limited -dwarf-ext-refs -fmodules \

// RUN:     -fmodule-format=obj -fimplicit-module-maps -DMODULES \
// RUN:     -fmodule-format=obj -fimplicit-module-maps -DMODULES \

// RUN:     -triple %itanium_abi_triple \
// RUN:     -triple %itanium_abi_triple \

// RUN:     -fmodules-cache-path=%t %s -I %S/Inputs -I %t -emit-llvm -o %t-mod.ll
// RUN:     -fmodules-cache-path=%t %s -I %S/Inputs -I %t -emit-llvm -o %t-mod.ll

// RUN: cat %t-mod.ll |  FileCheck %s
// RUN: cat %t-mod.ll |  FileCheck %s




// PCH:
// PCH:

// RUN: %clang_cc1 -x c++ -std=c++11 -fmodule-format=obj -emit-pch -I%S/Inputs \
// RUN: %clang_cc1 -x c++ -std=c++11 -fmodule-format=obj -emit-pch -I%S/Inputs \

// RUN:     -triple %itanium_abi_triple \
// RUN:     -triple %itanium_abi_triple \

// RUN:     -o %t.pch %S/Inputs/DebugCXX.h
// RUN:     -o %t.pch %S/Inputs/DebugCXX.h

// RUN: %clang_cc1 -std=c++11 -g -dwarf-ext-refs -fmodule-format=obj \
// RUN: %clang_cc1 -std=c++11 -di-kind=limited -dwarf-ext-refs -fmodule-format=obj \

// RUN:     -triple %itanium_abi_triple \
// RUN:     -triple %itanium_abi_triple \

// RUN:     -include-pch %t.pch %s -emit-llvm -o %t-pch.ll %s
// RUN:     -include-pch %t.pch %s -emit-llvm -o %t-pch.ll %s

// RUN: cat %t-pch.ll |  FileCheck %s
// RUN: cat %t-pch.ll |  FileCheck %s




#ifdef MODULES
#ifdef MODULES

@import DebugCXX;
@import DebugCXX;

#endif
#endif




▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines
test/Modules/ExtDebugInfo.m
// RUN: rm -rf %t
// RUN: rm -rf %t

// Test that only forward declarations are emitted for types defined in modules.
// Test that only forward declarations are emitted for types defined in modules.




// Modules:
// Modules:

// RUN: %clang_cc1 -x objective-c -g -dwarf-ext-refs -fmodules \
// RUN: %clang_cc1 -x objective-c -di-kind=limited -dwarf-ext-refs -fmodules \

// RUN:     -fmodule-format=obj -fimplicit-module-maps -DMODULES \
// RUN:     -fmodule-format=obj -fimplicit-module-maps -DMODULES \

// RUN:     -fmodules-cache-path=%t %s -I %S/Inputs -I %t -emit-llvm -o %t-mod.ll
// RUN:     -fmodules-cache-path=%t %s -I %S/Inputs -I %t -emit-llvm -o %t-mod.ll

// RUN: cat %t-mod.ll |  FileCheck %s
// RUN: cat %t-mod.ll |  FileCheck %s




// PCH:
// PCH:

// RUN: %clang_cc1 -x objective-c -fmodule-format=obj -emit-pch -I%S/Inputs \
// RUN: %clang_cc1 -x objective-c -fmodule-format=obj -emit-pch -I%S/Inputs \

// RUN:     -o %t.pch %S/Inputs/DebugObjC.h
// RUN:     -o %t.pch %S/Inputs/DebugObjC.h

// RUN: %clang_cc1 -x objective-c -g -dwarf-ext-refs -fmodule-format=obj \
// RUN: %clang_cc1 -x objective-c -di-kind=limited -dwarf-ext-refs -fmodule-format=obj \

// RUN:     -include-pch %t.pch %s -emit-llvm -o %t-pch.ll %s
// RUN:     -include-pch %t.pch %s -emit-llvm -o %t-pch.ll %s

// RUN: cat %t-pch.ll |  FileCheck %s
// RUN: cat %t-pch.ll |  FileCheck %s




#ifdef MODULES
#ifdef MODULES

@import DebugObjC;
@import DebugObjC;

#endif
#endif




int foo(ObjCClass *c) {
int foo(ObjCClass *c) {

Show All 11 Lines
test/Modules/ModuleDebugInfo.cpp
// Test that (the same) debug info is emitted for an Objective-C++
// Test that (the same) debug info is emitted for an Objective-C++

// module and a C++ precompiled header.
// module and a C++ precompiled header.




// REQUIRES: asserts, shell
// REQUIRES: asserts, shell




// Modules:
// Modules:

// RUN: rm -rf %t
// RUN: rm -rf %t

// RUN: %clang_cc1 -triple %itanium_abi_triple -x objective-c++ -std=c++11 -g -fmodules -fmodule-format=obj -fimplicit-module-maps -DMODULES -fmodules-cache-path=%t %s -I %S/Inputs -I %t -emit-llvm -o %t.ll -mllvm -debug-only=pchcontainer &>%t-mod.ll
// RUN: %clang_cc1 -triple %itanium_abi_triple -x objective-c++ -std=c++11 -di-kind=limited -fmodules -fmodule-format=obj -fimplicit-module-maps -DMODULES -fmodules-cache-path=%t %s -I %S/Inputs -I %t -emit-llvm -o %t.ll -mllvm -debug-only=pchcontainer &>%t-mod.ll

// RUN: cat %t-mod.ll | FileCheck %s
// RUN: cat %t-mod.ll | FileCheck %s

// RUN: cat %t-mod.ll | FileCheck --check-prefix=CHECK-NEG %s
// RUN: cat %t-mod.ll | FileCheck --check-prefix=CHECK-NEG %s

// RUN: cat %t-mod.ll | FileCheck --check-prefix=CHECK-DWO %s
// RUN: cat %t-mod.ll | FileCheck --check-prefix=CHECK-DWO %s




// PCH:
// PCH:

// RUN: %clang_cc1 -triple %itanium_abi_triple -x c++ -std=c++11 -emit-pch -fmodule-format=obj -I %S/Inputs -o %t.pch %S/Inputs/DebugCXX.h -mllvm -debug-only=pchcontainer &>%t-pch.ll
// RUN: %clang_cc1 -triple %itanium_abi_triple -x c++ -std=c++11 -emit-pch -fmodule-format=obj -I %S/Inputs -o %t.pch %S/Inputs/DebugCXX.h -mllvm -debug-only=pchcontainer &>%t-pch.ll

// RUN: cat %t-pch.ll | FileCheck %s
// RUN: cat %t-pch.ll | FileCheck %s

// RUN: cat %t-mod.ll | FileCheck --check-prefix=CHECK-NEG %s
// RUN: cat %t-mod.ll | FileCheck --check-prefix=CHECK-NEG %s

Show All 28 Lines
test/Modules/cxx-irgen.cpp
// RUN: rm -rf %t
// RUN: rm -rf %t

// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c++ -std=c++11 -fmodules-cache-path=%t -I %S/Inputs -triple %itanium_abi_triple -disable-llvm-optzns -emit-llvm -o - %s | FileCheck %s
// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c++ -std=c++11 -fmodules-cache-path=%t -I %S/Inputs -triple %itanium_abi_triple -disable-llvm-optzns -emit-llvm -o - %s | FileCheck %s

// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c++ -std=c++11 -fmodules-cache-path=%t -I %S/Inputs -triple %itanium_abi_triple -disable-llvm-optzns -emit-llvm -g -o - %s | FileCheck %s
// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c++ -std=c++11 -fmodules-cache-path=%t -I %S/Inputs -triple %itanium_abi_triple -disable-llvm-optzns -emit-llvm -di-kind=limited -o - %s | FileCheck %s

// FIXME: When we have a syntax for modules in C++, use that.
// FIXME: When we have a syntax for modules in C++, use that.




@import cxx_irgen_top;
@import cxx_irgen_top;




CtorInit<int> x;
CtorInit<int> x;




@import cxx_irgen_left;
@import cxx_irgen_left;

@import cxx_irgen_right;
@import cxx_irgen_right;

▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines
test/Modules/debug-info-moduleimport.m
// RUN: rm -rf %t
// RUN: rm -rf %t

// RUN: %clang_cc1 -g -fmodules -DGREETING="Hello World" -UNDEBUG -fimplicit-module-maps -fmodules-cache-path=%t %s -I %S/Inputs -isysroot /tmp/.. -I %t -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 -di-kind=limited -fmodules -DGREETING="Hello World" -UNDEBUG -fimplicit-module-maps -fmodules-cache-path=%t %s -I %S/Inputs -isysroot /tmp/.. -I %t -emit-llvm -o - | FileCheck %s




// CHECK: ![[CU:.*]] = distinct !DICompileUnit
// CHECK: ![[CU:.*]] = distinct !DICompileUnit

@import DebugObjC;
@import DebugObjC;

// CHECK: !DIImportedEntity(tag: DW_TAG_imported_declaration, scope: ![[CU]],
// CHECK: !DIImportedEntity(tag: DW_TAG_imported_declaration, scope: ![[CU]],

// CHECK-SAME:              entity: ![[MODULE:.*]], line: 5)
// CHECK-SAME:              entity: ![[MODULE:.*]], line: 5)

// CHECK: ![[MODULE]] = !DIModule(scope: null, name: "DebugObjC",
// CHECK: ![[MODULE]] = !DIModule(scope: null, name: "DebugObjC",

// CHECK-SAME:  configMacros: "\22-DGREETING=Hello World\22 \22-UNDEBUG\22",
// CHECK-SAME:  configMacros: "\22-DGREETING=Hello World\22 \22-UNDEBUG\22",

// CHECK-SAME:  includePath: "{{.*}}test{{.*}}Modules{{.*}}Inputs",
// CHECK-SAME:  includePath: "{{.*}}test{{.*}}Modules{{.*}}Inputs",

// CHECK-SAME:  isysroot: "/tmp/..")
// CHECK-SAME:  isysroot: "/tmp/..")







// RUN: %clang_cc1 -g -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \
// RUN: %clang_cc1 -di-kind=limited -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \

// RUN:   %s -I %S/Inputs -isysroot /tmp/.. -I %t -emit-llvm -o - \
// RUN:   %s -I %S/Inputs -isysroot /tmp/.. -I %t -emit-llvm -o - \

// RUN:     | FileCheck %s --check-prefix=NO-SKEL-CHECK
// RUN:     | FileCheck %s --check-prefix=NO-SKEL-CHECK

// NO-SKEL-CHECK: distinct !DICompileUnit
// NO-SKEL-CHECK: distinct !DICompileUnit

// NO-SKEL-CHECK-NOT: distinct !DICompileUnit
// NO-SKEL-CHECK-NOT: distinct !DICompileUnit




// RUN: %clang_cc1 -g -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \
// RUN: %clang_cc1 -di-kind=limited -fmodules -fimplicit-module-maps -fmodules-cache-path=%t \

// RUN:   -fmodule-format=obj -dwarf-ext-refs \
// RUN:   -fmodule-format=obj -dwarf-ext-refs \

// RUN:   %s -I %S/Inputs -isysroot /tmp/.. -I %t -emit-llvm -o - \
// RUN:   %s -I %S/Inputs -isysroot /tmp/.. -I %t -emit-llvm -o - \

// RUN:     | FileCheck %s --check-prefix=SKEL-CHECK
// RUN:     | FileCheck %s --check-prefix=SKEL-CHECK

// SKEL-CHECK: distinct !DICompileUnit
// SKEL-CHECK: distinct !DICompileUnit

// SKEL-CHECK: distinct !DICompileUnit{{.*}}dwoId
// SKEL-CHECK: distinct !DICompileUnit{{.*}}dwoId

test/OpenMP/atomic_codegen.cpp
// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -x c++ -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -x c++ -emit-llvm %s -o - | FileCheck %s

// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -gline-tables-only -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG
// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -di-kind=line-tables -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG

// expected-no-diagnostics
// expected-no-diagnostics




int a;
int a;

int b;
int b;




struct St {
struct St {

  unsigned long field;
  unsigned long field;

  St() {}
  St() {}

▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines
test/OpenMP/critical_codegen.cpp
// RUN: %clang_cc1 -verify -fopenmp -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s
// RUN: %clang_cc1 -verify -fopenmp -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s

// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s

// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s

// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -gline-tables-only -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG
// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -di-kind=line-tables -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG

// expected-no-diagnostics
// expected-no-diagnostics

// REQUIRES: x86-registered-target
// REQUIRES: x86-registered-target

#ifndef HEADER
#ifndef HEADER

#define HEADER
#define HEADER




// CHECK:       [[IDENT_T_TY:%.+]] = type { i32, i32, i32, i32, i8* }
// CHECK:       [[IDENT_T_TY:%.+]] = type { i32, i32, i32, i32, i8* }

// CHECK:       [[UNNAMED_LOCK:@.+]] = common global [8 x i32] zeroinitializer
// CHECK:       [[UNNAMED_LOCK:@.+]] = common global [8 x i32] zeroinitializer

// CHECK:       [[THE_NAME_LOCK:@.+]] = common global [8 x i32] zeroinitializer
// CHECK:       [[THE_NAME_LOCK:@.+]] = common global [8 x i32] zeroinitializer

▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines
test/OpenMP/flush_codegen.cpp
// RUN: %clang_cc1 -verify -fopenmp -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s
// RUN: %clang_cc1 -verify -fopenmp -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s

// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s

// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -g -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -di-kind=limited -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s

// expected-no-diagnostics
// expected-no-diagnostics

// REQUIRES: x86-registered-target
// REQUIRES: x86-registered-target

#ifndef HEADER
#ifndef HEADER

#define HEADER
#define HEADER




template <class T>
template <class T>

T tmain(T argc) {
T tmain(T argc) {

  static T a;
  static T a;

Show All 23 Lines
test/OpenMP/for_codegen.cpp
// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s
// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s

// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s

// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s

// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -gline-tables-only -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG
// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -di-kind=line-tables -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG

//
//

// expected-no-diagnostics
// expected-no-diagnostics

// REQUIRES: x86-registered-target
// REQUIRES: x86-registered-target

#ifndef HEADER
#ifndef HEADER

#define HEADER
#define HEADER

// CHECK: [[IDENT_T_TY:%.+]] = type { i32, i32, i32, i32, i8* }
// CHECK: [[IDENT_T_TY:%.+]] = type { i32, i32, i32, i32, i8* }

// CHECK-DAG: [[IMPLICIT_BARRIER_LOC:@.+]] = private unnamed_addr constant %{{.+}} { i32 0, i32 66, i32 0, i32 0, i8*
// CHECK-DAG: [[IMPLICIT_BARRIER_LOC:@.+]] = private unnamed_addr constant %{{.+}} { i32 0, i32 66, i32 0, i32 0, i8*

// CHECK-DAG: [[I:@.+]] = global i8 1,
// CHECK-DAG: [[I:@.+]] = global i8 1,

▲ Show 20 Lines • Show All 482 Lines • Show Last 20 Lines
test/OpenMP/for_simd_codegen.cpp
// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s
// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s

// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s

// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -g -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -di-kind=limited -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s

// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -gline-tables-only -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG
// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -di-kind=line-tables -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG

// REQUIRES: x86-registered-target
// REQUIRES: x86-registered-target

// expected-no-diagnostics
// expected-no-diagnostics

#ifndef HEADER
#ifndef HEADER

#define HEADER
#define HEADER




long long get_val() { return 0; }
long long get_val() { return 0; }

double *g_ptr;
double *g_ptr;




▲ Show 20 Lines • Show All 674 Lines • Show Last 20 Lines
test/OpenMP/master_codegen.cpp
// RUN: %clang_cc1 -verify -fopenmp -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s
// RUN: %clang_cc1 -verify -fopenmp -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s

// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s

// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s

// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -gline-tables-only -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG
// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -di-kind=line-tables -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG

// expected-no-diagnostics
// expected-no-diagnostics

// REQUIRES: x86-registered-target
// REQUIRES: x86-registered-target

#ifndef HEADER
#ifndef HEADER

#define HEADER
#define HEADER




// CHECK:       [[IDENT_T_TY:%.+]] = type { i32, i32, i32, i32, i8* }
// CHECK:       [[IDENT_T_TY:%.+]] = type { i32, i32, i32, i32, i8* }




// CHECK:       define {{.*}}void [[FOO:@.+]]()
// CHECK:       define {{.*}}void [[FOO:@.+]]()

▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines
test/OpenMP/parallel_codegen.cpp
// RUN: %clang_cc1 -verify -fopenmp -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s
// RUN: %clang_cc1 -verify -fopenmp -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s

// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s

// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -g -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix=CHECK-DEBUG %s
// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -di-kind=limited -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix=CHECK-DEBUG %s

// expected-no-diagnostics
// expected-no-diagnostics

// REQUIRES: x86-registered-target
// REQUIRES: x86-registered-target

#ifndef HEADER
#ifndef HEADER

#define HEADER
#define HEADER

// CHECK-DAG: %ident_t = type { i32, i32, i32, i32, i8* }
// CHECK-DAG: %ident_t = type { i32, i32, i32, i32, i8* }

// CHECK-DAG: [[STR:@.+]] = private unnamed_addr constant [23 x i8] c";unknown;unknown;0;0;;\00"
// CHECK-DAG: [[STR:@.+]] = private unnamed_addr constant [23 x i8] c";unknown;unknown;0;0;;\00"

// CHECK-DAG: [[DEF_LOC_2:@.+]] = private unnamed_addr constant %ident_t { i32 0, i32 2, i32 0, i32 0, i8* getelementptr inbounds ([23 x i8], [23 x i8]* [[STR]], i32 0, i32 0) }
// CHECK-DAG: [[DEF_LOC_2:@.+]] = private unnamed_addr constant %ident_t { i32 0, i32 2, i32 0, i32 0, i8* getelementptr inbounds ([23 x i8], [23 x i8]* [[STR]], i32 0, i32 0) }

// CHECK-DEBUG-DAG: %ident_t = type { i32, i32, i32, i32, i8* }
// CHECK-DEBUG-DAG: %ident_t = type { i32, i32, i32, i32, i8* }

▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines
test/OpenMP/parallel_for_codegen.cpp
// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s
// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s

// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s

// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s

// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -gline-tables-only -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG
// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -di-kind=line-tables -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG

// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -O1 -fopenmp -emit-llvm %s -o - | FileCheck %s --check-prefix=CLEANUP
// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -O1 -fopenmp -emit-llvm %s -o - | FileCheck %s --check-prefix=CLEANUP

// REQUIRES: x86-registered-target
// REQUIRES: x86-registered-target

// expected-no-diagnostics
// expected-no-diagnostics

#ifndef HEADER
#ifndef HEADER

#define HEADER
#define HEADER




// CHECK-DAG: [[IDENT_T_TY:%.+]] = type { i32, i32, i32, i32, i8* }
// CHECK-DAG: [[IDENT_T_TY:%.+]] = type { i32, i32, i32, i32, i8* }




▲ Show 20 Lines • Show All 390 Lines • Show Last 20 Lines
test/OpenMP/parallel_for_simd_codegen.cpp
// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s
// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s

// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s

// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -g -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -di-kind=limited -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s

// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -gline-tables-only -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG
// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -di-kind=line-tables -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG

// REQUIRES: x86-registered-target
// REQUIRES: x86-registered-target

// expected-no-diagnostics
// expected-no-diagnostics

#ifndef HEADER
#ifndef HEADER

#define HEADER
#define HEADER




long long get_val() { return 0; }
long long get_val() { return 0; }

double *g_ptr;
double *g_ptr;




▲ Show 20 Lines • Show All 681 Lines • Show Last 20 Lines
test/OpenMP/simd_codegen.cpp
// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s
// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s

// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s

// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -g -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -di-kind=limited -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s

// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -gline-tables-only -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG
// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -di-kind=line-tables -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG

// REQUIRES: x86-registered-target
// REQUIRES: x86-registered-target

// expected-no-diagnostics
// expected-no-diagnostics

#ifndef HEADER
#ifndef HEADER

#define HEADER
#define HEADER




long long get_val() { return 0; }
long long get_val() { return 0; }

double *g_ptr;
double *g_ptr;




▲ Show 20 Lines • Show All 624 Lines • Show Last 20 Lines
test/OpenMP/single_codegen.cpp
// RUN: %clang_cc1 -verify -fopenmp -fnoopenmp-use-tls -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s
// RUN: %clang_cc1 -verify -fopenmp -fnoopenmp-use-tls -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s

// RUN: %clang_cc1 -fopenmp -fnoopenmp-use-tls -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp -fnoopenmp-use-tls -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s

// RUN: %clang_cc1 -fopenmp -fnoopenmp-use-tls -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 -fopenmp -fnoopenmp-use-tls -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s

// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fnoopenmp-use-tls -fexceptions -fcxx-exceptions -gline-tables-only -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG
// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fnoopenmp-use-tls -fexceptions -fcxx-exceptions -di-kind=line-tables -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG

// RUN: %clang_cc1 -verify -fopenmp -fnoopenmp-use-tls -x c++ -std=c++11 -DARRAY -triple x86_64-apple-darwin10 -emit-llvm %s -o - | FileCheck -check-prefix=ARRAY %s
// RUN: %clang_cc1 -verify -fopenmp -fnoopenmp-use-tls -x c++ -std=c++11 -DARRAY -triple x86_64-apple-darwin10 -emit-llvm %s -o - | FileCheck -check-prefix=ARRAY %s

// expected-no-diagnostics
// expected-no-diagnostics

// REQUIRES: x86-registered-target
// REQUIRES: x86-registered-target

#ifndef ARRAY
#ifndef ARRAY

#ifndef HEADER
#ifndef HEADER

#define HEADER
#define HEADER




class TestClass {
class TestClass {

▲ Show 20 Lines • Show All 176 Lines • Show Last 20 Lines
test/OpenMP/taskgroup_codegen.cpp
// RUN: %clang_cc1 -verify -fopenmp -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s
// RUN: %clang_cc1 -verify -fopenmp -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s

// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s

// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s

// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -gline-tables-only -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG
// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -fexceptions -fcxx-exceptions -di-kind=line-tables -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG

// expected-no-diagnostics
// expected-no-diagnostics

// REQUIRES: x86-registered-target
// REQUIRES: x86-registered-target

#ifndef HEADER
#ifndef HEADER

#define HEADER
#define HEADER




// CHECK:       [[IDENT_T_TY:%.+]] = type { i32, i32, i32, i32, i8* }
// CHECK:       [[IDENT_T_TY:%.+]] = type { i32, i32, i32, i32, i8* }




// CHECK:       define {{.*}}void [[FOO:@.+]]()
// CHECK:       define {{.*}}void [[FOO:@.+]]()

▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines
test/OpenMP/threadprivate_codegen.cpp
// RUN: %clang_cc1 -verify -fopenmp -fnoopenmp-use-tls -DBODY -triple x86_64-unknown-unknown -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s
// RUN: %clang_cc1 -verify -fopenmp -fnoopenmp-use-tls -DBODY -triple x86_64-unknown-unknown -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s

// RUN: %clang_cc1 -fopenmp -fnoopenmp-use-tls -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp -fnoopenmp-use-tls -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s

// RUN: %clang_cc1 -fopenmp -fnoopenmp-use-tls -DBODY -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -g -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix=CHECK-DEBUG %s
// RUN: %clang_cc1 -fopenmp -fnoopenmp-use-tls -DBODY -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -di-kind=limited -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix=CHECK-DEBUG %s




// RUN: %clang_cc1 -verify -fopenmp -DBODY -triple x86_64-unknown-unknown -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s --check-prefix=CHECK-TLS
// RUN: %clang_cc1 -verify -fopenmp -DBODY -triple x86_64-unknown-unknown -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s --check-prefix=CHECK-TLS

// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s

// RUN: %clang_cc1 -fopenmp -DBODY -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -g -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix=CHECK-TLS %s
// RUN: %clang_cc1 -fopenmp -DBODY -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -di-kind=limited -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix=CHECK-TLS %s




// expected-no-diagnostics
// expected-no-diagnostics

// REQUIRES: x86-registered-target
// REQUIRES: x86-registered-target

#ifndef HEADER
#ifndef HEADER

#define HEADER
#define HEADER

// CHECK-DAG: [[IDENT:%.+]] = type { i32, i32, i32, i32, i8* }
// CHECK-DAG: [[IDENT:%.+]] = type { i32, i32, i32, i32, i8* }

// CHECK-DAG: [[S1:%.+]] = type { [[INT:i[0-9]+]] }
// CHECK-DAG: [[S1:%.+]] = type { [[INT:i[0-9]+]] }

// CHECK-DAG: [[S2:%.+]] = type { [[INT]], double }
// CHECK-DAG: [[S2:%.+]] = type { [[INT]], double }

▲ Show 20 Lines • Show All 937 Lines • Show Last 20 Lines
test/PCH/debug-info-limited-struct.c
// RUN: %clang_cc1 -emit-pch -o %t %S/debug-info-limited-struct.h
// RUN: %clang_cc1 -emit-pch -o %t %S/debug-info-limited-struct.h

// RUN: %clang_cc1 -include-pch %t -emit-llvm %s -g -o - | FileCheck %s
// RUN: %clang_cc1 -include-pch %t -emit-llvm %s -di-kind=limited -o - | FileCheck %s




// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "foo"
// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "foo"

// CHECK-NOT:              flags: {{[^,]*}}FlagFwdDecl
// CHECK-NOT:              flags: {{[^,]*}}FlagFwdDecl

// CHECK-SAME:             {{$}}
// CHECK-SAME:             {{$}}

test/PCH/pending-ids.m
// Test for rdar://10278815
// Test for rdar://10278815




// Without PCH
// Without PCH

// RUN: %clang_cc1 -fsyntax-only -verify -include %s %s
// RUN: %clang_cc1 -fsyntax-only -verify -include %s %s




// With PCH
// With PCH

// RUN: %clang_cc1 %s -emit-pch -o %t
// RUN: %clang_cc1 %s -emit-pch -o %t

// RUN: %clang_cc1 -emit-llvm-only -verify %s -include-pch %t -g
// RUN: %clang_cc1 -emit-llvm-only -verify %s -include-pch %t -di-kind=limited




// expected-no-diagnostics
// expected-no-diagnostics




#ifndef HEADER
#ifndef HEADER

#define HEADER
#define HEADER

//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//

// Header
// Header




Show All 19 Lines
test/Rewriter/line-generation-test.m
// RUN: %clang_cc1 -E %s -o %t.mm
// RUN: %clang_cc1 -E %s -o %t.mm

// RUN: %clang_cc1 -fms-extensions -rewrite-objc -g %t.mm -o %t-rw.cpp
// RUN: %clang_cc1 -fms-extensions -rewrite-objc -di-kind=limited %t.mm -o %t-rw.cpp

// RUN: FileCheck  -check-prefix CHECK-LINE --input-file=%t-rw.cpp %s
// RUN: FileCheck  -check-prefix CHECK-LINE --input-file=%t-rw.cpp %s

// RUN: %clang_cc1 -fms-extensions -rewrite-objc %t.mm -o %t-rwnog.cpp
// RUN: %clang_cc1 -fms-extensions -rewrite-objc %t.mm -o %t-rwnog.cpp

// RUN: FileCheck  -check-prefix CHECK-NOLINE --input-file=%t-rwnog.cpp %s
// RUN: FileCheck  -check-prefix CHECK-NOLINE --input-file=%t-rwnog.cpp %s

// rdar://13138170
// rdar://13138170




__attribute__((objc_root_class)) @interface MyObject {
__attribute__((objc_root_class)) @interface MyObject {

@public
@public

    id _myMaster;
    id _myMaster;

Show All 30 Lines
test/VFS/external-names.c
Show All 21 Lines
// CHECK-DIAG-EXTERNAL: {{.*}}Inputs{{.}}external-names.h:{{[0-9]*:[0-9]*}}: warning: incompatible pointer
// CHECK-DIAG-EXTERNAL: {{.*}}Inputs{{.}}external-names.h:{{[0-9]*:[0-9]*}}: warning: incompatible pointer




// RUN: %clang_cc1 -I %t -ivfsoverlay %t.yaml -fsyntax-only %s 2>&1 | FileCheck -check-prefix=CHECK-DIAG %s
// RUN: %clang_cc1 -I %t -ivfsoverlay %t.yaml -fsyntax-only %s 2>&1 | FileCheck -check-prefix=CHECK-DIAG %s

// CHECK-DIAG-NOT: Inputs
// CHECK-DIAG-NOT: Inputs




////
////

// Debug info
// Debug info




// RUN: %clang_cc1 -I %t -ivfsoverlay %t.external.yaml -triple %itanium_abi_triple -g -emit-llvm %s -o - | FileCheck -check-prefix=CHECK-DEBUG-EXTERNAL %s
// RUN: %clang_cc1 -I %t -ivfsoverlay %t.external.yaml -triple %itanium_abi_triple -di-kind=limited -emit-llvm %s -o - | FileCheck -check-prefix=CHECK-DEBUG-EXTERNAL %s

// CHECK-DEBUG-EXTERNAL: !DISubprogram({{.*}}file: ![[Num:[0-9]+]]
// CHECK-DEBUG-EXTERNAL: !DISubprogram({{.*}}file: ![[Num:[0-9]+]]

// CHECK-DEBUG-EXTERNAL: ![[Num]] = !DIFile(filename: "{{[^"]*}}Inputs{{.}}external-names.h"
// CHECK-DEBUG-EXTERNAL: ![[Num]] = !DIFile(filename: "{{[^"]*}}Inputs{{.}}external-names.h"




// RUN: %clang_cc1 -I %t -ivfsoverlay %t.yaml -triple %itanium_abi_triple -g -emit-llvm %s -o - | FileCheck -check-prefix=CHECK-DEBUG %s
// RUN: %clang_cc1 -I %t -ivfsoverlay %t.yaml -triple %itanium_abi_triple -di-kind=limited -emit-llvm %s -o - | FileCheck -check-prefix=CHECK-DEBUG %s

// CHECK-DEBUG-NOT: Inputs
// CHECK-DEBUG-NOT: Inputs

tools/driver/cc1as_main.cpp
Show First 20 Lines • Show All 189 Lines • ▼ Show 20 Linesbool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,

  // Use the default target triple if unspecified.
  // Use the default target triple if unspecified.

  if (Opts.Triple.empty())
  if (Opts.Triple.empty())

    Opts.Triple = llvm::sys::getDefaultTargetTriple();
    Opts.Triple = llvm::sys::getDefaultTargetTriple();




  // Language Options
  // Language Options

  Opts.IncludePaths = Args.getAllArgValues(OPT_I);
  Opts.IncludePaths = Args.getAllArgValues(OPT_I);

  Opts.NoInitialTextSection = Args.hasArg(OPT_n);
  Opts.NoInitialTextSection = Args.hasArg(OPT_n);

  Opts.SaveTemporaryLabels = Args.hasArg(OPT_msave_temp_labels);
  Opts.SaveTemporaryLabels = Args.hasArg(OPT_msave_temp_labels);

  Opts.GenDwarfForAssembly = Args.hasArg(OPT_g_Flag);
  // Any DebugInfoKind implies GenDwarfForAssembly.

  Opts.GenDwarfForAssembly = Args.hasArg(OPT_debug_info_kind_EQ);

  Opts.CompressDebugSections = Args.hasArg(OPT_compress_debug_sections);
  Opts.CompressDebugSections = Args.hasArg(OPT_compress_debug_sections);

  if (Args.hasArg(OPT_gdwarf_2))
  Opts.DwarfVersion = getLastArgIntValue(Args, OPT_dwarf_version_EQ, 0, Diags);

    Opts.DwarfVersion = 2;

  if (Args.hasArg(OPT_gdwarf_3))

    Opts.DwarfVersion = 3;

  if (Args.hasArg(OPT_gdwarf_4))

    Opts.DwarfVersion = 4;

  Opts.DwarfDebugFlags = Args.getLastArgValue(OPT_dwarf_debug_flags);
  Opts.DwarfDebugFlags = Args.getLastArgValue(OPT_dwarf_debug_flags);

  Opts.DwarfDebugProducer = Args.getLastArgValue(OPT_dwarf_debug_producer);
  Opts.DwarfDebugProducer = Args.getLastArgValue(OPT_dwarf_debug_producer);

  Opts.DebugCompilationDir = Args.getLastArgValue(OPT_fdebug_compilation_dir);
  Opts.DebugCompilationDir = Args.getLastArgValue(OPT_fdebug_compilation_dir);

  Opts.MainFileName = Args.getLastArgValue(OPT_main_file_name);
  Opts.MainFileName = Args.getLastArgValue(OPT_main_file_name);




  // Frontend Options
  // Frontend Options

  if (Args.hasArg(OPT_INPUT)) {
  if (Args.hasArg(OPT_INPUT)) {

    bool First = true;
    bool First = true;

▲ Show 20 Lines • Show All 292 Lines • ▼ Show 20 Linesint cc1as_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {

  bool Failed = Diags.hasErrorOccurred() || ExecuteAssembler(Asm, Diags);
  bool Failed = Diags.hasErrorOccurred() || ExecuteAssembler(Asm, Diags);




  // If any timers were active but haven't been destroyed yet, print their
  // If any timers were active but haven't been destroyed yet, print their

  // results now.
  // results now.

  TimerGroup::printAll(errs());
  TimerGroup::printAll(errs());




  return !!Failed;
  return !!Failed;

}
}