[lldb/lua] Supplement Lua bindings for lldb module

[siger-young]

Summary

Add necessary typemaps for Lua bindings, together with some other files.

Signed-off-by: Siger Yang <[e-mail]>

[siger-young]

Using lua_newuserdata instead of lua_newuserdatauv to support Lua 5.3

[tammela]

lldb/bindings/lua/lua-typemaps.swig

317

Please fix this

402

This seems it could leak.
Are you sure it doesn't? If so add a comment here explaining where it's freed.

425

426

433

453

The raw variants here are overkill, you can the use normal ones

460

Leaking?

470

else Lua error?

[tammela]

Missing test cases!
Either a script that test it all, individual unit tests or a combination of both.

[siger-young]

This update adds some tests for Lua LLDB module.

[tammela]

Trying to run the tests in my system failed with the following:

FAIL: lldb-api :: lua_api/TestLuaAPI.py (1793 of 2389)
******************** TEST 'lldb-api :: lua_api/TestLuaAPI.py' FAILED ********************
Script:
--
/usr/bin/python3.9 /home/pedro/vm/llvm-HEAD/lldb/test/API/dotest.py -u CXXFLAGS -u CFLAGS --env ARCHIVER=/usr/bin/ar --env OBJCOPY=/usr/bin/objcopy --env LLVM_LIBS_DIR=/home/pedro/vm/llvm-HEAD/build/./lib --arch x86_64 --build-dir /home/pedro/vm/llvm-HEAD/build/lldb-test-build.noindex --lldb-module-cache-dir /home/pedro/vm/llvm-HEAD/build/lldb-test-build.noindex/module-cache-lldb/lldb-api --clang-module-cache-dir /home/pedro/vm/llvm-HEAD/build/lldb-test-build.noindex/module-cache-clang/lldb-api --executable /home/pedro/vm/llvm-HEAD/build/./bin/lldb --compiler /home/pedro/vm/llvm-HEAD/build/./bin/clang --dsymutil /home/pedro/vm/llvm-HEAD/build/./bin/dsymutil --llvm-tools-dir /home/pedro/vm/llvm-HEAD/build/./bin --lldb-libs-dir /home/pedro/vm/llvm-HEAD/build/./lib /home/pedro/vm/llvm-HEAD/lldb/test/API/lua_api -p TestLuaAPI.py --env LUA_EXECUTABLE=/usr/bin/lua5.3
--
Exit Code: 1

Command Output (stdout):
--
lldb version 14.0.0 (https://github.com/llvm/llvm-project.git revision 3c5616bad32ec20af3d160dee79b6da6d5978857)
  clang revision 3c5616bad32ec20af3d160dee79b6da6d5978857
  llvm revision 3c5616bad32ec20af3d160dee79b6da6d5978857
Skipping the following test categories: ['libc++', 'dsym', 'gmodules', 'debugserver', 'objc']

--
Command Output (stderr):
--
Traceback (most recent call last):
  File "/home/pedro/vm/llvm-HEAD/lldb/test/API/dotest.py", line 7, in <module>
    lldbsuite.test.run_suite()
  File "/home/pedro/vm/llvm-HEAD/lldb/packages/Python/lldbsuite/test/dotest.py", line 974, in run_suite
    visit('Test', dirpath, filenames)
  File "/home/pedro/vm/llvm-HEAD/lldb/packages/Python/lldbsuite/test/dotest.py", line 681, in visit
    visit_file(dir, name)
  File "/home/pedro/vm/llvm-HEAD/lldb/packages/Python/lldbsuite/test/dotest.py", line 622, in visit_file
    module = __import__(base)
  File "/home/pedro/vm/llvm-HEAD/lldb/test/API/lua_api/TestLuaAPI.py", line 8, in <module>
    import lit.util
ModuleNotFoundError: No module named 'lit'

My guess is that you are not using LLVM's lit but instead using the system's

lldb/CMakeLists.txt

60–68

This is broken if the user specifies another INSTALL_PREFIX, as it forces it to /usr/local/lib/lua/5.3.
I think a safe option is to always set to lib/lua/5.3, so install prefixes can be concatenated freely.

105

I think we are missing the Framework build here.
LLDB_BUILD_FRAMEWORK is a Darwin specific variable, so you will most likely need one to test this.
I can help if you don't have access to a Darwin device.

lldb/bindings/lua/lua-typemaps.swig

195–213

Add comment here saying that the raw calls will restrict the table to be a sequence of strings.

Please add it in other functions as well.

219–221

This is not being generated by SWIG for some reason.

I think it's more readable to just have an else clause that raises an error on line 212.

275

Else clause here for raising an error for types that are not supported

278

This bug was not caught by the tests, perhaps we need to expand it more?
This would certainly generate a NULL pointer de-reference as the argument would always be NULL, since it's replacing the above code with just free().

[siger-young]

lldb/bindings/lua/lua-typemaps.swig

219–221

I tried commenting and uncommenting these lines then diff, found that the typecheck is actually generated on those overloaded functions. SBTarget::Launch no longer works after commenting in my cases:

lua5.3: test.lua:27: Wrong arguments for overloaded function 'SBTarget_Launch'
  Possible C/C++ prototypes are:
    lldb::SBTarget::Launch(lldb::SBListener &,char const **,char const **,char const *,char const *,char const *,char const *,uint32_t,bool,lldb::SBError &)
    lldb::SBTarget::Launch(lldb::SBLaunchInfo &,lldb::SBError &)

It seems that SWIG uses "SWIG_isptrtype" to decide arg matches "char**", so this typecheck is necessary.

For those functions with just one definition (i.e. not overloaded), this typecheck does nothing on them, so it will be typemap(in)'s responsibility to check arg types.

[tammela]

Hi Siger,

We are almost there.
I encourage you to continue working on this patch.

I have been busy the past weeks, but I will try to review ASAP once you address my comments.

lldb/bindings/lua/lua-typemaps.swig

219–221

I see, Thanks.
That was indeed a good way to see what SWIG is generating :).

[JDevlieghere]

lldb/CMakeLists.txt

55–60

FindLuaAndSwig.cmake is responsible for finding Lua. If LLDB_ENABLE_LUA is set, then you can assume Lua is available.

[siger-young]

This update mainly fixed problematic typemaps and adding necessary comments.

Together, it forced Lua installation path as "PREFIX/lib/lua/5.3" and removed "lit.util" in tests.

[siger-young]

Fix typo in SBData test.

[siger-young]

Rebase commits.

