Add CMAKE_EXECUTABLE_SUFFIX to build with Android toolchain on Windows.

[chaoren]

For some reason CMAKE_EXECUTABLE_SUFFIX is not actually set by cmake at this point, requiring a -DCMAKE_EXECUTABLE_SUFFIX=.exe flag. Perhaps we need to manually detect if the platform is Windows and set it?

[flackr]

I think we need to do the same in test/make/Makefile.rules for AR and OBJCOPY.

I'm curious why it's not getting set automatically, as far as I can tell it should be. It seems to be defined in the cmake source at Modules/Platform/Windows.cmake

[zturner]

Can we look into why it's not set automatically? If you litter some
messages around the cmake code that sets it, you should be able to figure
it out

[chaoren]

This is probably why:

http://www.cmake.org/cmake/help/v3.0/variable/CMAKE_TOOLCHAIN_FILE.html

a file which is read early in the CMake run

I guess we could just use the same fix as this: rL126219

[chaoren]

AR and OBJCOPY and workaround for CMAKE_EXECUTABLE_SUFFIX being undefined

[flackr]

I'm a little confused about why you're setting EXECUTABLE_SUFFIX in Android.cmake but checking CMAKE_EXECUTABLE_SUFFIX in Makefile.rules, shouldn't those both be CMAKE_EXECUTABLE_SUFFIX?

test/make/Makefile.rules

88 ↗

