Include inlined functions when figuring out a contiguous address range

[aadsm]

Summary

This diff changes the function LineEntry::GetSameLineContiguousAddressRange so that it also includes function calls that were inlined at the same line of code.

My motivation is to decrease the step over time of lines that heavly rely on inlined functions. I have multiple examples in the code base I work that makes a step over stop 20 or mote times internally. This can easly had up to step overs that take >500ms which I was able to lower to 25ms with this new strategy.

The reason the current code is not extending the address range beyond an inlined function is because when we resolve the symbol at the next address of the line entry we will get the entry line corresponding to where the original code for the inline function lives, making us barely extend the range. This then will end up on a step over having to stop multiple times everytime there's an inlined function.

To check if the range is an inlined function at that line I also get the block associated with the next address and check if there is a parent block with a call site at the line we're trying to extend.

To check this I created a new function in Block called GetContainingInlinedBlockWithCallSite that does exactly that. I also added a new function to Declaration for convinence of checking file/line named CompareFileAndLine.

To avoid potential issues when extending an address range I added an Extend function that extends the range by the AddressRange given as an argument. This function returns true to indicate sucess when the rage was agumented, false otherwise (e.g.: the ranges are not connected). The reason I do is to make sure that we're not just blindly extending complete_line_range by whatever GetByteSize() we got. If for some reason the ranges are not connected or overlap, or even 0, this could be an issue.

I also added a unit tests for this change and include the instructions on the test itself on how to generate the yaml file I use for testing.

[clayborg]

Jim: this is a modified version of the patch we had talked about a while ago with needed fixes for making sure the inline function call site is the same as the starting file and line. We have iterated on this locally already, so I am good with this patch. Let us know what you think.

[jingham]

This makes sense to me. Pinning the extension to the call site prevented all the cases I could think of where this might go wrong.

I had a bunch of small comments inline.

lldb/include/lldb/Symbol/Block.h

191–196 ↗

