This is an archive of the discontinued LLVM Phabricator instance.

Differential D4816

Get test executables compiling on Windows.
ClosedPublic

Authored by zturner on Aug 6 2014, 2:52 PM.

Details

Reviewers
emaste
tfiala
Commits
rGc7826524acda: Get test executables compiling on Windows.
rLLDB215562: Get test executables compiling on Windows.
rL215562: Get test executables compiling on Windows.
Summary

Many of the test executables use pthreads directly. This isn't portable on Windows, so this patch converts these test to use C++11 threads and mutexes. Since Windows' implementation of std::thread classes throw and catch from header files, this patch also disables exceptions when compiling with clang on Windows.

Diff Detail

Repository
rL LLVM

Event Timeline

zturner updated this revision to Diff 12256.Aug 6 2014, 2:52 PM
zturner retitled this revision from to Get test executables compiling on Windows..
zturner updated this object.
zturner edited the test plan for this revision. (Show Details)
zturner added a reviewer: emaste.
zturner added a subscriber: Unknown Object (MLST).
zturner updated this revision to Diff 12283.Aug 7 2014, 10:16 AM

Fixed some more places where tests don't compile on Windows.

emaste edited edge metadata.Aug 12 2014, 6:54 AM

A few minor nits, overall LGTM and still passes on FreeBSD.