(On Diff #24321)

Add $(CMAKE_EXECUTABLE_SUFFIX) here too. I believe libtool would need to be used if running the test suite from Windows against a remote mac target, just as we need to use ar for linking when targetting linux from mac.

[flackr]

In D9177#161956, @flackr wrote:

I'm a little confused about why you're setting EXECUTABLE_SUFFIX in Android.cmake but checking CMAKE_EXECUTABLE_SUFFIX in Makefile.rules, shouldn't those both be CMAKE_EXECUTABLE_SUFFIX?

Nevermind, I've looked up many examples to the contrary. I'm still not sure though if CMAKE_EXECUTABLE_SUFFIX will pick up the EXECUTABLE_SUFFIX or if the examples are just using a separate variable because CMAKE_EXECUTABLE_SUFFIX is not supposed to be settable. Maybe we need to set EXECUTABLE_SUFFIX in Makefile.rules and use that, i.e. in Makefile.rules:
EXECUTABLE_SUFFIX ?= $(CMAKE_EXECUTABLE_SUFFIX)

then use $(EXECUTABLE_SUFFIX)

[chaoren]

I think the reason CMAKE_EXECUTABLE_SUFFIX isn't being set is because Android.cmake is being run as a CMAKE_TOOLCHAIN_FILE.

Ugh, Makefile.rules is for Makefile rules not CMake rules so CMAKE_EXECUTABLE_SUFFIX makes no sense at all. Do you have Windows -> {Linux, OS X} tests running yet?

test/make/Makefile.rules

88 ↗

(On Diff #24321)

These look like rules for a mac host instead of a mac target, since xcrun looks like an XCode command.

[chaoren]

I think we need to do the same in test/make/Makefile.rules for AR and OBJCOPY.

Actually, I don't that'd be necessary. You can invoke executables on Windows without the extension, it's just that CMake actually checks if the executable exists. I originally made this CL because I wanted to cross compile the Android lldb-server on Windows (not terribly important, but sort of annoying if you have to switch to Linux while working on Windows -> Android). But there are other problems after this one, (e.g., Ninja generates response files with backslashes, but the ld.exe in the Android toolchain wants forward slashes). It's starting to look like more effort than it's worth.

[chaoren]

CMake variable shouldn't appear in Makefile rules.

cmake/platforms/Android.cmake

  set( ANDROID_TOOLCHAIN_NAME "mips64el-linux-android" )
 else()
  message( SEND_ERROR "Unknown ANDROID_ABI = \"${ANDROID_ABI}\"." )
 endif()
 
 set( ANDROID_TOOLCHAIN_DIR "${ANDROID_TOOLCHAIN_DIR}" CACHE INTERNAL "Android standalone toolchain directory" FORCE )
 set( ANDROID_SYSROOT "${ANDROID_TOOLCHAIN_DIR}/sysroot" CACHE INTERNAL "Android Sysroot" FORCE )
 
+# CMAKE_EXECUTABLE_SUFFIX is undefined in CMAKE_TOOLCHAIN_FILE
+if( WIN32 )
+ set( EXECUTABLE_SUFFIX ".exe" )
+endif()
+
 # force python exe to be the one in Android toolchian
-set( PYTHON_EXECUTABLE "${ANDROID_TOOLCHAIN_DIR}/bin/python" CACHE INTERNAL "Python exec path" FORCE )
+set( PYTHON_EXECUTABLE "${ANDROID_TOOLCHAIN_DIR}/bin/python${EXECUTABLE_SUFFIX}" CACHE INTERNAL "Python exec path" FORCE )
 
 if( NOT CMAKE_C_COMPILER )
- set( CMAKE_C_COMPILER   "${ANDROID_TOOLCHAIN_DIR}/bin/${ANDROID_TOOLCHAIN_NAME}-gcc"     CACHE PATH "C compiler" )
- set( CMAKE_CXX_COMPILER "${ANDROID_TOOLCHAIN_DIR}/bin/${ANDROID_TOOLCHAIN_NAME}-g++"     CACHE PATH "C++ compiler" )
- set( CMAKE_ASM_COMPILER "${ANDROID_TOOLCHAIN_DIR}/bin/${ANDROID_TOOLCHAIN_NAME}-gcc"     CACHE PATH "assembler" )
- set( CMAKE_STRIP        "${ANDROID_TOOLCHAIN_DIR}/bin/${ANDROID_TOOLCHAIN_NAME}-strip"   CACHE PATH "strip" )
- set( CMAKE_AR           "${ANDROID_TOOLCHAIN_DIR}/bin/${ANDROID_TOOLCHAIN_NAME}-ar"      CACHE PATH "archive" )
- set( CMAKE_LINKER       "${ANDROID_TOOLCHAIN_DIR}/bin/${ANDROID_TOOLCHAIN_NAME}-ld"      CACHE PATH "linker" )
- set( CMAKE_NM           "${ANDROID_TOOLCHAIN_DIR}/bin/${ANDROID_TOOLCHAIN_NAME}-nm"      CACHE PATH "nm" )
- set( CMAKE_OBJCOPY      "${ANDROID_TOOLCHAIN_DIR}/bin/${ANDROID_TOOLCHAIN_NAME}-objcopy" CACHE PATH "objcopy" )
- set( CMAKE_OBJDUMP      "${ANDROID_TOOLCHAIN_DIR}/bin/${ANDROID_TOOLCHAIN_NAME}-objdump" CACHE PATH "objdump" )
- set( CMAKE_RANLIB       "${ANDROID_TOOLCHAIN_DIR}/bin/${ANDROID_TOOLCHAIN_NAME}-ranlib"  CACHE PATH "ranlib" )
+ set( CMAKE_C_COMPILER   "${ANDROID_TOOLCHAIN_DIR}/bin/${ANDROID_TOOLCHAIN_NAME}-gcc${EXECUTABLE_SUFFIX}"     CACHE PATH "C compiler" )
+ set( CMAKE_CXX_COMPILER "${ANDROID_TOOLCHAIN_DIR}/bin/${ANDROID_TOOLCHAIN_NAME}-g++${EXECUTABLE_SUFFIX}"     CACHE PATH "C++ compiler" )
+ set( CMAKE_ASM_COMPILER "${ANDROID_TOOLCHAIN_DIR}/bin/${ANDROID_TOOLCHAIN_NAME}-gcc${EXECUTABLE_SUFFIX}"     CACHE PATH "assembler" )
+ set( CMAKE_STRIP        "${ANDROID_TOOLCHAIN_DIR}/bin/${ANDROID_TOOLCHAIN_NAME}-strip${EXECUTABLE_SUFFIX}"   CACHE PATH "strip" )
+ set( CMAKE_AR           "${ANDROID_TOOLCHAIN_DIR}/bin/${ANDROID_TOOLCHAIN_NAME}-ar${EXECUTABLE_SUFFIX}"      CACHE PATH "archive" )
+ set( CMAKE_LINKER       "${ANDROID_TOOLCHAIN_DIR}/bin/${ANDROID_TOOLCHAIN_NAME}-ld${EXECUTABLE_SUFFIX}"      CACHE PATH "linker" )
+ set( CMAKE_NM           "${ANDROID_TOOLCHAIN_DIR}/bin/${ANDROID_TOOLCHAIN_NAME}-nm${EXECUTABLE_SUFFIX}"      CACHE PATH "nm" )
+ set( CMAKE_OBJCOPY      "${ANDROID_TOOLCHAIN_DIR}/bin/${ANDROID_TOOLCHAIN_NAME}-objcopy${EXECUTABLE_SUFFIX}" CACHE PATH "objcopy" )
+ set( CMAKE_OBJDUMP      "${ANDROID_TOOLCHAIN_DIR}/bin/${ANDROID_TOOLCHAIN_NAME}-objdump${EXECUTABLE_SUFFIX}" CACHE PATH "objdump" )
+ set( CMAKE_RANLIB       "${ANDROID_TOOLCHAIN_DIR}/bin/${ANDROID_TOOLCHAIN_NAME}-ranlib${EXECUTABLE_SUFFIX}"  CACHE PATH "ranlib" )
 endif()
 
 set( ANDROID_CXX_FLAGS "--sysroot=${ANDROID_SYSROOT} -pie -fPIE -funwind-tables -fsigned-char -no-canonical-prefixes" )
 # TODO: different ARM abi have different flags such as neon, vfpv etc
 if( X86 )
  set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -funswitch-loops -finline-limit=300" )
 endif()
 

docs/lldb-for-gdb-users.txt

 
 (lldb) thread step-inst
 (lldb) thread step-over-inst
 
 Finally, there's:
 
 (lldb) thread until 100
 
-which runs the thread in the current frame till it reaches line 100 in
+Which runs the thread in the current frame till it reaches line 100 in
 this frame or stops if it leaves the current frame.  This is a pretty 
 close equivalent to gdb's "until" command.
 
 
 One thing here that might be a little disconcerting to gdb users here is that
 when you resume process execution, you immediately get a prompt back.  That's
 because the lldb interpreter remains live when you are running the target.
 This allows you to set a breakpoint, etc without having to explicitly interrupt

include/lldb/API/SBDefines.h

 class LLDB_API SBExpressionOptions;
 class LLDB_API SBFileSpec;
 class LLDB_API SBFileSpecList;
 class LLDB_API SBFrame;
 class LLDB_API SBFunction;
 class LLDB_API SBHostOS;
 class LLDB_API SBInstruction;
 class LLDB_API SBInstructionList;
+class LLDB_API SBLanguageRuntime;
 class LLDB_API SBLaunchInfo;
 class LLDB_API SBLineEntry;
 class LLDB_API SBListener;
 class LLDB_API SBModule;
 class LLDB_API SBModuleSpec;
 class LLDB_API SBModuleSpecList;
 class LLDB_API SBProcess;
 class LLDB_API SBQueue;

include/lldb/API/SBLanguageRuntime.h

+//===-- SBLanguageRuntime.h -------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SBLanguageRuntime_h_
+#define LLDB_SBLanguageRuntime_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class SBLanguageRuntime
+{
+public:
+    static lldb::LanguageType
+    GetLanguageTypeFromString (const char *string);
+    
+    static const char *
+    GetNameForLanguageType (lldb::LanguageType language);
+};
+
+} // namespace lldb
+
+#endif // LLDB_SBLanguageRuntime_h_

scripts/Python/build-swig-Python.sh

 " ${SRC_ROOT}/include/lldb/API/SBExecutionContext.h"\
 " ${SRC_ROOT}/include/lldb/API/SBExpressionOptions.h"\
 " ${SRC_ROOT}/include/lldb/API/SBFileSpec.h"\
 " ${SRC_ROOT}/include/lldb/API/SBFrame.h"\
 " ${SRC_ROOT}/include/lldb/API/SBFunction.h"\
 " ${SRC_ROOT}/include/lldb/API/SBHostOS.h"\
 " ${SRC_ROOT}/include/lldb/API/SBInstruction.h"\
 " ${SRC_ROOT}/include/lldb/API/SBInstructionList.h"\
+" ${SRC_ROOT}/include/lldb/API/SBLanguageRuntime.h"\
 " ${SRC_ROOT}/include/lldb/API/SBLaunchInfo.h"\
 " ${SRC_ROOT}/include/lldb/API/SBLineEntry.h"\
 " ${SRC_ROOT}/include/lldb/API/SBListener.h"\
 " ${SRC_ROOT}/include/lldb/API/SBModule.h"\
 " ${SRC_ROOT}/include/lldb/API/SBModuleSpec.h"\
 " ${SRC_ROOT}/include/lldb/API/SBProcess.h"\
 " ${SRC_ROOT}/include/lldb/API/SBQueue.h"\
 " ${SRC_ROOT}/include/lldb/API/SBQueueItem.h"\

 " ${SRC_ROOT}/scripts/interface/SBExecutionContext.i"\
 " ${SRC_ROOT}/scripts/interface/SBExpressionOptions.i"\
 " ${SRC_ROOT}/scripts/interface/SBFileSpec.i"\
 " ${SRC_ROOT}/scripts/interface/SBFrame.i"\
 " ${SRC_ROOT}/scripts/interface/SBFunction.i"\
 " ${SRC_ROOT}/scripts/interface/SBHostOS.i"\
 " ${SRC_ROOT}/scripts/interface/SBInstruction.i"\
 " ${SRC_ROOT}/scripts/interface/SBInstructionList.i"\
+" ${SRC_ROOT}/scripts/interface/SBLanguageRuntime.i"\
 " ${SRC_ROOT}/scripts/interface/SBLaunchInfo.i"\
 " ${SRC_ROOT}/scripts/interface/SBLineEntry.i"\
 " ${SRC_ROOT}/scripts/interface/SBListener.i"\
 " ${SRC_ROOT}/scripts/interface/SBModule.i"\
 " ${SRC_ROOT}/scripts/interface/SBModuleSpec.i"\
 " ${SRC_ROOT}/scripts/interface/SBPlatform.i"\
 " ${SRC_ROOT}/scripts/interface/SBProcess.i"\
 " ${SRC_ROOT}/scripts/interface/SBQueue.i"\

scripts/Python/buildSwigPython.py

listHeaderFiles = [ "/include/lldb/API/lldb.h", # .sh has /include/lldb/lldb.h 21/11/2013
             "/include/lldb/API/SBExpressionOptions.h",
             "/include/lldb/API/SBFileSpec.h",
             "/include/lldb/API/SBFrame.h",
             "/include/lldb/API/SBFunction.h",
             "/include/lldb/API/SBHostOS.h",
             "/include/lldb/API/SBInputReader.h",
             "/include/lldb/API/SBInstruction.h",
             "/include/lldb/API/SBInstructionList.h",
+            "/include/lldb/API/SBLanguageRuntime.h",
             "/include/lldb/API/SBLaunchInfo.h",
             "/include/lldb/API/SBLineEntry.h",
             "/include/lldb/API/SBListener.h",
             "/include/lldb/API/SBModule.h",
             "/include/lldb/API/SBModuleSpec.h",
             "/include/lldb/API/SBProcess.h",
             "/include/lldb/API/SBSourceManager.h",
             "/include/lldb/API/SBStream.h",
listIFaceFiles = [  "/scripts/interface/SBAddress.i",
             "/scripts/interface/SBExpressionOptions.i",
             "/scripts/interface/SBFileSpec.i",
             "/scripts/interface/SBFrame.i",
             "/scripts/interface/SBFunction.i",
             "/scripts/interface/SBHostOS.i",
             "/scripts/interface/SBInputReader.i",
             "/scripts/interface/SBInstruction.i",
             "/scripts/interface/SBInstructionList.i",
+            "/scripts/interface/SBLanguageRuntime.i",
             "/scripts/interface/SBLaunchInfo.i",
             "/scripts/interface/SBLineEntry.i",
             "/scripts/interface/SBListener.i",
             "/scripts/interface/SBModule.i",
             "/scripts/interface/SBModuleSpec.i",
             "/scripts/interface/SBProcess.i",
             "/scripts/interface/SBSourceManager.i",
             "/scripts/interface/SBStream.i",

scripts/interface/SBLanguageRuntime.i

+//===-- SWIG Interface for SBLanguageRuntime --------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+namespace lldb {
+
+class SBLanguageRuntime
+{
+public:
+    static lldb::LanguageType
+    GetLanguageTypeFromString (const char *string);
+    
+    static const char *
+    GetNameForLanguageType (lldb::LanguageType language);
+};
+
+} // namespace lldb

scripts/lldb.swig

 #include "lldb/API/SBExpressionOptions.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBFileSpecList.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBFunction.h"
 #include "lldb/API/SBHostOS.h"
 #include "lldb/API/SBInstruction.h"
 #include "lldb/API/SBInstructionList.h"
+#include "lldb/API/SBLanguageRuntime.h"
 #include "lldb/API/SBLaunchInfo.h"
 #include "lldb/API/SBLineEntry.h"
 #include "lldb/API/SBListener.h"
 #include "lldb/API/SBModule.h"
 #include "lldb/API/SBModuleSpec.h"
 #include "lldb/API/SBPlatform.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBQueue.h"

 %include "./interface/SBExpressionOptions.i"
 %include "./interface/SBFileSpec.i"
 %include "./interface/SBFileSpecList.i"
 %include "./interface/SBFrame.i"
 %include "./interface/SBFunction.i"
 %include "./interface/SBHostOS.i"
 %include "./interface/SBInstruction.i"
 %include "./interface/SBInstructionList.i"
+%include "./interface/SBLanguageRuntime.i"
 %include "./interface/SBLaunchInfo.i"
 %include "./interface/SBLineEntry.i"
 %include "./interface/SBListener.i"
 %include "./interface/SBModule.i"
 %include "./interface/SBModuleSpec.i"
 %include "./interface/SBPlatform.i"
 %include "./interface/SBProcess.i"
 %include "./interface/SBQueue.i"

source/API/CMakeLists.txt

add_lldb_library(liblldb SHARED
   SBExpressionOptions.cpp
   SBFileSpec.cpp
   SBFileSpecList.cpp
   SBFrame.cpp
   SBFunction.cpp
   SBHostOS.cpp
   SBInstruction.cpp
   SBInstructionList.cpp
+  SBLanguageRuntime.cpp
   SBLaunchInfo.cpp
   SBLineEntry.cpp
   SBListener.cpp
   SBModule.cpp
   SBModuleSpec.cpp
   SBPlatform.cpp
   SBProcess.cpp
   SBQueue.cpp

source/API/SBLanguageRuntime.cpp

+//===-- SBLanguageRuntime.cpp -----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/API/SBLanguageRuntime.h"
+#include "lldb/Target/LanguageRuntime.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+lldb::LanguageType
+SBLanguageRuntime::GetLanguageTypeFromString (const char *string)
+{
+    return LanguageRuntime::GetLanguageTypeFromString(string);
+}
+
+const char *
+SBLanguageRuntime::GetNameForLanguageType (lldb::LanguageType language)
+{
+    return LanguageRuntime::GetNameForLanguageType(language);
+}

source/Core/Address.cpp

case DumpStyleDetailedSymbolContext:
                     
                     const size_t num_variables = variable_list.GetSize();
                     for (size_t var_idx = 0; var_idx < num_variables; ++var_idx)
                     {
                         Variable *var = variable_list.GetVariableAtIndex (var_idx).get();
                         if (var && var->LocationIsValidForAddress (*this))
                         {
                             s->Indent();
-                            s->Printf ("   Variable: id = {0x%8.8" PRIx64 "}, name = \"%s\", type= \"%s\", location =",
+                            s->Printf ("   Variable: id = {0x%8.8" PRIx64 "}, name = \"%s\"",
                                        var->GetID(),
-                                       var->GetName().GetCString(),
-                                       var->GetType()->GetName().GetCString());
+                                       var->GetName().GetCString());
+                            Type *type = var->GetType();
+                            if (type)
+                                s->Printf(", type = \"%s\"", type->GetName().GetCString());
+                            else
+                                s->PutCString(", type = <unknown>");
+                            s->PutCString(", location = ");
                             var->DumpLocationForAddress(s, *this);
                             s->PutCString(", decl = ");
                             var->GetDeclaration().DumpStopContext(s, false);
                             s->EOL();
                         }
                     }
                 }
             }

source/Plugins/Process/Linux/NativeProcessLinux.h

private:
 
         static void *
         MonitorThread(void *baton);
 
         void
         MonitorCallback(lldb::pid_t pid, bool exited, int signal, int status);
 
         void
+        WaitForNewThread(::pid_t tid);
+
+        void
         MonitorSIGTRAP(const siginfo_t *info, lldb::pid_t pid);
 
         void
         MonitorTrace(lldb::pid_t pid, NativeThreadProtocolSP thread_sp);
 
         void
         MonitorBreakpoint(lldb::pid_t pid, NativeThreadProtocolSP thread_sp);
 

source/Plugins/Process/Linux/NativeProcessLinux.cpp

else
                 if (log)
                     log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " tid %" PRIu64 " non-main thread exit occurred, didn't tell delegate anything since thread disappeared out from underneath us", __FUNCTION__, GetID (), pid);
             }
         }
     }
 }
 
 void