[tammela]

Just one last thing and I think we are done!

Thanks for your work.

lldb/test/API/lua_api/lua_lldb_test.lua

4

Could we not use an external dependency?
For instance in my setup it fails because it couldn't find this library.

[siger-young]

lldb/test/API/lua_api/lua_lldb_test.lua

4

Does it make sense to directly copy "luaunit.lua" to the Lua test dir?

[tammela]

lldb/test/API/lua_api/lua_lldb_test.lua

4

You don't seem to have a hard dependency on it.
Couldn't you just replicate what you are interested? Instead of bringing in a full blown unit testing framework...

[siger-young]

Add dependency "luaunit" as an internal one.

[siger-young]

lldb/test/API/lua_api/lua_lldb_test.lua

4

Oh sorry, I didn't notice the comments here.

I will remove the dependency of "luaunit" soon.

[siger-young]

Add assertion functions and error status detection to remove "luaunit"

[tammela]

LGTM.

You will have to rebase to main.

Thanks!

[siger-young]

Pull and merge conflicts, will soon be merged into main.

lldb/CMakeLists.txt

if ("${LLDB_PYTHON_RELATIVE_PATH}" STREQUAL "")
         LLDB_PYTHON_RELATIVE_PATH.")
     endif ()
   endif ()
 
   set(LLDB_PYTHON_RELATIVE_PATH ${LLDB_PYTHON_DEFAULT_RELATIVE_PATH}
     CACHE STRING "Path where Python modules are installed, relative to install prefix")
 endif ()
 
+if (LLDB_ENABLE_LUA)
+  find_program(Lua_EXECUTABLE lua5.3)
+  set(LLDB_LUA_DEFAULT_RELATIVE_PATH "lib/lua/5.3")
+  set(LLDB_LUA_RELATIVE_PATH ${LLDB_LUA_DEFAULT_RELATIVE_PATH}
+    CACHE STRING "Path where Lua modules are installed, relative to install prefix")
+endif ()
+
 if (LLDB_ENABLE_PYTHON OR LLDB_ENABLE_LUA)
   add_subdirectory(bindings)
 endif ()
 
 # We need the headers generated by instrinsics_gen before we can compile
 # any source file in LLDB as the imported Clang modules might include
 # some of these generated headers. This approach is copied from Clang's main
 # CMakeLists.txt, so it should kept in sync the code in Clang which was added
 # in llvm-svn 308844.
 if(LLVM_ENABLE_MODULES)
   list(APPEND LLVM_COMMON_DEPENDS intrinsics_gen)
 endif()
 
 if(CMAKE_CROSSCOMPILING AND LLDB_BUILT_STANDALONE AND NOT LLDB_TABLEGEN_EXE)
   set(LLVM_USE_HOST_TOOLS ON)
   include(CrossCompile)
if(LLDB_BUILD_FRAMEWORK)
     set(lldb_python_target_dir "${LLDB_FRAMEWORK_ABSOLUTE_BUILD_DIR}/LLDB.framework/Resources/Python/lldb")
   else()
     set(lldb_python_target_dir "${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${LLDB_PYTHON_RELATIVE_PATH}/lldb")
   endif()
   get_target_property(lldb_python_bindings_dir swig_wrapper_python BINARY_DIR)
   finish_swig_python("lldb-python" "${lldb_python_bindings_dir}" "${lldb_python_target_dir}")
 endif()
 
+if (LLDB_ENABLE_LUA)
+  if(LLDB_BUILD_FRAMEWORK)
+    set(lldb_lua_target_dir "${LLDB_FRAMEWORK_ABSOLUTE_BUILD_DIR}/LLDB.framework/Resources/Lua")
+  else()
+    set(lldb_lua_target_dir "${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${LLDB_LUA_RELATIVE_PATH}")
+  endif()
+  get_target_property(lldb_lua_bindings_dir swig_wrapper_lua BINARY_DIR)
+  finish_swig_lua("lldb-lua" "${lldb_lua_bindings_dir}" "${lldb_lua_target_dir}")
+endif()
+
 option(LLDB_INCLUDE_TESTS "Generate build targets for the LLDB unit tests." ${LLVM_INCLUDE_TESTS})
 if(LLDB_INCLUDE_TESTS)
   add_subdirectory(test)
   add_subdirectory(unittests)
   add_subdirectory(utils)
 endif()
 
 if(LLDB_BUILT_STANDALONE AND NOT LLVM_ENABLE_IDE)
   llvm_distribution_add_targets()
 endif()

lldb/bindings/lua/CMakeLists.txt

COMMAND ${SWIG_EXECUTABLE}
       -o ${CMAKE_CURRENT_BINARY_DIR}/LLDBWrapLua.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/lua.swig
   VERBATIM
   COMMENT "Building LLDB Lua wrapper")
 
 add_custom_target(swig_wrapper_lua ALL DEPENDS
   ${CMAKE_CURRENT_BINARY_DIR}/LLDBWrapLua.cpp
 )