test/expression_command/timeout/wait-a-while.cpp
8 ↗(On Diff #12283)

git complained about trailing whitespace here

test/functionalities/attach_resume/Makefile
4 ↗(On Diff #12283)

Perhaps a $(LPTHREAD) make var that is set to -lpthread or empty by an included header?

test/lldbtest.py
557 ↗(On Diff #12283)

(Perhaps in a separate commit,) we should refactor the skipIf* decorators the same way I did expectedFailure*

test/make/Makefile.rules
84 ↗(On Diff #12283)

probably clearer to put this with the other 32-bit cases below

test/make/uncaught_exception.h
6 ↗(On Diff #12283)

Add newline

tfiala added a subscriber: tfiala.Aug 12 2014, 7:49 AM

Hey Zach,

I agree with Ed's comments. If you want to do any minor fixup there, I'll give the final a run on Linux (unless you want to do that part yourself - either way is fine).

zturner updated this revision to Diff 12414.Aug 12 2014, 1:12 PM
zturner edited edge metadata.

Fix issues pointed out in review. Also removed all instances of Makefiles directly including -lpthread for the link arguments. Instead, libraries now set ENABLE_THREADS := YES in the Makefile, which translates to the correct thing in Makefile.rules

tfiala added a comment.Aug 12 2014, 1:28 PM

Cool I'll give this a run over here this afternoon.

tfiala added a comment.Aug 13 2014, 6:48 AM

Cool I'll give this a run over here this afternoon.

Okay, so "this afternoon" => next morning. Sorry - looking at this now.

tfiala accepted this revision.Aug 13 2014, 7:09 AM
tfiala added a reviewer: tfiala.

Hey Zachary,

LGTM.

Tested:
Ubuntu 14.04 x86_64 - clang-built lldb.
MacOSX 10.9.4 - Xcode 6 Beta 5-built lldb.

Test Failures:
Unrelated - seeing TestCallStopAndContinue.py fail on both Linux and MacOSX occasionally both without and with the patch. Should not block.

This revision is now accepted and ready to land.Aug 13 2014, 7:09 AM
zturner closed this revision.Aug 13 2014, 10:54 AM
zturner updated this revision to Diff 12461.

Closed by commit rL215562 (authored by @zturner).

Revision Contents

PathSize
lldb/
trunk/
test/
api/
multiple-debuggers/
9 lines
expression_command/
call-restarts/
1 line
timeout/
2 lines
2 lines
41 lines
31 lines
functionalities/
attach_resume/
5 lines
2 lines
32 lines
31 lines
expr-doesnt-deadlock/
2 lines
stop-hook/
multiple_threads/
2 lines
thread/
2 lines
concurrent_events/
3 lines
step_out/
5 lines
thread_specific_break/
2 lines
watchpoint/
hello_watchlocation/
2 lines
multiple_threads/
2 lines
watchpoint_set_command/
2 lines
lang/
c/
tls_globals/
2 lines
15 lines
make/
29 lines
5 lines
python_api/
lldbutil/
iter/
4 lines
46 lines
process/
2 lines
44 lines
module_section/
2 lines
44 lines
signals/
8 lines
watchpoint/
watchlocation/
2 lines
tools/
lldb-gdbserver/
4 lines

Diff 12461

lldb/trunk/test/api/multiple-debuggers/multi-process-driver.cpp

Show All 23 Lines
#include <LLDB/SBDebugger.h> #include <LLDB/SBDebugger.h>
#else #else
#include "lldb/API/LLDB.h" #include "lldb/API/LLDB.h"
#include <lldb/API/SBCommandInterpreter.h> #include <lldb/API/SBCommandInterpreter.h>
#include <lldb/API/SBCommandReturnObject.h> #include <lldb/API/SBCommandReturnObject.h>
#include <lldb/API/SBDebugger.h> #include <lldb/API/SBDebugger.h>
#endif #endif
#include <chrono>
#include <thread>
#define NUMBER_OF_SIMULTANEOUS_DEBUG_SESSIONS 50 #define NUMBER_OF_SIMULTANEOUS_DEBUG_SESSIONS 50
#define DEBUG 0 #define DEBUG 0
using namespace lldb; using namespace lldb;
bool *completed_threads_array = 0; bool *completed_threads_array = 0;
bool *successful_threads_array = 0; bool *successful_threads_array = 0;
▲ Show 20 Lines • Show All 188 Lines • ▼ Show 20 Linesint main (int argc, char **argv)
successful_threads_array = (bool *) malloc (sizeof (bool) * NUMBER_OF_SIMULTANEOUS_DEBUG_SESSIONS); successful_threads_array = (bool *) malloc (sizeof (bool) * NUMBER_OF_SIMULTANEOUS_DEBUG_SESSIONS);
memset (successful_threads_array, 0, sizeof (bool) * NUMBER_OF_SIMULTANEOUS_DEBUG_SESSIONS); memset (successful_threads_array, 0, sizeof (bool) * NUMBER_OF_SIMULTANEOUS_DEBUG_SESSIONS);
if (argc > 1 && argv[1] != NULL) if (argc > 1 && argv[1] != NULL)
{ {
inferior_process_name = argv[1]; inferior_process_name = argv[1];
} }
std::thread threads[NUMBER_OF_SIMULTANEOUS_DEBUG_SESSIONS];
for (uint64_t i = 0; i< NUMBER_OF_SIMULTANEOUS_DEBUG_SESSIONS; i++) for (uint64_t i = 0; i< NUMBER_OF_SIMULTANEOUS_DEBUG_SESSIONS; i++)
{ {
pthread_t thread; threads[i] = std::move(std::thread(do_one_debugger, (void*)i));
pthread_create (&thread, NULL, do_one_debugger, (void*) i);
} }
int max_time_to_wait = 20; // 20 iterations, or 60 seconds int max_time_to_wait = 20; // 20 iterations, or 60 seconds
int iter = 0; int iter = 0;
while (1) while (1)
{ {
sleep (3); std::this_thread::sleep_for(std::chrono::seconds(3));
bool all_done = true; bool all_done = true;
int successful_threads = 0; int successful_threads = 0;
int total_completed_threads = 0; int total_completed_threads = 0;
for (uint64_t i = 0; i < NUMBER_OF_SIMULTANEOUS_DEBUG_SESSIONS; i++) for (uint64_t i = 0; i < NUMBER_OF_SIMULTANEOUS_DEBUG_SESSIONS; i++)
{ {
if (successful_threads_array[i] == true) if (successful_threads_array[i] == true)
successful_threads++; successful_threads++;
if (completed_threads_array[i] == true) if (completed_threads_array[i] == true)
Show All 32 Lines

lldb/trunk/test/expression_command/call-restarts/TestCallThatRestarts.py

Show All 24 Linesclass ExprCommandThatRestartsTestCase(TestBase):
def test_with_dsym(self): def test_with_dsym(self):
"""Test calling std::String member function.""" """Test calling std::String member function."""
self.buildDsym() self.buildDsym()
self.call_function() self.call_function()
@dwarf_test @dwarf_test
@skipIfLinux # llvm.org/pr19246: intermittent failure @skipIfLinux # llvm.org/pr19246: intermittent failure
@skipIfDarwin # llvm.org/pr19246: intermittent failure @skipIfDarwin # llvm.org/pr19246: intermittent failure
@skipIfWindows # Test relies on signals, unsupported on Windows
def test_with_dwarf(self): def test_with_dwarf(self):
"""Test calling std::String member function.""" """Test calling std::String member function."""
self.buildDwarf() self.buildDwarf()
self.call_function() self.call_function()
def check_after_call (self, num_sigchld): def check_after_call (self, num_sigchld):
after_call = self.sigchld_no.GetValueAsSigned(-1) after_call = self.sigchld_no.GetValueAsSigned(-1)
self.assertTrue (after_call - self.start_sigchld_no == num_sigchld, "Really got %d SIGCHLD signals through the call."%(num_sigchld)) self.assertTrue (after_call - self.start_sigchld_no == num_sigchld, "Really got %d SIGCHLD signals through the call."%(num_sigchld))
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

lldb/trunk/test/expression_command/timeout/Makefile

LEVEL = ../../make LEVEL = ../../make
C_SOURCES := wait-a-while.c CXX_SOURCES := wait-a-while.cpp
include $(LEVEL)/Makefile.rules include $(LEVEL)/Makefile.rules

lldb/trunk/test/expression_command/timeout/TestCallWithTimeout.py

Show All 9 Lines
class ExprCommandWithTimeoutsTestCase(TestBase): class ExprCommandWithTimeoutsTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
def setUp(self): def setUp(self):
# Call super's setUp(). # Call super's setUp().
TestBase.setUp(self) TestBase.setUp(self)
self.main_source = "wait-a-while.c" self.main_source = "wait-a-while.cpp"
self.main_source_spec = lldb.SBFileSpec (self.main_source) self.main_source_spec = lldb.SBFileSpec (self.main_source)
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
@dsym_test @dsym_test
def test_with_dsym(self): def test_with_dsym(self):
"""Test calling std::String member function.""" """Test calling std::String member function."""
self.buildDsym() self.buildDsym()
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

lldb/trunk/test/expression_command/timeout/wait-a-while.c

#include <stdio.h>
#include <unistd.h>
#include <sys/time.h>
#include <stdint.h>
int
wait_a_while (useconds_t interval)
{
int num_times = 0;
int return_value = 1;
struct timeval start_time;
gettimeofday(&start_time, NULL);
uint64_t target = start_time.tv_sec * 1000000 + start_time.tv_usec + interval;
while (1)
{
num_times++;
return_value = usleep (interval);
if (return_value != 0)
{
struct timeval now;
gettimeofday(&now, NULL);
interval = target - (now.tv_sec * 1000000 + now.tv_usec);
}
else
break;
}
return num_times;
}
int
main (int argc, char **argv)
{
printf ("stop here in main.\n");
int num_times = wait_a_while (argc * 1000);
printf ("Done, took %d times.\n", num_times);
return 0;
}

lldb/trunk/test/expression_command/timeout/wait-a-while.cpp

#include <stdio.h>
#include <stdint.h>
#include <chrono>
#include <thread>
int
wait_a_while (int microseconds)
{
int num_times = 0;
while (1)
{
num_times++;
std::this_thread::sleep_for(std::chrono::microseconds(microseconds));
break;
}
return num_times;
}
int
main (int argc, char **argv)
{
printf ("stop here in main.\n");
int num_times = wait_a_while (argc * 1000);
printf ("Done, took %d times.\n", num_times);
return 0;
}

lldb/trunk/test/functionalities/attach_resume/Makefile

LEVEL = ../../make LEVEL = ../../make
C_SOURCES := main.c CXX_SOURCES := main.cpp
LD_EXTRAS := -lpthread ENABLE_THREADS := Yes
EXE := AttachResume EXE := AttachResume
include $(LEVEL)/Makefile.rules include $(LEVEL)/Makefile.rules

lldb/trunk/test/functionalities/attach_resume/TestAttachResume.py

Show First 20 Lines • Show All 64 Lines • ▼ Show 20 Lines def process_attach_continue_interrupt_detach(self):
self.assertTrue(wait_for_state(lldb.eStateRunning), self.assertTrue(wait_for_state(lldb.eStateRunning),
'Process not running after continue') 'Process not running after continue')
self.runCmd("process interrupt") self.runCmd("process interrupt")
self.assertTrue(wait_for_state(lldb.eStateStopped), self.assertTrue(wait_for_state(lldb.eStateStopped),
'Process not stopped after interrupt') 'Process not stopped after interrupt')
# check that this breakpoint is auto-cleared on detach (r204752) # check that this breakpoint is auto-cleared on detach (r204752)
self.runCmd("br set -f main.c -l 12") self.runCmd("br set -f main.cpp -l 12")
self.runCmd("c") self.runCmd("c")
self.assertTrue(wait_for_state(lldb.eStateRunning), self.assertTrue(wait_for_state(lldb.eStateRunning),
'Process not running after continue') 'Process not running after continue')
self.assertTrue(wait_for_state(lldb.eStateStopped), self.assertTrue(wait_for_state(lldb.eStateStopped),
'Process not stopped after breakpoint') 'Process not stopped after breakpoint')
self.expect('br list', 'Breakpoint not hit', self.expect('br list', 'Breakpoint not hit',
Show All 16 Lines

lldb/trunk/test/functionalities/attach_resume/main.c

#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <pthread.h>
void *start(void *data)
{
int i;
size_t idx = (size_t)data;
for (i=0; i<30; i++)
{
if ( idx == 0 )
usleep(1);
sleep(1);
}
return 0;
}
int main(int argc, char const *argv[])
{
static const size_t nthreads = 16;
pthread_attr_t attr;
pthread_t threads[nthreads];
size_t i;
pthread_attr_init(&attr);
for (i=0; i<nthreads; i++)
pthread_create(&threads[i], &attr, &start, (void *)i);
for (i=0; i<nthreads; i++)
pthread_join(threads[i], 0);
}

lldb/trunk/test/functionalities/attach_resume/main.cpp

#include <stdio.h>
#include <fcntl.h>
#include <chrono>
#include <thread>
void *start(void *data)
{
int i;
size_t idx = (size_t)data;
for (i=0; i<30; i++)
{
if ( idx == 0 )
std::this_thread::sleep_for(std::chrono::microseconds(1));
std::this_thread::sleep_for(std::chrono::seconds(1));
}
return 0;
}
int main(int argc, char const *argv[])
{
static const size_t nthreads = 16;
std::thread threads[nthreads];
size_t i;
for (i=0; i<nthreads; i++)
threads[i] = std::move(std::thread(start, (void*)i));
for (i=0; i<nthreads; i++)
threads[i].join();
}

lldb/trunk/test/functionalities/expr-doesnt-deadlock/Makefile

LEVEL = ../../make LEVEL = ../../make
CFLAGS_EXTRAS := -lpthread
C_SOURCES := locking.c C_SOURCES := locking.c
ENABLE_THREADS := YES
include $(LEVEL)/Makefile.rules include $(LEVEL)/Makefile.rules

lldb/trunk/test/functionalities/stop-hook/multiple_threads/Makefile

LEVEL = ../../../make LEVEL = ../../../make
LD_EXTRAS := -lpthread
CXX_SOURCES := main.cpp CXX_SOURCES := main.cpp
ENABLE_THREADS := YES
include $(LEVEL)/Makefile.rules include $(LEVEL)/Makefile.rules

lldb/trunk/test/functionalities/thread/Makefile

LEVEL = ../../make LEVEL = ../../make
C_SOURCES := main.c C_SOURCES := main.c
LD_EXTRAS := -lpthread ENABLE_THREADS := YES
include $(LEVEL)/Makefile.rules include $(LEVEL)/Makefile.rules

lldb/trunk/test/functionalities/thread/concurrent_events/Makefile

LEVEL = ../../../make LEVEL = ../../../make
CXX_SOURCES := main.cpp CXX_SOURCES := main.cpp
CFLAGS_EXTRAS += -std=c++11 -lpthread ENABLE_THREADS := YES
LD_EXTRAS += -lpthread
include $(LEVEL)/Makefile.rules include $(LEVEL)/Makefile.rules

lldb/trunk/test/functionalities/thread/step_out/Makefile

LEVEL = ../../../make LEVEL = ../../../make
CXX_SOURCES := main.cpp
LD_EXTRAS := -lpthread
CFLAGS_EXTRAS += -std=c++11 CXX_SOURCES := main.cpp
ENABLE_THREADS := YES
include $(LEVEL)/Makefile.rules include $(LEVEL)/Makefile.rules

lldb/trunk/test/functionalities/thread/thread_specific_break/Makefile

LEVEL = ../../../make LEVEL = ../../../make
C_SOURCES := main.c C_SOURCES := main.c
LD_EXTRAS := -lpthread ENABLE_THREADS := YES
include $(LEVEL)/Makefile.rules include $(LEVEL)/Makefile.rules

lldb/trunk/test/functionalities/watchpoint/hello_watchlocation/Makefile

LEVEL = ../../../make LEVEL = ../../../make
LD_EXTRAS := -lpthread ENABLE_THREADS := YES
CXX_SOURCES := main.cpp CXX_SOURCES := main.cpp
include $(LEVEL)/Makefile.rules include $(LEVEL)/Makefile.rules

lldb/trunk/test/functionalities/watchpoint/multiple_threads/Makefile

LEVEL = ../../../make LEVEL = ../../../make
LD_EXTRAS := -lpthread ENABLE_THREADS := YES
CXX_SOURCES := main.cpp CXX_SOURCES := main.cpp
include $(LEVEL)/Makefile.rules include $(LEVEL)/Makefile.rules

lldb/trunk/test/functionalities/watchpoint/watchpoint_set_command/Makefile

LEVEL = ../../../make LEVEL = ../../../make
LD_EXTRAS := -lpthread ENABLE_THREADS := YES
CXX_SOURCES := main.cpp CXX_SOURCES := main.cpp
include $(LEVEL)/Makefile.rules include $(LEVEL)/Makefile.rules

lldb/trunk/test/lang/c/tls_globals/Makefile

LEVEL = ../../../make LEVEL = ../../../make
C_SOURCES := main.c C_SOURCES := main.c
CFLAGS_EXTRAS += -fPIC CFLAGS_EXTRAS += -fPIC
DYLIB_NAME := a DYLIB_NAME := a
DYLIB_C_SOURCES := a.c DYLIB_C_SOURCES := a.c
LD_EXTRAS += -lpthread ENABLE_THREADS := YES
include $(LEVEL)/Makefile.rules include $(LEVEL)/Makefile.rules

lldb/trunk/test/lldbtest.py

Show First 20 Lines • Show All 548 Lines • ▼ Show 20 Lines def wrapper(*args, **kwargs):
self = args[0] self = args[0]
platform = sys.platform platform = sys.platform
if "linux" in platform: if "linux" in platform:
self.skipTest("skip on linux") self.skipTest("skip on linux")
else: else:
func(*args, **kwargs) func(*args, **kwargs)
return wrapper return wrapper
def skipIfWindows(func):
"""Decorate the item to skip tests that should be skipped on Windows."""
if isinstance(func, type) and issubclass(func, unittest2.TestCase):
raise Exception("@skipIfWindows can only be used to decorate a test method")
@wraps(func)
def wrapper(*args, **kwargs):
from unittest2 import case
self = args[0]
platform = sys.platform
if "win32" in platform:
self.skipTest("skip on Windows")
else:
func(*args, **kwargs)
return wrapper
def skipIfDarwin(func): def skipIfDarwin(func):
"""Decorate the item to skip tests that should be skipped on Darwin.""" """Decorate the item to skip tests that should be skipped on Darwin."""
if isinstance(func, type) and issubclass(func, unittest2.TestCase): if isinstance(func, type) and issubclass(func, unittest2.TestCase):
raise Exception("@skipIfDarwin can only be used to decorate a test method") raise Exception("@skipIfDarwin can only be used to decorate a test method")
@wraps(func) @wraps(func)
def wrapper(*args, **kwargs): def wrapper(*args, **kwargs):
from unittest2 import case from unittest2 import case
self = args[0] self = args[0]
▲ Show 20 Lines • Show All 1,331 Lines • Show Last 20 Lines

lldb/trunk/test/make/Makefile.rules

Show All 20 Lines
# And test/functionalities/archives/Makefile: # And test/functionalities/archives/Makefile:
# MAKE_DSYM := NO # MAKE_DSYM := NO
# ARCHIVE_NAME := libfoo.a # ARCHIVE_NAME := libfoo.a
# ARCHIVE_C_SOURCES := a.c b.c # ARCHIVE_C_SOURCES := a.c b.c
# Uncomment line below for debugging shell commands # Uncomment line below for debugging shell commands
# SHELL = /bin/sh -x # SHELL = /bin/sh -x
THIS_FILE_DIR := $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))/
LLDB_BASE_DIR := $(THIS_FILE_DIR)../../
#---------------------------------------------------------------------- #----------------------------------------------------------------------
# If ARCH is not defined, default to x86_64. # If ARCH is not defined, default to x86_64.
# If OS is not defined, use 'uname -s' to determine the OS name. # If OS is not defined, use 'uname -s' to determine the OS name.
#---------------------------------------------------------------------- #----------------------------------------------------------------------
ifeq "$(ARCH)" "" ifeq "$(ARCH)" ""
ARCH = x86_64 ARCH = x86_64
endif endif
Show All 31 Linesifeq "$(OS)" "Darwin"
DSFLAGS = DSFLAGS =
DSYM = $(EXE).dSYM DSYM = $(EXE).dSYM
AR := libtool AR := libtool
ARFLAGS := -static -o ARFLAGS := -static -o
else else
# On non-Apple platforms, -arch becomes -m # On non-Apple platforms, -arch becomes -m
ARCHFLAG := -m ARCHFLAG := -m
# i386,i686 -> 32 # i386, i686, x86 -> 32
# amd64, x86_64, x64 -> 64 # amd64, x86_64, x64 -> 64
ifeq "$(ARCH)" "amd64" ifeq "$(ARCH)" "amd64"
override ARCH := $(subst amd64,64,$(ARCH)) override ARCH := $(subst amd64,64,$(ARCH))
endif endif
ifeq "$(ARCH)" "x86_64" ifeq "$(ARCH)" "x86_64"
override ARCH := $(subst x86_64,64,$(ARCH)) override ARCH := $(subst x86_64,64,$(ARCH))
endif endif
ifeq "$(ARCH)" "x64" ifeq "$(ARCH)" "x64"
override ARCH := $(subst x64,64,$(ARCH)) override ARCH := $(subst x64,64,$(ARCH))
endif endif
ifeq "$(ARCH)" "x86"
override ARCH := $(subst x86,32,$(ARCH))
endif
ifeq "$(ARCH)" "i386" ifeq "$(ARCH)" "i386"
override ARCH := $(subst i386,32,$(ARCH)) override ARCH := $(subst i386,32,$(ARCH))
endif endif
ifeq "$(ARCH)" "i686" ifeq "$(ARCH)" "i686"
override ARCH := $(subst i686,32,$(ARCH)) override ARCH := $(subst i686,32,$(ARCH))
endif endif
ifeq "$(SPLIT_DEBUG_SYMBOLS)" "YES" ifeq "$(SPLIT_DEBUG_SYMBOLS)" "YES"
DSYM = $(EXE).debug DSYM = $(EXE).debug
endif endif
endif endif
CFLAGS ?= -g -O0 CFLAGS ?= -g -O0
CFLAGS += $(ARCHFLAG)$(ARCH) $(FRAMEWORK_INCLUDES) $(CFLAGS_EXTRAS) CFLAGS += $(ARCHFLAG)$(ARCH) $(FRAMEWORK_INCLUDES) $(CFLAGS_EXTRAS) -I$(LLDB_BASE_DIR)include
# Use this one if you want to build one part of the result without debug information: # Use this one if you want to build one part of the result without debug information:
CFLAGS_NO_DEBUG = -O0 $(ARCHFLAG)$(ARCH) $(FRAMEWORK_INCLUDES) $(CFLAGS_EXTRAS) CFLAGS_NO_DEBUG = -O0 $(ARCHFLAG)$(ARCH) $(FRAMEWORK_INCLUDES) $(CFLAGS_EXTRAS)
CXXFLAGS += -std=c++11
CXXFLAGS +=$(CFLAGS) CXXFLAGS += $(CFLAGS)
LD = $(CC) LD = $(CC)
LDFLAGS ?= $(CFLAGS) LDFLAGS ?= $(CFLAGS)
LDFLAGS += $(LD_EXTRAS) LDFLAGS += $(LD_EXTRAS)
ifneq "$(OS)" "Windows_NT"
ifeq "$(ENABLE_THREADS)" "Yes"
LDFLAGS += -lpthread
endif
endif
OBJECTS = OBJECTS =
EXE ?= a.out EXE ?= a.out
ifneq "$(DYLIB_NAME)" "" ifneq "$(DYLIB_NAME)" ""
ifeq "$(OS)" "Darwin" ifeq "$(OS)" "Darwin"
DYLIB_FILENAME = lib$(DYLIB_NAME).dylib DYLIB_FILENAME = lib$(DYLIB_NAME).dylib
else else
DYLIB_FILENAME = lib$(DYLIB_NAME).so DYLIB_FILENAME = lib$(DYLIB_NAME).so
endif endif
endif endif
# Function that returns the counterpart C++ compiler, given $(CC) as arg. # Function that returns the counterpart C++ compiler, given $(CC) as arg.
cxx_compiler_notdir = $(if $(findstring clang,$(1)), $(subst clang,clang++,$(1)), $(if $(findstring icc,$(1)), $(subst icc,icpc,$(1)), $(if $(findstring llvm-gcc,$(1)), $(subst llvm-gcc,llvm-g++,$(1)), $(subst gcc,g++,$(1))))) cxx_compiler_notdir = $(if $(findstring clang,$(1)), $(subst clang,clang++,$(1)), $(if $(findstring icc,$(1)), $(subst icc,icpc,$(1)), $(if $(findstring llvm-gcc,$(1)), $(subst llvm-gcc,llvm-g++,$(1)), $(subst gcc,g++,$(1)))))
cxx_compiler = $(if $(findstring /,$(1)),$(join $(dir $(1)), $(call cxx_compiler_notdir,$(notdir $(1)))),$(call cxx_compiler_notdir,$(1))) cxx_compiler = $(if $(findstring /,$(1)),$(join $(dir $(1)), $(call cxx_compiler_notdir,$(notdir $(1)))),$(call cxx_compiler_notdir,$(1)))
# Function that returns the C++ linker, given $(CC) as arg. # Function that returns the C++ linker, given $(CC) as arg.
cxx_linker_notdir = $(if $(findstring clang,$(1)), $(subst clang,clang++,$(1)), $(if $(findstring icc,$(1)), $(subst icc,icpc,$(1)), $(if $(findstring llvm-gcc,$(1)), $(subst llvm-gcc,llvm-g++,$(1)), $(subst gcc,g++,$(1))))) cxx_linker_notdir = $(if $(findstring clang,$(1)), $(subst clang,clang++,$(1)), $(if $(findstring icc,$(1)), $(subst icc,icpc,$(1)), $(if $(findstring llvm-gcc,$(1)), $(subst llvm-gcc,llvm-g++,$(1)), $(subst gcc,g++,$(1)))))
cxx_linker = $(if $(findstring /,$(1)),$(join $(dir $(1)), $(call cxx_linker_notdir,$(notdir $(1)))),$(call cxx_linker_notdir,$(1))) cxx_linker = $(if $(findstring /,$(1)),$(join $(dir $(1)), $(call cxx_linker_notdir,$(notdir $(1)))),$(call cxx_linker_notdir,$(1)))
#---------------------------------------------------------------------- #----------------------------------------------------------------------
# Clang for Windows doesn't yet support exceptions
#----------------------------------------------------------------------
ifeq "$(OS)" "Windows_NT"
ifneq (,$(findstring clang,$(CC)))
CXXFLAGS += -fno-exceptions
CXXFLAGS += -include $(THIS_FILE_DIR)uncaught_exception.h
CXXFLAGS += -D_HAS_EXCEPTIONS=0
endif
endif
#----------------------------------------------------------------------
# C++ standard library options # C++ standard library options
#---------------------------------------------------------------------- #----------------------------------------------------------------------
ifeq (1,$(USE_LIBSTDCPP)) ifeq (1,$(USE_LIBSTDCPP))
# Clang requires an extra flag: -stdlib=libstdc++ # Clang requires an extra flag: -stdlib=libstdc++
ifneq (,$(findstring clang,$(CC))) ifneq (,$(findstring clang,$(CC)))
CXXFLAGS += -stdlib=libstdc++ CXXFLAGS += -stdlib=libstdc++
LDFLAGS += -stdlib=libstdc++ LDFLAGS += -stdlib=libstdc++
endif endif
▲ Show 20 Lines • Show All 265 Lines • Show Last 20 Lines

lldb/trunk/test/make/uncaught_exception.h

// MSVC header files have compilation issues when compiling with exceptions disabled. Notably,
// this function is compiled out when _HAS_EXCEPTIONS=0, but this function is called from another
// place even when _HAS_EXCEPTIONS=0. So we define a dummy implementation as a workaround and
// force include this header file.
static void *__uncaught_exception() { return nullptr; }

lldb/trunk/test/python_api/lldbutil/iter/Makefile

LEVEL = ../../../make LEVEL = ../../../make
CFLAGS_EXTRAS := -D__STDC_LIMIT_MACROS CFLAGS_EXTRAS := -D__STDC_LIMIT_MACROS
LD_EXTRAS := -lpthread ENABLE_THREADS := YES
CXX_SOURCES := main.cpp CXX_SOURCES := main.cpp
MAKE_DSYM :=NO MAKE_DSYM := NO
include $(LEVEL)/Makefile.rules include $(LEVEL)/Makefile.rules

lldb/trunk/test/python_api/lldbutil/iter/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===// //===-- main.cpp ------------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C includes // C includes
#include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h>
pthread_t g_thread_1 = NULL; // C++ includes
pthread_t g_thread_2 = NULL; #include <chrono>
pthread_t g_thread_3 = NULL; #include <mutex>
#include <random>
#include <thread>
std::thread g_thread_1;
std::thread g_thread_2;
std::thread g_thread_3;
std::mutex g_mask_mutex;
typedef enum { typedef enum {
eGet, eGet,
eAssign, eAssign,
eClearBits eClearBits
} MaskAction; } MaskAction;
uint32_t mask_access (MaskAction action, uint32_t mask = 0); uint32_t mask_access (MaskAction action, uint32_t mask = 0);
uint32_t uint32_t
mask_access (MaskAction action, uint32_t mask) mask_access (MaskAction action, uint32_t mask)
{ {
static pthread_mutex_t g_mask_mutex = PTHREAD_MUTEX_INITIALIZER;
static uint32_t g_mask = 0; static uint32_t g_mask = 0;
::pthread_mutex_lock (&g_mask_mutex);
std::lock_guard<std::mutex> lock(g_mask_mutex);
switch (action) switch (action)
{ {
case eGet: case eGet:
break; break;
case eAssign: case eAssign:
g_mask |= mask; g_mask |= mask;
break; break;
case eClearBits: case eClearBits:
g_mask &= ~mask; g_mask &= ~mask;
break; break;
} }
uint32_t new_mask = g_mask; return g_mask;
::pthread_mutex_unlock (&g_mask_mutex);
return new_mask;
} }
void * void *
thread_func (void *arg) thread_func (void *arg)
{ {
uint32_t thread_index = *((uint32_t *)arg); uint32_t thread_index = *((uint32_t *)arg);
uint32_t thread_mask = (1u << (thread_index)); uint32_t thread_mask = (1u << (thread_index));
printf ("%s (thread index = %u) startng...\n", __FUNCTION__, thread_index); printf ("%s (thread index = %u) startng...\n", __FUNCTION__, thread_index);
std::default_random_engine generator;
std::uniform_int_distribution<int> distribution(0, 3000000);
while (mask_access(eGet) & thread_mask) while (mask_access(eGet) & thread_mask)
{ {
// random micro second sleep from zero to 3 seconds // random micro second sleep from zero to 3 seconds
int usec = ::rand() % 3000000; int usec = distribution(generator);
printf ("%s (thread = %u) doing a usleep (%d)...\n", __FUNCTION__, thread_index, usec); printf ("%s (thread = %u) doing a usleep (%d)...\n", __FUNCTION__, thread_index, usec);
::usleep (usec);
std::chrono::microseconds duration(usec);
std::this_thread::sleep_for(duration);
printf ("%s (thread = %u) after usleep ...\n", __FUNCTION__, thread_index); // Set break point at this line. printf ("%s (thread = %u) after usleep ...\n", __FUNCTION__, thread_index); // Set break point at this line.
} }
printf ("%s (thread index = %u) exiting...\n", __FUNCTION__, thread_index); printf ("%s (thread index = %u) exiting...\n", __FUNCTION__, thread_index);
return NULL; return NULL;
} }
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
int err;
void *thread_result = NULL;
uint32_t thread_index_1 = 1; uint32_t thread_index_1 = 1;
uint32_t thread_index_2 = 2; uint32_t thread_index_2 = 2;
uint32_t thread_index_3 = 3; uint32_t thread_index_3 = 3;
uint32_t thread_mask_1 = (1u << thread_index_1); uint32_t thread_mask_1 = (1u << thread_index_1);
uint32_t thread_mask_2 = (1u << thread_index_2); uint32_t thread_mask_2 = (1u << thread_index_2);
uint32_t thread_mask_3 = (1u << thread_index_3); uint32_t thread_mask_3 = (1u << thread_index_3);
// Make a mask that will keep all threads alive // Make a mask that will keep all threads alive
mask_access (eAssign, thread_mask_1 | thread_mask_2 | thread_mask_3); // And that line. mask_access (eAssign, thread_mask_1 | thread_mask_2 | thread_mask_3); // And that line.
// Create 3 threads // Create 3 threads
err = ::pthread_create (&g_thread_1, NULL, thread_func, &thread_index_1); g_thread_1 = std::thread(thread_func, (void*)&thread_index_1);
err = ::pthread_create (&g_thread_2, NULL, thread_func, &thread_index_2); g_thread_2 = std::thread(thread_func, (void*)&thread_index_2);
err = ::pthread_create (&g_thread_3, NULL, thread_func, &thread_index_3); g_thread_3 = std::thread(thread_func, (void*)&thread_index_3);
char line[64]; char line[64];
while (mask_access(eGet) != 0) while (mask_access(eGet) != 0)
{ {
printf ("Enter thread index to kill or ENTER for all:\n"); printf ("Enter thread index to kill or ENTER for all:\n");
fflush (stdout); fflush (stdout);
// Kill threads by index, or ENTER for all threads // Kill threads by index, or ENTER for all threads
Show All 16 Lines while (mask_access(eGet) != 0)
break; break;
} }
// Clear all thread bits to they all exit // Clear all thread bits to they all exit
mask_access (eClearBits, UINT32_MAX); mask_access (eClearBits, UINT32_MAX);
// Join all of our threads // Join all of our threads
err = ::pthread_join (g_thread_1, &thread_result); g_thread_1.join();
err = ::pthread_join (g_thread_2, &thread_result); g_thread_2.join();
err = ::pthread_join (g_thread_3, &thread_result); g_thread_3.join();
return 0; return 0;
} }

lldb/trunk/test/python_api/lldbutil/process/Makefile

LEVEL = ../../../make LEVEL = ../../../make
CFLAGS_EXTRAS := -D__STDC_LIMIT_MACROS CFLAGS_EXTRAS := -D__STDC_LIMIT_MACROS
LD_EXTRAS := -lpthread ENABLE_THREADS := YES
CXX_SOURCES := main.cpp CXX_SOURCES := main.cpp
MAKE_DSYM :=NO MAKE_DSYM :=NO
include $(LEVEL)/Makefile.rules include $(LEVEL)/Makefile.rules

lldb/trunk/test/python_api/lldbutil/process/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===// //===-- main.cpp ------------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C includes // C includes
#include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h>
pthread_t g_thread_1 = NULL; // C++ includes
pthread_t g_thread_2 = NULL; #include <chrono>
pthread_t g_thread_3 = NULL; #include <mutex>
#include <random>
#include <thread>
std::thread g_thread_1;
std::thread g_thread_2;
std::thread g_thread_3;
std::mutex g_mask_mutex;
typedef enum { typedef enum {
eGet, eGet,
eAssign, eAssign,
eClearBits eClearBits
} MaskAction; } MaskAction;
uint32_t mask_access (MaskAction action, uint32_t mask = 0); uint32_t mask_access (MaskAction action, uint32_t mask = 0);
uint32_t uint32_t
mask_access (MaskAction action, uint32_t mask) mask_access (MaskAction action, uint32_t mask)
{ {
static pthread_mutex_t g_mask_mutex = PTHREAD_MUTEX_INITIALIZER;
static uint32_t g_mask = 0; static uint32_t g_mask = 0;
::pthread_mutex_lock (&g_mask_mutex);
std::lock_guard<std::mutex> lock(g_mask_mutex);
switch (action) switch (action)
{ {
case eGet: case eGet:
break; break;
case eAssign: case eAssign:
g_mask |= mask; g_mask |= mask;
break; break;
case eClearBits: case eClearBits:
g_mask &= ~mask; g_mask &= ~mask;
break; break;
} }
uint32_t new_mask = g_mask; return g_mask;
::pthread_mutex_unlock (&g_mask_mutex);
return new_mask;
} }
void * void *
thread_func (void *arg) thread_func (void *arg)
{ {
uint32_t thread_index = *((uint32_t *)arg); uint32_t thread_index = *((uint32_t *)arg);
uint32_t thread_mask = (1u << (thread_index)); uint32_t thread_mask = (1u << (thread_index));
printf ("%s (thread index = %u) startng...\n", __FUNCTION__, thread_index); printf ("%s (thread index = %u) startng...\n", __FUNCTION__, thread_index);
std::default_random_engine generator;
std::uniform_int_distribution<int> distribution(0, 3000000);
while (mask_access(eGet) & thread_mask) while (mask_access(eGet) & thread_mask)
{ {
// random micro second sleep from zero to 3 seconds // random micro second sleep from zero to 3 seconds
int usec = ::rand() % 3000000; int usec = distribution(generator);
printf ("%s (thread = %u) doing a usleep (%d)...\n", __FUNCTION__, thread_index, usec); printf ("%s (thread = %u) doing a usleep (%d)...\n", __FUNCTION__, thread_index, usec);
::usleep (usec); std::chrono::microseconds duration(usec);
std::this_thread::sleep_for(duration);
printf ("%s (thread = %u) after usleep ...\n", __FUNCTION__, thread_index); // Set break point at this line. printf ("%s (thread = %u) after usleep ...\n", __FUNCTION__, thread_index); // Set break point at this line.
} }
printf ("%s (thread index = %u) exiting...\n", __FUNCTION__, thread_index); printf ("%s (thread index = %u) exiting...\n", __FUNCTION__, thread_index);
return NULL; return NULL;
} }
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
int err; int err;
void *thread_result = NULL; void *thread_result = NULL;
uint32_t thread_index_1 = 1; uint32_t thread_index_1 = 1;
uint32_t thread_index_2 = 2; uint32_t thread_index_2 = 2;
uint32_t thread_index_3 = 3; uint32_t thread_index_3 = 3;
uint32_t thread_mask_1 = (1u << thread_index_1); uint32_t thread_mask_1 = (1u << thread_index_1);
uint32_t thread_mask_2 = (1u << thread_index_2); uint32_t thread_mask_2 = (1u << thread_index_2);
uint32_t thread_mask_3 = (1u << thread_index_3); uint32_t thread_mask_3 = (1u << thread_index_3);
// Make a mask that will keep all threads alive // Make a mask that will keep all threads alive
mask_access (eAssign, thread_mask_1 | thread_mask_2 | thread_mask_3); // And that line. mask_access (eAssign, thread_mask_1 | thread_mask_2 | thread_mask_3); // And that line.
// Create 3 threads // Create 3 threads
err = ::pthread_create (&g_thread_1, NULL, thread_func, &thread_index_1); g_thread_1 = std::thread(thread_func, (void*)&thread_index_1);
err = ::pthread_create (&g_thread_2, NULL, thread_func, &thread_index_2); g_thread_2 = std::thread(thread_func, (void*)&thread_index_2);
err = ::pthread_create (&g_thread_3, NULL, thread_func, &thread_index_3); g_thread_3 = std::thread(thread_func, (void*)&thread_index_3);
char line[64]; char line[64];
while (mask_access(eGet) != 0) while (mask_access(eGet) != 0)
{ {
printf ("Enter thread index to kill or ENTER for all:\n"); printf ("Enter thread index to kill or ENTER for all:\n");
fflush (stdout); fflush (stdout);
// Kill threads by index, or ENTER for all threads // Kill threads by index, or ENTER for all threads
Show All 16 Lines while (mask_access(eGet) != 0)
break; break;
} }
// Clear all thread bits to they all exit // Clear all thread bits to they all exit
mask_access (eClearBits, UINT32_MAX); mask_access (eClearBits, UINT32_MAX);
// Join all of our threads // Join all of our threads
err = ::pthread_join (g_thread_1, &thread_result); g_thread_1.join();
err = ::pthread_join (g_thread_2, &thread_result); g_thread_2.join();
err = ::pthread_join (g_thread_3, &thread_result); g_thread_3.join();
return 0; return 0;
} }

lldb/trunk/test/python_api/module_section/Makefile

LEVEL = ../../make LEVEL = ../../make
CFLAGS_EXTRAS := -D__STDC_LIMIT_MACROS CFLAGS_EXTRAS := -D__STDC_LIMIT_MACROS
LD_EXTRAS := -lpthread ENABLE_THREADS := YES
CXX_SOURCES := main.cpp b.cpp c.cpp CXX_SOURCES := main.cpp b.cpp c.cpp
MAKE_DSYM :=NO MAKE_DSYM :=NO
include $(LEVEL)/Makefile.rules include $(LEVEL)/Makefile.rules

lldb/trunk/test/python_api/module_section/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===// //===-- main.cpp ------------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// C includes // C includes
#include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h>
pthread_t g_thread_1 = NULL; // C++ includes
pthread_t g_thread_2 = NULL; #include <chrono>
pthread_t g_thread_3 = NULL; #include <mutex>
#include <random>
#include <thread>
std::thread g_thread_1;
std::thread g_thread_2;
std::thread g_thread_3;
std::mutex g_mask_mutex;
typedef enum { typedef enum {
eGet, eGet,
eAssign, eAssign,
eClearBits eClearBits
} MaskAction; } MaskAction;
uint32_t mask_access (MaskAction action, uint32_t mask = 0); uint32_t mask_access (MaskAction action, uint32_t mask = 0);
uint32_t uint32_t
mask_access (MaskAction action, uint32_t mask) mask_access (MaskAction action, uint32_t mask)
{ {
static pthread_mutex_t g_mask_mutex = PTHREAD_MUTEX_INITIALIZER;
static uint32_t g_mask = 0; static uint32_t g_mask = 0;
::pthread_mutex_lock (&g_mask_mutex);
std::lock_guard<std::mutex> lock(g_mask_mutex);
switch (action) switch (action)
{ {
case eGet: case eGet:
break; break;
case eAssign: case eAssign:
g_mask |= mask; g_mask |= mask;
break; break;
case eClearBits: case eClearBits:
g_mask &= ~mask; g_mask &= ~mask;
break; break;
} }
uint32_t new_mask = g_mask; return g_mask;
::pthread_mutex_unlock (&g_mask_mutex);
return new_mask;
} }
void * void *
thread_func (void *arg) thread_func (void *arg)
{ {
uint32_t thread_index = *((uint32_t *)arg); uint32_t thread_index = *((uint32_t *)arg);
uint32_t thread_mask = (1u << (thread_index)); uint32_t thread_mask = (1u << (thread_index));
printf ("%s (thread index = %u) startng...\n", __FUNCTION__, thread_index); printf ("%s (thread index = %u) startng...\n", __FUNCTION__, thread_index);
std::default_random_engine generator;
std::uniform_int_distribution<int> distribution(0, 3000000);
while (mask_access(eGet) & thread_mask) while (mask_access(eGet) & thread_mask)
{ {
// random micro second sleep from zero to 3 seconds // random micro second sleep from zero to 3 seconds
int usec = ::rand() % 3000000; int usec = distribution(generator);
printf ("%s (thread = %u) doing a usleep (%d)...\n", __FUNCTION__, thread_index, usec); printf ("%s (thread = %u) doing a usleep (%d)...\n", __FUNCTION__, thread_index, usec);
::usleep (usec); std::chrono::microseconds duration(usec);
std::this_thread::sleep_for(duration);
printf ("%s (thread = %u) after usleep ...\n", __FUNCTION__, thread_index); // Set break point at this line. printf ("%s (thread = %u) after usleep ...\n", __FUNCTION__, thread_index); // Set break point at this line.
} }
printf ("%s (thread index = %u) exiting...\n", __FUNCTION__, thread_index); printf ("%s (thread index = %u) exiting...\n", __FUNCTION__, thread_index);
return NULL; return NULL;
} }
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
int err; int err;
void *thread_result = NULL; void *thread_result = NULL;
uint32_t thread_index_1 = 1; uint32_t thread_index_1 = 1;
uint32_t thread_index_2 = 2; uint32_t thread_index_2 = 2;
uint32_t thread_index_3 = 3; uint32_t thread_index_3 = 3;
uint32_t thread_mask_1 = (1u << thread_index_1); uint32_t thread_mask_1 = (1u << thread_index_1);
uint32_t thread_mask_2 = (1u << thread_index_2); uint32_t thread_mask_2 = (1u << thread_index_2);
uint32_t thread_mask_3 = (1u << thread_index_3); uint32_t thread_mask_3 = (1u << thread_index_3);
// Make a mask that will keep all threads alive // Make a mask that will keep all threads alive
mask_access (eAssign, thread_mask_1 | thread_mask_2 | thread_mask_3); // And that line. mask_access (eAssign, thread_mask_1 | thread_mask_2 | thread_mask_3); // And that line.
// Create 3 threads // Create 3 threads
err = ::pthread_create (&g_thread_1, NULL, thread_func, &thread_index_1); g_thread_1 = std::thread(thread_func, (void*)&thread_index_1);
err = ::pthread_create (&g_thread_2, NULL, thread_func, &thread_index_2); g_thread_2 = std::thread(thread_func, (void*)&thread_index_2);
err = ::pthread_create (&g_thread_3, NULL, thread_func, &thread_index_3); g_thread_3 = std::thread(thread_func, (void*)&thread_index_3);
char line[64]; char line[64];
while (mask_access(eGet) != 0) while (mask_access(eGet) != 0)
{ {
printf ("Enter thread index to kill or ENTER for all:\n"); printf ("Enter thread index to kill or ENTER for all:\n");
fflush (stdout); fflush (stdout);
// Kill threads by index, or ENTER for all threads // Kill threads by index, or ENTER for all threads
Show All 16 Lines while (mask_access(eGet) != 0)
break; break;
} }
// Clear all thread bits to they all exit // Clear all thread bits to they all exit
mask_access (eClearBits, UINT32_MAX); mask_access (eClearBits, UINT32_MAX);
// Join all of our threads // Join all of our threads
err = ::pthread_join (g_thread_1, &thread_result); g_thread_1.join();
err = ::pthread_join (g_thread_2, &thread_result); g_thread_2.join();
err = ::pthread_join (g_thread_3, &thread_result); g_thread_3.join();
return 0; return 0;
} }

lldb/trunk/test/python_api/signals/main.cpp

//===-- main.c --------------------------------------------------*- C++ -*-===// //===-- main.c --------------------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <sys/types.h> #include <sys/types.h>
#if defined(_WIN32)
#include <windows.h>
#else
#include <unistd.h> #include <unistd.h>
#include <signal.h> #include <signal.h>
#endif
// This simple program is to test the lldb Python API related to process. // This simple program is to test the lldb Python API related to process.
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
#if defined(_WIN32)
::ExitProcess(1);
#else
kill(getpid(), SIGINT); // Set break point at this line and setup signal ignores. kill(getpid(), SIGINT); // Set break point at this line and setup signal ignores.
#endif
return 0; return 0;
} }

lldb/trunk/test/python_api/watchpoint/watchlocation/Makefile

LEVEL = ../../../make LEVEL = ../../../make
LD_EXTRAS := -lpthread ENABLE_THREADS := YES
CXX_SOURCES := main.cpp CXX_SOURCES := main.cpp
include $(LEVEL)/Makefile.rules include $(LEVEL)/Makefile.rules

lldb/trunk/test/tools/lldb-gdbserver/Makefile

LEVEL = ../../make LEVEL = ../../make
CFLAGS_EXTRAS := -D__STDC_LIMIT_MACROS -D__STDC_FORMAT_MACROS -std=c++11 CFLAGS_EXTRAS := -D__STDC_LIMIT_MACROS -D__STDC_FORMAT_MACROS
LD_EXTRAS := -lpthread ENABLE_THREADS := YES
CXX_SOURCES := main.cpp CXX_SOURCES := main.cpp
MAKE_DSYM :=NO MAKE_DSYM :=NO
include $(LEVEL)/Makefile.rules include $(LEVEL)/Makefile.rules
lldb/trunk/test/functionalities/attach_resume/Makefile