+NativeProcessLinux::WaitForNewThread(::pid_t tid)
+{
+    Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
+
+    NativeThreadProtocolSP new_thread_sp = GetThreadByID(tid);
+
+    if (new_thread_sp)
+    {
+        // We are already tracking the thread - we got the event on the new thread (see
+        // MonitorSignal) before this one. We are done.
+        return;
+    }
+
+    // The thread is not tracked yet, let's wait for it to appear.
+    int status = -1;
+    ::pid_t wait_pid;
+    do
+    {
+        if (log)
+            log->Printf ("NativeProcessLinux::%s() received thread creation event for tid %" PRIu32 ". tid not tracked yet, waiting for thread to appear...", __FUNCTION__, tid);
+        wait_pid = waitpid(tid, &status, __WALL);
+    }
+    while (wait_pid == -1 && errno == EINTR);
+    // Since we are waiting on a specific tid, this must be the creation event. But let's do
+    // some checks just in case.
+    if (wait_pid != tid) {
+        if (log)
+            log->Printf ("NativeProcessLinux::%s() waiting for tid %" PRIu32 " failed. Assuming the thread has disappeared in the meantime", __FUNCTION__, tid);
+        // The only way I know of this could happen is if the whole process was
+        // SIGKILLed in the mean time. In any case, we can't do anything about that now.
+        return;
+    }
+    if (WIFEXITED(status))
+    {
+        if (log)
+            log->Printf ("NativeProcessLinux::%s() waiting for tid %" PRIu32 " returned an 'exited' event. Not tracking the thread.", __FUNCTION__, tid);
+        // Also a very improbable event.
+        return;
+    }
+
+    siginfo_t info;
+    Error error = GetSignalInfo(tid, &info);
+    if (error.Fail())
+    {
+        if (log)
+            log->Printf ("NativeProcessLinux::%s() GetSignalInfo for tid %" PRIu32 " failed. Assuming the thread has disappeared in the meantime.", __FUNCTION__, tid);
+        return;
+    }
+
+    if (((info.si_pid != 0) || (info.si_code != SI_USER)) && log)
+    {
+        // We should be getting a thread creation signal here, but we received something
+        // else. There isn't much we can do about it now, so we will just log that. Since the
+        // thread is alive and we are receiving events from it, we shall pretend that it was
+        // created properly.
+        log->Printf ("NativeProcessLinux::%s() GetSignalInfo for tid %" PRIu32 " received unexpected signal with code %d from pid %d.", __FUNCTION__, tid, info.si_code, info.si_pid);
+    }
+
+    if (log)
+        log->Printf ("NativeProcessLinux::%s() pid = %" PRIu64 ": tracking new thread tid %" PRIu32,
+                 __FUNCTION__, GetID (), tid);
+
+    new_thread_sp = AddThread(tid);
+    std::static_pointer_cast<NativeThreadLinux> (new_thread_sp)->SetRunning ();
+    Resume (tid, LLDB_INVALID_SIGNAL_NUMBER);
+    m_coordinator_up->NotifyThreadCreate (tid, false, CoordinatorErrorHandler);
+}
+
+void
 NativeProcessLinux::MonitorSIGTRAP(const siginfo_t *info, lldb::pid_t pid)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
     const bool is_main_thread = (pid == GetID ());
 
     assert(info && info->si_signo == SIGTRAP && "Unexpected child signal!");
     if (!info)
         return;