+
+function(create_lua_package swig_target working_dir pkg_dir)
+  cmake_parse_arguments(ARG "NOINIT" "" "FILES" ${ARGN})
+  add_custom_command(TARGET ${swig_target} POST_BUILD VERBATIM
+    COMMAND ${CMAKE_COMMAND} -E make_directory ${pkg_dir}
+    WORKING_DIRECTORY ${working_dir})
+endfunction()
+
+function(finish_swig_lua swig_target lldb_lua_bindings_dir lldb_lua_target_dir)
+  add_custom_target(${swig_target} ALL VERBATIM
+    COMMAND ${CMAKE_COMMAND} -E make_directory ${lldb_lua_target_dir}
+    DEPENDS swig_wrapper_lua
+    COMMENT "LLDB Lua API")
+  if(LLDB_BUILD_FRAMEWORK)
+    set(LIBLLDB_SYMLINK_DEST "${LLDB_FRAMEWORK_ABSOLUTE_BUILD_DIR}/LLDB.framework/LLDB")
+  else()
+    set(LIBLLDB_SYMLINK_DEST "${LLVM_SHLIB_OUTPUT_INTDIR}/liblldb${CMAKE_SHARED_LIBRARY_SUFFIX}")
+  endif()
+  if(WIN32)
+    if(CMAKE_BUILD_TYPE STREQUAL Debug)
+      set(LIBLLDB_SYMLINK_OUTPUT_FILE "_lldb_d.pyd")
+    else()
+      set(LIBLLDB_SYMLINK_OUTPUT_FILE "_lldb.pyd")
+    endif()
+  else()
+    set(LIBLLDB_SYMLINK_OUTPUT_FILE "lldb.so")
+  endif()
+  create_relative_symlink(${swig_target} ${LIBLLDB_SYMLINK_DEST}
+                          ${lldb_lua_target_dir} ${LIBLLDB_SYMLINK_OUTPUT_FILE})
+  set(lldb_lua_library_target "${swig_target}-library")
+  add_custom_target(${lldb_lua_library_target})
+  add_dependencies(${lldb_lua_library_target} ${swig_target})
+
+  # Ensure we do the Lua post-build step when building lldb.
+  add_dependencies(lldb ${swig_target})
+
+  if(LLDB_BUILD_FRAMEWORK)
+    set(LLDB_LUA_INSTALL_PATH ${LLDB_FRAMEWORK_INSTALL_DIR}/LLDB.framework/Resources/Python)
+  else()
+    set(LLDB_LUA_INSTALL_PATH ${LLDB_LUA_RELATIVE_PATH})
+  endif()
+  install(DIRECTORY ${lldb_lua_target_dir}/
+          DESTINATION ${LLDB_LUA_INSTALL_PATH}
+          COMPONENT ${lldb_lua_library_target})
+
+  set(lldb_lua_library_install_target "install-${lldb_lua_library_target}")
+  if (NOT LLVM_ENABLE_IDE)
+    add_llvm_install_targets(${lldb_lua_library_install_target}
+                            COMPONENT ${lldb_lua_library_target}
+                            DEPENDS ${lldb_lua_library_target})
+  endif()
+endfunction()

lldb/bindings/lua/lua-typemaps.swig

 %include <typemaps.i>
 
 // FIXME: We need to port more typemaps from Python
 
 //===----------------------------------------------------------------------===//
 
 // In Lua 5.3 and beyond the VM supports integers, so we need to remap
 // SWIG's internal handling of integers.
 
 
 %define LLDB_NUMBER_TYPEMAP(TYPE)
 
 // Primitive integer mapping
 %typemap(in,checkfn="lua_isinteger") TYPE
-%{ $1 = (TYPE)lua_tointeger(L, $input); %}
+%{ $1 = ($type)lua_tointeger(L, $input); %}
 %typemap(in,checkfn="lua_isinteger") const TYPE&($basetype temp)
 %{ temp=($basetype)lua_tointeger(L,$input); $1=&temp;%}
 %typemap(out) TYPE
 %{ lua_pushinteger(L, (lua_Integer) $1); SWIG_arg++;%}
 %typemap(out) const TYPE&
 %{ lua_pushinteger(L, (lua_Integer) $1); SWIG_arg++;%}
 
 // Pointer and reference mapping

 LLDB_NUMBER_TYPEMAP(unsigned int);
 LLDB_NUMBER_TYPEMAP(signed int);
 LLDB_NUMBER_TYPEMAP(long);
 LLDB_NUMBER_TYPEMAP(unsigned long);
 LLDB_NUMBER_TYPEMAP(signed long);
 LLDB_NUMBER_TYPEMAP(long long);
 LLDB_NUMBER_TYPEMAP(unsigned long long);
 LLDB_NUMBER_TYPEMAP(signed long long);
+LLDB_NUMBER_TYPEMAP(enum SWIGTYPE);
 
 %apply unsigned long { size_t };
 %apply const unsigned long & { const size_t & };
 %apply long { ssize_t };
 %apply const long & { const ssize_t & };
 
 //===----------------------------------------------------------------------===//
 
 // FIXME:
 //  Ideally all the typemaps should be revisited in a future SB API revision.
 //  Typemaps, usually, modifies the function signatures and might spawn
 //  different LLDB APIs across languages (C++, Python, Lua...).
 //  Historically, typemaps have been used to replace SWIG's deficiencies,
 //  but SWIG itself evolved and some API design choices are now redundant.
 
 //===----------------------------------------------------------------------===//
 
 // Typemap definitions to allow SWIG to properly handle char buffer.
 
 // typemap for a char buffer
 %typemap(in) (char *dst, size_t dst_len) {
    $2 = luaL_checkinteger(L, $input);
    if ($2 <= 0) {
-       return luaL_error(L, "Positive integer expected");
    }
    $1 = (char *) malloc($2);
 }
 
 // SBProcess::ReadCStringFromMemory() uses a void*, but needs to be treated
 // as char data instead of byte data.
 %typemap(in) (void *char_buf, size_t size) = (char *dst, size_t dst_len);
 
+// Also SBProcess::ReadMemory.
+%typemap(in) (void *buf, size_t size) = (char *dst, size_t dst_len);
+
 // Return the char buffer.  Discarding any previous return result
 %typemap(argout) (char *dst, size_t dst_len) {
    lua_pop(L, 1); // Blow away the previous result
    if ($result == 0) {
       lua_pushliteral(L, "");
    } else {
       lua_pushlstring(L, (const char *)$1, $result);
    }
    free($1);
    // SWIG_arg was already incremented
 }
 
 // SBProcess::ReadCStringFromMemory() uses a void*, but needs to be treated
 // as char data instead of byte data.
 %typemap(argout) (void *char_buf, size_t size) = (char *dst, size_t dst_len);
 