(On Diff #197245)

The docs don't match the function signature.

lldb/include/lldb/Symbol/Declaration.h

112–113 ↗

(On Diff #197245)

The argument is not called "rhs" anymore.

I'm not at all sure of the value of returning > < here. If you get > or < you have no way of knowing if that's because the files don't match, in which case so far as I can see the ordering is not useful, or if they are in the same file but with greater or lesser line number. To actually use the < or > you would have to go back and compare the files again anyway, so for all practical purposes you're really just returning a bool... And certainly that's how you are using it.

You were probably just copying the behavior from the function above, but that one doesn't make much sense either...

lldb/include/lldb/Symbol/LineEntry.h

135 ↗

(On Diff #197245)

are -> or

140 ↗

(On Diff #197245)

We try to avoid default arguments unless there's a good reason, and in this case it looks like you pass the argument explicitly in almost all the uses, so I would make this a regular argument.

lldb/source/Core/AddressRange.cpp

131 ↗

(On Diff #197245)

intercept -> intersect

lldb/source/Symbol/LineEntry.cpp

199 ↗

(On Diff #197245)

start_call_site would be a clearer name for this. find_call_site doesn't say what it is.

lldb/unittests/Symbol/TestLineEntry.cpp

60–87 ↗

(On Diff #197245)

These defines don't seem specific to this test, is there a more general place you could put them?

96–122 ↗

(On Diff #197245)

It looks like this bit of business has been copied around in a bunch of other tests in the unittest framework. Could we put this in a common place (like make a LLDBUnitTest : testing::Test class that does this?

193–194 ↗

(On Diff #197245)

Can you make the return here not trivial (like return result + 5)} The way you have written the line return line doesn't contribute any code so you would step all the way out to the caller, but it would be good to test that we didn't just extend the range to our caller, i.e. that next on "int result ="... stops at the "return result" which it should do except in your example line 13 contributes no code.

279 ↗

(On Diff #197245)

Add newline.

[clayborg]

lldb/include/lldb/Symbol/Declaration.h

113 ↗

(On Diff #197245)

How about just returning a bool:

bool FileAndLineEqual(const Declaration &rhs);

lldb/include/lldb/Symbol/LineEntry.h

140 ↗

(On Diff #197245)

We tried that but the patch becomes a lot bigger if so. Happy to add all the other changes back, or we can make a new fucntion?

[jingham]

lldb/include/lldb/Symbol/Declaration.h

113 ↗

(On Diff #197245)

That would be great. The whole "Compare" thing for Declarations doesn't make any sense to me. If you were trying to put Declarations in a container that required an ordering??? But that's not what this is for.

lldb/include/lldb/Symbol/LineEntry.h

140 ↗

(On Diff #197245)

Besides the declaration and definition, I only see 5 uses of GetSameLineContiguousAddressRange in lldb, and you've touched three of them. Am I missing something? If not, might as well change the other two.

[aadsm]

lldb/include/lldb/Symbol/Declaration.h

112–113 ↗

(On Diff #197245)

Oh, originally it was rhs but then I renamed and forgot to update the documentation.
Just to give some context: the reason I used the same interface was to provide a consistent API in the methods that do comparisons, but I see what you mean, I'll change it then.

[aadsm]

lldb/unittests/Symbol/TestLineEntry.cpp

60–87 ↗

(On Diff #197245)

I could put it in TestUtilities.h?

96–122 ↗

(On Diff #197245)

How about adding a new function to TestUtilities.cpp named ReadYAMLObject?

193–194 ↗

(On Diff #197245)

That's a good idea, thanks.

[labath]

I'm impressed by the test. I've tried to think of an alternative strategy for testing this (perhaps by adding a suitable mode to lldb-test), but I couldn't come up with one that a reasonable one, so this might be the best we can do right now. Thank you for taking the trouble to write that.

lldb/unittests/Symbol/TestLineEntry.cpp

60–87 ↗

(On Diff #197245)

I don't think most of these should exist actually... Instead of EXPECTED_NO_ERROR, you can use write if(std::error_code ec = ...) return llvm::errorCodeToError(ec);

For the rest, I'd suggest just inlining the macros and using llvm::createStringError instead of llvm::make_error<llvm::StringError>, as it's somewhat shorter (if you want, you can make a utility wrapper function around that to avoid the inconvertibleErrorCode argument).

89–94 ↗

(On Diff #197245)

This is unused (and it wouldn't be right anyway).

96–122 ↗

(On Diff #197245)

A utility function sounds nice. (a test class would be fine too, but I'd name it a bit less generic, as not all of our unit tests are in business of running yaml2obj and creating modules).

The part I'm not so sure about is the location. Originally the idea was that we would have a special subfolder for test helpers related to each module under test, but then at some point that got changed into TestingSupport which sounds more generic (this evolution here is visible in the fact that the cmake target name in that folder is called lldbUtilityHelpers). If we put this function there then we'd have to pull in the Core module (and everything that goes with it). Though that isn't that bad on it's own, it is a bit unfortunate, as right now the Utility unit test executable is our best defense against unexpected dependencies creeping into the main module. After this, that executable would link in the whole world again, and we'd lose this defense.

Another possibility might be to just put the yaml2obj (which is the main source of mess here) part in that file, and leave the construction of the Module object to the users.

150–152 ↗

(On Diff #197245)

replace with ASSERT_THAT_EXPECTED(..., llvm::Succeeded()); (and in subsequent tests)

208 ↗

(On Diff #197245)

The instructions aren't real (MachO obj2yaml does not preserve them), so it may be best to just leave them out to avoid confusion.

[aadsm]

@labath thank you for your kind words!

lldb/unittests/Symbol/TestLineEntry.cpp

96–122 ↗

(On Diff #197245)

Yeah, the way I did it locally was to create a function that only handles the yaml2obj part. Some tests use the file for other things other than creating a ModuleSpec.
I also put the responsibility of creating and cleaning up the object file in the caller. I was not sure how to handle the clean up of the temporary file for all different cases. Here's how it looks like from the caller side.

llvm::SmallString<128> obj;
if (auto ec = llvm::sys::fs::createTemporaryFile("source-%%%%%%", "obj", obj))
  return llvm::errorCodeToError(ec);
llvm::FileRemover obj_remover(obj);
if (auto error = ReadYAMLObjectFile("inlined-functions.yaml", obj))
  return llvm::Error(std::move(error));

What do you think?

[aadsm]

• Renamed CompareFileAndLine to FileAndLineEqual and made it return a bool
• Made include_inlined_functions a mandatory parameter in GetSameLineContiguousAddressRange
• Fix documentation
• Refactored the object file creation from YAML
• Got rid of a bunch of macros
• Improved the test case

[jingham]

LGTM, you should probably wait on Pavel's okay to the testing framework changes since that's more his baby...

[labath]

The test changes look fine to me. Thank you for doing that.

lldb/unittests/Symbol/TestLineEntry.cpp

96–122 ↗

(On Diff #197245)

Yeah, that's fine. I can think of a couple of ways of simplifying that further, but that would require making some tweaks to the FileRemover class (the class only has a handful of uses in llvm, so it's not surprising it has some rough edges). However, this is already a pretty big improvement over the current state, so thank you for doing that.

lldb/unittests/TestingSupport/TestUtilities.cpp

12 ↗

(On Diff #198115)

What is this header used for? If need something to include to use createStringError, you should include llvm/Support/Error.h, as that's what defines it.

[aadsm]

lldb/unittests/TestingSupport/TestUtilities.cpp

12 ↗

(On Diff #198115)

I just forgot to remove it, I was using llvm::formatv before switching to createStringError.

[aadsm]

Remove unused include

[rnk]

I think TestLineEntry.cpp didn't get added to the commit, so I removed it in r360076 to try to fix the build.

lldb/trunk/include/lldb/Core/AddressRange.h

public:
   ///     A section offset address object reference.
   ///
   /// \return
   ///     Returns \b true if both \a this has a resolvable load
   ///     address value and \a so_addr is contained in the address
   ///     range, \b false otherwise.
   bool ContainsLoadAddress(lldb::addr_t load_addr, Target *target) const;
 
+  //------------------------------------------------------------------
+  /// Extends this range with \b rhs_range if it overlaps this range on the
+  /// right side. The range overlaps on the right side if the base address
+  /// of \b rhs_range lies within this range or if it's contiguous on its
+  /// right side.
+  ///
+  /// @param[in] rhs_range
+  ///     The range to extend at the right side.
+  ///
+  /// @return
+  ///     Returns \b true if this range was extended, \b false otherwise.
+  //------------------------------------------------------------------
+  bool Extend(const AddressRange &rhs_range);
+
   /// Dump a description of this object to a Stream.
   ///
   /// Dump a description of the contents of this object to the supplied stream
   /// \a s. There are many ways to display a section offset based address
   /// range, and \a style lets the user choose how the base address gets
   /// displayed.
   ///
   /// \param[in] s

lldb/trunk/include/lldb/Symbol/Block.h

public:
 
   /// Get the inlined parent block for this block.
   ///
   /// \return
   ///     The parent block pointer, or nullptr if this block has no
   ///     parent.
   Block *GetInlinedParent();
 
+  //------------------------------------------------------------------
+  /// Get the inlined block at the given call site that contains this block.
+  ///
+  /// @param[in] find_call_site
+  ///     a declaration with the file and line of the call site to find.
+  ///
+  /// @return
+  ///     If this block contains inlined function info and is at the call
+  ///     site given by the file and line at the given \b declaration, then
+  ///     it will return this block, otherwise the parent blocks will be
+  ///     searched to see if any is at the call site. nullptr will be returned
+  ///     if no block is found at the call site.
+  //------------------------------------------------------------------
+  Block *
+  GetContainingInlinedBlockWithCallSite(const Declaration &find_call_site);
+
   /// Get the sibling block for this block.
   ///
   /// \return
   ///     The sibling block pointer, or nullptr if this block has no
   ///     sibling.
   Block *GetSibling() const;
 
   /// Get the first child block.

lldb/trunk/include/lldb/Symbol/Declaration.h

#endif
   ///     The Right Hand Side const Declaration object reference.
   ///
   /// \return
   ///     \li -1 if lhs < rhs
   ///     \li 0 if lhs == rhs
   ///     \li 1 if lhs > rhs
   static int Compare(const Declaration &lhs, const Declaration &rhs);
 
+  /// Checks if this object has the same file and line as another declaration
+  /// object.
+  ///
+  /// \param[in] declaration
+  ///     The const Declaration object to compare with.
+  ///
+  /// \return
+  ///     Returns \b true if \b declaration is at the same file and
+  ///     line, \b false otherwise.
+  bool FileAndLineEqual(const Declaration &declaration) const;
+
   /// Dump a description of this object to a Stream.
   ///
   /// Dump a description of the contents of this object to the supplied stream
   /// \a s.
   ///
   /// \param[in] s
   ///     The stream to which to dump the object description.
   void Dump(Stream *s, bool show_fullpaths) const;

lldb/trunk/include/lldb/Symbol/LineEntry.h

struct LineEntry {
   /// Line entries with a line number of 0 are treated specially - these are
   /// compiler-generated line table entries that the user did not write in
   /// their source code, and we want to skip past in the debugger. If this
   /// LineEntry is for line 32, and the following LineEntry is for line 0, we
   /// will extend the range to include the AddressRange of the line 0
   /// LineEntry (and it will include the range of the following LineEntries
   /// that match either 32 or 0.)
   ///
+  /// When \b include_inlined_functions is \b true inlined functions with
+  /// a call site at this LineEntry will also be included in the complete
+  /// range.
+  ///
   /// If the initial LineEntry this method is called on is a line #0, only the
   /// range of contiuous LineEntries with line #0 will be included in the
   /// complete range.
   ///
+  /// @param[in] include_inlined_functions
+  ///     Whether to include inlined functions at the same line or not.
+  ///
   /// \return
   ///     The contiguous AddressRange for this source line.
-  AddressRange GetSameLineContiguousAddressRange() const;
+  AddressRange
+  GetSameLineContiguousAddressRange(bool include_inlined_functions) const;
 
   /// Apply file mappings from target.source-map to the LineEntry's file.
   ///
   /// \param[in] target_sp
   ///     Shared pointer to the target this LineEntry belongs to.
 
   void ApplyFileMappings(lldb::TargetSP target_sp);
 

lldb/trunk/lldb.xcodeproj/xcshareddata/xcschemes/desktop.xcscheme

<TestAction
             BlueprintName = "lldb-tool"
             ReferencedContainer = "container:lldb.xcodeproj">
          </BuildableReference>
       </MacroExpansion>
       <AdditionalOptions>
       </AdditionalOptions>
    </TestAction>
    <LaunchAction
-      buildConfiguration = "DebugClang"
+      buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      launchStyle = "1"
+      launchStyle = "0"
       useCustomWorkingDirectory = "NO"
       ignoresPersistentStateOnLaunch = "NO"
       debugDocumentVersioning = "YES"
       debugServiceExtension = "internal"
       allowLocationSimulation = "YES">
       <BuildableProductRunnable
          runnableDebuggingMode = "0">
          <BuildableReference
             BuildableIdentifier = "primary"
             BlueprintIdentifier = "26F5C26910F3D9A4009D5894"
             BuildableName = "lldb"
             BlueprintName = "lldb-tool"
             ReferencedContainer = "container:lldb.xcodeproj">
          </BuildableReference>
       </BuildableProductRunnable>
+      <CommandLineArguments>
+         <CommandLineArgument
+            argument = "-o &apos;command script import /Users/gclayton/fbsource/fbandroid/scripts/lldb/commands/fbsymbols.py&apos;"
+            isEnabled = "NO">
+         </CommandLineArgument>
+         <CommandLineArgument
+            argument = "-o &apos;log enable lldb unwind&apos; -o &apos;command script import /Users/gclayton/fbsource/fbandroid/scripts/lldb/commands/fbsymbols.py&apos; -o &apos;fbsymbols --minidump GLWubgKtZo80qCYDAAAAAADejTIHbggUAAAA&apos; -o &apos;command script import ~/Dropbox/bin/sbt.py&apos;"
+            isEnabled = "YES">
+         </CommandLineArgument>
+         <CommandLineArgument
+            argument = "-o &apos;fbsymbols --minidump GLWubgKtZo80qCYDAAAAAADejTIHbggUAAAA&apos;"
+            isEnabled = "NO">
+         </CommandLineArgument>
+      </CommandLineArguments>
       <AdditionalOptions>
       </AdditionalOptions>
    </LaunchAction>
    <ProfileAction
       buildConfiguration = "Release"
       shouldUseLaunchSchemeArgsEnv = "YES"
       savedToolIdentifier = ""
       useCustomWorkingDirectory = "NO"

lldb/trunk/lldb.xcodeproj/xcshareddata/xcschemes/lldb-tool.xcscheme

<TestAction
             value = "0x802e0e"
             isEnabled = "YES">
          </EnvironmentVariable>
       </EnvironmentVariables>
       <AdditionalOptions>
       </AdditionalOptions>
    </TestAction>
    <LaunchAction
-      buildConfiguration = "DebugClang"
+      buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      launchStyle = "1"
+      launchStyle = "0"
       useCustomWorkingDirectory = "NO"
       customWorkingDirectory = "/Volumes/work/gclayton/Documents/devb/attach"
       ignoresPersistentStateOnLaunch = "YES"
       debugDocumentVersioning = "YES"
       debugServiceExtension = "internal"
       allowLocationSimulation = "YES"
       queueDebuggingEnabled = "No">
       <BuildableProductRunnable
          runnableDebuggingMode = "0">
          <BuildableReference
             BuildableIdentifier = "primary"
             BlueprintIdentifier = "26F5C26910F3D9A4009D5894"
             BuildableName = "lldb"
             BlueprintName = "lldb-tool"
             ReferencedContainer = "container:lldb.xcodeproj">
          </BuildableReference>
       </BuildableProductRunnable>
+      <CommandLineArguments>
+         <CommandLineArgument
+            argument = "-o &apos;command script import /Users/gclayton/fbsource/fbandroid/scripts/lldb/commands/fbsymbols.py&apos;"
+            isEnabled = "YES">
+         </CommandLineArgument>
+         <CommandLineArgument
+            argument = "--no-use-colors"
+            isEnabled = "YES">
+         </CommandLineArgument>
+         <CommandLineArgument
+            argument = "-o &apos;fbsymbols --minidump GLWubgKtZo80qCYDAAAAAADejTIHbggUAAAA&apos;"
+            isEnabled = "YES">
+         </CommandLineArgument>
+      </CommandLineArguments>
       <EnvironmentVariables>
          <EnvironmentVariable
             key = "LLDB_LAUNCH_FLAG_DISABLE_ASLR"
             value = "YES"
             isEnabled = "NO">
          </EnvironmentVariable>
          <EnvironmentVariable
             key = "LLDB_LAUNCH_FLAG_LAUNCH_IN_TTY"

lldb/trunk/source/Core/AddressRange.cpp

if (load_base_addr == LLDB_INVALID_ADDRESS)
     return false;
 
   if (load_base_addr <= load_addr)
     return (load_addr - load_base_addr) < GetByteSize();
 
   return false;
 }
 
+bool AddressRange::Extend(const AddressRange &rhs_range) {
+  addr_t lhs_end_addr = GetBaseAddress().GetFileAddress() + GetByteSize();
+  addr_t rhs_base_addr = rhs_range.GetBaseAddress().GetFileAddress();
+
+  if (!ContainsFileAddress(rhs_range.GetBaseAddress()) &&
+      lhs_end_addr != rhs_base_addr)
+    // The ranges don't intersect at all on the right side of this range.
+    return false;
+
+  addr_t rhs_end_addr = rhs_base_addr + rhs_range.GetByteSize();
+  if (lhs_end_addr >= rhs_end_addr)
+    // The rhs range totally overlaps this one, nothing to add.
+    return false;
+
+  m_byte_size += rhs_end_addr - lhs_end_addr;
+  return true;
+}
+
 void AddressRange::Clear() {
   m_base_addr.Clear();
   m_byte_size = 0;
 }
 
 bool AddressRange::Dump(Stream *s, Target *target, Address::DumpStyle style,
                         Address::DumpStyle fallback_style) const {
   addr_t vmaddr = LLDB_INVALID_ADDRESS;

lldb/trunk/source/Symbol/Block.cpp

if (parent_block) {
     if (parent_block->GetInlinedFunctionInfo())
       return parent_block;
     else
       return parent_block->GetInlinedParent();
   }
   return nullptr;
 }
 
+Block *Block::GetContainingInlinedBlockWithCallSite(
+    const Declaration &find_call_site) {
+  auto inlined_block = GetContainingInlinedBlock();
+
+  while (inlined_block) {
+    auto function_info = inlined_block->GetInlinedFunctionInfo();
+
+    if (function_info &&
+        function_info->GetCallSite().FileAndLineEqual(find_call_site))
+      return inlined_block;
+    inlined_block = inlined_block->GetInlinedParent();
+  }
+  return nullptr;
+}
+
 bool Block::GetRangeContainingOffset(const addr_t offset, Range &range) {
   const Range *range_ptr = m_ranges.FindEntryThatContains(offset);
   if (range_ptr) {
     range = *range_ptr;
     return true;
   }
   range.Clear();
   return false;

lldb/trunk/source/Symbol/Declaration.cpp

#ifdef LLDB_ENABLE_DECLARATION_COLUMNS
   if (a.m_column < b.m_column)
     return -1;
   else if (a.m_column > b.m_column)
     return 1;
 #endif
   return 0;
 }
 
+bool Declaration::FileAndLineEqual(const Declaration &declaration) const {
+  int file_compare = FileSpec::Compare(this->m_file, declaration.m_file, true);
+  return file_compare == 0 && this->m_line == declaration.m_line;
+}
+
 bool lldb_private::operator==(const Declaration &lhs, const Declaration &rhs) {
 #ifdef LLDB_ENABLE_DECLARATION_COLUMNS
   if (lhs.GetColumn() == rhs.GetColumn())
     if (lhs.GetLine() == rhs.GetLine())
       return lhs.GetFile() == rhs.GetFile();
 #else
   if (lhs.GetLine() == rhs.GetLine())
     return FileSpec::Equal(lhs.GetFile(), rhs.GetFile(), true);
 #endif
   return false;
 }

lldb/trunk/source/Symbol/LineEntry.cpp

int LineEntry::Compare(const LineEntry &a, const LineEntry &b) {
   if (a.column < b.column)
     return -1;
   if (a.column > b.column)
     return +1;
 
   return FileSpec::Compare(a.file, b.file, true);
 }
 
-AddressRange LineEntry::GetSameLineContiguousAddressRange() const {
+AddressRange LineEntry::GetSameLineContiguousAddressRange(
+    bool include_inlined_functions) const {
   // Add each LineEntry's range to complete_line_range until we find a
   // different file / line number.
   AddressRange complete_line_range = range;
+  auto symbol_context_scope = lldb::eSymbolContextLineEntry;
+  Declaration start_call_site(original_file, line);
+  if (include_inlined_functions)
+    symbol_context_scope |= lldb::eSymbolContextBlock;
 
   while (true) {
     SymbolContext next_line_sc;
     Address range_end(complete_line_range.GetBaseAddress());
     range_end.Slide(complete_line_range.GetByteSize());
-    range_end.CalculateSymbolContext(&next_line_sc,
-                                     lldb::eSymbolContextLineEntry);
+    range_end.CalculateSymbolContext(&next_line_sc, symbol_context_scope);
 
-    if (next_line_sc.line_entry.IsValid() &&
-        next_line_sc.line_entry.range.GetByteSize() > 0 &&
-        original_file == next_line_sc.line_entry.original_file) {
+    if (!next_line_sc.line_entry.IsValid() ||
+        next_line_sc.line_entry.range.GetByteSize() == 0)
+      break;
+
+    if (original_file == next_line_sc.line_entry.original_file &&
+        (next_line_sc.line_entry.line == 0 ||
+         line == next_line_sc.line_entry.line)) {
       // Include any line 0 entries - they indicate that this is compiler-
       // generated code that does not correspond to user source code.
-      if (next_line_sc.line_entry.line == 0) {
-        complete_line_range.SetByteSize(
-            complete_line_range.GetByteSize() +
-            next_line_sc.line_entry.range.GetByteSize());
-        continue;
-      }
-
-      if (line == next_line_sc.line_entry.line) {
-        // next_line_sc is the same file & line as this LineEntry, so extend
-        // our AddressRange by its size and continue to see if there are more
-        // LineEntries that we can combine.
-        complete_line_range.SetByteSize(
-            complete_line_range.GetByteSize() +
-            next_line_sc.line_entry.range.GetByteSize());
-        continue;
-      }
+      // LineEntries that we can combine. However, if there was nothing to
+      // extend we're done.
+      if (!complete_line_range.Extend(next_line_sc.line_entry.range))
+        break;
+
+    if (include_inlined_functions && next_line_sc.block &&
+        next_line_sc.block->GetContainingInlinedBlock() != nullptr) {
+      // The next_line_sc might be in a different file if it's an inlined
+      // function. If this is the case then we still want to expand our line
+      // range to include them if the inlined function is at the same call site
+      // as this line entry. The current block could represent a nested inline
+      // function call so we need to need to check up the block tree to see if
+      // we find one.
+      auto inlined_parent_block =
+          next_line_sc.block->GetContainingInlinedBlockWithCallSite(
+              start_call_site);
+      if (!inlined_parent_block)
+        // We didn't find any parent inlined block with a call site at this line
+        // entry so this inlined function is probably at another line.
+        break;
+      // Extend our AddressRange by the size of the inlined block, but if there
+      // was nothing to add then we're done.
+      if (!complete_line_range.Extend(next_line_sc.line_entry.range))
+        break;
+      continue;
     }
+
     break;
   }
   return complete_line_range;
 }
 
 void LineEntry::ApplyFileMappings(lldb::TargetSP target_sp) {
   if (target_sp) {
     // Apply any file remappings to our file
     FileSpec new_file_spec;
     if (target_sp->GetSourcePathMap().FindFile(original_file, new_file_spec))
       file = new_file_spec;
   }
 }

lldb/trunk/source/Target/Thread.cpp

 }
 
 // Call the QueueThreadPlanForStepOverRange method which takes an address
 // range.
 ThreadPlanSP Thread::QueueThreadPlanForStepOverRange(
     bool abort_other_plans, const LineEntry &line_entry,
     const SymbolContext &addr_context, lldb::RunMode stop_other_threads,
     Status &status, LazyBool step_out_avoids_code_withoug_debug_info) {
+  const bool include_inlined_functions = true;
+  auto address_range =
+      line_entry.GetSameLineContiguousAddressRange(include_inlined_functions);
   return QueueThreadPlanForStepOverRange(
-      abort_other_plans, line_entry.GetSameLineContiguousAddressRange(),
-      addr_context, stop_other_threads, status,
-      step_out_avoids_code_withoug_debug_info);
+      abort_other_plans, address_range, addr_context, stop_other_threads,
+      status, step_out_avoids_code_withoug_debug_info);
 }
 
 ThreadPlanSP Thread::QueueThreadPlanForStepInRange(
     bool abort_other_plans, const AddressRange &range,
     const SymbolContext &addr_context, const char *step_in_target,
     lldb::RunMode stop_other_threads, Status &status,
     LazyBool step_in_avoids_code_without_debug_info,
     LazyBool step_out_avoids_code_without_debug_info) {

 
 // Call the QueueThreadPlanForStepInRange method which takes an address range.
 ThreadPlanSP Thread::QueueThreadPlanForStepInRange(
     bool abort_other_plans, const LineEntry &line_entry,
     const SymbolContext &addr_context, const char *step_in_target,
     lldb::RunMode stop_other_threads, Status &status,
     LazyBool step_in_avoids_code_without_debug_info,
     LazyBool step_out_avoids_code_without_debug_info) {
+  const bool include_inlined_functions = false;
   return QueueThreadPlanForStepInRange(
-      abort_other_plans, line_entry.GetSameLineContiguousAddressRange(),
+      abort_other_plans,
+      line_entry.GetSameLineContiguousAddressRange(include_inlined_functions),
       addr_context, step_in_target, stop_other_threads, status,
       step_in_avoids_code_without_debug_info,
       step_out_avoids_code_without_debug_info);
 }
 
 ThreadPlanSP Thread::QueueThreadPlanForStepOut(
     bool abort_other_plans, SymbolContext *addr_context, bool first_insn,
     bool stop_other_threads, Vote stop_vote, Vote run_vote, uint32_t frame_idx,

lldb/trunk/source/Target/ThreadPlanStepOut.cpp

if (continue_to_next_branch) {
       AddressRange range;
       Address return_address_decr_pc = return_address;
       if (return_address_decr_pc.GetOffset() > 0)
         return_address_decr_pc.Slide(-1);
 
       return_address_decr_pc.CalculateSymbolContext(
           &return_address_sc, lldb::eSymbolContextLineEntry);
       if (return_address_sc.line_entry.IsValid()) {
-        range =
-            return_address_sc.line_entry.GetSameLineContiguousAddressRange();
+        const bool include_inlined_functions = false;
+        range = return_address_sc.line_entry.GetSameLineContiguousAddressRange(
+            include_inlined_functions);
         if (range.GetByteSize() > 0) {
           return_address =
               m_thread.GetProcess()->AdvanceAddressToNextBranchInstruction(
                   return_address, range);
         }
       }
     }
     m_return_addr =

lldb/trunk/source/Target/ThreadPlanStepRange.cpp

if (!ret_value && !m_given_ranges_only) {
     SymbolContext new_context(
         frame->GetSymbolContext(eSymbolContextEverything));
     if (m_addr_context.line_entry.IsValid() &&
         new_context.line_entry.IsValid()) {
       if (m_addr_context.line_entry.original_file ==
           new_context.line_entry.original_file) {
         if (m_addr_context.line_entry.line == new_context.line_entry.line) {
           m_addr_context = new_context;
-          AddRange(
-              m_addr_context.line_entry.GetSameLineContiguousAddressRange());
+          const bool include_inlined_functions =
+              GetKind() == eKindStepOverRange;
+          AddRange(m_addr_context.line_entry.GetSameLineContiguousAddressRange(
+              include_inlined_functions));
           ret_value = true;
           if (log) {
             StreamString s;
             m_addr_context.line_entry.Dump(&s, m_thread.CalculateTarget().get(),
                                            true, Address::DumpStyleLoadAddress,
                                            Address::DumpStyleLoadAddress, true);
 
             log->Printf(
                 "Step range plan stepped to another range of same line: %s",
                 s.GetData());
           }
         } else if (new_context.line_entry.line == 0) {
           new_context.line_entry.line = m_addr_context.line_entry.line;
           m_addr_context = new_context;
-          AddRange(
-              m_addr_context.line_entry.GetSameLineContiguousAddressRange());
+          const bool include_inlined_functions =
+              GetKind() == eKindStepOverRange;
+          AddRange(m_addr_context.line_entry.GetSameLineContiguousAddressRange(
+              include_inlined_functions));
           ret_value = true;
           if (log) {
             StreamString s;
             m_addr_context.line_entry.Dump(&s, m_thread.CalculateTarget().get(),
                                            true, Address::DumpStyleLoadAddress,
                                            Address::DumpStyleLoadAddress, true);
 
             log->Printf("Step range plan stepped to a range at linenumber 0 "

lldb/trunk/tools/lldb-test/lldb-test.cpp

for (size_t i = 0; i < cu_count; i++) {
       lldb::CompUnitSP cu_sp = Module.GetCompileUnitAtIndex(i);
       if (!cu_sp)
         continue;
 
       LineEntry le;
       cu_sp->FindLineEntry(0, Line, &src_file, false, &le);
       if (!le.IsValid())
         continue;
-
-      auto addr = le.GetSameLineContiguousAddressRange().GetBaseAddress();
+      const bool include_inlined_functions = false;
+      auto addr =
+          le.GetSameLineContiguousAddressRange(include_inlined_functions)
+              .GetBaseAddress();
       if (!addr.IsValid())
         continue;
 
       SymbolContext sc;
       uint32_t resolved =
           addr.CalculateSymbolContext(&sc, eSymbolContextFunction);
       if (resolved & eSymbolContextFunction)
         List.Append(sc);
for (size_t i = 0; i < cu_count; i++) {
     lldb::CompUnitSP cu_sp = Module.GetCompileUnitAtIndex(i);
     if (!cu_sp)
       continue;
 
     LineEntry le;
     cu_sp->FindLineEntry(0, Line, &src_file, false, &le);
     if (!le.IsValid())
       continue;
-
-    auto addr = le.GetSameLineContiguousAddressRange().GetBaseAddress();
+    const bool include_inlined_functions = false;
+    auto addr = le.GetSameLineContiguousAddressRange(include_inlined_functions)
+                    .GetBaseAddress();
     if (!addr.IsValid())
       continue;
 
     SymbolContext sc;
     uint32_t resolved = addr.CalculateSymbolContext(&sc, eSymbolContextBlock);
     if (resolved & eSymbolContextBlock)
       List.Append(sc);
   }

lldb/trunk/unittests/Core/CMakeLists.txt

 add_lldb_unittest(LLDBCoreTests
   MangledTest.cpp
   RichManglingContextTest.cpp
   StreamCallbackTest.cpp
 
   LINK_LIBS
     lldbCore
     lldbHost
     lldbSymbol
     lldbPluginObjectFileELF
     lldbPluginSymbolVendorELF
     lldbUtilityHelpers
+    LLVMTestingSupport
   LINK_COMPONENTS
     Support
   )
 
-add_dependencies(LLDBCoreTests yaml2obj)
-add_definitions(-DYAML2OBJ="$<TARGET_FILE:yaml2obj>")
-
 set(test_inputs
   mangled-function-names.yaml
   )
 add_unittest_inputs(LLDBCoreTests "${test_inputs}")

lldb/trunk/unittests/Core/MangledTest.cpp

 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/SymbolContext.h"
 
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
+#include "llvm/Testing/Support/Error.h"
 
 #include "gtest/gtest.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 TEST(MangledTest, ResultForValidName) {
   ConstString MangledName("_ZN1a1b1cIiiiEEvm");
TEST(MangledTest, EmptyForInvalidName) {
 
   Mangled TheMangled(MangledName, IsMangled);
   ConstString TheDemangled =
       TheMangled.GetDemangledName(eLanguageTypeC_plus_plus);
 
   EXPECT_STREQ("", TheDemangled.GetCString());
 }
 
-#define ASSERT_NO_ERROR(x)                                                     \
-  if (std::error_code ASSERT_NO_ERROR_ec = x) {                                \
-    llvm::SmallString<128> MessageStorage;                                     \
-    llvm::raw_svector_ostream Message(MessageStorage);                         \
-    Message << #x ": did not return errc::success.\n"                          \
-            << "error number: " << ASSERT_NO_ERROR_ec.value() << "\n"          \
-            << "error message: " << ASSERT_NO_ERROR_ec.message() << "\n";      \
-    GTEST_FATAL_FAILURE_(MessageStorage.c_str());                              \
-  } else {                                                                     \
-  }
-
 TEST(MangledTest, NameIndexes_FindFunctionSymbols) {
   FileSystem::Initialize();
   HostInfo::Initialize();
   ObjectFileELF::Initialize();
   SymbolVendorELF::Initialize();
 
-  std::string Yaml = GetInputFilePath("mangled-function-names.yaml");
   llvm::SmallString<128> Obj;
   ASSERT_NO_ERROR(llvm::sys::fs::createTemporaryFile(
       "mangled-function-names-%%%%%%", "obj", Obj));
-
   llvm::FileRemover Deleter(Obj);
-  llvm::StringRef Args[] = {YAML2OBJ, Yaml};
-  llvm::StringRef ObjRef = Obj;
-  const llvm::Optional<llvm::StringRef> redirects[] = {llvm::None, ObjRef,
-                                                       llvm::None};
-  ASSERT_EQ(0,
-            llvm::sys::ExecuteAndWait(YAML2OBJ, Args, llvm::None, redirects));
-  uint64_t Size;
-  ASSERT_NO_ERROR(llvm::sys::fs::file_size(Obj, Size));
-  ASSERT_GT(Size, 0u);
+  ASSERT_THAT_ERROR(ReadYAMLObjectFile("mangled-function-names.yaml", Obj),
+                    llvm::Succeeded());
 
   ModuleSpec Spec{FileSpec(Obj)};
   Spec.GetSymbolFileSpec().SetFile(Obj, FileSpec::Style::native);
   auto M = std::make_shared<Module>(Spec);
 
   auto Count = [M](const char *Name, FunctionNameType Type) -> int {
     SymbolContextList SymList;
     return M->FindFunctionSymbols(ConstString(Name), Type, SymList);

lldb/trunk/unittests/Interpreter/TestCompletion.cpp

 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Utility/StringList.h"
 #include "lldb/Utility/TildeExpressionResolver.h"
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 #include "TestingSupport/MockTildeExpressionResolver.h"
+#include "TestingSupport/TestUtilities.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace fs = llvm::sys::fs;
 namespace path = llvm::sys::path;
 using namespace llvm;
 using namespace lldb_private;
 
-#define ASSERT_NO_ERROR(x)                                                     \
-  if (std::error_code ASSERT_NO_ERROR_ec = x) {                                \
-    SmallString<128> MessageStorage;                                           \
-    raw_svector_ostream Message(MessageStorage);                               \
-    Message << #x ": did not return errc::success.\n"                          \
-            << "error number: " << ASSERT_NO_ERROR_ec.value() << "\n"          \
-            << "error message: " << ASSERT_NO_ERROR_ec.message() << "\n";      \
-    GTEST_FATAL_FAILURE_(MessageStorage.c_str());                              \
-  } else {                                                                     \
-  }
-
 namespace {
 
 class CompletionTest : public testing::Test {
 protected:
   /// Unique temporary directory in which all created filesystem entities must
   /// be placed. It is removed at the end of the test suite.
   SmallString<128> BaseDir;
 

lldb/trunk/unittests/ObjectFile/ELF/CMakeLists.txt

 add_lldb_unittest(ObjectFileELFTests
   TestObjectFileELF.cpp
 
   LINK_LIBS
     lldbPluginObjectFileELF
     lldbPluginSymbolVendorELF
     lldbCore
     lldbUtilityHelpers
+    LLVMTestingSupport
   )
 
-add_dependencies(ObjectFileELFTests yaml2obj)
-add_definitions(-DYAML2OBJ="$<TARGET_FILE:yaml2obj>")
-
 set(test_inputs
   early-section-headers.so
   debug-info-relocations.pcm.yaml
   sections-resolve-consistently.yaml
   )
 add_unittest_inputs(ObjectFileELFTests "${test_inputs}")

lldb/trunk/unittests/ObjectFile/ELF/TestObjectFileELF.cpp

 #include "lldb/Host/HostInfo.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
 class ObjectFileELFTest : public testing::Test {
 public:
   void SetUp() override {
     FileSystem::Initialize();
     HostInfo::Initialize();
     ObjectFileELF::Initialize();
     SymbolVendorELF::Initialize();
   }
 
   void TearDown() override {
     SymbolVendorELF::Terminate();
     ObjectFileELF::Terminate();
     HostInfo::Terminate();
     FileSystem::Terminate();
   }
 
 protected:
 };
 
-#define ASSERT_NO_ERROR(x)                                                     \
-  if (std::error_code ASSERT_NO_ERROR_ec = x) {                                \
-    llvm::SmallString<128> MessageStorage;                                     \
-    llvm::raw_svector_ostream Message(MessageStorage);                         \
-    Message << #x ": did not return errc::success.\n"                          \
-            << "error number: " << ASSERT_NO_ERROR_ec.value() << "\n"          \
-            << "error message: " << ASSERT_NO_ERROR_ec.message() << "\n";      \
-    GTEST_FATAL_FAILURE_(MessageStorage.c_str());                              \
-  } else {                                                                     \
-  }
-
 TEST_F(ObjectFileELFTest, SectionsResolveConsistently) {
-  std::string yaml = GetInputFilePath("sections-resolve-consistently.yaml");
   llvm::SmallString<128> obj;
   ASSERT_NO_ERROR(llvm::sys::fs::createTemporaryFile(
       "sections-resolve-consistently-%%%%%%", "obj", obj));
-
   llvm::FileRemover remover(obj);
-  llvm::StringRef args[] = {YAML2OBJ, yaml};
-  llvm::StringRef obj_ref = obj;
-  const llvm::Optional<llvm::StringRef> redirects[] = {llvm::None, obj_ref,
-                                                       llvm::None};
-  ASSERT_EQ(0,
-            llvm::sys::ExecuteAndWait(YAML2OBJ, args, llvm::None, redirects));
-  uint64_t size;
-  ASSERT_NO_ERROR(llvm::sys::fs::file_size(obj, size));
-  ASSERT_GT(size, 0u);
+  ASSERT_THAT_ERROR(
+      ReadYAMLObjectFile("sections-resolve-consistently.yaml", obj),
+      llvm::Succeeded());
 
   ModuleSpec spec{FileSpec(obj)};
   spec.GetSymbolFileSpec().SetFile(obj, FileSpec::Style::native);
   auto module_sp = std::make_shared<Module>(spec);
   SectionList *list = module_sp->GetSectionList();
   ASSERT_NE(nullptr, list);
 
   auto bss_sp = list->FindSectionByName(ConstString(".bss"));

 
 static void CHECK_ABS64(uint8_t *bytes, uint64_t offset, uint64_t addend) {
   uint64_t res;
   memcpy(&res, reinterpret_cast<uint64_t *>(bytes + offset), sizeof(uint64_t));
   ASSERT_EQ(addend, res);
 }
 
 TEST_F(ObjectFileELFTest, TestAARCH64Relocations) {
-  std::string yaml = GetInputFilePath("debug-info-relocations.pcm.yaml");
   llvm::SmallString<128> obj;
   ASSERT_NO_ERROR(llvm::sys::fs::createTemporaryFile(
       "debug-info-relocations-%%%%%%", "obj", obj));
-
   llvm::FileRemover remover(obj);
-  llvm::StringRef args[] = {YAML2OBJ, yaml};
-  llvm::StringRef obj_ref = obj;
-  const llvm::Optional<llvm::StringRef> redirects[] = {llvm::None, obj_ref,
-                                                       llvm::None};
-  ASSERT_EQ(0,
-            llvm::sys::ExecuteAndWait(YAML2OBJ, args, llvm::None, redirects));
-  uint64_t size;
-  ASSERT_NO_ERROR(llvm::sys::fs::file_size(obj, size));
-  ASSERT_GT(size, 0u);
+  ASSERT_THAT_ERROR(ReadYAMLObjectFile("debug-info-relocations.pcm.yaml", obj),
+                    llvm::Succeeded());
 
   ModuleSpec spec{FileSpec(obj)};
   spec.GetSymbolFileSpec().SetFile(obj, FileSpec::Style::native);
   auto module_sp = std::make_shared<Module>(spec);
 
   auto objfile = static_cast<ObjectFileELF *>(module_sp->GetObjectFile());
   SectionList *section_list = objfile->GetSectionList();
   ASSERT_NE(nullptr, section_list);

lldb/trunk/unittests/Symbol/CMakeLists.txt

 add_lldb_unittest(SymbolTests
   LocateSymbolFileTest.cpp
   PostfixExpressionTest.cpp
   TestClangASTContext.cpp
   TestDWARFCallFrameInfo.cpp
   TestType.cpp
+  TestLineEntry.cpp
 
   LINK_LIBS
     lldbHost
     lldbSymbol
     lldbUtilityHelpers
     lldbPluginObjectFileELF
+    lldbPluginObjectFileMachO
+    lldbPluginSymbolVendorMacOSX
+    lldbPluginSymbolFileDWARF
+    LLVMTestingSupport
   )
 
-add_dependencies(SymbolTests yaml2obj)
-add_definitions(-DYAML2OBJ="$<TARGET_FILE:yaml2obj>")
 set(test_inputs
   basic-call-frame-info.yaml
+  inlined-functions.yaml
   )
 add_unittest_inputs(SymbolTests "${test_inputs}")

lldb/trunk/unittests/Symbol/TestDWARFCallFrameInfo.cpp

 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/DWARFCallFrameInfo.h"
 #include "lldb/Utility/StreamString.h"
+#include "llvm/Testing/Support/Error.h"
 
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace lldb_private;
 using namespace lldb;
void TearDown() override {
     HostInfo::Terminate();
     FileSystem::Terminate();
   }
 
 protected:
   void TestBasic(DWARFCallFrameInfo::Type type, llvm::StringRef symbol);
 };
 
-#define ASSERT_NO_ERROR(x)                                                     \
-  if (std::error_code ASSERT_NO_ERROR_ec = x) {                                \
-    llvm::SmallString<128> MessageStorage;                                     \
-    llvm::raw_svector_ostream Message(MessageStorage);                         \
-    Message << #x ": did not return errc::success.\n"                          \
-            << "error number: " << ASSERT_NO_ERROR_ec.value() << "\n"          \
-            << "error message: " << ASSERT_NO_ERROR_ec.message() << "\n";      \
-    GTEST_FATAL_FAILURE_(MessageStorage.c_str());                              \
-  } else {                                                                     \
-  }
-
 namespace lldb_private {
 static std::ostream &operator<<(std::ostream &OS, const UnwindPlan::Row &row) {
   StreamString SS;
   row.Dump(SS, nullptr, nullptr, 0);
   return OS << SS.GetData();
 }
 } // namespace lldb_private
 
static UnwindPlan::Row GetExpectedRow2() {
   row.GetCFAValue().SetIsRegisterPlusOffset(dwarf_rbp_x86_64, 16);
   row.SetRegisterLocationToAtCFAPlusOffset(dwarf_rip_x86_64, -8, false);
   row.SetRegisterLocationToAtCFAPlusOffset(dwarf_rbp_x86_64, -16, false);
   return row;
 }
 
 void DWARFCallFrameInfoTest::TestBasic(DWARFCallFrameInfo::Type type,
                                        llvm::StringRef symbol) {
-  std::string yaml = GetInputFilePath("basic-call-frame-info.yaml");
   llvm::SmallString<128> obj;
-
   ASSERT_NO_ERROR(llvm::sys::fs::createTemporaryFile(
       "basic-call-frame-info-%%%%%%", "obj", obj));
   llvm::FileRemover obj_remover(obj);
-
-  llvm::StringRef args[] = {YAML2OBJ, yaml};
-  llvm::StringRef obj_ref = obj;
-  const llvm::Optional<llvm::StringRef> redirects[] = {llvm::None, obj_ref,
-                                                       llvm::None};
-  ASSERT_EQ(0,
-            llvm::sys::ExecuteAndWait(YAML2OBJ, args, llvm::None, redirects));
-
-  uint64_t size;
-  ASSERT_NO_ERROR(llvm::sys::fs::file_size(obj, size));
-  ASSERT_GT(size, 0u);
+  ASSERT_THAT_ERROR(ReadYAMLObjectFile("basic-call-frame-info.yaml", obj),
+                    llvm::Succeeded());
 
   auto module_sp = std::make_shared<Module>(ModuleSpec(FileSpec(obj)));
   SectionList *list = module_sp->GetSectionList();
   ASSERT_NE(nullptr, list);
 
   auto section_sp = list->FindSectionByType(type == DWARFCallFrameInfo::EH
                                                 ? eSectionTypeEHFrame
                                                 : eSectionTypeDWARFDebugFrame,

lldb/trunk/unittests/TestingSupport/CMakeLists.txt

 set(EXCLUDE_FROM_ALL ON)
 add_lldb_library(lldbUtilityHelpers
   MockTildeExpressionResolver.cpp
   TestUtilities.cpp
 
   LINK_LIBS
     lldbUtility
 
   LINK_COMPONENTS
     Support
   )
+
+add_dependencies(lldbUtilityHelpers yaml2obj)
+add_definitions(-DYAML2OBJ="$<TARGET_FILE:yaml2obj>")
 No newline at end of file

lldb/trunk/unittests/TestingSupport/TestUtilities.h

 //===- TestUtilities.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_UNITTESTS_UTILITY_HELPERS_TESTUTILITIES_H
 #define LLDB_UNITTESTS_UTILITY_HELPERS_TESTUTILITIES_H
 
+#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/Support/Error.h"
 #include <string>
 
+#define ASSERT_NO_ERROR(x)                                                     \
+  if (std::error_code ASSERT_NO_ERROR_ec = x) {                                \
+    llvm::SmallString<128> MessageStorage;                                     \
+    llvm::raw_svector_ostream Message(MessageStorage);                         \
+    Message << #x ": did not return errc::success.\n"                          \
+            << "error number: " << ASSERT_NO_ERROR_ec.value() << "\n"          \
+            << "error message: " << ASSERT_NO_ERROR_ec.message() << "\n";      \
+    GTEST_FATAL_FAILURE_(MessageStorage.c_str());                              \
+  } else {                                                                     \
+  }
+
 namespace lldb_private {
 std::string GetInputFilePath(const llvm::Twine &name);
+llvm::Error ReadYAMLObjectFile(const llvm::Twine &yaml_name,
+                               llvm::SmallString<128> &obj);
 }
 
 #endif

lldb/trunk/unittests/TestingSupport/TestUtilities.cpp

 //===- TestUtilities.cpp ----------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "TestUtilities.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/Program.h"
 
 extern const char *TestMainArgv0;
 
 std::string lldb_private::GetInputFilePath(const llvm::Twine &name) {
   llvm::SmallString<128> result = llvm::sys::path::parent_path(TestMainArgv0);
   llvm::sys::fs::make_absolute(result);
   llvm::sys::path::append(result, "Inputs", name);
   return result.str();
 }
+
+llvm::Error
+lldb_private::ReadYAMLObjectFile(const llvm::Twine &yaml_name,
+                                 llvm::SmallString<128> &object_file) {
+  std::string yaml = GetInputFilePath(yaml_name);
+  llvm::StringRef args[] = {YAML2OBJ, yaml};
+  llvm::StringRef obj_ref = object_file;
+  const llvm::Optional<llvm::StringRef> redirects[] = {llvm::None, obj_ref,
+                                                       llvm::None};
+  if (llvm::sys::ExecuteAndWait(YAML2OBJ, args, llvm::None, redirects) != 0)
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "Error running yaml2obj %s.", yaml.c_str());
+  uint64_t size;
+  if (auto ec = llvm::sys::fs::file_size(object_file, size))
+    return llvm::errorCodeToError(ec);
+  if (size == 0)
+    return llvm::createStringError(
+        llvm::inconvertibleErrorCode(),
+        "Empty object file created from yaml2obj %s.", yaml.c_str());
+  return llvm::Error::success();
+}
 No newline at end of file