NativeProcessLinux::MonitorSIGTRAP(const siginfo_t *info, lldb::pid_t pid)
     {
     // TODO: these two cases are required if we want to support tracing of the inferiors' children.  We'd need this to debug a monitor.
     // case (SIGTRAP | (PTRACE_EVENT_FORK << 8)):
     // case (SIGTRAP | (PTRACE_EVENT_VFORK << 8)):
 
     case (SIGTRAP | (PTRACE_EVENT_CLONE << 8)):
     {
         // This is the notification on the parent thread which informs us of new thread
-        // creation. We are not interested in these events at this point (an interesting use
-        // case would be to stop the process upon thread creation), so we just resume the thread.
-        // We will pickup the new thread when we get its SIGSTOP notification.
+        // creation.
+        // We don't want to do anything with the parent thread so we just resume it. In case we
+        // want to implement "break on thread creation" functionality, we would need to stop
+        // here.
 
-        if (log)
-        {
-            unsigned long event_message = 0;
-            if (GetEventMessage (pid, &event_message).Success())
-            {
-                lldb::tid_t tid = static_cast<lldb::tid_t> (event_message);
-                log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 " received thread creation event for tid %" PRIu64, __FUNCTION__, pid, tid);
-
-            }
-            else
+        if (GetEventMessage (pid, &event_message).Fail())
+            if (log)
                 log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 " received thread creation event but GetEventMessage failed so we don't know the new tid", __FUNCTION__, pid);
-        }
+        } else 
+            WaitForNewThread(event_message);
 
         Resume (pid, LLDB_INVALID_SIGNAL_NUMBER);
         break;
     }
 
     case (SIGTRAP | (PTRACE_EVENT_EXEC << 8)):
     {
         NativeThreadProtocolSP main_thread_sp;
if (info->si_code == SI_TKILL || info->si_code == SI_USER)
                             info->si_pid,
                             is_from_llgs ? "from llgs" : "not from llgs",
                             pid);
     }
 
     // Check for new thread notification.
     if ((info->si_pid == 0) && (info->si_code == SI_USER))
     {
-        // A new thread creation is being signaled.  This is one of two parts that come in
-        // a non-deterministic order.  pid is the thread id.
+        // A new thread creation is being signaled. This is one of two parts that come in
+        // a non-deterministic order. This code handles the case where the new thread event comes
+        // before the event on the parent thread. For the opposite case see code in
+        // MonitorSIGTRAP.
         if (log)
             log->Printf ("NativeProcessLinux::%s() pid = %" PRIu64 " tid %" PRIu64 ": new thread notification",
                      __FUNCTION__, GetID (), pid);
 
         thread_sp = AddThread(pid);
         assert (thread_sp.get() && "failed to create the tracking data for newly created inferior thread");
         // We can now resume the newly created thread.
         std::static_pointer_cast<NativeThreadLinux> (thread_sp)->SetRunning ();

test/functionalities/process_attach/TestProcessAttach.py

class ProcessAttachTestCase(TestBase):
     @skipUnlessDarwin
     @dsym_test
     def test_attach_to_process_by_id_with_dsym(self):
         """Test attach by process id"""
         self.buildDsym()
         self.process_attach_by_id()
 
     @dwarf_test
+    @skipIfLinux # llvm.org/pr23360
     def test_attach_to_process_by_id_with_dwarf(self):
         """Test attach by process id"""
         self.buildDwarf()
         self.process_attach_by_id()
 
     @skipUnlessDarwin
     @dsym_test
     def test_attach_to_process_by_name_with_dsym(self):
         """Test attach by process name"""
         self.buildDsym()
         self.process_attach_by_name()
 
     @dwarf_test
+    @skipIfLinux # llvm.org/pr23360
     def test_attach_to_process_by_name_with_dwarf(self):
         """Test attach by process name"""
         self.buildDwarf()
         self.process_attach_by_name()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)