+// Also SBProcess::ReadMemory.
+%typemap(argout) (void *buf, size_t size) = (char *dst, size_t dst_len);
+
+//===----------------------------------------------------------------------===//
+
+// Typemap for handling a snprintf-like API like SBThread::GetStopDescription.
+
+%typemap(in) (char *dst_or_null, size_t dst_len) {
+   $2 = luaL_checkinteger(L, $input);
+   if ($2 <= 0) {
+      return luaL_error(L, "Positive integer expected");
+   }
+   $1 = (char *)malloc($2);
+}
+
+%typemap(argout) (char *dst_or_null, size_t dst_len) {
+   lua_pop(L, 1); // Blow away the previous result
+   lua_pushlstring(L, (const char *)$1, $result);
+   free($1);
+   // SWIG_arg was already incremented
+}
+
+//===----------------------------------------------------------------------===//
+
+// Typemap for handling SBModule::GetVersion
+
+%typemap(in) (uint32_t *versions, uint32_t num_versions) {
+   $2 = 99;
+   $1 = (uint32_t *)malloc(sizeof(uint32_t) * $2);
+}
+
+%typemap(argout) (uint32_t *versions, uint32_t num_versions) {
+   uint32_t count = result;
+   if (count >= $2)
+      count = $2;
+   lua_newtable(L);
+   int i = 0;
+   while (i++ < count) {
+      lua_pushinteger(L, $1[i - 1]);
+      lua_seti(L, -2, i);
+   }
+   SWIG_arg++;
+   free($1);
+}
+
+//===----------------------------------------------------------------------===//
+
+// Typemap for handling SBDebugger::SetLoggingCallback
+
+%typemap(in) (lldb::LogOutputCallback log_callback, void *baton) {
+   $1 = LLDBSwigLuaCallLuaLogOutputCallback;
+   $2 = (void *)L;
+
+   luaL_checktype(L, 2, LUA_TFUNCTION);
+   lua_settop(L, 2);
+
+   lua_pushlightuserdata(L, (void *)&LLDBSwigLuaCallLuaLogOutputCallback);
+   lua_insert(L, 2);
+   lua_settable(L, LUA_REGISTRYINDEX);
+}
+
+//===----------------------------------------------------------------------===//
+
+// Typemap for handling SBEvent::SBEvent(uint32_t event, const char *cstr, uint32_t cstr_len)
+
+%typemap(in) (const char *cstr, uint32_t cstr_len) {
+   $1 = (char *)luaL_checklstring(L, $input, (size_t *)&$2);
+}
+
+// Typemap for handling SBProcess::PutSTDIN
+
+%typemap(in) (const char *src, size_t src_len) {
+   $1 = (char *)luaL_checklstring(L, $input, &$2);
+}
+
+// Typemap for handling SBProcess::WriteMemory, SBTarget::GetInstructions...
+
+%typemap(in) (const void *buf, size_t size),
+             (const void *data, size_t data_len) {
+   $1 = (void *)luaL_checklstring(L, $input, &$2);
+}
+
+//===----------------------------------------------------------------------===//
+
+// Typemap for handling char ** in SBTarget::LaunchSimple, SBTarget::Launch...
+
+// It should accept a Lua table of strings, for stuff like "argv" and "envp".
+
+%typemap(in) char ** {
+   if (lua_istable(L, $input)) {
+      size_t size = lua_rawlen(L, $input);
+      $1 = (char **)malloc((size + 1) * sizeof(char *));
+      int i = 0, j = 0;
+      while (i++ < size) {
+         lua_rawgeti(L, $input, i);
+         if (!lua_isstring(L, -1)) {
+            // if current element cannot be converted to string, raise an error
+            lua_pop(L, 1);
+            return luaL_error(L, "List should only contain strings");
+         }
+         $1[j++] = (char *)lua_tostring(L, -1);
+         lua_pop(L, 1);
+      }
+      $1[j] = 0;
+   } else if (lua_isnil(L, $input)) {
+      // "nil" is also acceptable, equivalent as an empty table
+      $1 = NULL;
+   } else {
+      return luaL_error(L, "A list of strings expected");
+   }
+}
+
+%typemap(freearg) char ** {
+   free((char *) $1);
+}
+
+%typecheck(SWIG_TYPECHECK_STRING_ARRAY) char ** {
+   $1 = (lua_istable(L, $input) || lua_isnil(L, $input));
+}
+
+//===----------------------------------------------------------------------===//
+
+// Typemap for file handles (e.g. used in SBDebugger::SetOutputFile)
+
+%typemap(in) lldb::FileSP {
+   luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, $input, LUA_FILEHANDLE);
+   lldb::FileSP file_sp;
+   file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false);
+   if (!file_sp->IsValid())
+      return luaL_error(L, "Invalid file");
+   $1 = file_sp;
+}
+
+%typecheck(SWIG_TYPECHECK_POINTER) lldb::FileSP {
+   $1 = (lua_isuserdata(L, $input)) &&
+        (luaL_testudata(L, $input, LUA_FILEHANDLE) != nullptr);
+}
+
+// Typemap for file handles (e.g. used in SBDebugger::GetOutputFileHandle)
+
+%typemap(out) lldb::FileSP {
+   lldb::FileSP &sp = $1;
+   if (sp && sp->IsValid()) {
+      luaL_Stream *p = (luaL_Stream *)lua_newuserdata(L, sizeof(luaL_Stream));
+      p->closef = &LLDBSwigLuaCloseFileHandle;
+      p->f = sp->GetStream();
+      luaL_setmetatable(L, LUA_FILEHANDLE);
+      SWIG_arg++;
+   }
+}
+
+//===----------------------------------------------------------------------===//
+
+// Typemap for SBData::CreateDataFromUInt64Array, SBData::SetDataFromUInt64Array ...
+
+%typemap(in) (uint64_t* array, size_t array_len),
+             (uint32_t* array, size_t array_len),
+             (int64_t* array, size_t array_len),
+             (int32_t* array, size_t array_len),
+             (double* array, size_t array_len) {
+   if (lua_istable(L, $input)) {
+      // It should accept a table of numbers.
+      $2 = lua_rawlen(L, $input);
+      $1 = ($1_ltype)malloc(($2) * sizeof($*1_type));
+      int i = 0, j = 0;
+      while (i++ < $2) {
+         lua_rawgeti(L, $input, i);
+         if (!lua_isnumber(L, -1)) {
+            // if current element cannot be converted to number, raise an error
+            lua_pop(L, 1);
+            return luaL_error(L, "List should only contain numbers");
+         }
+         $1[j++] = ($*1_ltype)lua_tonumber(L, -1);
+         lua_pop(L, 1);
+      }
+   } else if (lua_isnil(L, $input)) {
+      // "nil" is also acceptable, equivalent as an empty table
+      $1 = NULL;
+      $2 = 0;
+   } else {
+      // else raise an error
+      return luaL_error(L, "A list of numbers expected.");
+   }
+}
+
+%typemap(freearg) (uint64_t* array, size_t array_len),
+             (uint32_t* array, size_t array_len),
+             (int64_t* array, size_t array_len),
+             (int32_t* array, size_t array_len),
+             (double* array, size_t array_len) {
+   free($1);
+}
+
+//===----------------------------------------------------------------------===//
+
+// Typemap for SBCommandReturnObject::PutCString
+
+%typemap(in) (const char *string, int len) {
+   if (lua_isnil(L, $input)) {
+      $1 = NULL;
+      $2 = 0;
+   }
+   else {
+      $1 = (char *)luaL_checklstring(L, $input, (size_t *)&$2);
+   }
+}
+
 //===----------------------------------------------------------------------===//

