Implement trampoline step-through for Windows-x86.

[sas]

Summary

This is required to be able to step through calls to external functions
that are not properly marked with __declspec(dllimport). When a call
like this is emitted, the linker will inject a trampoline to produce an
indirect call through the IAT.

[zturner]

Excited to see this working. I will look at the patch in detail later, do you think you could make a test for it?

[jingham]

Can't you just call "thread->QueueThreadPlanForStepSingleInstruction"? For the most part, it doesn't make sense to make a thread plan and not queue it right away. So the "Thread::QueueThreadPlanFor..." API's are the public ones.

[sas]

@jingham, it looks like the GetStepThroughTrampolinePlan functions do not queue the thread plan themselves. See DynamicLoaderPOSIXDYLD::GetStepThroughTrampolinePlan for instance that just does new ThreadPlanRunToAddress(...).

If I understand correctly, the thread plan is pushed to the stack later on, by the caller. Let me know if I got something wrong there.

[jingham]

Yes, that's sad. It needs to be done that way because the plan that organizes stepping "through" and provides a safety backstop if the step through runs away needs to push the sub-plans after it has been pushed. We could move all the stuff in the ThreadPlanStepThrough constructor to the DidPush method, then let the various GetStepThroughTrampolinePlan methods -> PushStepThroughTrampolinePlans. But it looks like we've already made a bunch of the ThreadPlan constructors public to work around this sort of problem, so we should probably just give in and make all the constructors public, and just document that you should preferentially call QueueThreadPlan if you are in a place where that's possible...

[sas]

Sounds good. I can make a separate patch to make all the constructors
public if you think that's better. See http://reviews.llvm.org/D22230
for a patch that makes one of the constructors public.

Is this patch good to go in its current form then?

[clayborg]

Jim Ingham should OK any changes. If Jim is happy, then I am OK.

[jingham]

I seem not to close the formal loop on these reviews...

[sas]

Rebase + clang-format.

lldb/trunk/source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.cpp

 //===-- DynamicLoaderWindowsDYLD.cpp --------------------------------*- C++
 //-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DynamicLoaderWindowsDYLD.h"
 
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
+#include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
+#include "lldb/Target/ThreadPlanStepInstruction.h"
 
 #include "llvm/ADT/Triple.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 DynamicLoaderWindowsDYLD::DynamicLoaderWindowsDYLD(Process *process)
     : DynamicLoader(process) {}
ConstString DynamicLoaderWindowsDYLD::GetPluginName() {
   return GetPluginNameStatic();
 }
 
 uint32_t DynamicLoaderWindowsDYLD::GetPluginVersion() { return 1; }
 
 ThreadPlanSP
 DynamicLoaderWindowsDYLD::GetStepThroughTrampolinePlan(Thread &thread,
                                                        bool stop) {
+  auto arch = m_process->GetTarget().GetArchitecture();
+  if (arch.GetMachine() != llvm::Triple::x86) {
     return ThreadPlanSP();
   }
+
+  uint64_t pc = thread.GetRegisterContext()->GetPC();
+  // Max size of an instruction in x86 is 15 bytes.
+  AddressRange range(pc, 2 * 15);
+
+  ExecutionContext exe_ctx(m_process->GetTarget());
+  DisassemblerSP disassembler_sp = Disassembler::DisassembleRange(
+      arch, nullptr, nullptr, exe_ctx, range, true);
+  if (!disassembler_sp) {
+    return ThreadPlanSP();
+  }
+
+  InstructionList *insn_list = &disassembler_sp->GetInstructionList();
+  if (insn_list == nullptr) {
+    return ThreadPlanSP();
+  }
+
+  // First instruction in a x86 Windows trampoline is going to be an indirect
+  // jump through the IAT and the next one will be a nop (usually there for
+  // alignment purposes). e.g.:
+  //     0x70ff4cfc <+956>: jmpl   *0x7100c2a8
+  //     0x70ff4d02 <+962>: nop
+
+  auto first_insn = insn_list->GetInstructionAtIndex(0);
+  auto second_insn = insn_list->GetInstructionAtIndex(1);
+
+  if (first_insn == nullptr || second_insn == nullptr ||
+      strcmp(first_insn->GetMnemonic(&exe_ctx), "jmpl") != 0 ||
+      strcmp(second_insn->GetMnemonic(&exe_ctx), "nop") != 0) {
+    return ThreadPlanSP();
+  }
+
+  assert(first_insn->DoesBranch() && !second_insn->DoesBranch());
+
+  return ThreadPlanSP(new ThreadPlanStepInstruction(
+      thread, false, false, eVoteNoOpinion, eVoteNoOpinion));
+}