test/tools/lldb-mi/TestMiGdbSetShow.py

def test_lldbmi_gdb_show_target_async(self):
         self.spawnLldbMi(args = None)
 
         # Test that default target-async value is "on"
         self.runCmd("-gdb-show target-async")
         self.expect("\^done,value=\"on\"")
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
+    def test_lldbmi_gdb_show_language(self):
+        """Test that 'lldb-mi --interpreter' can get current language."""
+
+        self.spawnLldbMi(args = None)
+
+        # Load executable
+        self.runCmd("-file-exec-and-symbols %s" % self.myexe)
+        self.expect("\^done")
+
+        # Run to main
+        self.runCmd("-break-insert -f main")
+        self.expect("\^done,bkpt={number=\"1\"")
+        self.runCmd("-exec-run")
+        self.expect("\^running")
+        self.expect("\*stopped,reason=\"breakpoint-hit\"")
+
+        # Test that -gdb-show language gets current language
+        self.runCmd("-gdb-show language")
+        self.expect("\^done,value=\"c\+\+\"")
+
+    @lldbmi_test
+    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @unittest2.expectedFailure("-gdb-set ignores unknown properties")
     def test_lldbmi_gdb_set_unknown(self):
         """Test that 'lldb-mi --interpreter' fails when setting an unknown property."""
 
         self.spawnLldbMi(args = None)
 
         # Test that -gdb-set fails if property is unknown
         self.runCmd("-gdb-set unknown some_value")