lldb/bindings/lua/lua-wrapper.swig

 %header %{
 
 template <typename T>
 void
 PushSBClass(lua_State* L, T* obj);
 
 %}
 
+%runtime %{
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void LLDBSwigLuaCallLuaLogOutputCallback(const char *str, void *baton);
+int LLDBSwigLuaCloseFileHandle(lua_State *L);
+
+#ifdef __cplusplus
+}
+#endif
+%}
+
 %wrapper %{
 
 // This function is called from Lua::CallBreakpointCallback
 SWIGEXPORT llvm::Expected<bool>
 LLDBSwigLuaBreakpointCallbackFunction
 (
    lua_State *L,
    lldb::StackFrameSP stop_frame_sp,
)
 
    // Boolean return from the callback
    bool stop = lua_toboolean(L, -1);
    lua_pop(L, 1);
 
    return stop;
 }
 
+SWIGEXPORT void
+LLDBSwigLuaCallLuaLogOutputCallback(const char *str, void *baton) {
+   lua_State *L = (lua_State *)baton;
+
+   lua_pushlightuserdata(L, (void *)&LLDBSwigLuaCallLuaLogOutputCallback);
+   lua_gettable(L, LUA_REGISTRYINDEX);
+
+   // FIXME: There's no way to report errors back to the user
+   lua_pushstring(L, str);
+   lua_pcall(L, 1, 0, 0);
+}
+
+int LLDBSwigLuaCloseFileHandle(lua_State *L) {
+   return luaL_error(L, "You cannot close a file handle used by lldb.");
+}
 
 %}

lldb/bindings/lua/lua.swig

 %include "lua-typemaps.swig"
 %include "macros.swig"
 %include "headers.swig"
 
 %{
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "../bindings/lua/lua-swigsafecast.swig"
+
+// required headers for typemaps
+#include "lldb/Host/File.h"
+
 using namespace lldb_private;
 using namespace lldb;
 %}
 
 %include "interfaces.swig"
 %include "lua-wrapper.swig"

lldb/source/API/liblldb-private.exports

 _ZN4lldb*
 _ZNK4lldb*
 _ZN12lldb_private*
 _ZNK12lldb_private*
 init_lld*
 PyInit__lldb*
+luaopen_lldb*

lldb/source/API/liblldb.exports

 _ZN4lldb*
 _ZNK4lldb*
 init_lld*
 PyInit__lldb*
+luaopen_lldb*

lldb/test/API/lit.site.cfg.py.in

 config.cmake_cxx_compiler = "@CMAKE_CXX_COMPILER@"
 config.host_os = "@HOST_OS@"
 config.host_triple = "@LLVM_HOST_TRIPLE@"
 config.shared_libs = @LLVM_ENABLE_SHARED_LIBS@
 config.llvm_use_sanitizer = "@LLVM_USE_SANITIZER@"
 config.target_triple = "@TARGET_TRIPLE@"
 config.lldb_build_directory = "@LLDB_TEST_BUILD_DIRECTORY@"
 config.python_executable = "@Python3_EXECUTABLE@"
+config.lua_executable = "@Lua_EXECUTABLE@"
+config.lua_test_entry = "TestLuaAPI.py"
 config.dotest_args_str = "@LLDB_DOTEST_ARGS@"
 config.lldb_enable_python = @LLDB_ENABLE_PYTHON@
 config.dotest_lit_args_str = None
 config.enabled_plugins = []
 config.lldb_executable = '@LLDB_TEST_EXECUTABLE@'
 config.test_arch = '@LLDB_TEST_ARCH@'
 config.test_compiler = '@LLDB_TEST_COMPILER@'
 config.dsymutil = '@LLDB_TEST_DSYMUTIL@'

lldb/test/API/lldbtest.py

def execute(self, test, litConfig):
             return (lit.Test.UNSUPPORTED, 'Test is unsupported')
 
         testPath, testFile = os.path.split(test.getSourcePath())
 
         # The Python used to run lit can be different from the Python LLDB was
         # build with.
         executable = test.config.python_executable
 
+        isLuaTest = testFile == test.config.lua_test_entry
+
         # On Windows, the system does not always correctly interpret
         # shebang lines.  To make sure we can execute the tests, add
         # python exe as the first parameter of the command.
         cmd = [executable] + self.dotest_cmd + [testPath, '-p', testFile]
 
+        if isLuaTest:
+            luaExecutable = test.config.lua_executable
+            cmd.extend(['--env', 'LUA_EXECUTABLE=%s' % luaExecutable])
+
         timeoutInfo = None
         try:
             out, err, exitCode = lit.util.executeCommand(
                 cmd,
                 env=test.config.environment,
                 timeout=litConfig.maxIndividualTestTime)
         except lit.util.ExecuteCommandTimeoutException as e:
             out = e.out

lldb/test/API/lua_api/Makefile

+C_SOURCES := main.c
+
+include Makefile.rules

lldb/test/API/lua_api/TestBreakpointAPI.lua

+_T = require('lua_lldb_test').create_test('TestBreakpointAPI')
+
+function _T:TestBreakpointIsValid()
+    local target = self:create_target()
+    local breakpoint = target:BreakpointCreateByName('AFunction', 'a.out')
+    assertTrue(breakpoint:IsValid() and breakpoint:GetNumLocations() == 1)
+    local did_delete = target:BreakpointDelete(breakpoint:GetID())
+    assertTrue(did_delete)
+    local del_bkpt = target:FindBreakpointByID(breakpoint:GetID())
+    assertFalse(del_bkpt:IsValid())
+    assertFalse(breakpoint:IsValid())
+end
+
+function _T:TestTargetDelete()
+    local target = self:create_target()
+    local breakpoint = target:BreakpointCreateByName('AFunction', 'a.out')
+    assertTrue(breakpoint:IsValid() and breakpoint:GetNumLocations() == 1)
+    local location = breakpoint:GetLocationAtIndex(0)
+    assertTrue(location:IsValid())
+    assertEquals(target, breakpoint:GetTarget())
+    assertTrue(self.debugger:DeleteTarget(target))
+    assertFalse(breakpoint:IsValid())
+    assertFalse(location:IsValid())
+end
+
+function _T:TestBreakpointHitCount()
+    local target = self:create_target()
+    local breakpoint = target:BreakpointCreateByName('BFunction', 'a.out')
+    assertTrue(breakpoint:IsValid() and breakpoint:GetNumLocations() == 1)
+    breakpoint:SetAutoContinue(true)
+    target:LaunchSimple(nil, nil, nil)
+    assertEquals(breakpoint:GetHitCount(), 100)
+end
+
+function _T:TestBreakpointFrame()
+    local target = self:create_target()
+    local breakpoint = target:BreakpointCreateByName('main', 'a.out')
+    assertTrue(breakpoint:IsValid() and breakpoint:GetNumLocations() == 1)
+    local process = target:LaunchSimple({ 'arg1', 'arg2' }, nil, nil)
+    local thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+    assertNotNil(thread)
+    assertTrue(thread:IsValid())
+    local frame = thread:GetFrameAtIndex(0)
+    assertTrue(frame:IsValid())
+    local error = lldb.SBError()
+    local var_argc = frame:FindVariable('argc')
+    local var_argc_value = var_argc:GetValueAsSigned(error, 0)
+    assertTrue(error:Success())
+    assertEquals(var_argc_value, 3)
+end
+
+os.exit(_T:run())

