[lldb] Refactor argument group by SourceLocationSpec (NFCI)

[mib]

Summary

This patch refactors a good part of the code base turning the usual
FileSpec, Line, Column, CheckInlines, ExactMatch arguments into a
SourceLocationSpec object.

This change is required for a following patch that will add handling of the
column line information when doing symbol resolution.

Signed-off-by: Med Ismail Bennani <[e-mail]>

[JDevlieghere]

Nice, it's great to see functions taking less arguments for a change ;-)

lldb/include/lldb/Breakpoint/BreakpointResolverFileLine.h

12–15

30

Was this meant to be a const ref? There's no point in making objects passed by value const, as they're already copied in and this just means that if the function wants to modify them, they have to make a second copy while the function already has its own copy.

lldb/include/lldb/Core/AddressResolverFileLine.h

43–44

[jingham]

It seems like most of the places where you use the SourceLocationSpec, you also pass "check_inlines" and "exact". Those seem to me natural parts of a source location search specification class, and including them in the Spec would clean up the API's even further. Not necessary if it gets ugly for some reason, but it would look nicer.

[mib]

Address @JDevlieghere & @jingham feedbacks.

[mib]

Update LineEntry unit test.

[mib]

Update BreakpointResolver column default value and fix typo

[JDevlieghere]

In several places you have SourceLocationSpec::Create followed by a lldbassert. That's not sufficient, because in a non-assert build, the lldbassert is going to print a message but not halt the program and we'll crash when trying to dereference the expected. You'll need to add proper error handling to those places to bail out if the location spec is not valid.

lldb/include/lldb/Breakpoint/BreakpointResolverFileLine.h

63–64

Move this before the bool to reduce padding.

lldb/source/API/SBThread.cpp

866

This will crash in a non-assert build. You can't rely on the assert to make this unreachable.

lldb/source/Breakpoint/BreakpointResolverFileLine.cpp

269–270

I'd get the column, check if it's valid, and use it, instead of calling HasColumn before GetColumn.

lldb/source/Breakpoint/BreakpointResolverFileRegex.cpp

113

Same here

[shafik]

lldb/source/API/SBThread.cpp

866

step_file_spec, line, /*column*/llvm::None, check_inlines, exact);

lldb/source/Breakpoint/BreakpointResolverFileRegex.cpp

111

cu_file_spec, line_matches[i], /*column*/llvm::None, search_inlines, m_exact_match);

[mib]

Addressed @JDevlieghere @shafik feedbacks.

[JDevlieghere]

lldb/source/API/SBThread.cpp

866

As @teemperor pointed out in another patch, the llvm style includes a = at the end (https://www.llvm.org/docs/CodingStandards.html#comment-formatting)

auto location_spec = SourceLocationSpec::Create(
        step_file_spec, line, /*colum=*/llvm::None, check_inlines, exact);

868–871

Let's move Invalid SourceLocationSpec: (without the capitalization) into the error reported by SourceLocationSpec::Create and use the Status ctor that takes an llvm::Error to avoid this code duplication.

[mib]

Addressed @JDevlieghere comments.

[mib]

Fix test failures.

[JDevlieghere]

lldb/source/API/SBThread.cpp

868

Why not sb_error = location_spec.takeError()?

[mib]

lldb/source/API/SBThread.cpp

868

takeError returns an llvm::Error not a lldb_private::Status, and there is no SBError constructor for Status so I don't think that's possible.

[JDevlieghere]

lldb/source/API/SBThread.cpp

868

There is:

explicit Status(llvm::Error error) { *this = std::move(error); }
const Status &operator=(llvm::Error error);

[teemperor]

I am wondering how SourceLocationSpec is related to lldb's Declaration class (which is FileSpec + line + column and describes a location in source code)? It seems like the current SourceLocationSpec is just a Declaration with the two additional search variables (and the first iteration was exactly the same as Declaration).

Could we maybe turn SourceLocationSpec to store a lldb::Declaration instead of file/line/column? I'm aware that the Declaration class first needs some cleanup (and a removal of that #ifdef around column....), but right now we are already using Declarations in a bunch of places to describe source locations.

[mib]

Use llvm::Expected error when possible.

[mib]

In D100965#2716239, @teemperor wrote:

I am wondering how SourceLocationSpec is related to lldb's Declaration class (which is FileSpec + line + column and describes a location in source code)? It seems like the current SourceLocationSpec is just a Declaration with the two additional search variables (and the first iteration was exactly the same as Declaration).
Could we maybe turn SourceLocationSpec to store a lldb::Declaration instead of file/line/column? I'm aware that the Declaration class first needs some cleanup (and a removal of that #ifdef around column....), but right now we are already using Declarations in a bunch of places to describe source locations.

I don't think adding a level of indirection would serve much purpose and I don't like the fact that Declaration is an exposed class (being part of the lldb namespace), and that it uses a macro-based system for invalid values. Also SourceLocationSpec instances are immutable and must be valid. May be I could try to replace all occurrences of Declaration by SourceLocationSpec in a follow-up patch ?

[jingham]

In D100965#2716239, @teemperor wrote:

I am wondering how SourceLocationSpec is related to lldb's Declaration class (which is FileSpec + line + column and describes a location in source code)? It seems like the current SourceLocationSpec is just a Declaration with the two additional search variables (and the first iteration was exactly the same as Declaration).

Could we maybe turn SourceLocationSpec to store a lldb::Declaration instead of file/line/column? I'm aware that the Declaration class first needs some cleanup (and a removal of that #ifdef around column....), but right now we are already using Declarations in a bunch of places to describe source locations.

Seems to me Declarations and SourceLocationSpec's are different things. A Declaration describes just where something is in a source file. And moreover, there need to be a lot of them, since every function, type etc has one. So you might be concerned about size for this entity.

A SourceLocationSpec (maybe we should make a better name?) is about specifying how you search for a source location (e.g. to set a breakpoint on it.) And there are never going to be lots of them in flight, since they are tied to user actions. So we are fairly free to add extra fields to this if we have other ways of specifying the match to a source location. OTOH, Declarations don't need "include_inlines" or "exact_match" or anything else we might end up adding to specify how to look for matches against a source line specification somebody used in break set or other places.

So I don't think it makes sense to conflate the two.

[JDevlieghere]

lldb/source/Breakpoint/BreakpointResolverFileLine.cpp

230

lldb/source/Breakpoint/BreakpointResolverFileRegex.cpp

114

We can't write straight to stderr. We should either have this return an Expected<Searcher::CallbackReturn> or deal with the error in some other way.

lldb/source/Core/Module.cpp

609

Same here

933

and here

lldb/source/Symbol/CompileUnit.cpp

234

and here

[teemperor]

In D100965#2720235, @jingham wrote:

In D100965#2716239, @teemperor wrote:

I am wondering how SourceLocationSpec is related to lldb's Declaration class (which is FileSpec + line + column and describes a location in source code)? It seems like the current SourceLocationSpec is just a Declaration with the two additional search variables (and the first iteration was exactly the same as Declaration).

Could we maybe turn SourceLocationSpec to store a lldb::Declaration instead of file/line/column? I'm aware that the Declaration class first needs some cleanup (and a removal of that #ifdef around column....), but right now we are already using Declarations in a bunch of places to describe source locations.

Seems to me Declarations and SourceLocationSpec's are different things. A Declaration describes just where something is in a source file. And moreover, there need to be a lot of them, since every function, type etc has one. So you might be concerned about size for this entity.

A SourceLocationSpec (maybe we should make a better name?) is about specifying how you search for a source location (e.g. to set a breakpoint on it.) And there are never going to be lots of them in flight, since they are tied to user actions. So we are fairly free to add extra fields to this if we have other ways of specifying the match to a source location. OTOH, Declarations don't need "include_inlines" or "exact_match" or anything else we might end up adding to specify how to look for matches against a source line specification somebody used in break set or other places.

So I don't think it makes sense to conflate the two.

My point was that Declaration should be a member of SourceLocationSpec (which will then be a Declaration + the search parameters). I agree that those two should stay two different classes. From what understand from Ismail this patch is (was?) going in the direction you're describing of having SourceLocationSpec taking over Declaration (which would then raise the memory concerns you mentioned).

In other words: If the file/line/column members could just be a Declaration (assuming we remove that ifdef around Declarations column member) then IMHO this would be nicer. I would also like the idea of maybe typedef'ing the line/column member types in addition to that. Not sure if we need uint32_t for columns or maybe we need one day uint64_t for lines.

[jingham]

In D100965#2722149, @teemperor wrote:

In D100965#2720235, @jingham wrote:

In D100965#2716239, @teemperor wrote:

I am wondering how SourceLocationSpec is related to lldb's Declaration class (which is FileSpec + line + column and describes a location in source code)? It seems like the current SourceLocationSpec is just a Declaration with the two additional search variables (and the first iteration was exactly the same as Declaration).

Could we maybe turn SourceLocationSpec to store a lldb::Declaration instead of file/line/column? I'm aware that the Declaration class first needs some cleanup (and a removal of that #ifdef around column....), but right now we are already using Declarations in a bunch of places to describe source locations.

Seems to me Declarations and SourceLocationSpec's are different things. A Declaration describes just where something is in a source file. And moreover, there need to be a lot of them, since every function, type etc has one. So you might be concerned about size for this entity.

A SourceLocationSpec (maybe we should make a better name?) is about specifying how you search for a source location (e.g. to set a breakpoint on it.) And there are never going to be lots of them in flight, since they are tied to user actions. So we are fairly free to add extra fields to this if we have other ways of specifying the match to a source location. OTOH, Declarations don't need "include_inlines" or "exact_match" or anything else we might end up adding to specify how to look for matches against a source line specification somebody used in break set or other places.

So I don't think it makes sense to conflate the two.

My point was that Declaration should be a member of SourceLocationSpec (which will then be a Declaration + the search parameters). I agree that those two should stay two different classes. From what understand from Ismail this patch is (was?) going in the direction you're describing of having SourceLocationSpec taking over Declaration (which would then raise the memory concerns you mentioned).

In other words: If the file/line/column members could just be a Declaration (assuming we remove that ifdef around Declarations column member) then IMHO this would be nicer. I would also like the idea of maybe typedef'ing the line/column member types in addition to that. Not sure if we need uint32_t for columns or maybe we need one day uint64_t for lines.

Ah, I see. Yes, that's reasonable. Then when source files get 3-dimensional we can add in the z-axis column w/o having to change our API's!

[mib]

As discussed with @JDevlieghere offline, at the moment SearchFilter and Searcher (from which many class inherit) are not designed for error handling so I removed the SourceLocationSpec::Create factory method and added an IsValid method to check the state optionally.

[mib]

The points that @teemperor brought up have been implemented in D101556 and D100962.

[JDevlieghere]

A few nits but overall this looks like a great cleanup!

lldb/source/Breakpoint/BreakpointResolverFileLine.cpp

255–256

Would it make sense for the column here to be passed as an optional. Right now you're unpacking it which means we potentially have to check for LLDB_INVALID_COLUMN again in the function that's called here.

lldb/source/Core/Module.cpp

603–605

nit: This probably won't matter after the todo, but we should be consistent between using the comment or a named variable. Same observation below.

[JDevlieghere]

LGTM

lldb/source/Breakpoint/BreakpointResolverFileLine.cpp

266–272

I was going to suggest calling the location spec's dump method, but I assume we don't want to change the format. Would it make sense to have a GetDescription in the SourceLocationSpec class or change the dump format to match this format?

lldb/include/lldb/Breakpoint/BreakpointResolver.h

 //===-- BreakpointResolver.h ------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_BREAKPOINT_BREAKPOINTRESOLVER_H
 #define LLDB_BREAKPOINT_BREAKPOINTRESOLVER_H
 
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/SearchFilter.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
protected:
   /// same file and line number in a CU, and find the nearest actual line
   /// number that matches, and then filter down the matching addresses to
   /// unique entries, and skip the prologue if asked to do so, and then set
   /// breakpoint locations in this breakpoint for all the resultant addresses.
   /// When \p column is nonzero the \p line and \p column args are used to
   /// filter the results to find the first breakpoint >= (line, column).
   void SetSCMatchesByLine(SearchFilter &filter, SymbolContextList &sc_list,
                           bool skip_prologue, llvm::StringRef log_ident,
-                          uint32_t line = 0, uint32_t column = 0);
+                          uint32_t line = 0,
+                          llvm::Optional<uint16_t> column = llvm::None);
   void SetSCMatchesByLine(SearchFilter &, SymbolContextList &, bool,
                           const char *) = delete;
 
   lldb::BreakpointLocationSP AddLocation(Address loc_addr,
                                          bool *new_location = nullptr);
 
 private:
   /// Helper for \p SetSCMatchesByLine.