test/tools/lldb-mi/variable/TestMiVar.py

def test_lldbmi_eval(self):
         self.expect("\^done,value=\"3\"")
         self.runCmd("-var-create var2 * g_MyVar")
         self.expect("\^done,name=\"var2\",numchild=\"0\",value=\"3\",type=\"int\",thread-id=\"1\",has_more=\"0\"")
         self.runCmd("-var-evaluate-expression var2")
         self.expect("\^done,value=\"3\"")
         self.runCmd("-var-show-attributes var2")
         self.expect("\^done,status=\"editable\"")
         self.runCmd("-var-list-children var2")
-        self.expect("\^done,numchild=\"0\",children=\"\[\]\"")
+        self.expect("\^done,numchild=\"0\"")
         self.runCmd("-data-evaluate-expression \"g_MyVar=30\"")
         self.expect("\^done,value=\"30\"")
         self.runCmd("-var-update --all-values var2")
         #self.expect("\^done,changelist=\[\{name=\"var2\",value=\"30\",in_scope=\"true\",type_changed=\"false\",has_more=\"0\"\}\]") #FIXME -var-update doesn't work
         self.runCmd("-var-delete var2")
         self.expect("\^done")
         self.runCmd("-var-create var2 * g_MyVar")
         self.expect("\^done,name=\"var2\",numchild=\"0\",value=\"30\",type=\"int\",thread-id=\"1\",has_more=\"0\"")
 
         # Print static "s_MyVar", modify, delete and create again
         self.runCmd("-data-evaluate-expression s_MyVar")
         self.expect("\^done,value=\"30\"")
         self.runCmd("-var-create var3 * s_MyVar")
         self.expect("\^done,name=\"var3\",numchild=\"0\",value=\"30\",type=\"int\",thread-id=\"1\",has_more=\"0\"")
         self.runCmd("-var-evaluate-expression var3")
         self.expect("\^done,value=\"30\"")
         self.runCmd("-var-show-attributes var3")
         self.expect("\^done,status=\"editable\"")
         self.runCmd("-var-list-children var3")