lldb/test/API/lua_api/TestComprehensive.lua

+_T = require('lua_lldb_test').create_test('TestComprehensive')
+
+function _T:Test0_CreateTarget()
+    self.target = self:create_target()
+    assertTrue(self.target:IsValid())
+end
+
+function _T:Test1_Breakpoint()
+    self.main_bp = self.target:BreakpointCreateByName('main', 'a.out')
+    self.loop_bp = self.target:BreakpointCreateByLocation('main.c', 28)
+    assertTrue(self.main_bp:IsValid() and self.main_bp:GetNumLocations() == 1)
+    assertTrue(self.loop_bp:IsValid() and self.loop_bp:GetNumLocations() == 1)
+end
+
+function _T:Test2_Launch()
+    local error = lldb.SBError()
+    self.args = { 'arg' }
+    self.process = self.target:Launch(
+        self.debugger:GetListener(),
+        self.args,
+        nil,
+        nil,
+        self.output,
+        nil,
+        nil,
+        0,
+        false,
+        error
+    )
+    assertTrue(error:Success())
+    assertTrue(self.process:IsValid())
+end
+
+function _T:Test3_BreakpointFindVariables()
+    -- checking "argc" value
+    local thread = get_stopped_thread(self.process, lldb.eStopReasonBreakpoint)
+    assertNotNil(thread)
+    assertTrue(thread:IsValid())
+    local frame = thread:GetFrameAtIndex(0)
+    assertTrue(frame:IsValid())
+    local error = lldb.SBError()
+    local var_argc = frame:FindVariable('argc')
+    assertTrue(var_argc:IsValid())
+    local var_argc_value = var_argc:GetValueAsSigned(error, 0)
+    assertTrue(error:Success())
+    assertEquals(var_argc_value, 2)
+
+    -- checking "inited" value
+    local continue = self.process:Continue()
+    assertTrue(continue:Success())
+    thread = get_stopped_thread(self.process, lldb.eStopReasonBreakpoint)
+    assertNotNil(thread)
+    assertTrue(thread:IsValid())
+    frame = thread:GetFrameAtIndex(0)
+    assertTrue(frame:IsValid())
+    error = lldb.SBError()
+    local var_inited = frame:FindVariable('inited')
+    assertTrue(var_inited:IsValid())
+    self.var_inited = var_inited
+    local var_inited_value = var_inited:GetValueAsUnsigned(error, 0)
+    assertTrue(error:Success())
+    assertEquals(var_inited_value, 0xDEADBEEF)
+end
+
+function _T:Test3_RawData()
+    local error = lldb.SBError()
+    local address = self.var_inited:GetAddress()
+    assertTrue(address:IsValid())
+    local size = self.var_inited:GetByteSize()
+    local raw_data = self.process:ReadMemory(address:GetOffset(), size, error)
+    assertTrue(error:Success())
+    local data_le = lldb.SBData.CreateDataFromUInt32Array(lldb.eByteOrderLittle, 1, {0xDEADBEEF})
+    local data_be = lldb.SBData.CreateDataFromUInt32Array(lldb.eByteOrderBig, 1, {0xDEADBEEF})
+    assertTrue(data_le:GetUnsignedInt32(error, 0) == 0xDEADBEEF or data_be:GetUnsignedInt32(error, 0) == 0xDEADBEEF)
+    assertTrue(raw_data == "\xEF\xBE\xAD\xDE" or raw_data == "\xDE\xAD\xBE\xEF")
+end
+
+function _T:Test4_ProcessExit()
+    self.loop_bp:SetAutoContinue(true)
+    local continue = self.process:Continue()
+    assertTrue(continue:Success())
+    assertTrue(self.process:GetExitStatus() == 0)
+end
+
+function _T:Test5_FileOutput()
+    local f = io.open(self.output, 'r')
+    assertEquals(
+        read_file_non_empty_lines(f),
+        {
+            self.exe,
+            table.unpack(self.args),
+            'I am a function.',
+            'sum = 5050'
+        }
+    )
+    f:close()
+end
+
+os.exit(_T:run())

lldb/test/API/lua_api/TestFileHandle.lua

+_T = require('lua_lldb_test').create_test('TestFileHandle')
+
+function _T:TestLegacyFileOutScript()
+    local f = io.open(self.output, 'w')
+    self.debugger:SetOutputFile(f)
+    self:handle_command('script print(1+1)')
+    self.debugger:GetOutputFileHandle():write('FOO\n')
+    self.debugger:GetOutputFileHandle():flush()
+    f:close()
+
+    f = io.open(self.output, 'r')
+    assertEquals(read_file_non_empty_lines(f), {'2', 'FOO'})
+    f:close()
+end
+
+function _T:TestLegacyFileOut()
+    local f = io.open(self.output, 'w')
+    self.debugger:SetOutputFile(f)
+    self:handle_command('p/x 3735928559', false)
+    f:close()
+
+    f = io.open(self.output, 'r')
+    assertStrContains(f:read('*l'), 'deadbeef')
+    f:close()
+end
+
+function _T:TestLegacyFileErr()
+    local f = io.open(self.output, 'w')
+    self.debugger:SetErrorFile(f)
+    self:handle_command('lol', false)
+
+    f = io.open(self.output, 'r')
+    assertStrContains(f:read('*l'), 'is not a valid command')
+    f:close()
+end
+
+os.exit(_T:run())

lldb/test/API/lua_api/TestLuaAPI.py