lldb/include/lldb/Breakpoint/BreakpointResolverFileLine.h

 //===-- BreakpointResolverFileLine.h ----------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_BREAKPOINT_BREAKPOINTRESOLVERFILELINE_H
 #define LLDB_BREAKPOINT_BREAKPOINTRESOLVERFILELINE_H
 
 #include "lldb/Breakpoint/BreakpointResolver.h"
+#include "lldb/Core/SourceLocationSpec.h"
 
 namespace lldb_private {
 
 /// \class BreakpointResolverFileLine BreakpointResolverFileLine.h
 /// "lldb/Breakpoint/BreakpointResolverFileLine.h" This class sets breakpoints
 /// by file and line.  Optionally, it will look for inlined instances of the
 /// file and line specification.
 
 class BreakpointResolverFileLine : public BreakpointResolver {
 public:
   BreakpointResolverFileLine(const lldb::BreakpointSP &bkpt,
-                             const FileSpec &resolver,
-                             uint32_t line_no, uint32_t column,
-                             lldb::addr_t m_offset, bool check_inlines,
-                             bool skip_prologue, bool exact_match);
+                             lldb::addr_t offset, bool skip_prologue,
+                             const SourceLocationSpec &location_spec);
 
   static BreakpointResolver *
   CreateFromStructuredData(const lldb::BreakpointSP &bkpt,
                            const StructuredData::Dictionary &data_dict,
                            Status &error);
 
   StructuredData::ObjectSP SerializeToStructuredData() override;
 
   ~BreakpointResolverFileLine() override = default;
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                           SymbolContext &context,
public:
 
   lldb::BreakpointResolverSP
   CopyForBreakpoint(lldb::BreakpointSP &breakpoint) override;
 
 protected:
   void FilterContexts(SymbolContextList &sc_list, bool is_relative);
 
   friend class Breakpoint;
-  FileSpec m_file_spec;   ///< This is the file spec we are looking for.
-  uint32_t m_line_number; ///< This is the line number that we are looking for.
-  uint32_t m_column;      ///< This is the column that we are looking for.
-  bool m_inlines; ///< This determines whether the resolver looks for inlined
-                  ///< functions or not.
+  SourceLocationSpec m_location_spec;
   bool m_skip_prologue;
-  bool m_exact_match;
 
 private:
   BreakpointResolverFileLine(const BreakpointResolverFileLine &) = delete;
   const BreakpointResolverFileLine &
   operator=(const BreakpointResolverFileLine &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_BREAKPOINT_BREAKPOINTRESOLVERFILELINE_H

lldb/include/lldb/Core/AddressResolverFileLine.h

 //===-- AddressResolverFileLine.h -------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_CORE_ADDRESSRESOLVERFILELINE_H
 #define LLDB_CORE_ADDRESSRESOLVERFILELINE_H
 
 #include "lldb/Core/AddressResolver.h"
 #include "lldb/Core/SearchFilter.h"
-#include "lldb/Utility/FileSpec.h"
+#include "lldb/Core/SourceLocationSpec.h"
 #include "lldb/lldb-defines.h"
 
 #include <stdint.h>
 
 namespace lldb_private {
 class Address;
 class Stream;
 class SymbolContext;
 
 /// \class AddressResolverFileLine AddressResolverFileLine.h
 /// "lldb/Core/AddressResolverFileLine.h" This class finds address for source
 /// file and line.  Optionally, it will look for inlined instances of the file
 /// and line specification.
 
 class AddressResolverFileLine : public AddressResolver {
 public:
-  AddressResolverFileLine(const FileSpec &resolver, uint32_t line_no,
-                          bool check_inlines);
+  AddressResolverFileLine(SourceLocationSpec location_spec);
 
   ~AddressResolverFileLine() override;
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                           SymbolContext &context,
                                           Address *addr) override;
 
   lldb::SearchDepth GetDepth() override;
 
   void GetDescription(Stream *s) override;
 
 protected:
-  FileSpec m_file_spec;   // This is the file spec we are looking for.
-  uint32_t m_line_number; // This is the line number that we are looking for.
-  bool m_inlines; // This determines whether the resolver looks for inlined
-                  // functions or not.
+  SourceLocationSpec m_src_location_spec;
 
 private:
   AddressResolverFileLine(const AddressResolverFileLine &) = delete;
   const AddressResolverFileLine &
   operator=(const AddressResolverFileLine &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_ADDRESSRESOLVERFILELINE_H

lldb/include/lldb/Symbol/CompileUnit.h

 //===-- CompileUnit.h -------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SYMBOL_COMPILEUNIT_H
 #define LLDB_SYMBOL_COMPILEUNIT_H
 
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/ModuleChild.h"
+#include "lldb/Core/SourceLocationSpec.h"
 #include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/SourceModule.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/UserID.h"
 #include "lldb/lldb-enumerations.h"
 
public:
   /// lists and are ready to hand ownership of the list over to this object.
   ///
   /// \param[in] variable_list_sp
   ///     A shared pointer to a VariableList.
   void SetVariableList(lldb::VariableListSP &variable_list_sp);
 
   /// Resolve symbol contexts by file and line.
   ///
-  /// Given a file in \a file_spec, and a line number, find all instances and
+  /// Given a file in \a src_location_spec, find all instances and
   /// append them to the supplied symbol context list \a sc_list.
   ///
-  /// \param[in] file_spec
-  ///     A file specification. If \a file_spec contains no directory
-  ///     information, only the basename will be used when matching
-  ///     contexts. If the directory in \a file_spec is valid, a
-  ///     complete file specification match will be performed.
-  ///
-  /// \param[in] line
-  ///     The line number to match against the compile unit's line
-  ///     tables.
+  /// \param[in] src_location_spec
+  ///     The \a src_location_spec containing the \a file_spec, the line and the
+  ///     column of the symbol to look for. Also hold the inlines and
+  ///     exact_match flags.
   ///
-  /// \param[in] check_inlines
-  ///     If \b true this function will also match any inline
+  ///     If check_inlines is \b true, this function will also match any inline
   ///     file and line matches. If \b false, the compile unit's
   ///     file specification must match \a file_spec for any matches
   ///     to be returned.
   ///
-  /// \param[in] exact
-  ///     If true, only resolve the context if \a line exists in the line table.
-  ///     If false, resolve the context to the closest line greater than \a line
-  ///     in the line table.
+  ///     If exact_match is \b true, only resolve the context if \a line and \a
+  ///     column exists in the line table. If \b false, resolve the context to
+  ///     the closest line greater than \a line in the line table.
   ///
   /// \param[in] resolve_scope
   ///     For each matching line entry, this bitfield indicates what
   ///     values within each SymbolContext that gets added to \a
   ///     sc_list will be resolved. See the SymbolContext::Scope
   ///     enumeration for a list of all available bits that can be
   ///     resolved. Only SymbolContext entries that can be resolved
   ///     using a LineEntry base address will be able to be resolved.
   ///
   /// \param[out] sc_list
   ///     A SymbolContext list class that will get any matching
   ///     entries appended to.
   ///
   /// \see enum SymbolContext::Scope
-  void ResolveSymbolContext(const FileSpec &file_spec, uint32_t line,
-                            bool check_inlines, bool exact,
+  void ResolveSymbolContext(const SourceLocationSpec &src_location_spec,
                             lldb::SymbolContextItem resolve_scope,
                             SymbolContextList &sc_list);
 
   /// Get whether compiler optimizations were enabled for this compile unit
   ///
   /// "optimized" means that the debug experience may be difficult for the
   /// user to understand.  Variables may not be available when the developer
   /// would expect them, stepping through the source lines in the function may

lldb/include/lldb/Symbol/LineTable.h

 //===-- LineTable.h ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SYMBOL_LINETABLE_H
 #define LLDB_SYMBOL_LINETABLE_H
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/ModuleChild.h"
 #include "lldb/Core/Section.h"
+#include "lldb/Core/SourceLocationSpec.h"
 #include "lldb/Symbol/LineEntry.h"
 #include "lldb/Utility/RangeMap.h"
 #include "lldb/lldb-private.h"
 #include <vector>
 
 namespace lldb_private {
 
 /// \class LineSequence LineTable.h "lldb/Symbol/LineTable.h" An abstract base
public:
   ///     The number of entries to skip when starting the search.
   ///
   /// \param[out] file_idx
   ///     The file index to search for that should be found prior
   ///     to calling this function using the following functions:
   ///     CompileUnit::GetSupportFiles()
   ///     FileSpecList::FindFileIndex (uint32_t, const FileSpec &) const
   ///
-  /// \param[in] line
-  ///     The source line to match.
-  ///
-  /// \param[in] exact
-  ///     If true, match only if you find a line entry exactly matching \a line.
-  ///     If false, return the closest line entry greater than \a line.
+  /// \param[in] src_location_spec
+  ///     The source location specifier to match.
   ///
   /// \param[out] line_entry_ptr
   ///     A pointer to a line entry object that will get a copy of
   ///     the line entry if \b true is returned, otherwise \a
   ///     line_entry is left untouched.
   ///
   /// \return
   ///     Returns \b true if a matching line entry is found in this
   ///     line table, \b false otherwise.
   ///
   /// \see CompileUnit::GetSupportFiles()
   /// \see FileSpecList::FindFileIndex (uint32_t, const FileSpec &) const
-  uint32_t FindLineEntryIndexByFileIndex(uint32_t start_idx, uint32_t file_idx,
-                                         uint32_t line, bool exact,
-                                         LineEntry *line_entry_ptr);
+  uint32_t
+  FindLineEntryIndexByFileIndex(uint32_t start_idx, uint32_t file_idx,
+                                const SourceLocationSpec &src_location_spec,
 
   uint32_t FindLineEntryIndexByFileIndex(
       uint32_t start_idx, const std::vector<uint32_t> &file_indexes,
-      uint32_t line, bool exact, LineEntry *line_entry_ptr);
+      const SourceLocationSpec &src_location_spec, LineEntry *line_entry_ptr);
 
   size_t FineLineEntriesForFileIndex(uint32_t file_idx, bool append,
                                      SymbolContextList &sc_list);
 
   /// Get the line entry from the line table at index \a idx.
   ///
   /// \param[in] idx
   ///     An index into the line table entry collection.

lldb/include/lldb/Symbol/SymbolFile.h

 //===-- SymbolFile.h --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SYMBOL_SYMBOLFILE_H
 #define LLDB_SYMBOL_SYMBOLFILE_H
 
 #include "lldb/Core/PluginInterface.h"
+#include "lldb/Core/SourceLocationSpec.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/SourceModule.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/TypeSystem.h"
virtual CompilerDeclContext GetDeclContextForUID(lldb::user_id_t uid) {
     return CompilerDeclContext();
   }
   virtual CompilerDeclContext GetDeclContextContainingUID(lldb::user_id_t uid) {
     return CompilerDeclContext();
   }
   virtual uint32_t ResolveSymbolContext(const Address &so_addr,
                                         lldb::SymbolContextItem resolve_scope,
                                         SymbolContext &sc) = 0;
-  virtual uint32_t ResolveSymbolContext(const FileSpec &file_spec,
-                                        uint32_t line, bool check_inlines,
-                                        lldb::SymbolContextItem resolve_scope,
-                                        SymbolContextList &sc_list);
+  virtual uint32_t
+  ResolveSymbolContext(const SourceLocationSpec &src_location_spec,
 
   virtual void DumpClangAST(Stream &s) {}
   virtual void FindGlobalVariables(ConstString name,
                                    const CompilerDeclContext &parent_decl_ctx,
                                    uint32_t max_matches,
                                    VariableList &variables);
   virtual void FindGlobalVariables(const RegularExpression &regex,
                                    uint32_t max_matches,

lldb/source/API/SBThread.cpp

 //===-- SBThread.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBThread.h"
 #include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBProcess.h"
if (exe_ctx.HasThreadScope()) {
     // appropriate error message.
 
     bool all_in_function = true;
     AddressRange fun_range = frame_sc.function->GetAddressRange();
 
     std::vector<addr_t> step_over_until_addrs;
     const bool abort_other_plans = false;
     const bool stop_other_threads = false;
-    const bool check_inlines = true;
-    const bool exact = false;
+    // TODO: Handle SourceLocationSpec column information
+    SourceLocationSpec location_spec(
+        step_file_spec, line, /*column=*/llvm::None, /*check_inlines=*/true,
+        /*exact_match=*/false);
 
     SymbolContextList sc_list;
-    frame_sc.comp_unit->ResolveSymbolContext(step_file_spec, line,
-                                             check_inlines, exact,
+    frame_sc.comp_unit->ResolveSymbolContext(location_spec,
                                              eSymbolContextLineEntry, sc_list);
     const uint32_t num_matches = sc_list.GetSize();
     if (num_matches > 0) {
       SymbolContext sc;
       for (uint32_t i = 0; i < num_matches; ++i) {
         if (sc_list.GetContextAtIndex(i, sc)) {
           addr_t step_addr =
               sc.line_entry.range.GetBaseAddress().GetLoadAddress(target);
           if (step_addr != LLDB_INVALID_ADDRESS) {
             if (fun_range.ContainsLoadAddress(step_addr, target))
               step_over_until_addrs.push_back(step_addr);
             else
               all_in_function = false;

lldb/source/Breakpoint/Breakpoint.cpp

 //===-- Breakpoint.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/Casting.h"
 
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/BreakpointLocationCollection.h"
 #include "lldb/Breakpoint/BreakpointPrecondition.h"
 #include "lldb/Breakpoint/BreakpointResolver.h"
 #include "lldb/Breakpoint/BreakpointResolverFileLine.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
bool Breakpoint::GetMatchingFileLine(ConstString filename,
   // TODO: To be correct, this method needs to fill the breakpoint location
   // collection
   //       with the location IDs which match the filename and line_number.
   //
 
   if (m_resolver_sp) {
     BreakpointResolverFileLine *resolverFileLine =
         dyn_cast<BreakpointResolverFileLine>(m_resolver_sp.get());
+
+    // TODO: Handle SourceLocationSpec column information
     if (resolverFileLine &&
-        resolverFileLine->m_file_spec.GetFilename() == filename &&
-        resolverFileLine->m_line_number == line_number) {
+        resolverFileLine->m_location_spec.GetFileSpec().GetFilename() ==
+            filename &&
+        resolverFileLine->m_location_spec.GetLine() == line_number) {
       return true;
     }
   }
   return false;
 }
 
 void Breakpoint::GetFilterDescription(Stream *s) {
   m_filter_sp->GetDescription(s);

lldb/source/Breakpoint/BreakpointResolver.cpp

 //===-- BreakpointResolver.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Breakpoint/BreakpointResolver.h"
 
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 // Have to include the other breakpoint resolver types here so the static
 // create from StructuredData can call them.
 #include "lldb/Breakpoint/BreakpointResolverAddress.h"
 #include "lldb/Breakpoint/BreakpointResolverFileLine.h"
 #include "lldb/Breakpoint/BreakpointResolverFileRegex.h"

 
 void BreakpointResolver::ResolveBreakpoint(SearchFilter &filter) {
   filter.Search(*this);
 }
 
 namespace {
 struct SourceLoc {
   uint32_t line = UINT32_MAX;
-  uint32_t column;
-  SourceLoc(uint32_t l, uint32_t c) : line(l), column(c ? c : UINT32_MAX) {}
+  uint16_t column;
+  SourceLoc(uint32_t l, llvm::Optional<uint16_t> c)
+      : line(l), column(c ? *c : LLDB_INVALID_COLUMN_NUMBER) {}
   SourceLoc(const SymbolContext &sc)
       : line(sc.line_entry.line),
-        column(sc.line_entry.column ? sc.line_entry.column : UINT32_MAX) {}
+        column(sc.line_entry.column ? sc.line_entry.column
+                                    : LLDB_INVALID_COLUMN_NUMBER) {}
 };
 
-bool operator<(const SourceLoc a, const SourceLoc b) {
-  if (a.line < b.line)
+bool operator<(const SourceLoc lhs, const SourceLoc rhs) {
+  if (lhs.line < rhs.line)
     return true;
-  if (a.line > b.line)
+  if (lhs.line > rhs.line)
     return false;
-  uint32_t a_col = a.column ? a.column : UINT32_MAX;
-  uint32_t b_col = b.column ? b.column : UINT32_MAX;
-  return a_col < b_col;
+  //  uint32_t a_col = lhs.column ? lhs.column : LLDB_INVALID_COLUMN_NUMBER;
+  //  uint32_t b_col = rhs.column ? rhs.column : LLDB_INVALID_COLUMN_NUMBER;
+  return lhs.column < rhs.column;
 }
 } // namespace
 
-void BreakpointResolver::SetSCMatchesByLine(SearchFilter &filter,
-                                            SymbolContextList &sc_list,
-                                            bool skip_prologue,
-                                            llvm::StringRef log_ident,
-                                            uint32_t line, uint32_t column) {
+void BreakpointResolver::SetSCMatchesByLine(
+    SearchFilter &filter, SymbolContextList &sc_list, bool skip_prologue,
+    llvm::StringRef log_ident, uint32_t line, llvm::Optional<uint16_t> column) {
   llvm::SmallVector<SymbolContext, 16> all_scs;
   for (uint32_t i = 0; i < sc_list.GetSize(); ++i)
     all_scs.push_back(sc_list[i]);
 
   while (all_scs.size()) {
     uint32_t closest_line = UINT32_MAX;
 
     // Move all the elements with a matching file spec to the end.
while (all_scs.size()) {
 
     // (worklist_begin, worklist_end) now contains all entries for one filespec.
     auto worklist_end = all_scs.end();
 
     if (column) {
       // If a column was requested, do a more precise match and only
       // return the first location that comes after or at the
       // requested location.
-      SourceLoc requested(line, column);
+      SourceLoc requested(line, *column);
       // First, filter out all entries left of the requested column.
       worklist_end = std::remove_if(
           worklist_begin, worklist_end,
           [&](const SymbolContext &sc) { return SourceLoc(sc) < requested; });
       // Sort the remaining entries by (line, column).
       llvm::sort(worklist_begin, worklist_end,
                  [](const SymbolContext &a, const SymbolContext &b) {
                    return SourceLoc(a) < SourceLoc(b);

lldb/source/Breakpoint/BreakpointResolverFileLine.cpp

 //===-- BreakpointResolverFileLine.cpp ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Breakpoint/BreakpointResolverFileLine.h"
 
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // BreakpointResolverFileLine:
 BreakpointResolverFileLine::BreakpointResolverFileLine(
-    const BreakpointSP &bkpt, const FileSpec &file_spec, uint32_t line_no,
-    uint32_t column, lldb::addr_t offset, bool check_inlines,
-    bool skip_prologue, bool exact_match)
+    const BreakpointSP &bkpt, lldb::addr_t offset, bool skip_prologue,
+    const SourceLocationSpec &location_spec)
     : BreakpointResolver(bkpt, BreakpointResolver::FileLineResolver, offset),
-      m_file_spec(file_spec), m_line_number(line_no), m_column(column),
-      m_inlines(check_inlines), m_skip_prologue(skip_prologue),
-      m_exact_match(exact_match) {}
+      m_location_spec(location_spec), m_skip_prologue(skip_prologue) {}
 
 BreakpointResolver *BreakpointResolverFileLine::CreateFromStructuredData(
     const BreakpointSP &bkpt, const StructuredData::Dictionary &options_dict,
     Status &error) {
   llvm::StringRef filename;
-  uint32_t line_no;
-  uint32_t column;
+  uint32_t line;
+  uint16_t column;
   bool check_inlines;
   bool skip_prologue;
   bool exact_match;
   bool success;
 
   lldb::addr_t offset = 0;
 
   success = options_dict.GetValueForKeyAsString(GetKey(OptionNames::FileName),
                                                 filename);
   if (!success) {
     error.SetErrorString("BRFL::CFSD: Couldn't find filename entry.");
     return nullptr;
   }
 
   success = options_dict.GetValueForKeyAsInteger(
-      GetKey(OptionNames::LineNumber), line_no);
+      GetKey(OptionNames::LineNumber), line);
   if (!success) {
     error.SetErrorString("BRFL::CFSD: Couldn't find line number entry.");
     return nullptr;
   }
 
   success =
       options_dict.GetValueForKeyAsInteger(GetKey(OptionNames::Column), column);
   if (!success) {
BreakpointResolver *BreakpointResolverFileLine::CreateFromStructuredData(
 
   success = options_dict.GetValueForKeyAsBoolean(
       GetKey(OptionNames::ExactMatch), exact_match);
   if (!success) {
     error.SetErrorString("BRFL::CFSD: Couldn't find exact match entry.");
     return nullptr;
   }
 
-  FileSpec file_spec(filename);
+  SourceLocationSpec location_spec(FileSpec(filename), line, column,
+                                   check_inlines, exact_match);
+  if (!location_spec)
+    return nullptr;
 
-  return new BreakpointResolverFileLine(bkpt, file_spec, line_no, column,
-                                        offset, check_inlines, skip_prologue,
-                                        exact_match);
+  return new BreakpointResolverFileLine(bkpt, offset, skip_prologue,
+                                        location_spec);
 }
 
 StructuredData::ObjectSP
 BreakpointResolverFileLine::SerializeToStructuredData() {
   StructuredData::DictionarySP options_dict_sp(
       new StructuredData::Dictionary());
 
-  options_dict_sp->AddStringItem(GetKey(OptionNames::FileName),
-                                 m_file_spec.GetPath());
-  options_dict_sp->AddIntegerItem(GetKey(OptionNames::LineNumber),
-                                  m_line_number);
-  options_dict_sp->AddIntegerItem(GetKey(OptionNames::Column),
-                                  m_column);
-  options_dict_sp->AddBooleanItem(GetKey(OptionNames::Inlines), m_inlines);
   options_dict_sp->AddBooleanItem(GetKey(OptionNames::SkipPrologue),
                                   m_skip_prologue);
+  options_dict_sp->AddStringItem(GetKey(OptionNames::FileName),
+                                 m_location_spec.GetFileSpec().GetPath());
+  options_dict_sp->AddIntegerItem(GetKey(OptionNames::LineNumber),
+                                  m_location_spec.GetLine().getValueOr(0));
+  options_dict_sp->AddIntegerItem(
+      GetKey(OptionNames::Column),
+      m_location_spec.GetColumn().getValueOr(LLDB_INVALID_COLUMN_NUMBER));
+  options_dict_sp->AddBooleanItem(GetKey(OptionNames::Inlines),
+                                  m_location_spec.GetCheckInlines());
   options_dict_sp->AddBooleanItem(GetKey(OptionNames::ExactMatch),
-                                  m_exact_match);
+                                  m_location_spec.GetExactMatch());
 
   return WrapOptionsDict(options_dict_sp);
 }
 
 // Filter the symbol context list to remove contexts where the line number was
 // moved into a new function. We do this conservatively, so if e.g. we cannot
 // resolve the function in the context (which can happen in case of line-table-
 // only debug info), we leave the context as is. The trickiest part here is
 // handling inlined functions -- in this case we need to make sure we look at
 // the declaration line of the inlined function, NOT the function it was
 // inlined into.
 void BreakpointResolverFileLine::FilterContexts(SymbolContextList &sc_list,
                                                 bool is_relative) {
-  if (m_exact_match)
+  if (m_location_spec.GetExactMatch())
     return; // Nothing to do. Contexts are precise.
 
   llvm::StringRef relative_path;
   if (is_relative)
-    relative_path = m_file_spec.GetDirectory().GetStringRef();
+    relative_path = m_location_spec.GetFileSpec().GetDirectory().GetStringRef();
 
   Log * log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS);
   for(uint32_t i = 0; i < sc_list.GetSize(); ++i) {
     SymbolContext sc;
     sc_list.GetContextAtIndex(i, sc);
     if (is_relative) {
       // If the path was relative, make sure any matches match as long as the
       // relative parts of the path match the path from support files
for(uint32_t i = 0; i < sc_list.GetSize(); ++i) {
     // One complication, if the line number returned from GetStartLineSourceInfo
     // is 0, then we can't do this calculation.  That can happen if
     // GetStartLineSourceInfo gets an error, or if the first line number in
     // the function really is 0 - which happens for some languages.
     
     // But only do this calculation if the line number we found in the SC
     // was different from the one requested in the source file.  If we actually
     // found an exact match it must be valid.
-    
-    if (m_line_number == sc.line_entry.line)
+    if (m_location_spec.GetLine() == sc.line_entry.line)
       continue;
 
     const int decl_line_is_too_late_fudge = 1;
-    if (line && m_line_number < line - decl_line_is_too_late_fudge) {
+    if (line &&
+        m_location_spec.GetLine() < line - decl_line_is_too_late_fudge) {
       LLDB_LOG(log, "removing symbol context at {0}:{1}", file, line);
       sc_list.RemoveContextAtIndex(i);
       --i;
     }
   }
 }
 
 Searcher::CallbackReturn BreakpointResolverFileLine::SearchCallback(
Searcher::CallbackReturn BreakpointResolverFileLine::SearchCallback(
   // number match, and only set breakpoints on that match.
 
   // Note also that if file_spec only had a file name and not a directory,
   // there may be many different file spec's in the resultant list.  The
   // closest line match for one will not be right for some totally different
   // file.  So we go through the match list and pull out the sets that have the
   // same file spec in their line_entry and treat each set separately.
 
-  FileSpec search_file_spec = m_file_spec;
-  const bool is_relative = m_file_spec.IsRelative();
+  const uint32_t line = m_location_spec.GetLine().getValueOr(0);
+  const uint16_t column =
+      m_location_spec.GetColumn().getValueOr(LLDB_INVALID_COLUMN_NUMBER);
+
+  FileSpec search_file_spec = m_location_spec.GetFileSpec();
+  const bool is_relative = search_file_spec.IsRelative();
   if (is_relative)
     search_file_spec.GetDirectory().Clear();
 
   const size_t num_comp_units = context.module_sp->GetNumCompileUnits();
   for (size_t i = 0; i < num_comp_units; i++) {
     CompUnitSP cu_sp(context.module_sp->GetCompileUnitAtIndex(i));
     if (cu_sp) {
       if (filter.CompUnitPasses(*cu_sp))
-        cu_sp->ResolveSymbolContext(search_file_spec, m_line_number, m_inlines,
-                                    m_exact_match, eSymbolContextEverything,
+        cu_sp->ResolveSymbolContext(m_location_spec, eSymbolContextEverything,
                                     sc_list);
     }
   }
 
   FilterContexts(sc_list, is_relative);
 
   StreamString s;
-  s.Printf("for %s:%d ", m_file_spec.GetFilename().AsCString("<Unknown>"),
-           m_line_number);
+  s.Printf("for %s:%d ",
+           m_location_spec.GetFileSpec().GetFilename().AsCString("<Unknown>"),
+           line);
 
-  SetSCMatchesByLine(filter, sc_list, m_skip_prologue, s.GetString(),
-                     m_line_number, m_column);
+  SetSCMatchesByLine(filter, sc_list, m_skip_prologue, s.GetString(), line,
+                     column);
 
   return Searcher::eCallbackReturnContinue;
 }
 
 lldb::SearchDepth BreakpointResolverFileLine::GetDepth() {
   return lldb::eSearchDepthModule;
 }
 
 void BreakpointResolverFileLine::GetDescription(Stream *s) {
-  s->Printf("file = '%s', line = %u, ", m_file_spec.GetPath().c_str(),
-            m_line_number);
-  if (m_column)
-    s->Printf("column = %u, ", m_column);
-  s->Printf("exact_match = %d", m_exact_match);
+  s->Printf("file = '%s', line = %u, ",
+            m_location_spec.GetFileSpec().GetPath().c_str(),
+            m_location_spec.GetLine().getValueOr(0));
+  auto column = m_location_spec.GetColumn();
+  if (column)
+    s->Printf("column = %u, ", *column);
+  s->Printf("exact_match = %d", m_location_spec.GetExactMatch());
 }
 
 void BreakpointResolverFileLine::Dump(Stream *s) const {}
 
 lldb::BreakpointResolverSP
 BreakpointResolverFileLine::CopyForBreakpoint(BreakpointSP &breakpoint) {
   lldb::BreakpointResolverSP ret_sp(new BreakpointResolverFileLine(
-      breakpoint, m_file_spec, m_line_number, m_column, GetOffset(), m_inlines,
-      m_skip_prologue, m_exact_match));
+      breakpoint, GetOffset(), m_skip_prologue, m_location_spec));
 
   return ret_sp;
 }

lldb/source/Breakpoint/BreakpointResolverFileRegex.cpp

 //===-- BreakpointResolverFileRegex.cpp -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Breakpoint/BreakpointResolverFileRegex.h"
 
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/SourceManager.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
Searcher::CallbackReturn BreakpointResolverFileRegex::SearchCallback(
   FileSpec cu_file_spec = cu->GetPrimaryFile();
   std::vector<uint32_t> line_matches;
   context.target_sp->GetSourceManager().FindLinesMatchingRegex(
       cu_file_spec, m_regex, 1, UINT32_MAX, line_matches);
 
   uint32_t num_matches = line_matches.size();
   for (uint32_t i = 0; i < num_matches; i++) {
     SymbolContextList sc_list;
-    const bool search_inlines = false;
-
-    cu->ResolveSymbolContext(cu_file_spec, line_matches[i], search_inlines,
-                             m_exact_match, eSymbolContextEverything, sc_list);
+    // TODO: Handle SourceLocationSpec column information
+    SourceLocationSpec location_spec(cu_file_spec, line_matches[i],
+                                     /*column=*/llvm::None,
+                                     /*search_inlines=*/false, m_exact_match);
+    cu->ResolveSymbolContext(location_spec, eSymbolContextEverything, sc_list);
     // Find all the function names:
     if (!m_function_names.empty()) {
       std::vector<size_t> sc_to_remove;
       for (size_t i = 0; i < sc_list.GetSize(); i++) {
         SymbolContext sc_ctx;
         sc_list.GetContextAtIndex(i, sc_ctx);
         std::string name(
             sc_ctx

lldb/source/Core/AddressResolverFileLine.cpp

 //===-- AddressResolverFileLine.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/AddressResolverFileLine.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineEntry.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Logging.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-types.h"
 
 #include <inttypes.h>
 #include <vector>
 
 using namespace lldb;
 using namespace lldb_private;
 
 // AddressResolverFileLine:
-AddressResolverFileLine::AddressResolverFileLine(const FileSpec &file_spec,
-                                                 uint32_t line_no,
-                                                 bool check_inlines)
-    : AddressResolver(), m_file_spec(file_spec), m_line_number(line_no),
-      m_inlines(check_inlines) {}
+AddressResolverFileLine::AddressResolverFileLine(
+    SourceLocationSpec location_spec)
+    : AddressResolver(), m_src_location_spec(location_spec) {}
 
 AddressResolverFileLine::~AddressResolverFileLine() {}
 
 Searcher::CallbackReturn
 AddressResolverFileLine::SearchCallback(SearchFilter &filter,
                                         SymbolContext &context, Address *addr) {
   SymbolContextList sc_list;
   CompileUnit *cu = context.comp_unit;
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
 
-  cu->ResolveSymbolContext(m_file_spec, m_line_number, m_inlines, false,
-                           eSymbolContextEverything, sc_list);
+  // TODO: Handle SourceLocationSpec column information
+  cu->ResolveSymbolContext(m_src_location_spec, eSymbolContextEverything,
+                           sc_list);
   uint32_t sc_list_size = sc_list.GetSize();
   for (uint32_t i = 0; i < sc_list_size; i++) {
     SymbolContext sc;
     if (sc_list.GetContextAtIndex(i, sc)) {
       Address line_start = sc.line_entry.range.GetBaseAddress();
       addr_t byte_size = sc.line_entry.range.GetByteSize();
       if (line_start.IsValid()) {
         AddressRange new_range(line_start, byte_size);
         m_address_ranges.push_back(new_range);
-        if (log) {
-          StreamString s;
-          // new_bp_loc->GetDescription (&s, lldb::eDescriptionLevelVerbose);
-          // LLDB_LOGF(log, "Added address: %s\n", s.GetData());
-        }
       } else {
         LLDB_LOGF(log,
                   "error: Unable to resolve address at file address 0x%" PRIx64
                   " for %s:%d\n",
                   line_start.GetFileAddress(),
-                  m_file_spec.GetFilename().AsCString("<Unknown>"),
-                  m_line_number);
+                  m_src_location_spec.GetFileSpec().GetFilename().AsCString(
+                      "<Unknown>"),
+                  m_src_location_spec.GetLine().getValueOr(0));
       }
     }
   }
   return Searcher::eCallbackReturnContinue;
 }
 
 lldb::SearchDepth AddressResolverFileLine::GetDepth() {
   return lldb::eSearchDepthCompUnit;
 }
 
 void AddressResolverFileLine::GetDescription(Stream *s) {
-  s->Printf("File and line address - file: \"%s\" line: %u",
-            m_file_spec.GetFilename().AsCString("<Unknown>"), m_line_number);
+  s->Printf(
+      "File and line address - file: \"%s\" line: %u",
+      m_src_location_spec.GetFileSpec().GetFilename().AsCString("<Unknown>"),
+      m_src_location_spec.GetLine().getValueOr(0));
 }

lldb/source/Core/Module.cpp

 //===-- Module.cpp --------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/Module.h"
 
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/AddressResolverFileLine.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/Mangled.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/SearchFilter.h"
uint32_t Module::ResolveSymbolContextsForFileSpec(
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   LLDB_SCOPED_TIMERF("Module::ResolveSymbolContextForFilePath (%s:%u, "
                      "check_inlines = %s, resolve_scope = 0x%8.8x)",
                      file_spec.GetPath().c_str(), line,
                      check_inlines ? "yes" : "no", resolve_scope);
 
   const uint32_t initial_count = sc_list.GetSize();
 
-  if (SymbolFile *symbols = GetSymbolFile())
-    symbols->ResolveSymbolContext(file_spec, line, check_inlines, resolve_scope,
-                                  sc_list);
+  if (SymbolFile *symbols = GetSymbolFile()) {
+    // TODO: Handle SourceLocationSpec column information
+    SourceLocationSpec location_spec(file_spec, line, /*column=*/llvm::None,
+                                     check_inlines, /*exact_match=*/false);
+
+    symbols->ResolveSymbolContext(location_spec, resolve_scope, sc_list);
+  }
 
   return sc_list.GetSize() - initial_count;
 }
 
 void Module::FindGlobalVariables(ConstString name,
                                  const CompilerDeclContext &parent_decl_ctx,
                                  size_t max_matches, VariableList &variables) {
   if (SymbolFile *symbols = GetSymbolFile())
     symbols->FindGlobalVariables(name, parent_decl_ctx, max_matches, variables);
 }

 }
 
 void Module::FindAddressesForLine(const lldb::TargetSP target_sp,
                                   const FileSpec &file, uint32_t line,
                                   Function *function,
                                   std::vector<Address> &output_local,
                                   std::vector<Address> &output_extern) {
   SearchFilterByModule filter(target_sp, m_file);
-  AddressResolverFileLine resolver(file, line, true);
+
+  // TODO: Handle SourceLocationSpec column information
+  SourceLocationSpec location_spec(file, line, /*column=*/llvm::None,
+                                   /*check_inlines=*/true,
+                                   /*exact_match=*/false);
+  AddressResolverFileLine resolver(location_spec);
   resolver.ResolveAddress(filter);
 
   for (size_t n = 0; n < resolver.GetNumberOfAddresses(); n++) {
     Address addr = resolver.GetAddressRangeAtIndex(n).GetBaseAddress();
     Function *f = addr.CalculateSymbolContextFunction();
     if (f && f == function)
       output_local.push_back(addr);
     else
       output_extern.push_back(addr);
   }
 }
 

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h

 //===-- SymbolFileBreakpad.h ------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_BREAKPAD_SYMBOLFILEBREAKPAD_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_BREAKPAD_SYMBOLFILEBREAKPAD_H
 
 #include "Plugins/ObjectFile/Breakpad/BreakpadRecords.h"
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/PostfixExpression.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/UnwindPlan.h"
 
 namespace lldb_private {
 
llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
     return llvm::None;
   }
 
   bool CompleteType(CompilerType &compiler_type) override { return false; }
   uint32_t ResolveSymbolContext(const Address &so_addr,
                                 lldb::SymbolContextItem resolve_scope,
                                 SymbolContext &sc) override;
 
-  uint32_t ResolveSymbolContext(const FileSpec &file_spec, uint32_t line,
-                                bool check_inlines,
+  uint32_t ResolveSymbolContext(const SourceLocationSpec &src_location_spec,
                                 lldb::SymbolContextItem resolve_scope,
                                 SymbolContextList &sc_list) override;
 
   void GetTypes(SymbolContextScope *sc_scope, lldb::TypeClass type_mask,
                 TypeList &type_list) override {}
 
   void FindFunctions(ConstString name,
                      const CompilerDeclContext &parent_decl_ctx,

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp

 //===-- SymbolFileBreakpad.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h"
 #include "Plugins/ObjectFile/Breakpad/BreakpadRecords.h"
 #include "Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/ObjectFile.h"
if (sc.comp_unit->GetLineTable()->FindLineEntryByAddress(so_addr,
       result |= eSymbolContextLineEntry;
     }
   }
 
   return result;
 }
 
 uint32_t SymbolFileBreakpad::ResolveSymbolContext(
-    const FileSpec &file_spec, uint32_t line, bool check_inlines,
+    const SourceLocationSpec &src_location_spec,
     lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (!(resolve_scope & eSymbolContextCompUnit))
     return 0;
 
   uint32_t old_size = sc_list.GetSize();
   for (size_t i = 0, size = GetNumCompileUnits(); i < size; ++i) {
     CompileUnit &cu = *GetCompileUnitAtIndex(i);
-    cu.ResolveSymbolContext(file_spec, line, check_inlines,
-                            /*exact*/ false, resolve_scope, sc_list);
+    cu.ResolveSymbolContext(src_location_spec, resolve_scope, sc_list);
   }
   return sc_list.GetSize() - old_size;
 }
 
 void SymbolFileBreakpad::FindFunctions(
     ConstString name, const CompilerDeclContext &parent_decl_ctx,
     FunctionNameType name_type_mask, bool include_inlines,
     SymbolContextList &sc_list) {
void SymbolFileBreakpad::ParseLineTableAndSupportFiles(CompileUnit &cu,
 
   SupportFileMap map;
   std::vector<std::unique_ptr<LineSequence>> sequences;
   std::unique_ptr<LineSequence> line_seq_up =
       LineTable::CreateLineSequenceContainer();
   llvm::Optional<addr_t> next_addr;
   auto finish_sequence = [&]() {
     LineTable::AppendLineEntryToSequence(
-        line_seq_up.get(), *next_addr, /*line*/ 0, /*column*/ 0,
-        /*file_idx*/ 0, /*is_start_of_statement*/ false,
-        /*is_start_of_basic_block*/ false, /*is_prologue_end*/ false,
-        /*is_epilogue_begin*/ false, /*is_terminal_entry*/ true);
+        line_seq_up.get(), *next_addr, /*line=*/0, /*column=*/0,
+        /*file_idx=*/0, /*is_start_of_statement=*/false,
+        /*is_start_of_basic_block=*/false, /*is_prologue_end=*/false,
+        /*is_epilogue_begin=*/false, /*is_terminal_entry=*/true);
     sequences.push_back(std::move(line_seq_up));
     line_seq_up = LineTable::CreateLineSequenceContainer();
   };
 
   LineIterator It(*m_objfile_sp, Record::Func, data.bookmark),
       End(*m_objfile_sp);
   assert(Record::classify(*It) == Record::Func);
   for (++It; It != End; ++It) {
     auto record = LineRecord::parse(*It);
     if (!record)
       break;
 
     record->Address += base;
 
     if (next_addr && *next_addr != record->Address) {
       // Discontiguous entries. Finish off the previous sequence and reset.
       finish_sequence();
     }
     LineTable::AppendLineEntryToSequence(
-        line_seq_up.get(), record->Address, record->LineNum, /*column*/ 0,
-        map[record->FileNum], /*is_start_of_statement*/ true,
-        /*is_start_of_basic_block*/ false, /*is_prologue_end*/ false,
-        /*is_epilogue_begin*/ false, /*is_terminal_entry*/ false);
+        line_seq_up.get(), record->Address, record->LineNum, /*column=*/0,
+        map[record->FileNum], /*is_start_of_statement=*/true,
+        /*is_start_of_basic_block=*/false, /*is_prologue_end=*/false,
+        /*is_epilogue_begin=*/false, /*is_terminal_entry=*/false);
     next_addr = record->Address + record->Size;
   }
   if (next_addr)
     finish_sequence();
   data.line_table_up = std::make_unique<LineTable>(&cu, std::move(sequences));
   data.support_files = map.translate(cu.GetPrimaryFile(), *m_files);
 }
 

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

 #include <mutex>
 #include <unordered_map>
 #include <vector>
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Support/Threading.h"
 
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/Core/dwarf.h"
 #include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Flags.h"
 #include "lldb/Utility/RangeMap.h"
 #include "lldb/lldb-private.h"
public:
 
   void
   ParseDeclsForContext(lldb_private::CompilerDeclContext decl_ctx) override;
 
   uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,
                                 lldb::SymbolContextItem resolve_scope,
                                 lldb_private::SymbolContext &sc) override;
 
-  uint32_t
-  ResolveSymbolContext(const lldb_private::FileSpec &file_spec, uint32_t line,
-                       bool check_inlines,
-                       lldb::SymbolContextItem resolve_scope,
-                       lldb_private::SymbolContextList &sc_list) override;
+  uint32_t ResolveSymbolContext(
+      const lldb_private::SourceLocationSpec &src_location_spec,
 
   void
   FindGlobalVariables(lldb_private::ConstString name,
                       const lldb_private::CompilerDeclContext &parent_decl_ctx,
                       uint32_t max_matches,
                       lldb_private::VariableList &variables) override;
 
   void FindGlobalVariables(const lldb_private::RegularExpression &regex,

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (cu_offset == DW_INVALID_OFFSET) {
               cu_offset, cu_idx);
         }
       }
     }
   }
   return resolved;
 }
 
-uint32_t SymbolFileDWARF::ResolveSymbolContext(const FileSpec &file_spec,
-                                               uint32_t line,
-                                               bool check_inlines,
-                                               SymbolContextItem resolve_scope,
-                                               SymbolContextList &sc_list) {
+uint32_t SymbolFileDWARF::ResolveSymbolContext(
+    const SourceLocationSpec &src_location_spec,
+    SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
+  const bool check_inlines = src_location_spec.GetCheckInlines();
   const uint32_t prev_size = sc_list.GetSize();
   if (resolve_scope & eSymbolContextCompUnit) {
     for (uint32_t cu_idx = 0, num_cus = GetNumCompileUnits(); cu_idx < num_cus;
          ++cu_idx) {
       CompileUnit *dc_cu = ParseCompileUnitAtIndex(cu_idx).get();
       if (!dc_cu)
         continue;
 
-      bool file_spec_matches_cu_file_spec =
-          FileSpec::Match(file_spec, dc_cu->GetPrimaryFile());
+      bool file_spec_matches_cu_file_spec = FileSpec::Match(
+          src_location_spec.GetFileSpec(), dc_cu->GetPrimaryFile());
       if (check_inlines || file_spec_matches_cu_file_spec) {
-        dc_cu->ResolveSymbolContext(file_spec, line, check_inlines, false,
-                                    resolve_scope, sc_list);
+        dc_cu->ResolveSymbolContext(src_location_spec, resolve_scope, sc_list);
         if (!check_inlines)
           break;
       }
     }
   }
   return sc_list.GetSize() - prev_size;
 }
 

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

 //===-- SymbolFileDWARFDebugMap.h ------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_SYMBOLFILEDWARFDEBUGMAP_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_SYMBOLFILEDWARFDEBUGMAP_H
 
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Utility/RangeMap.h"
 #include "llvm/Support/Chrono.h"
 #include <bitset>
 #include <map>
 #include <vector>
 
 #include "UniqueDWARFASTType.h"
 
public:
   GetDeclContextContainingUID(lldb::user_id_t uid) override;
   void
   ParseDeclsForContext(lldb_private::CompilerDeclContext decl_ctx) override;
 
   bool CompleteType(lldb_private::CompilerType &compiler_type) override;
   uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,
                                 lldb::SymbolContextItem resolve_scope,
                                 lldb_private::SymbolContext &sc) override;
-  uint32_t
-  ResolveSymbolContext(const lldb_private::FileSpec &file_spec, uint32_t line,
-                       bool check_inlines,
-                       lldb::SymbolContextItem resolve_scope,
-                       lldb_private::SymbolContextList &sc_list) override;
+  uint32_t ResolveSymbolContext(
+      const lldb_private::SourceLocationSpec &src_location_spec,
   void
   FindGlobalVariables(lldb_private::ConstString name,
                       const lldb_private::CompilerDeclContext &parent_decl_ctx,
                       uint32_t max_matches,
                       lldb_private::VariableList &variables) override;
   void FindGlobalVariables(const lldb_private::RegularExpression &regex,
                            uint32_t max_matches,
                            lldb_private::VariableList &variables) override;

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

if (debug_map_entry) {
         }
       }
     }
   }
   return resolved_flags;
 }
 
 uint32_t SymbolFileDWARFDebugMap::ResolveSymbolContext(
-    const FileSpec &file_spec, uint32_t line, bool check_inlines,
+    const SourceLocationSpec &src_location_spec,
     SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   const uint32_t initial = sc_list.GetSize();
   const uint32_t cu_count = GetNumCompileUnits();
 
   for (uint32_t i = 0; i < cu_count; ++i) {
     // If we are checking for inlines, then we need to look through all compile
     // units no matter if "file_spec" matches.
-    bool resolve = check_inlines;
+    bool resolve = src_location_spec.GetCheckInlines();
 
     if (!resolve) {
       FileSpec so_file_spec;
       if (GetFileSpecForSO(i, so_file_spec))
-        resolve = FileSpec::Match(file_spec, so_file_spec);
+        resolve =
+            FileSpec::Match(src_location_spec.GetFileSpec(), so_file_spec);
     }
     if (resolve) {
       SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(i);
       if (oso_dwarf)
-        oso_dwarf->ResolveSymbolContext(file_spec, line, check_inlines,
-                                        resolve_scope, sc_list);
+        oso_dwarf->ResolveSymbolContext(src_location_spec, resolve_scope,
+                                        sc_list);
     }
   }
   return sc_list.GetSize() - initial;
 }
 
 void SymbolFileDWARFDebugMap::PrivateFindGlobalVariables(
     ConstString name, const CompilerDeclContext &parent_decl_ctx,
     const std::vector<uint32_t>

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

 //===-- SymbolFileNativePDB.h -----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_NATIVEPDB_SYMBOLFILENATIVEPDB_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_NATIVEPDB_SYMBOLFILENATIVEPDB_H
 
 #include "lldb/Symbol/SymbolFile.h"
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/PDB/PDBTypes.h"
 
 #include "CompileUnitIndex.h"
 #include "PdbIndex.h"
public:
   llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
       lldb::user_id_t type_uid,
       const lldb_private::ExecutionContext *exe_ctx) override;
 
   bool CompleteType(CompilerType &compiler_type) override;
   uint32_t ResolveSymbolContext(const Address &so_addr,
                                 lldb::SymbolContextItem resolve_scope,
                                 SymbolContext &sc) override;
-  uint32_t ResolveSymbolContext(const FileSpec &file_spec, uint32_t line,
-                                bool check_inlines,
+  uint32_t ResolveSymbolContext(const SourceLocationSpec &src_location_spec,
                                 lldb::SymbolContextItem resolve_scope,
                                 SymbolContextList &sc_list) override;
 
   void GetTypes(SymbolContextScope *sc_scope, lldb::TypeClass type_mask,
                 TypeList &type_list) override;
 
   void FindFunctions(ConstString name,
                      const CompilerDeclContext &parent_decl_ctx,

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

if (auto *line_table = sc.comp_unit->GetLineTable()) {
         resolved_flags |= eSymbolContextLineEntry;
     }
   }
 
   return resolved_flags;
 }
 
 uint32_t SymbolFileNativePDB::ResolveSymbolContext(
-    const FileSpec &file_spec, uint32_t line, bool check_inlines,
+    const SourceLocationSpec &src_location_spec,
     lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
   return 0;
 }
 
 static void AppendLineEntryToSequence(LineTable &table, LineSequence &sequence,
                                       const CompilandIndexItem &cci,
                                       lldb::addr_t base_addr,
                                       uint32_t file_number,

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

 //===-- SymbolFilePDB.h -------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_PDB_SYMBOLFILEPDB_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_PDB_SYMBOLFILEPDB_H
 
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Utility/UserID.h"
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/DebugInfo/PDB/IPDBSession.h"
 #include "llvm/DebugInfo/PDB/PDB.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
public:
 
   void
   ParseDeclsForContext(lldb_private::CompilerDeclContext decl_ctx) override;
 
   uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,
                                 lldb::SymbolContextItem resolve_scope,
                                 lldb_private::SymbolContext &sc) override;
 
-  uint32_t
-  ResolveSymbolContext(const lldb_private::FileSpec &file_spec, uint32_t line,
-                       bool check_inlines,
-                       lldb::SymbolContextItem resolve_scope,
-                       lldb_private::SymbolContextList &sc_list) override;
+  uint32_t ResolveSymbolContext(
+      const lldb_private::SourceLocationSpec &src_location_spec,
 
   void
   FindGlobalVariables(lldb_private::ConstString name,
                       const lldb_private::CompilerDeclContext &parent_decl_ctx,
                       uint32_t max_matches,
                       lldb_private::VariableList &variables) override;
 
   void FindGlobalVariables(const lldb_private::RegularExpression &regex,

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

if (auto *line_table = sc.comp_unit->GetLineTable()) {
         resolved_flags |= eSymbolContextLineEntry;
     }
   }
 
   return resolved_flags;
 }
 
 uint32_t SymbolFilePDB::ResolveSymbolContext(
-    const lldb_private::FileSpec &file_spec, uint32_t line, bool check_inlines,
+    const lldb_private::SourceLocationSpec &src_location_spec,
     SymbolContextItem resolve_scope, lldb_private::SymbolContextList &sc_list) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   const size_t old_size = sc_list.GetSize();
+  const FileSpec &file_spec = src_location_spec.GetFileSpec();
+  const uint32_t line = src_location_spec.GetLine().getValueOr(0);
   if (resolve_scope & lldb::eSymbolContextCompUnit) {
     // Locate all compilation units with line numbers referencing the specified
     // file.  For example, if `file_spec` is <vector>, then this should return
     // all source files and header files that reference <vector>, either
     // directly or indirectly.
     auto compilands = m_session_up->findCompilandsForSourceFile(
         file_spec.GetPath(), PDB_NameSearchFlags::NS_CaseInsensitive);
 
     if (!compilands)
       return 0;
 
     // For each one, either find its previously parsed data or parse it afresh
     // and add it to the symbol context list.
     while (auto compiland = compilands->getNext()) {
       // If we're not checking inlines, then don't add line information for
       // this file unless the FileSpec matches. For inline functions, we don't
       // have to match the FileSpec since they could be defined in headers
       // other than file specified in FileSpec.
-      if (!check_inlines) {
+      if (!src_location_spec.GetCheckInlines()) {
         std::string source_file = compiland->getSourceFileFullPath();
         if (source_file.empty())
           continue;
         FileSpec this_spec(source_file, FileSpec::Style::windows);
         bool need_full_match = !file_spec.GetDirectory().IsEmpty();
         if (FileSpec::Compare(file_spec, this_spec, need_full_match) != 0)
           continue;
       }

lldb/source/Symbol/CompileUnit.cpp

 //===-- CompileUnit.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Utility/Timer.h"
 
 using namespace lldb;
uint32_t CompileUnit::FindLineEntry(uint32_t start_idx, uint32_t line,
                                     const FileSpec *file_spec_ptr, bool exact,
                                     LineEntry *line_entry_ptr) {
   if (!file_spec_ptr)
     file_spec_ptr = &GetPrimaryFile();
   std::vector<uint32_t> file_indexes = FindFileIndexes(GetSupportFiles(), *file_spec_ptr);
   if (file_indexes.empty())
     return UINT32_MAX;
 
+  // TODO: Handle SourceLocationSpec column information
+  SourceLocationSpec location_spec(*file_spec_ptr, line, /*column=*/llvm::None,
+                                   /*check_inlines=*/false, exact);
+
   LineTable *line_table = GetLineTable();
   if (line_table)
     return line_table->FindLineEntryIndexByFileIndex(
-        start_idx, file_indexes, line, exact, line_entry_ptr);
+        start_idx, file_indexes, location_spec, line_entry_ptr);
   return UINT32_MAX;
 }
 
-void CompileUnit::ResolveSymbolContext(const FileSpec &file_spec,
-                                       uint32_t line, bool check_inlines,
-                                       bool exact,
-                                       SymbolContextItem resolve_scope,
-                                       SymbolContextList &sc_list) {
+void CompileUnit::ResolveSymbolContext(
+    const SourceLocationSpec &src_location_spec,
+    SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
+  const FileSpec file_spec = src_location_spec.GetFileSpec();
+  const uint32_t line = src_location_spec.GetLine().getValueOr(0);
+  const bool check_inlines = src_location_spec.GetCheckInlines();
+
   // First find all of the file indexes that match our "file_spec". If
   // "file_spec" has an empty directory, then only compare the basenames when
   // finding file indexes
   std::vector<uint32_t> file_indexes;
   bool file_spec_matches_cu_file_spec =
       FileSpec::Match(file_spec, this->GetPrimaryFile());
 
   // If we are not looking for inlined functions and our file spec doesn't
void CompileUnit::ResolveSymbolContext(
   uint32_t line_idx;
   LineEntry line_entry;
 
   if (num_file_indexes == 1) {
     // We only have a single support file that matches, so use the line
     // table function that searches for a line entries that match a single
     // support file index
     line_idx = line_table->FindLineEntryIndexByFileIndex(
-        0, file_indexes.front(), line, exact, &line_entry);
+        0, file_indexes.front(), src_location_spec, &line_entry);
   } else {
     // We found multiple support files that match "file_spec" so use the
     // line table function that searches for a line entries that match a
     // multiple support file indexes.
-    line_idx = line_table->FindLineEntryIndexByFileIndex(0, file_indexes, line,
-                                                         exact, &line_entry);
+    line_idx = line_table->FindLineEntryIndexByFileIndex(
+        0, file_indexes, src_location_spec, &line_entry);
   }
   
   // If "exact == true", then "found_line" will be the same as "line". If
   // "exact == false", the "found_line" will be the closest line entry
   // with a line number greater than "line" and we will use this for our
   // subsequent line exact matches below.
-  uint32_t found_line = line_entry.line;
-  
+  const bool inlines = false;
+  const bool exact = true;
+  SourceLocationSpec found_entry(line_entry.file, line_entry.line,
+                                 line_entry.column, inlines, exact);
   while (line_idx != UINT32_MAX) {
     // If they only asked for the line entry, then we're done, we can
     // just copy that over. But if they wanted more than just the line
     // number, fill it in.
     if (resolve_scope == eSymbolContextLineEntry) {
       sc.line_entry = line_entry;
     } else {
       line_entry.range.GetBaseAddress().CalculateSymbolContext(&sc,
                                                                resolve_scope);
     }
 
     sc_list.Append(sc);
     if (num_file_indexes == 1)
       line_idx = line_table->FindLineEntryIndexByFileIndex(
-          line_idx + 1, file_indexes.front(), found_line, true, &line_entry);
+          line_idx + 1, file_indexes.front(), found_entry, &line_entry);
     else
       line_idx = line_table->FindLineEntryIndexByFileIndex(
-          line_idx + 1, file_indexes, found_line, true, &line_entry);
+          line_idx + 1, file_indexes, found_entry, &line_entry);
   }
 }
 
 bool CompileUnit::GetIsOptimized() {
   if (m_is_optimized == eLazyBoolCalculate) {
     m_is_optimized = eLazyBoolNo;
     if (SymbolFile *symfile = GetModule()->GetSymbolFile()) {
       if (symfile->ParseIsOptimized(*this))

lldb/source/Symbol/LineTable.cpp

 //===-- LineTable.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Utility/Stream.h"
 #include <algorithm>
 
 using namespace lldb;
bool LineTable::ConvertEntryAtIndexToLineEntry(uint32_t idx,
   line_entry.is_prologue_end = entry.is_prologue_end;
   line_entry.is_epilogue_begin = entry.is_epilogue_begin;
   line_entry.is_terminal_entry = entry.is_terminal_entry;
   return true;
 }
 
 uint32_t LineTable::FindLineEntryIndexByFileIndex(
     uint32_t start_idx, const std::vector<uint32_t> &file_indexes,
-    uint32_t line, bool exact, LineEntry *line_entry_ptr) {
+    const SourceLocationSpec &src_location_spec, LineEntry *line_entry_ptr) {
 
   const size_t count = m_entries.size();
   size_t best_match = UINT32_MAX;
 
   for (size_t idx = start_idx; idx < count; ++idx) {
     // Skip line table rows that terminate the previous row (is_terminal_entry
     // is non-zero)
     if (m_entries[idx].is_terminal_entry)
       continue;
 
     if (!llvm::is_contained(file_indexes, m_entries[idx].file_idx))
       continue;
 
     // Exact match always wins.  Otherwise try to find the closest line > the
     // desired line.
     // FIXME: Maybe want to find the line closest before and the line closest
     // after and
     // if they're not in the same function, don't return a match.
 
+    uint32_t line = src_location_spec.GetLine().getValueOr(0);
+
     if (m_entries[idx].line < line) {
       continue;
     } else if (m_entries[idx].line == line) {
       if (line_entry_ptr)
         ConvertEntryAtIndexToLineEntry(idx, *line_entry_ptr);
       return idx;
-    } else if (!exact) {
+    } else if (!src_location_spec.GetExactMatch()) {
       if (best_match == UINT32_MAX)
         best_match = idx;
       else if (m_entries[idx].line < m_entries[best_match].line)
         best_match = idx;
     }
   }
 
   if (best_match != UINT32_MAX) {
     if (line_entry_ptr)
       ConvertEntryAtIndexToLineEntry(best_match, *line_entry_ptr);
     return best_match;
   }
   return UINT32_MAX;
 }
 
-uint32_t LineTable::FindLineEntryIndexByFileIndex(uint32_t start_idx,
-                                                  uint32_t file_idx,
-                                                  uint32_t line, bool exact,
-                                                  LineEntry *line_entry_ptr) {
+uint32_t LineTable::FindLineEntryIndexByFileIndex(
+    uint32_t start_idx, uint32_t file_idx,
+    const SourceLocationSpec &src_location_spec, LineEntry *line_entry_ptr) {
   const size_t count = m_entries.size();
   size_t best_match = UINT32_MAX;
 
   for (size_t idx = start_idx; idx < count; ++idx) {
     // Skip line table rows that terminate the previous row (is_terminal_entry
     // is non-zero)
     if (m_entries[idx].is_terminal_entry)
       continue;
 
     if (m_entries[idx].file_idx != file_idx)
       continue;
 
     // Exact match always wins.  Otherwise try to find the closest line > the
     // desired line.
     // FIXME: Maybe want to find the line closest before and the line closest
     // after and
     // if they're not in the same function, don't return a match.
 
+    uint32_t line = src_location_spec.GetLine().getValueOr(0);
+
     if (m_entries[idx].line < line) {
       continue;
     } else if (m_entries[idx].line == line) {
       if (line_entry_ptr)
         ConvertEntryAtIndexToLineEntry(idx, *line_entry_ptr);
       return idx;
-    } else if (!exact) {
+    } else if (!src_location_spec.GetExactMatch()) {
       if (best_match == UINT32_MAX)
         best_match = idx;
       else if (m_entries[idx].line < m_entries[best_match].line)
         best_match = idx;
     }
   }
 
   if (best_match != UINT32_MAX) {

lldb/source/Symbol/SymbolFile.cpp

 //===-- SymbolFile.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/SymbolFile.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/TypeMap.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Symbol/VariableList.h"
SymbolFile::GetTypeSystemForLanguage(lldb::LanguageType language) {
   auto type_system_or_err =
       m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
   if (type_system_or_err) {
     type_system_or_err->SetSymbolFile(this);
   }
   return type_system_or_err;
 }
 
-uint32_t SymbolFile::ResolveSymbolContext(const FileSpec &file_spec,
-                                          uint32_t line, bool check_inlines,
-                                          lldb::SymbolContextItem resolve_scope,
-                                          SymbolContextList &sc_list) {
+uint32_t
+SymbolFile::ResolveSymbolContext(const SourceLocationSpec &src_location_spec,
   return 0;
 }
 
 void SymbolFile::FindGlobalVariables(ConstString name,
                                      const CompilerDeclContext &parent_decl_ctx,
                                      uint32_t max_matches,
                                      VariableList &variables) {}
 

lldb/source/Target/Target.cpp

 //===-- Target.cpp --------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/Target.h"
 #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"
 #include "lldb/Breakpoint/BreakpointIDList.h"
 #include "lldb/Breakpoint/BreakpointPrecondition.h"
 #include "lldb/Breakpoint/BreakpointResolver.h"
 #include "lldb/Breakpoint/BreakpointResolverAddress.h"
 #include "lldb/Breakpoint/BreakpointResolverFileLine.h"
 #include "lldb/Breakpoint/BreakpointResolverFileRegex.h"
 #include "lldb/Breakpoint/BreakpointResolverName.h"
BreakpointSP Target::CreateBreakpoint(const FileSpecList *containingModules,
   } else {
     filter_sp = GetSearchFilterForModuleList(containingModules);
   }
   if (skip_prologue == eLazyBoolCalculate)
     skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
   if (move_to_nearest_code == eLazyBoolCalculate)
     move_to_nearest_code = GetMoveToNearestCode() ? eLazyBoolYes : eLazyBoolNo;
 
+  SourceLocationSpec location_spec(remapped_file, line_no, column,
+                                   check_inlines,
+                                   !static_cast<bool>(move_to_nearest_code));
+  if (!location_spec)
+    return nullptr;
+
   BreakpointResolverSP resolver_sp(new BreakpointResolverFileLine(
-      nullptr, remapped_file, line_no, column, offset, check_inlines,
-      skip_prologue, !static_cast<bool>(move_to_nearest_code)));
+      nullptr, offset, skip_prologue, location_spec));
   return CreateBreakpoint(filter_sp, resolver_sp, internal, hardware, true);
 }
 
 BreakpointSP Target::CreateBreakpoint(lldb::addr_t addr, bool internal,
                                       bool hardware) {
   Address so_addr;
 
   // Check for any reason we want to move this breakpoint to other address.

lldb/unittests/Symbol/TestLineEntry.cpp

 //===-- TestLineEntry.cpp -------------------------------------------------===//
 //
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
 #include <iostream>
 
 #include "Plugins/ObjectFile/Mach-O/ObjectFileMachO.h"
 #include "Plugins/SymbolFile/DWARF/DWARFASTParserClang.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/TestUtilities.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Host/FileSystem.h"

 void LineEntryTest::SetUp() {
   auto ExpectedFile = TestFile::fromYamlFile("inlined-functions.yaml");
   ASSERT_THAT_EXPECTED(ExpectedFile, llvm::Succeeded());
   m_file.emplace(std::move(*ExpectedFile));
   m_module_sp = std::make_shared<Module>(m_file->moduleSpec());
 }
 
 llvm::Expected<LineEntry> LineEntryTest::GetLineEntryForLine(uint32_t line) {
-  bool check_inlines = true;
-  bool exact = true;
+  // TODO: Handle SourceLocationSpec column information
   SymbolContextList sc_comp_units;
   SymbolContextList sc_line_entries;
   FileSpec file_spec("inlined-functions.cpp");
-  m_module_sp->ResolveSymbolContextsForFileSpec(file_spec, line, check_inlines,
-                                                lldb::eSymbolContextCompUnit,
-                                                sc_comp_units);
+  m_module_sp->ResolveSymbolContextsForFileSpec(
+      file_spec, line, /*check_inlines=*/true, lldb::eSymbolContextCompUnit,
   if (sc_comp_units.GetSize() == 0)
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "No comp unit found on the test object.");
+
+  SourceLocationSpec location_spec(file_spec, line, /*column=*/llvm::None,
+                                   /*check_inlines=*/true,
+                                   /*exact_match=*/true);
+
   sc_comp_units[0].comp_unit->ResolveSymbolContext(
-      file_spec, line, check_inlines, exact, eSymbolContextLineEntry,
-      sc_line_entries);
+      location_spec, eSymbolContextLineEntry, sc_line_entries);
   if (sc_line_entries.GetSize() == 0)
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "No line entry found on the test object.");
   return sc_line_entries[0].line_entry;
 }
 
 TEST_F(LineEntryTest, GetSameLineContiguousAddressRangeNoInlines) {
   auto line_entry = GetLineEntryForLine(18);