-        self.expect("\^done,numchild=\"0\",children=\"\[\]\"")
+        self.expect("\^done,numchild=\"0\"")
         self.runCmd("-data-evaluate-expression \"s_MyVar=3\"")
         self.expect("\^done,value=\"3\"")
         self.runCmd("-var-update --all-values var3")
         #self.expect("\^done,changelist=\[\{name=\"var3\",value=\"3\",in_scope=\"true\",type_changed=\"false\",has_more=\"0\"\}\]") #FIXME -var-update doesn't work
         self.runCmd("-var-delete var3")
         self.expect("\^done")
         self.runCmd("-var-create var3 * s_MyVar")
         self.expect("\^done,name=\"var3\",numchild=\"0\",value=\"3\",type=\"int\",thread-id=\"1\",has_more=\"0\"")
 
         # Print local "b", modify, delete and create again
         self.runCmd("-data-evaluate-expression b")
         self.expect("\^done,value=\"20\"")
         self.runCmd("-var-create var4 * b")
         self.expect("\^done,name=\"var4\",numchild=\"0\",value=\"20\",type=\"int\",thread-id=\"1\",has_more=\"0\"")
         self.runCmd("-var-evaluate-expression var4")
         self.expect("\^done,value=\"20\"")
         self.runCmd("-var-show-attributes var4")
         self.expect("\^done,status=\"editable\"")
         self.runCmd("-var-list-children var4")
-        self.expect("\^done,numchild=\"0\",children=\"\[\]\"")
+        self.expect("\^done,numchild=\"0\"")
         self.runCmd("-data-evaluate-expression \"b=2\"")
         self.expect("\^done,value=\"2\"")
         self.runCmd("-var-update --all-values var4")
         #self.expect("\^done,changelist=\[\{name=\"var4\",value=\"2\",in_scope=\"true\",type_changed=\"false\",has_more=\"0\"\}\]") #FIXME -var-update doesn't work
         self.runCmd("-var-delete var4")
         self.expect("\^done")
         self.runCmd("-var-create var4 * b")
         self.expect("\^done,name=\"var4\",numchild=\"0\",value=\"2\",type=\"int\",thread-id=\"1\",has_more=\"0\"")
 
         # Print temp "a + b"
         self.runCmd("-data-evaluate-expression \"a + b\"")
         self.expect("\^done,value=\"12\"")
         self.runCmd("-var-create var5 * \"a + b\"")
         self.expect("\^done,name=\"var5\",numchild=\"0\",value=\"12\",type=\"int\",thread-id=\"1\",has_more=\"0\"")
         self.runCmd("-var-evaluate-expression var5")
         self.expect("\^done,value=\"12\"")
         self.runCmd("-var-show-attributes var5")
         self.expect("\^done,status=\"editable\"") #FIXME editable or not?
         self.runCmd("-var-list-children var5")
-        self.expect("\^done,numchild=\"0\",children=\"\[\]\"")
+        self.expect("\^done,numchild=\"0\"")
 
         # Print argument "argv[0]"
         self.runCmd("-data-evaluate-expression \"argv[0]\"")
         self.expect("\^done,value=\"0x[0-9a-f]+\"")
         self.runCmd("-var-create var6 * \"argv[0]\"")
         self.expect("\^done,name=\"var6\",numchild=\"1\",value=\"0x[0-9a-f]+ \\\\\\\".*?%s\\\\\\\"\",type=\"const char \*\",thread-id=\"1\",has_more=\"0\"" % self.myexe)
         self.runCmd("-var-evaluate-expression var6")
         self.expect("\^done,value=\"0x[0-9a-f]+ \\\\\\\".*?%s\\\\\\\"\"" % self.myexe)

tools/lldb-mi/MICmdCmdGdbShow.h

private:
     typedef bool (CMICmdCmdGdbShow::*FnGdbOptionPtr)(const CMIUtilString::VecString_t &vrWords);
     typedef std::map<CMIUtilString, FnGdbOptionPtr> MapGdbOptionNameToFnGdbOptionPtr_t;
 
     // Methods:
   private:
     bool GetOptionFn(const CMIUtilString &vrGdbOptionName, FnGdbOptionPtr &vrwpFn) const;
     bool OptionFnTargetAsync(const CMIUtilString::VecString_t &vrWords);
     bool OptionFnPrint(const CMIUtilString::VecString_t &vrWords);
+    bool OptionFnLanguage(const CMIUtilString::VecString_t &vrWords);
     bool OptionFnFallback(const CMIUtilString::VecString_t &vrWords);
 
     // Attributes:
   private:
     const static MapGdbOptionNameToFnGdbOptionPtr_t ms_mapGdbOptionNameToFnGdbOptionPtr;
     //
     const CMIUtilString m_constStrArgNamedThreadGrp;
     const CMIUtilString m_constStrArgNamedGdbOption;
     bool m_bGdbOptionRecognised;   // True = This command has a function with a name that matches the Print argument, false = not found
     bool m_bGdbOptionFnSuccessful; // True = The print function completed its task ok, false = function failed for some reason
     bool m_bGbbOptionFnHasError;   // True = The option function has an error condition (not the command!), false = option function ok.
     CMIUtilString m_strGdbOptionName;
     CMIUtilString m_strGdbOptionFnError;
     CMIUtilString m_strValue;
 };

tools/lldb-mi/MICmdCmdGdbShow.cpp

 //===-- MICmdCmdGdbShow.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // Overview:    CMICmdCmdGdbShow implementation.
 