+"""
+Test Lua API wrapper
+"""
+
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+import subprocess
+
+def to_string(b):
+    """Return the parameter as type 'str', possibly encoding it.
+
+    In Python2, the 'str' type is the same as 'bytes'. In Python3, the
+    'str' type is (essentially) Python2's 'unicode' type, and 'bytes' is
+    distinct.
+
+    """
+    if isinstance(b, str):
+        # In Python2, this branch is taken for types 'str' and 'bytes'.
+        # In Python3, this branch is taken only for 'str'.
+        return b
+    if isinstance(b, bytes):
+        # In Python2, this branch is never taken ('bytes' is handled as 'str').
+        # In Python3, this is true only for 'bytes'.
+        try:
+            return b.decode('utf-8')
+        except UnicodeDecodeError:
+            # If the value is not valid Unicode, return the default
+            # repr-line encoding.
+            return str(b)
+
+    # By this point, here's what we *don't* have:
+    #
+    #  - In Python2:
+    #    - 'str' or 'bytes' (1st branch above)
+    #  - In Python3:
+    #    - 'str' (1st branch above)
+    #    - 'bytes' (2nd branch above)
+    #
+    # The last type we might expect is the Python2 'unicode' type. There is no
+    # 'unicode' type in Python3 (all the Python3 cases were already handled). In
+    # order to get a 'str' object, we need to encode the 'unicode' object.
+    try:
+        return b.encode('utf-8')
+    except AttributeError:
+        raise TypeError('not sure how to convert %s to %s' % (type(b), str))
+
+class ExecuteCommandTimeoutException(Exception):
+    def __init__(self, msg, out, err, exitCode):
+        assert isinstance(msg, str)
+        assert isinstance(out, str)
+        assert isinstance(err, str)
+        assert isinstance(exitCode, int)
+        self.msg = msg
+        self.out = out
+        self.err = err
+        self.exitCode = exitCode
+
+
+# Close extra file handles on UNIX (on Windows this cannot be done while
+# also redirecting input).
+kUseCloseFDs = not (platform.system() == 'Windows')
+
+
+def executeCommand(command, cwd=None, env=None, input=None, timeout=0):
+    """Execute command ``command`` (list of arguments or string) with.
+
+    * working directory ``cwd`` (str), use None to use the current
+    working directory
+    * environment ``env`` (dict), use None for none
+    * Input to the command ``input`` (str), use string to pass
+    no input.
+    * Max execution time ``timeout`` (int) seconds. Use 0 for no timeout.
+
+    Returns a tuple (out, err, exitCode) where
+    * ``out`` (str) is the standard output of running the command
+    * ``err`` (str) is the standard error of running the command
+    * ``exitCode`` (int) is the exitCode of running the command
+
+    If the timeout is hit an ``ExecuteCommandTimeoutException``
+    is raised.
+
+    """
+    if input is not None:
+        input = to_bytes(input)
+    p = subprocess.Popen(command, cwd=cwd,
+                        stdin=subprocess.PIPE,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                        env=env, close_fds=kUseCloseFDs)
+    timerObject = None
+    # FIXME: Because of the way nested function scopes work in Python 2.x we
+    # need to use a reference to a mutable object rather than a plain
+    # bool. In Python 3 we could use the "nonlocal" keyword but we need
+    # to support Python 2 as well.
+    hitTimeOut = [False]
+    try:
+        if timeout > 0:
+            def killProcess():
+                # We may be invoking a shell so we need to kill the
+                # process and all its children.
+                hitTimeOut[0] = True
+                killProcessAndChildren(p.pid)
+
+            timerObject = threading.Timer(timeout, killProcess)
+            timerObject.start()
+
+        out, err = p.communicate(input=input)
+        exitCode = p.wait()
+    finally:
+        if timerObject != None:
+            timerObject.cancel()
+
+    # Ensure the resulting output is always of string type.
+    out = to_string(out)
+    err = to_string(err)
+
+    if hitTimeOut[0]:
+        raise ExecuteCommandTimeoutException(
+            msg='Reached timeout of {} seconds'.format(timeout),
+            out=out,
+            err=err,
+            exitCode=exitCode
+        )
+
+    # Detect Ctrl-C in subprocess.
+    if exitCode == -signal.SIGINT:
+        raise KeyboardInterrupt
+
+    return out, err, exitCode
+
+class TestLuaAPI(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
+
+    def get_tests(self):
+        tests = []
+        for filename in os.listdir():
+            # Ignore dot files and excluded tests.
+            if filename.startswith('.'):
+                continue
+
+            # Ignore files that don't start with 'Test'.
+            if not filename.startswith('Test'):
+                continue
+
+            if not os.path.isdir(filename):
+                base, ext = os.path.splitext(filename)
+                if ext == '.lua':
+                    tests.append(filename)
+        return tests
+
+    def test_lua_api(self):  
+        if "LUA_EXECUTABLE" not in os.environ or len(os.environ["LUA_EXECUTABLE"]) == 0:
+           self.skipTest("Lua API tests could not find Lua executable.")
+           return
+        lua_executable = os.environ["LUA_EXECUTABLE"]
+
+        self.build()
+        test_exe = self.getBuildArtifact("a.out")
+        test_output = self.getBuildArtifact("output")
+        test_input = self.getBuildArtifact("input")
+
+        lua_lldb_cpath = "%s/lua/5.3/?.so" % configuration.lldb_libs_dir
+
+        lua_prelude = "package.cpath = '%s;' .. package.cpath" % lua_lldb_cpath
+
+        lua_env = {
+            "TEST_EXE":     os.path.join(self.getBuildDir(), test_exe),
+            "TEST_OUTPUT":  os.path.join(self.getBuildDir(), test_output),
+            "TEST_INPUT":   os.path.join(self.getBuildDir(), test_input)
+        }
+
+        for lua_test in self.get_tests():
+            cmd = [lua_executable] + ["-e", lua_prelude] + [lua_test]
+            out, err, exitCode = executeCommand(cmd, env=lua_env)
+
+            # Redirect Lua output
+            print(out)
+            print(err, file=sys.stderr)
+
+            self.assertTrue(
+                exitCode == 0,
+                "Lua test '%s' failure." % lua_test
+            )

lldb/test/API/lua_api/TestProcessAPI.lua

+_T = require('lua_lldb_test').create_test('TestProcessAPI')
+
+function _T:TestProcessLaunchSimple()
+    local target = self:create_target()
+    local args = { 'arg1', 'arg2', 'arg3' }
+    local process = target:LaunchSimple(
+        -- argv
+        args,
+        -- envp
+        nil,
+        -- working directory
+        nil
+    )
+    assertTrue(process:IsValid())
+    local stdout = process:GetSTDOUT(1000)
+    assertEquals(split_lines(stdout), {self.exe, table.unpack(args)})
+end
+
+function _T:TestProcessLaunch()
+    local target = self:create_target()
+    local args = { 'arg1', 'arg2', 'arg3' }
+    local error = lldb.SBError()
+    local f = io.open(self.output, 'w')
+    f:write()
+    f:close()
+    local process = target:Launch(
+        -- listener
+        self.debugger:GetListener(),
+        -- argv
+        args,
+        -- envp
+        nil,
+        -- stdin
+        nil,
+        -- stdout
+        self.output,
+        -- stderr
+        nil,
+        -- working directory
+        nil,
+        -- launch flags
+        0,
+        -- stop at entry
+        true,
+        -- error
+        error
+    )
+    assertTrue(error:Success())
+    assertTrue(process:IsValid())
+    local threads = get_stopped_threads(process, lldb.eStopReasonSignal)
+    assertTrue(#threads ~= 0)
+    local continue = process:Continue()
+    assertTrue(continue:Success())
+    local f = io.open(self.output, 'r')
+    assertEquals(read_file_non_empty_lines(f), {self.exe, table.unpack(args)})
+    f:close()
+end
+
+os.exit(_T:run())

lldb/test/API/lua_api/lua_lldb_test.lua

+-- Make lldb available in global
+lldb = require('lldb')
+
+-- Global assertion functions
+function assertTrue(x)
+    if not x then error('assertTrue failure') end
+end
+
+function assertFalse(x)
+    if x then error('assertNotNil failure') end
+end
+
+function assertNotNil(x)
+    if x == nil then error('assertNotNil failure') end
+end
+
+function assertEquals(x, y)
+    if type(x) == 'table' and type(y) == 'table' then
+        for k, _ in pairs(x) do
+            assertEquals(x[k], y[k])
+        end
+    elseif type(x) ~= type(y) then
+        error('assertEquals failure')
+    elseif x ~= y then
+        error('assertEquals failure')
+    end
+end
+
+function assertStrContains(x, y)
+    if not string.find(x, y, 1, true) then
+        error('assertStrContains failure')
+    end
+end
+
+-- Global helper functions
+function read_file_non_empty_lines(f)
+    local lines = {}
+    while true do
+        local line = f:read('*l')
+        if not line then break end
+        if line ~= '\n' then table.insert(lines, line) end
+    end
+    return lines
+end
+
+function split_lines(str)
+    local lines = {}
+    for line in str:gmatch("[^\r\n]+") do
+        table.insert(lines, line)
+    end
+    return lines
+end
+
+function get_stopped_threads(process, reason)
+    local threads = {}
+    for i = 0, process:GetNumThreads() - 1 do
+        local t = process:GetThreadAtIndex(i)
+        if t:IsValid() and t:GetStopReason() == reason then
+            table.insert(threads, t)
+        end
+    end
+    return threads
+end
+
+function get_stopped_thread(process, reason)
+    local threads = get_stopped_threads(process, reason)
+    if #threads ~= 0 then return threads[1]
+    else return nil end
+end
+
+-- Test helper
+
+local _M = {}
+local _m = {}
+
+local _mt = { __index = _m }
+
+function _M.create_test(name, exe, output, input)
+    print('[lldb/lua] Create test ' .. name)
+    exe = exe or os.getenv('TEST_EXE')
+    output = output or os.getenv('TEST_OUTPUT')
+    input = input or os.getenv('TEST_INPUT')
+    lldb.SBDebugger.Initialize()
+    local debugger = lldb.SBDebugger.Create()
+    -- Ensure that debugger is created
+    assertNotNil(debugger)
+    assertTrue(debugger:IsValid())
+
+    debugger:SetAsync(false)
+
+    local lua_language = debugger:GetScriptingLanguage('lua')
+    assertNotNil(lua_language)
+    debugger:SetScriptLanguage(lua_language)
+
+    local test = setmetatable({
+        output = output,
+        input = input,
+        name = name,
+        exe = exe,
+        debugger = debugger
+    }, _mt)
+    _G[name] = test
+    return test
+end
+
+function _m:create_target(exe)
+    local target
+    if not exe then exe = self.exe end
+    target = self.debugger:CreateTarget(exe)
+    -- Ensure that target is created
+    assertNotNil(target)
+    assertTrue(target:IsValid())
+    return target
+end
+
+function _m:handle_command(command, collect)
+    if collect == nil then collect = true end
+    if collect then
+        local ret = lldb.SBCommandReturnObject()
+        local interpreter = self.debugger:GetCommandInterpreter()
+        assertTrue(interpreter:IsValid())
+        interpreter:HandleCommand(command, ret)
+        self.debugger:GetOutputFile():Flush()
+        self.debugger:GetErrorFile():Flush()
+        assertTrue(ret:Succeeded())
+        return ret:GetOutput()
+    else
+        self.debugger:HandleCommand(command)
+        self.debugger:GetOutputFile():Flush()
+        self.debugger:GetErrorFile():Flush()
+    end
+end
+
+function _m:run()
+    local tests = {}
+    for k, v in pairs(self) do
+        if string.sub(k, 1, 4) == 'Test' then
+            table.insert(tests, k)
+        end
+    end
+    table.sort(tests)
+    for _, t in ipairs(tests) do
+        print('[lldb/lua] Doing test ' .. self.name .. ' - ' .. t)
+        local success = xpcall(self[t], function(e)
+            print(debug.traceback())
+        end, self)
+        if not success then
+            print('[lldb/lua] Failure in test ' .. self.name .. ' - ' .. t)
+            return 1
+        end
+    end
+    return 0
+end
+
+return _M

lldb/test/API/lua_api/main.c

+#include <stdio.h>
+
+void BFunction()
+{
+}
+
+void AFunction()
+{
+    printf("I am a function.\n");
+}
+
+int main(int argc, const char *argv[])
+{
+    int inited = 0xDEADBEEF;
+    int sum = 0;
+    if(argc > 1)
+    {
+        for(int i = 0; i < argc; i++)
+        {
+            puts(argv[i]);
+        }
+        if(argc > 2)
+        {
+            return argc;
+        }
+    }
+    AFunction();
+    for(int i = 1; i <= 100; i++)
+    {
+        BFunction();
+        sum += i;
+    }
+    printf("sum = %d\n", sum);
+    return 0;
+}