+// Third party headers:
+#include "lldb/API/SBCompileUnit.h"
+#include "lldb/API/SBFrame.h"
+#include "lldb/API/SBLanguageRuntime.h"
+#include "lldb/API/SBThread.h"
+
 // In-house headers:
 #include "MICmdCmdGdbShow.h"
 #include "MICmnMIResultRecord.h"
 #include "MICmnMIValueConst.h"
 #include "MICmdArgValString.h"
 #include "MICmdArgValListOfN.h"
 #include "MICmdArgValOptionLong.h"
 #include "MICmnLLDBDebugSessionInfo.h"
 
 // Instantiations:
 const CMICmdCmdGdbShow::MapGdbOptionNameToFnGdbOptionPtr_t CMICmdCmdGdbShow::ms_mapGdbOptionNameToFnGdbOptionPtr = {
     {"target-async", &CMICmdCmdGdbShow::OptionFnTargetAsync},
     {"print", &CMICmdCmdGdbShow::OptionFnPrint},
+    {"language", &CMICmdCmdGdbShow::OptionFnLanguage},
     {"fallback", &CMICmdCmdGdbShow::OptionFnFallback}};
 
 //++ ------------------------------------------------------------------------------------
 // Details: CMICmdCmdGdbShow constructor.
 // Type:    Method.
 // Args:    None.
 // Return:  None.
 // Throws:  None.
CMICmdCmdGdbShow::OptionFnPrint(const CMIUtilString::VecString_t &vrWords)
     bOptionValue = bOptionValueDefault ? !m_rLLDBDebugSessionInfo.SharedDataRetrieve<bool>(strOptionKey, bOptionValue) || bOptionValue
         : m_rLLDBDebugSessionInfo.SharedDataRetrieve<bool>(strOptionKey, bOptionValue) && bOptionValue;
 
     m_strValue = bOptionValue ? "on" : "off";
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
+// Details: Carry out work to complete the GDB show option 'language' to prepare
+//          and send back the requested information.
+// Type:    Method.
+// Args:    vrWords - (R) List of additional parameters used by this option.
+// Return:  MIstatus::success - Function succeeded.
+//          MIstatus::failure - Function failed.
+// Throws:  None.
+//--
+bool
+CMICmdCmdGdbShow::OptionFnLanguage(const CMIUtilString::VecString_t &vrWords)
+{
+    MIunused(vrWords);
+
+    // Get current language
+    CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
+    lldb::SBThread sbThread = rSessionInfo.GetProcess().GetSelectedThread();
+    const lldb::SBFrame sbFrame = sbThread.GetSelectedFrame();
+    lldb::SBCompileUnit sbCompileUnit = sbFrame.GetCompileUnit();
+    const lldb::LanguageType eLanguageType = sbCompileUnit.GetLanguage();
+
+    m_strValue = lldb::SBLanguageRuntime::GetNameForLanguageType(eLanguageType);
+    return MIstatus::success;
+}
+
+//++ ------------------------------------------------------------------------------------
 // Details: Carry out work to complete the GDB show option to prepare and send back the
 //          requested information.
 // Type:    Method.
 // Args:    None.
 // Return:  MIstatus::success - Function succeeded.
 //          MIstatus::failure - Function failed.
 // Throws:  None.
 //--

tools/lldb-mi/MICmdCmdVar.cpp

CMICmdCmdVarListChildren::Acknowledge(void)
     if (m_bValueValid)
     {
         // MI print "%s^done,numchild=\"%u\",children=[]""
         const CMIUtilString strNumChild(CMIUtilString::Format("%u", m_nChildren));
         const CMICmnMIValueConst miValueConst(strNumChild);
         CMICmnMIValueResult miValueResult("numchild", miValueConst);
 
         VecMIValueResult_t::const_iterator it = m_vecMiValueResult.begin();
-        if (it == m_vecMiValueResult.end())
-        {
-            const CMICmnMIValueConst miValueConst("[]");
-            miValueResult.Add("children", miValueConst);
-        }
-        else
+        if (it != m_vecMiValueResult.end())
         {
             CMICmnMIValueList miValueList(*it);
             ++it;
             while (it != m_vecMiValueResult.end())
             {
                 const CMICmnMIValueResult &rResult(*it);
                 miValueList.Add(rResult);
 

tools/lldb-mi/MIUtilString.cpp

 #include <limits.h>   // for ULONG_MAX
 #include <memory>     // std::unique_ptr
 #include <sstream>    // std::stringstream
 #include <stdarg.h>   // va_list, va_start, var_end
 #include <string.h>   // for strncmp
 
 // In-house headers:
 #include "MIUtilString.h"
+#include "Platform.h"
 
 //++ ------------------------------------------------------------------------------------
 // Details: CMIUtilString constructor.
 // Type:    Method.
 // Args:    None.
 // Return:  None.
 // Throws:  None.
 //--
for (MIuint nIndex(0); nIndex < nLen; ++nIndex)
                     break;
                 }
                 // FALLTHROUGH
             default:
                 if (::isprint(cUnescapedChar))
                     strNew.push_back(cUnescapedChar);
                 else
                 {
-                    char strEscapedChar[sizeof("\\xXX")];
-                    ::sprintf(strEscapedChar, "\\x%02" PRIx8, cUnescapedChar);
+                    const size_t size = sizeof("\\xXX");
+                    char strEscapedChar[size];
+                    ::snprintf(strEscapedChar, size, "\\x%02" PRIx8, cUnescapedChar);
                     strNew.append(strEscapedChar);
                 }
                 break;
         }
     }
     return strNew;
 }