This is an archive of the discontinued LLVM Phabricator instance.

Differential D74839

[lldb] Remove license headers from all test source files
ClosedPublic

Authored by teemperor on Feb 19 2020, 8:04 AM.

Details

Reviewers
• espindola
JDevlieghere
Group Reviewers
Restricted Project
Commits
rGfdea9a4ec9b0: [lldb] Remove license headers from all test source files
Summary

Around a third of our test sources have LLVM license headers. This patch removes those headers from all test
sources and also fixes any tests that depended on the length of the license header.

The reasons for this are:

  • A few tests verify line numbers and will start failing if the number of lines in the LLVM license header changes. Once I landed my patch for valid SourceLocations in debug info we will probably have even more tests that verify line numbers.
  • No other LLVM project is putting license headers in its test files to my knowledge.
  • They make the test sources much more verbose than they have to be. Several tests have longer license headers than the actual test source.

For the record, the following tests had their line numbers changed to pass with the removal of the license header:

lldb-api :: functionalities/breakpoint/breakpoint_by_line_and_column/TestBreakpointByLineAndColumn.py
lldb-shell :: Reproducer/TestGDBRemoteRepro.test
lldb-shell :: Reproducer/TestMultipleTargets.test
lldb-shell :: Reproducer/TestReuseDirectory.test
lldb-shell :: ExecControl/StopHook/stop-hook-threads.test
lldb-shell :: ExecControl/StopHook/stop-hook.test
lldb-api :: lang/objc/exceptions/TestObjCExceptions.py

Diff Detail

Event Timeline

teemperor created this revision.Feb 19 2020, 8:04 AM
Herald added a reviewer: • espindola. · View Herald TranscriptFeb 19 2020, 8:05 AM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: lldb-commits, JDevlieghere, arphaman and 2 others. · View Herald Transcript
teemperor edited the summary of this revision. (Show Details)Feb 19 2020, 8:09 AM
JDevlieghere accepted this revision.Feb 19 2020, 8:55 AM

Perfect, we already agreed upon this in the past, thanks for making things consistent!

This revision is now accepted and ready to land.Feb 19 2020, 8:55 AM
Closed by commit rGfdea9a4ec9b0: [lldb] Remove license headers from all test source files (authored by teemperor). · Explain WhyFeb 19 2020, 11:36 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
lldb/
test/
API/
android/
platform/
8 lines
api/
check_public_api_headers/
8 lines
benchmarks/
expression/
7 lines
commands/
add-dsym/
uuid/
8 lines
apropos/
with-process/
7 lines
command/
nested_alias/
7 lines
script/
8 lines
disassemble/
basic/
8 lines
expression/
ir-interpreter-phi-nodes/
8 lines
persistent_types/
8 lines
persistent_variables/
8 lines
radar_8638051/
7 lines
radar_9531204/
7 lines
radar_9673664/
7 lines
save_jit_objects/
8 lines
frame/
recognizer/
8 lines
var-scope/
8 lines
log/
basic/
8 lines
register/
register/
intel_xtended_registers/
7 lines
mpx_bound_violation/
7 lines
register_command/
7 lines
7 lines
settings/
8 lines
target/
basic/
8 lines
8 lines
7 lines
7 lines
create-deps/
8 lines
8 lines
watchpoints/
hello_watchlocation/
8 lines
hello_watchpoint/
7 lines
multi_watchpoint_slots/
7 lines
multiple_hits/
7 lines
multiple_threads/
8 lines
watchpoint_commands/
command/
7 lines
condition/
7 lines
7 lines
watchpoint_on_vectors/
7 lines
watchpoint_set_command/
8 lines
watchpoint_size/
7 lines
functionalities/
archives/
7 lines
7 lines
7 lines
asan/
7 lines
breakpoint/
breakpoint_by_line_and_column/
8 lines
8 lines
breakpoint_command/
8 lines
breakpoint_conditions/
7 lines
breakpoint_hit_count/
8 lines
breakpoint_ids/
8 lines
breakpoint_ignore_count/
7 lines
breakpoint_names/
7 lines
breakpoint_set_restart/
8 lines
comp_dir_symlink/
8 lines
consecutive_breakpoints/
8 lines
cpp/
7 lines
hardware_breakpoints/
hardware_breakpoint_on_multiple_threads/
8 lines
serialize/
7 lines
conditional_break/
7 lines
darwin_log/
basic/
8 lines
filter/
exact_match/
activity-chain/
8 lines
activity/
8 lines
category/
8 lines
message/
8 lines
subsystem/
8 lines
regex/
activity-chain/
8 lines
activity/
8 lines
category/
8 lines
message/
8 lines
subsystem/
8 lines
format/
8 lines
source/
debug/
8 lines
info/
8 lines
data-formatter/
boolreference/
8 lines
compactvectors/
8 lines
data-formatter-advanced/
8 lines
data-formatter-categories/
8 lines
data-formatter-cpp/
8 lines
data-formatter-globals/
8 lines
data-formatter-named-summaries/
8 lines
data-formatter-objc/
cmtime/
8 lines
8 lines
nsindexpath/
8 lines
nsstring/
8 lines
data-formatter-proper-plurals/
8 lines
data-formatter-ptr-to-array/
8 lines
data-formatter-script/
8 lines
data-formatter-smart-array/
8 lines
data-formatter-stl/
libcxx/
atomic/
8 lines
function/
10 lines
8 lines
initializerlist/
8 lines
data-formatter-synth/
8 lines
dump_dynamic/
8 lines
frameformat_smallstruct/
8 lines
hexcaps/
8 lines
language_category_updates/
8 lines
nsarraysynth/
8 lines
nsdictionarysynth/
8 lines
nssetsynth/
8 lines
ostypeformatting/
8 lines
parray/
8 lines
poarray/
8 lines
ptr_ref_typedef/
8 lines
pyobjsynthprovider/
8 lines
setvaluefromcstring/
7 lines
stringprinter/
8 lines
summary-string-onfail/
8 lines
synthupdate/
8 lines
typedef_array/
7 lines
user-format-vs-summary/
8 lines
var-in-aggregate-misuse/
8 lines
vector-types/
8 lines
dead-strip/
7 lines
inferior-assert/
7 lines
inferior-changed/
7 lines
7 lines
inferior-crashing/
7 lines
load_unload/
7 lines
8 lines
7 lines
8 lines
hidden/
8 lines
7 lines
load_using_paths/
hidden/
8 lines
7 lines
longjmp/
7 lines
memory/
cache/
8 lines
find/
7 lines
read/
7 lines
non-overlapping-index-variable-i/
8 lines
plugins/
command_plugin/
8 lines
postmortem/
elf-core/
gcore/
8 lines
thread_crash/
8 lines
ptr_refs/
8 lines
recursion/
8 lines
tail_call_frames/
ambiguous_tail_call_seq1/
8 lines
ambiguous_tail_call_seq2/
8 lines
disambiguate_call_site/
8 lines
disambiguate_paths_to_common_sink/
8 lines
disambiguate_tail_call_seq/
8 lines
inlining_and_tail_calls/
8 lines
sbapi_support/
8 lines
thread_step_out_message/
8 lines
thread_step_out_or_return/
8 lines
unambiguous_sequence/
8 lines
thread/
break_after_join/
8 lines
concurrent_events/
8 lines
crash_during_step/
8 lines
create_during_step/
8 lines
exit_during_break/
8 lines
exit_during_step/
8 lines
jump/
8 lines
8 lines
multi_break/
8 lines
state/
8 lines
step_out/
8 lines
thread_exit/
8 lines
tsan/
basic/
7 lines
cpp_global_location/
7 lines
global_location/
7 lines
multiple/
8 lines
thread_leak/
7 lines
thread_numbers/
7 lines
type_completion/
8 lines
type_lookup/
8 lines
unwind/
standard/
hand_written/
8 lines
8 lines
8 lines
value_md5_crash/
8 lines
issue_verification/
7 lines
lang/
c/
array_types/
7 lines
bitfields/
7 lines
enum_types/
7 lines
function_types/
8 lines
global_variables/
7 lines
8 lines
set_values/
7 lines
stepping/
8 lines
strings/
8 lines
struct_types/
8 lines
tls_globals/
8 lines
7 lines
typedef/
7 lines
cpp/
auto/
8 lines
bool/
8 lines
char1632_t/
8 lines
class-template-parameter-pack/
8 lines
class_static/
8 lines
class_types/
8 lines
const_this/
8 lines
diamond/
7 lines
dynamic-value/
7 lines
enum_types/
7 lines
extern_c/
8 lines
frame-var-anon-unions/
8 lines
function-template-parameter-pack/
8 lines
global_variables/
7 lines
lambdas/
8 lines
llvm-style/
8 lines
namespace/
8 lines
8 lines
8 lines
8 lines
8 lines
namespace_conflicts/
8 lines
namespace_definitions/
8 lines
8 lines
8 lines
8 lines
printf/
8 lines
signed_types/
7 lines
static_members/
8 lines
static_methods/
8 lines
stl/
7 lines
symbols/
8 lines
template-function/
8 lines
template/
7 lines
this/
8 lines
type_lookup/
8 lines
unicode-literals/
9 lines
unique-types/
7 lines
unsigned_types/
7 lines
wchar_t/
8 lines
objc/
bitfield_ivars/
8 lines
exceptions/
8 lines
8 lines
print-obj/
8 lines
ptr_refs/
8 lines
self/
8 lines
variadic_methods/
8 lines
linux/
builtin_trap/
8 lines
thread/
create_during_instruction_step/
8 lines
macosx/
duplicate-archive-members/
7 lines
7 lines
sub1/
7 lines
nslog/
8 lines
order/
7 lines
python_api/
class_members/
8 lines
event/
7 lines
exprpath_synthetic/
7 lines
frame/
get-variables/
7 lines
7 lines
function_symbol/
7 lines
lldbutil/
frame/
7 lines
iter/
8 lines
process/
8 lines
objc_type/
8 lines
process/
7 lines
sbdata/
7 lines
sbtype_typeclass/
7 lines
section/
7 lines
signals/
7 lines
symbol-context/
7 lines
target/
7 lines
thread/
7 lines
7 lines
type/
7 lines
value/
empty_class/
8 lines
linked_list/
7 lines
7 lines
watchpoint/
condition/
7 lines
7 lines
watchlocation/
8 lines
tools/
lldb-server/
libraries-svr4/
8 lines
8 lines
8 lines
8 lines
signal-filtering/
8 lines
Shell/
ExecControl/
StopHook/
Inputs/
2 lines
2 lines
8 lines
7 lines
Reproducer/
Inputs/
2 lines
2 lines
4 lines
8 lines
4 lines

Diff 245589

lldb/test/API/android/platform/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int main () int main ()
{ {
return 0; return 0;
} }

lldb/test/API/api/check_public_api_headers/main.cpp.template

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
%include_SB_APIs% %include_SB_APIs%
using namespace lldb; using namespace lldb;
int int
main(int argc, char const *argv[]) main(int argc, char const *argv[])
{ {
SBDebugger::Initialize(); SBDebugger::Initialize();
SBDebugger dbg = SBDebugger::Create(); SBDebugger dbg = SBDebugger::Create();
printf("Hello SBDebugger %llu\n", dbg.GetID()); // Set breakpoint here. printf("Hello SBDebugger %llu\n", dbg.GetID()); // Set breakpoint here.
SBDebugger::Terminate(); SBDebugger::Terminate();
return 0; return 0;
} }

lldb/test/API/benchmarks/expression/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
class Point { class Point {
public: public:
int x; int x;
int y; int y;
Point(int a, int b): Point(int a, int b):
x(a), x(a),
Show All 35 Lines

lldb/test/API/commands/add-dsym/uuid/main.cpp.template

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
int int
main(int argc, char const *argv[]) main(int argc, char const *argv[])
{ {
int my_int = argc + 3; int my_int = argc + 3;
printf("Hello UUID Mismatch: %d\n", my_int); // Set breakpoint here. printf("Hello UUID Mismatch: %d\n", my_int); // Set breakpoint here.
%ADD_EXTRA_CODE% %ADD_EXTRA_CODE%
return 0; return 0;
} }

lldb/test/API/commands/apropos/with-process/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
return 0; // break here return 0; // break here
} }

lldb/test/API/commands/command/nested_alias/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
void* my_ptr[] = { void* my_ptr[] = {
reinterpret_cast<void*>(0xDEADBEEF), reinterpret_cast<void*>(0xDEADBEEF),
reinterpret_cast<void*>(main), reinterpret_cast<void*>(main),
reinterpret_cast<void*>(0xFEEDBEEF), reinterpret_cast<void*>(0xFEEDBEEF),
reinterpret_cast<void*>(0xFEEDDEAD), reinterpret_cast<void*>(0xFEEDDEAD),
reinterpret_cast<void*>(0xDEADFEED) reinterpret_cast<void*>(0xDEADFEED)
}; };
return 0; // break here return 0; // break here
} }

lldb/test/API/commands/command/script/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <cstdlib> #include <cstdlib>
#include <cstring> #include <cstring>
#include <string> #include <string>
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>
int int
product (int x, int y) product (int x, int y)
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

lldb/test/API/commands/disassemble/basic/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int int
sum (int a, int b) sum (int a, int b)
{ {
int result = a + b; // Set a breakpoint here int result = a + b; // Set a breakpoint here
return result; return result;
} }
int int
Show All 11 Lines

lldb/test/API/commands/expression/ir-interpreter-phi-nodes/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int main() int main()
{ {
int i; int i;
i = 5; i = 5;
i = 2; i = 2;
i = 3; i = 3;
return 0; return 0;
} }

lldb/test/API/commands/expression/persistent_types/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
const char* foo = "Hello world"; const char* foo = "Hello world";
return 0; return 0;
} }

lldb/test/API/commands/expression/persistent_variables/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
int i = 5; int i = 5;
return 0; // Set breakpoint here return 0; // Set breakpoint here
} }

lldb/test/API/commands/expression/radar_8638051/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
// This simple program is to demonstrate the capability of the lldb command // This simple program is to demonstrate the capability of the lldb command
// "breakpoint command add" to add a set of commands to a breakpoint to be // "breakpoint command add" to add a set of commands to a breakpoint to be
// executed when the breakpoint is hit. // executed when the breakpoint is hit.
// //
// In particular, we want to break within c(), but only if the immediate caller // In particular, we want to break within c(), but only if the immediate caller
// is a(). // is a().
Show All 38 Lines

lldb/test/API/commands/expression/radar_9531204/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
// breakpoint set -n foo // breakpoint set -n foo
// //
// //
int foo (int value) int foo (int value)
{ {
printf ("I got the value: %d.\n", value); printf ("I got the value: %d.\n", value);
Show All 9 Lines

lldb/test/API/commands/expression/radar_9673664/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
printf("Hello, world.\n"); // Set breakpoint here. printf("Hello, world.\n"); // Set breakpoint here.
return 0; return 0;
} }

lldb/test/API/commands/expression/save_jit_objects/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
const char* foo = "Hello world"; // break here const char* foo = "Hello world"; // break here
return 0; return 0;
} }

lldb/test/API/commands/frame/recognizer/main.m

//===-- main.m ------------------------------------------------*- ObjC -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
void foo(int a, int b) void foo(int a, int b)
{ {
printf("%d %d\n", a, b); printf("%d %d\n", a, b);
} }
void bar(int *ptr) void bar(int *ptr)
Show All 11 Lines

lldb/test/API/commands/frame/var-scope/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int foo(int x, int y) { int foo(int x, int y) {
int z = 3 + x; int z = 3 + x;
return z + y; //% self.expect("frame variable -s", substrs=['ARG: (int) x = -3','ARG: (int) y = 0']) return z + y; //% self.expect("frame variable -s", substrs=['ARG: (int) x = -3','ARG: (int) y = 0'])
//% self.expect("frame variable -s x", substrs=['ARG: (int) x = -3']) //% self.expect("frame variable -s x", substrs=['ARG: (int) x = -3'])
//% self.expect("frame variable -s y", substrs=['ARG: (int) y = 0']) //% self.expect("frame variable -s y", substrs=['ARG: (int) y = 0'])
//% self.expect("frame variable -s z", substrs=['LOCAL: (int) z = 0']) //% self.expect("frame variable -s z", substrs=['LOCAL: (int) z = 0'])
} }
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
return foo(-3,0); //% self.expect("frame variable -s argc argv", substrs=['ARG: (int) argc =']) return foo(-3,0); //% self.expect("frame variable -s argc argv", substrs=['ARG: (int) argc ='])
} }

lldb/test/API/commands/log/basic/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <cstdlib> #include <cstdlib>
#include <string> #include <string>
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>
int int
product (int x, int y) product (int x, int y)
{ {
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

lldb/test/API/commands/register/register/intel_xtended_registers/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
////
//// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
//// See https://llvm.org/LICENSE.txt for license information.
//// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
////
////===----------------------------------------------------------------------===//
// //
#include <cpuid.h> #include <cpuid.h>
#include <cstddef> #include <cstddef>
int int
main(int argc, char const *argv[]) main(int argc, char const *argv[])
{ {
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

lldb/test/API/commands/register/register/intel_xtended_registers/mpx_bound_violation/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
////
//// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
//// See https://llvm.org/LICENSE.txt for license information.
//// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
////
////===----------------------------------------------------------------------===//
// //
#include <cstddef> #include <cstddef>
#include <sys/prctl.h> #include <sys/prctl.h>
static void violate_upper_bound(int *ptr, int size) static void violate_upper_bound(int *ptr, int size)
{ {
int i; int i;
Show All 29 Lines

lldb/test/API/commands/register/register/register_command/a.cpp

//===-- a.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
long double long double
return_long_double (long double value) return_long_double (long double value)
{ {
#if defined (__i386__) || defined (__x86_64__) #if defined (__i386__) || defined (__x86_64__)
float a=2, b=4,c=8, d=16, e=32, f=64, k=128, l=256, add=0; float a=2, b=4,c=8, d=16, e=32, f=64, k=128, l=256, add=0;
__asm__ ( __asm__ (
Show All 28 Lines

lldb/test/API/commands/register/register/register_command/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <chrono> #include <chrono>
#include <thread> #include <thread>
long double outermost_return_long_double (long double my_long_double); long double outermost_return_long_double (long double my_long_double);
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
Show All 20 Lines

lldb/test/API/commands/settings/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <cstdlib> #include <cstdlib>
#include <string> #include <string>
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>
int numberfn() int numberfn()
{ {
return 0x5a; return 0x5a;
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

lldb/test/API/commands/target/basic/a.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int main(int argc, const char* argv[]) int main(int argc, const char* argv[])
{ {
int *null_ptr = 0; int *null_ptr = 0;
printf("Hello, segfault!\n"); printf("Hello, segfault!\n");
printf("Now crash %d\n", *null_ptr); // Crash here. printf("Now crash %d\n", *null_ptr); // Crash here.
} }

lldb/test/API/commands/target/basic/b.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
return 0; // Set break point at this line. return 0; // Set break point at this line.
} }

lldb/test/API/commands/target/basic/c.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
enum days { enum days {
Monday = 10, Monday = 10,
Tuesday, Tuesday,
Wednesday, Wednesday,
Show All 13 Lines

lldb/test/API/commands/target/basic/globals.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
char my_global_char = 'X'; char my_global_char = 'X';
const char* my_global_str = "abc"; const char* my_global_str = "abc";
const char **my_global_str_ptr = &my_global_str; const char **my_global_str_ptr = &my_global_str;
static int my_static_int = 228; static int my_static_int = 228;
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
Show All 9 Lines

lldb/test/API/commands/target/create-deps/a.cpp

//===-- b.c -----------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int a_function () int a_function ()
{ {
return 500; return 500;
} }

lldb/test/API/commands/target/create-deps/main.cpp

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
extern int a_function (); extern int a_function ();
extern int b_function (); extern int b_function ();
int int
main (int argc, char const *argv[]) main (int argc, char const *argv[])
{ {
return a_function(); return a_function();
} }

lldb/test/API/commands/watchpoints/hello_watchlocation/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <chrono> #include <chrono>
#include <condition_variable> #include <condition_variable>
#include <cstdio> #include <cstdio>
#include <random> #include <random>
#include <thread> #include <thread>
std::default_random_engine g_random_engine{std::random_device{}()}; std::default_random_engine g_random_engine{std::random_device{}()};
std::uniform_int_distribution<> g_distribution{0, 3000000}; std::uniform_int_distribution<> g_distribution{0, 3000000};
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

lldb/test/API/commands/watchpoints/hello_watchpoint/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
int32_t global = 10; // Watchpoint variable declaration. int32_t global = 10; // Watchpoint variable declaration.
char gchar1 = 'a'; char gchar1 = 'a';
char gchar2 = 'b'; char gchar2 = 'b';
int main(int argc, char** argv) { int main(int argc, char** argv) {
Show All 14 Lines

lldb/test/API/commands/watchpoints/multi_watchpoint_slots/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
uint64_t pad0 = 0; uint64_t pad0 = 0;
uint8_t byteArray[4] = {0}; uint8_t byteArray[4] = {0};
uint64_t pad1 = 0; uint64_t pad1 = 0;
int main(int argc, char** argv) { int main(int argc, char** argv) {
Show All 13 Lines

lldb/test/API/commands/watchpoints/multiple_hits/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
alignas(16) uint8_t buf[32]; alignas(16) uint8_t buf[32];
// This uses inline assembly to generate an instruction that writes to a large // This uses inline assembly to generate an instruction that writes to a large
// block of memory. If it fails on your compiler/architecture, please add // block of memory. If it fails on your compiler/architecture, please add
// appropriate code to generate a large write to "buf". If you cannot write at // appropriate code to generate a large write to "buf". If you cannot write at
// least 2*sizeof(void*) bytes with a single instruction, you will have to skip // least 2*sizeof(void*) bytes with a single instruction, you will have to skip
// this test. // this test.
Show All 13 Lines

lldb/test/API/commands/watchpoints/multiple_threads/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "pseudo_barrier.h" #include "pseudo_barrier.h"
#include <cstdio> #include <cstdio>
#include <thread> #include <thread>
volatile uint32_t g_val = 0; volatile uint32_t g_val = 0;
pseudo_barrier_t g_barrier; pseudo_barrier_t g_barrier;
void thread_func() { void thread_func() {
Show All 18 Lines

lldb/test/API/commands/watchpoints/watchpoint_commands/command/main.cpp

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
int32_t global = 0; // Watchpoint variable declaration. int32_t global = 0; // Watchpoint variable declaration.
int32_t cookie = 0; int32_t cookie = 0;
static void modify(int32_t &var) { static void modify(int32_t &var) {
++var; ++var;
Show All 12 Lines

lldb/test/API/commands/watchpoints/watchpoint_commands/condition/main.cpp

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
int32_t global = 0; // Watchpoint variable declaration. int32_t global = 0; // Watchpoint variable declaration.
static void modify(int32_t &var) { static void modify(int32_t &var) {
++var; ++var;
} }
Show All 12 Lines

lldb/test/API/commands/watchpoints/watchpoint_commands/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
int32_t global = 10; // Watchpoint variable declaration. int32_t global = 10; // Watchpoint variable declaration.
int main(int argc, char** argv) { int main(int argc, char** argv) {
int local = 0; int local = 0;
printf("&global=%p\n", &global); printf("&global=%p\n", &global);
printf("about to write to 'global'...\n"); // Set break point at this line. printf("about to write to 'global'...\n"); // Set break point at this line.
// When stopped, watch 'global'. // When stopped, watch 'global'.
global = 20; global = 20;
local += argc; local += argc;
++local; // Set 2nd break point for disable_then_enable test case. ++local; // Set 2nd break point for disable_then_enable test case.
printf("local: %d\n", local); printf("local: %d\n", local);
printf("global=%d\n", global); printf("global=%d\n", global);
} }

lldb/test/API/commands/watchpoints/watchpoint_on_vectors/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
typedef signed char v4i8 __attribute__ ((vector_size(4))); typedef signed char v4i8 __attribute__ ((vector_size(4)));
v4i8 global_vector = {1, 2, 3, 4}; v4i8 global_vector = {1, 2, 3, 4};
int int
main () main ()
{ {
return 0; return 0;
} }

lldb/test/API/commands/watchpoints/watchpoint_set_command/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <chrono> #include <chrono>
#include <condition_variable> #include <condition_variable>
#include <cstdio> #include <cstdio>
#include <thread> #include <thread>
std::condition_variable g_condition_variable; std::condition_variable g_condition_variable;
std::mutex g_mutex; std::mutex g_mutex;
int g_count; int g_count;
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

lldb/test/API/commands/watchpoints/watchpoint_size/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
uint64_t pad0 = 0; uint64_t pad0 = 0;
uint8_t byteArray[8] = {0}; uint8_t byteArray[8] = {0};
uint64_t pad1 = 0; uint64_t pad1 = 0;
uint16_t wordArray[4] = {0}; uint16_t wordArray[4] = {0};
uint64_t pad2 = 0; uint64_t pad2 = 0;
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

lldb/test/API/functionalities/archives/a.c

//===-- a.c -----------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int __a_global = 1; int __a_global = 1;
int a(int arg) { int a(int arg) {
int result = arg + __a_global; int result = arg + __a_global;
return result; // Set file and line breakpoint inside a(). return result; // Set file and line breakpoint inside a().
} }
int aa(int arg1) { int aa(int arg1) {
int result1 = arg1 - __a_global; int result1 = arg1 - __a_global;
return result1; return result1;
} }

lldb/test/API/functionalities/archives/b.c

//===-- b.c -----------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
static int __b_global = 2; static int __b_global = 2;
int b(int arg) { int b(int arg) {
int result = arg + __b_global; int result = arg + __b_global;
return result; return result;
} }
int bb(int arg1) { int bb(int arg1) {
int result2 = arg1 - __b_global; int result2 = arg1 - __b_global;
return result2; return result2;
} }

lldb/test/API/functionalities/archives/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
extern int a(int); extern int a(int);
extern int b(int); extern int b(int);
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
printf ("a(1) returns %d\n", a(1)); printf ("a(1) returns %d\n", a(1));
printf ("b(2) returns %d\n", b(2)); printf ("b(2) returns %d\n", b(2));
} }

lldb/test/API/functionalities/asan/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
char *pointer; char *pointer;
char *another_pointer; char *another_pointer;
void f1() { void f1() {
pointer = malloc(10); // malloc line pointer = malloc(10); // malloc line
Show All 18 Lines

lldb/test/API/functionalities/breakpoint/breakpoint_by_line_and_column/TestBreakpointByLineAndColumn.py

Show All 14 Linesclass BreakpointByLineAndColumnTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__) mydir = TestBase.compute_mydir(__file__)
## Skip gcc version less 7.1 since it doesn't support -gcolumn-info ## Skip gcc version less 7.1 since it doesn't support -gcolumn-info
@skipIf(compiler="gcc", compiler_version=['<', '7.1']) @skipIf(compiler="gcc", compiler_version=['<', '7.1'])
def testBreakpointByLineAndColumn(self): def testBreakpointByLineAndColumn(self):
self.build() self.build()
main_c = lldb.SBFileSpec("main.c") main_c = lldb.SBFileSpec("main.c")
_, _, _, breakpoint = lldbutil.run_to_line_breakpoint(self, _, _, _, breakpoint = lldbutil.run_to_line_breakpoint(self,
main_c, 19, 50) main_c, 11, 50)
self.expect("fr v did_call", substrs='1') self.expect("fr v did_call", substrs='1')
in_then = False in_then = False
for i in range(breakpoint.GetNumLocations()): for i in range(breakpoint.GetNumLocations()):
b_loc = breakpoint.GetLocationAtIndex(i).GetAddress().GetLineEntry() b_loc = breakpoint.GetLocationAtIndex(i).GetAddress().GetLineEntry()
self.assertEqual(b_loc.GetLine(), 19) self.assertEqual(b_loc.GetLine(), 11)
in_then |= b_loc.GetColumn() == 50 in_then |= b_loc.GetColumn() == 50
self.assertTrue(in_then) self.assertTrue(in_then)
## Skip gcc version less 7.1 since it doesn't support -gcolumn-info ## Skip gcc version less 7.1 since it doesn't support -gcolumn-info
@skipIf(compiler="gcc", compiler_version=['<', '7.1']) @skipIf(compiler="gcc", compiler_version=['<', '7.1'])
def testBreakpointByLine(self): def testBreakpointByLine(self):
self.build() self.build()
main_c = lldb.SBFileSpec("main.c") main_c = lldb.SBFileSpec("main.c")
_, _, _, breakpoint = lldbutil.run_to_line_breakpoint(self, main_c, 19) _, _, _, breakpoint = lldbutil.run_to_line_breakpoint(self, main_c, 11)
self.expect("fr v did_call", substrs='0') self.expect("fr v did_call", substrs='0')
in_condition = False in_condition = False
for i in range(breakpoint.GetNumLocations()): for i in range(breakpoint.GetNumLocations()):
b_loc = breakpoint.GetLocationAtIndex(i).GetAddress().GetLineEntry() b_loc = breakpoint.GetLocationAtIndex(i).GetAddress().GetLineEntry()
self.assertEqual(b_loc.GetLine(), 19) self.assertEqual(b_loc.GetLine(), 11)
in_condition |= b_loc.GetColumn() < 30 in_condition |= b_loc.GetColumn() < 30
self.assertTrue(in_condition) self.assertTrue(in_condition)

lldb/test/API/functionalities/breakpoint/breakpoint_by_line_and_column/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int square(int x) int square(int x)
{ {
return x * x; return x * x;
} }
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
int did_call = 0; int did_call = 0;
// Line 20. v Column 50. // Line 20. v Column 50.
if(square(argc+1) != 0) { did_call = 1; return square(argc); } if(square(argc+1) != 0) { did_call = 1; return square(argc); }
// ^ // ^
return square(0); return square(0);
} }

lldb/test/API/functionalities/breakpoint/breakpoint_command/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
// Add a body to the function, so we can set more than one // Add a body to the function, so we can set more than one
// breakpoint in it. // breakpoint in it.
static volatile int var = 0; static volatile int var = 0;
var++; var++;
return 0; // Set break point at this line. return 0; // Set break point at this line.
} }

lldb/test/API/functionalities/breakpoint/breakpoint_conditions/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
// This simple program is to demonstrate the capability of the lldb command // This simple program is to demonstrate the capability of the lldb command
// "breakpoint modify -c 'val == 3' breakpt-id" to break within c(int val) only // "breakpoint modify -c 'val == 3' breakpt-id" to break within c(int val) only
// when the value of the arg is 3. // when the value of the arg is 3.
int a(int); int a(int);
int b(int); int b(int);
Show All 38 Lines

lldb/test/API/functionalities/breakpoint/breakpoint_hit_count/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int a(int val) int a(int val)
{ {
return val; // Breakpoint Location 1 return val; // Breakpoint Location 1
} }
float a(float val) float a(float val)
{ {
return val; // Breakpoint Location 2 return val; // Breakpoint Location 2
Show All 10 Lines

lldb/test/API/functionalities/breakpoint/breakpoint_ids/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <cstdlib> #include <cstdlib>
#include <string> #include <string>
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>
#define INLINE inline __attribute__((always_inline)) #define INLINE inline __attribute__((always_inline))
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

lldb/test/API/functionalities/breakpoint/breakpoint_ignore_count/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
// This simple program is to demonstrate the capability of the lldb command // This simple program is to demonstrate the capability of the lldb command
// "breakpoint modify -i <count> breakpt-id" to set the number of times a // "breakpoint modify -i <count> breakpt-id" to set the number of times a
// breakpoint is skipped before stopping. Ignore count can also be set upon // breakpoint is skipped before stopping. Ignore count can also be set upon
// breakpoint creation by 'breakpoint set ... -i <count>'. // breakpoint creation by 'breakpoint set ... -i <count>'.
int a(int); int a(int);
Show All 38 Lines

lldb/test/API/functionalities/breakpoint/breakpoint_names/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
// This simple program is to demonstrate the capability of the lldb command // This simple program is to demonstrate the capability of the lldb command
// "breakpoint modify -i <count> breakpt-id" to set the number of times a // "breakpoint modify -i <count> breakpt-id" to set the number of times a
// breakpoint is skipped before stopping. Ignore count can also be set upon // breakpoint is skipped before stopping. Ignore count can also be set upon
// breakpoint creation by 'breakpoint set ... -i <count>'. // breakpoint creation by 'breakpoint set ... -i <count>'.
int a(int); int a(int);
Show All 38 Lines

lldb/test/API/functionalities/breakpoint/breakpoint_set_restart/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <chrono> #include <chrono>
#include <stdio.h> #include <stdio.h>
#include <thread> #include <thread>
int main(int argc, char const *argv[]) int main(int argc, char const *argv[])
{ {
static bool done = false; static bool done = false;
while (!done) while (!done)
{ {
std::this_thread::sleep_for(std::chrono::milliseconds{100}); std::this_thread::sleep_for(std::chrono::milliseconds{100});
} }
printf("Set a breakpoint here.\n"); printf("Set a breakpoint here.\n");
return 0; return 0;
} }

lldb/test/API/functionalities/breakpoint/comp_dir_symlink/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
return 0; // Set break point at this line. return 0; // Set break point at this line.
} }

lldb/test/API/functionalities/breakpoint/consecutive_breakpoints/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int int
main(int argc, char const *argv[]) main(int argc, char const *argv[])
{ {
int a = 0; int a = 0;
int b = 1; int b = 1;
a = b + 1; // Set breakpoint here a = b + 1; // Set breakpoint here
b = a + 1; b = a + 1;
return 0; return 0;
} }

lldb/test/API/functionalities/breakpoint/cpp/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
namespace a { namespace a {
class c { class c {
public: public:
c(); c();
~c(); ~c();
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

lldb/test/API/functionalities/breakpoint/hardware_breakpoints/hardware_breakpoint_on_multiple_threads/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <chrono> #include <chrono>
#include <cstdio> #include <cstdio>
#include <mutex> #include <mutex>
#include <random> #include <random>
#include <thread> #include <thread>
#define NUM_OF_THREADS 4 #define NUM_OF_THREADS 4
Show All 34 Lines

lldb/test/API/functionalities/breakpoint/serialize/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
// This simple program is to demonstrate the capability of the lldb command // This simple program is to demonstrate the capability of the lldb command
// "breakpoint modify -i <count> breakpt-id" to set the number of times a // "breakpoint modify -i <count> breakpt-id" to set the number of times a
// breakpoint is skipped before stopping. Ignore count can also be set upon // breakpoint is skipped before stopping. Ignore count can also be set upon
// breakpoint creation by 'breakpoint set ... -i <count>'. // breakpoint creation by 'breakpoint set ... -i <count>'.
int a(int); int a(int);
Show All 38 Lines

lldb/test/API/functionalities/conditional_break/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
// This simple program is to demonstrate the capability of the lldb command // This simple program is to demonstrate the capability of the lldb command
// "breakpoint command add" to add a set of commands to a breakpoint to be // "breakpoint command add" to add a set of commands to a breakpoint to be
// executed when the breakpoint is hit. // executed when the breakpoint is hit.
// //
// In particular, we want to break within c(), but only if the immediate caller // In particular, we want to break within c(), but only if the immediate caller
// is a(). // is a().
Show All 38 Lines

lldb/test/API/functionalities/darwin_log/basic/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <os/log.h> #include <os/log.h>
#include <stdio.h> #include <stdio.h>
#include "../common/darwin_log_common.h" #include "../common/darwin_log_common.h"
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
os_log_t logger = os_log_create("org.llvm.lldb.test", "basic-test"); os_log_t logger = os_log_create("org.llvm.lldb.test", "basic-test");
Show All 15 Lines

lldb/test/API/functionalities/darwin_log/filter/exact_match/activity-chain/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <os/activity.h> #include <os/activity.h>
#include <os/log.h> #include <os/log.h>
#include <stdio.h> #include <stdio.h>
#include "../../../common/darwin_log_common.h" #include "../../../common/darwin_log_common.h"
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
Show All 26 Lines

lldb/test/API/functionalities/darwin_log/filter/exact_match/activity/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <os/activity.h> #include <os/activity.h>
#include <os/log.h> #include <os/log.h>
#include <stdio.h> #include <stdio.h>
#include "../../../common/darwin_log_common.h" #include "../../../common/darwin_log_common.h"
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
Show All 26 Lines

lldb/test/API/functionalities/darwin_log/filter/exact_match/category/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <os/activity.h> #include <os/activity.h>
#include <os/log.h> #include <os/log.h>
#include <stdio.h> #include <stdio.h>
#include "../../../common/darwin_log_common.h" #include "../../../common/darwin_log_common.h"
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
Show All 26 Lines

lldb/test/API/functionalities/darwin_log/filter/exact_match/message/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <os/activity.h> #include <os/activity.h>
#include <os/log.h> #include <os/log.h>
#include <stdio.h> #include <stdio.h>
#include "../../../common/darwin_log_common.h" #include "../../../common/darwin_log_common.h"
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
Show All 18 Lines

lldb/test/API/functionalities/darwin_log/filter/exact_match/subsystem/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <os/activity.h> #include <os/activity.h>
#include <os/log.h> #include <os/log.h>
#include <stdio.h> #include <stdio.h>
#include "../../../common/darwin_log_common.h" #include "../../../common/darwin_log_common.h"
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
Show All 26 Lines

lldb/test/API/functionalities/darwin_log/filter/regex/activity-chain/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <os/activity.h> #include <os/activity.h>
#include <os/log.h> #include <os/log.h>
#include <stdio.h> #include <stdio.h>
#include "../../../common/darwin_log_common.h" #include "../../../common/darwin_log_common.h"
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
Show All 26 Lines

lldb/test/API/functionalities/darwin_log/filter/regex/activity/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <os/activity.h> #include <os/activity.h>
#include <os/log.h> #include <os/log.h>
#include <stdio.h> #include <stdio.h>
#include "../../../common/darwin_log_common.h" #include "../../../common/darwin_log_common.h"
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
Show All 26 Lines

lldb/test/API/functionalities/darwin_log/filter/regex/category/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <os/activity.h> #include <os/activity.h>
#include <os/log.h> #include <os/log.h>
#include <stdio.h> #include <stdio.h>
#include "../../../common/darwin_log_common.h" #include "../../../common/darwin_log_common.h"
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
Show All 26 Lines

lldb/test/API/functionalities/darwin_log/filter/regex/message/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <os/activity.h> #include <os/activity.h>
#include <os/log.h> #include <os/log.h>
#include <stdio.h> #include <stdio.h>
#include "../../../common/darwin_log_common.h" #include "../../../common/darwin_log_common.h"
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
Show All 18 Lines

lldb/test/API/functionalities/darwin_log/filter/regex/subsystem/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <os/activity.h> #include <os/activity.h>
#include <os/log.h> #include <os/log.h>
#include <stdio.h> #include <stdio.h>
#include "../../../common/darwin_log_common.h" #include "../../../common/darwin_log_common.h"
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
Show All 26 Lines

lldb/test/API/functionalities/darwin_log/format/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <os/activity.h> #include <os/activity.h>
#include <os/log.h> #include <os/log.h>
#include <stdio.h> #include <stdio.h>
#include "../common/darwin_log_common.h" #include "../common/darwin_log_common.h"
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
Show All 24 Lines

lldb/test/API/functionalities/darwin_log/source/debug/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <os/log.h> #include <os/log.h>
#include <stdio.h> #include <stdio.h>
#include "../../common/darwin_log_common.h" #include "../../common/darwin_log_common.h"
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
os_log_t logger_sub1 = os_log_create("org.llvm.lldb.test.sub1", "cat1"); os_log_t logger_sub1 = os_log_create("org.llvm.lldb.test.sub1", "cat1");
Show All 17 Lines

lldb/test/API/functionalities/darwin_log/source/info/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <os/log.h> #include <os/log.h>
#include <stdio.h> #include <stdio.h>
#include "../../common/darwin_log_common.h" #include "../../common/darwin_log_common.h"
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
os_log_t logger_sub1 = os_log_create("org.llvm.lldb.test.sub1", "cat1"); os_log_t logger_sub1 = os_log_create("org.llvm.lldb.test.sub1", "cat1");
Show All 17 Lines

lldb/test/API/functionalities/data-formatter/boolreference/main.mm

//===-- main.m ------------------------------------------------*- ObjC -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
int main (int argc, const char * argv[]) int main (int argc, const char * argv[])
{ {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
BOOL yes = YES; BOOL yes = YES;
BOOL no = NO; BOOL no = NO;
Show All 14 Lines

lldb/test/API/functionalities/data-formatter/compactvectors/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <Accelerate/Accelerate.h> #include <Accelerate/Accelerate.h>
int main() int main()
{ {
vFloat valueFL = {1.25,0,0.25,0}; vFloat valueFL = {1.25,0,0.25,0};
vDouble valueDL = {1.25,2.25}; vDouble valueDL = {1.25,2.25};
int16_t valueI16[8] = {1,0,4,0,0,1,0,4}; int16_t valueI16[8] = {1,0,4,0,0,1,0,4};
int32_t valueI32[4] = {1,0,4,0}; int32_t valueI32[4] = {1,0,4,0};
Show All 9 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-advanced/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdint.h> #include <stdint.h>
struct i_am_cool struct i_am_cool
{ {
int integer; int integer;
float floating; float floating;
▲ Show 20 Lines • Show All 157 Lines • Show Last 20 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-categories/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdint.h> #include <stdint.h>
struct Shape struct Shape
{ {
bool dummy; bool dummy;
Shape() : dummy(true) {} Shape() : dummy(true) {}
Show All 29 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-cpp/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdint.h> #include <stdint.h>
typedef float RealNumber; // should show as char typedef float RealNumber; // should show as char
typedef RealNumber Temperature; // should show as float typedef RealNumber Temperature; // should show as float
typedef RealNumber Speed; // should show as hex typedef RealNumber Speed; // should show as hex
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-globals/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdint.h> #include <stdint.h>
struct Point { struct Point {
int x; int x;
int y; int y;
Point(int X = 3, int Y = 2) : x(X), y(Y) {} Point(int X = 3, int Y = 2) : x(X), y(Y) {}
Show All 10 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-named-summaries/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdint.h> #include <stdint.h>
struct First struct First
{ {
int x; int x;
int y; int y;
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-objc/cmtime/main.m

//===-- main.m ------------------------------------------------*- ObjC -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <CoreMedia/CoreMedia.h> #import <CoreMedia/CoreMedia.h>
int main(int argc, const char **argv) int main(int argc, const char **argv)
{ {
@autoreleasepool @autoreleasepool
{ {
CMTime t1 = CMTimeMake(1, 2); CMTime t1 = CMTimeMake(1, 2);
CMTime t2 = CMTimeMake(1, 3); CMTime t2 = CMTimeMake(1, 3);
Show All 19 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-objc/main.m

//===-- main.m ------------------------------------------------*- ObjC -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
#if defined(__APPLE__) #if defined(__APPLE__)
#if defined(__arm__) || defined(__arm64__) || defined(__aarch64__) #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
#define IOS #define IOS
#endif #endif
#endif #endif
▲ Show 20 Lines • Show All 616 Lines • Show Last 20 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-objc/nsindexpath/main.m

//===-- main.m ------------------------------------------------*- ObjC -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
int main(int argc, const char **argv) int main(int argc, const char **argv)
{ {
@autoreleasepool @autoreleasepool
{ {
const NSUInteger values[] = { 1, 2, 3, 4, 5 }; const NSUInteger values[] = { 1, 2, 3, 4, 5 };
Show All 14 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-objc/nsstring/main.m

//===-- main.m ------------------------------------------------*- ObjC -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
#if defined(__APPLE__) #if defined(__APPLE__)
#if defined(__arm__) || defined(__arm64__) || defined(__aarch64__) #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
#define IOS #define IOS
#endif #endif
#endif #endif
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-proper-plurals/main.m

//===-- main.m ------------------------------------------------*- ObjC -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
int main (int argc, const char * argv[]) int main (int argc, const char * argv[])
{ {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
NSArray* key = [NSArray arrayWithObjects:@"foo",nil]; NSArray* key = [NSArray arrayWithObjects:@"foo",nil];
NSArray* value = [NSArray arrayWithObjects:@"key",nil]; NSArray* value = [NSArray arrayWithObjects:@"key",nil];
Show All 14 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-ptr-to-array/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
bool bar(int const *foo) { bool bar(int const *foo) {
return foo != 0; // Set break point at this line. return foo != 0; // Set break point at this line.
} }
int main() { int main() {
int foo[] = {1,2,3}; int foo[] = {1,2,3};
return bar(foo); return bar(foo);
} }

lldb/test/API/functionalities/data-formatter/data-formatter-script/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdint.h> #include <stdint.h>
struct i_am_cool struct i_am_cool
{ {
int integer; int integer;
float floating; float floating;
Show All 36 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-smart-array/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>
struct SomeData struct SomeData
{ {
int x; int x;
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/atomic/main.cpp

//===-- main.cpp --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <atomic> #include <atomic>
// Define a Parent and Child struct that can point to each other. // Define a Parent and Child struct that can point to each other.
class Parent; class Parent;
struct Child { struct Child {
// This should point to the parent which in turn owns this // This should point to the parent which in turn owns this
// child instance. This cycle should not cause LLDB to infinite loop // child instance. This cycle should not cause LLDB to infinite loop
// during printing. // during printing.
Show All 25 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/function/TestLibCxxFunction.py

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines def test(self):
self.runCmd("run", RUN_SUCCEEDED) self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint. # The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', substrs=['stopped',
'stop reason = breakpoint']) 'stop reason = breakpoint'])
self.run_frame_var_check_cache_use("foo2_f", "Lambda in File main.cpp at Line 30") self.run_frame_var_check_cache_use("foo2_f", "Lambda in File main.cpp at Line 22")
lldbutil.continue_to_breakpoint(self.process(), bkpt) lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.run_frame_var_check_cache_use("add_num2_f", "Lambda in File main.cpp at Line 21") self.run_frame_var_check_cache_use("add_num2_f", "Lambda in File main.cpp at Line 13")
lldbutil.continue_to_breakpoint(self.process(), bkpt) lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.run_frame_var_check_cache_use("f2", "Lambda in File main.cpp at Line 43") self.run_frame_var_check_cache_use("f2", "Lambda in File main.cpp at Line 35")
self.run_frame_var_check_cache_use("f3", "Lambda in File main.cpp at Line 47", True) self.run_frame_var_check_cache_use("f3", "Lambda in File main.cpp at Line 39", True)
# TODO reenable this case when std::function formatter supports # TODO reenable this case when std::function formatter supports
# general callable object case. # general callable object case.
#self.run_frame_var_check_cache_use("f4", "Function in File main.cpp at Line 16") #self.run_frame_var_check_cache_use("f4", "Function in File main.cpp at Line 8")
# These cases won't hit the cache at all but also don't require # These cases won't hit the cache at all but also don't require
# an expensive lookup. # an expensive lookup.
self.expect("frame variable f1", self.expect("frame variable f1",
substrs=['f1 = Function = foo(int, int)']) substrs=['f1 = Function = foo(int, int)'])
self.expect("frame variable f5", self.expect("frame variable f5",
substrs=['f5 = Function = Bar::add_num(int) const']) substrs=['f5 = Function = Bar::add_num(int) const'])

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/function/main.cpp

//===-- main.cpp --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <functional> #include <functional>
int foo(int x, int y) { int foo(int x, int y) {
return x + y - 1; return x + y - 1;
} }
struct Bar { struct Bar {
int operator()() { int operator()() {
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/initializerlist/main.cpp

//===-- main.cpp --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <string> #include <string>
#include <vector> #include <vector>
#include <initializer_list> #include <initializer_list>
int main () int main ()
{ {
std::initializer_list<int> ili{1,2,3,4,5}; std::initializer_list<int> ili{1,2,3,4,5};
std::initializer_list<std::string> ils{"1","2","3","4","surprise it is a long string!! yay!!"}; std::initializer_list<std::string> ils{"1","2","3","4","surprise it is a long string!! yay!!"};
return 0; // Set break point at this line. return 0; // Set break point at this line.
} }

lldb/test/API/functionalities/data-formatter/data-formatter-synth/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdint.h> #include <stdint.h>
struct BagOfInts struct BagOfInts
{ {
int x; int x;
int y; int y;
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

lldb/test/API/functionalities/data-formatter/dump_dynamic/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
class Base { class Base {
public: public:
Base () = default; Base () = default;
virtual int func() { return 1; } virtual int func() { return 1; }
virtual ~Base() = default; virtual ~Base() = default;
}; };
class Derived : public Base { class Derived : public Base {
Show All 18 Lines

lldb/test/API/functionalities/data-formatter/frameformat_smallstruct/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
struct Pair { struct Pair {
int x; int x;
int y; int y;
Pair(int _x, int _y) : x(_x), y(_y) {} Pair(int _x, int _y) : x(_x), y(_y) {}
}; };
int addPair(Pair p) int addPair(Pair p)
{ {
return p.x + p.y; // Set break point at this line. return p.x + p.y; // Set break point at this line.
} }
int main() { int main() {
Pair p1(3,-3); Pair p1(3,-3);
return addPair(p1); return addPair(p1);
} }

lldb/test/API/functionalities/data-formatter/hexcaps/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
struct foo struct foo
{ {
int first; int first;
int second; int second;
}; };
Show All 11 Lines

lldb/test/API/functionalities/data-formatter/language_category_updates/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
struct S { struct S {
int x; int x;
int y; int y;
S() : x(123), y(456) {} S() : x(123), y(456) {}
}; };
int main() { int main() {
S object; S object;
return 0; // break here return 0; // break here
} }

lldb/test/API/functionalities/data-formatter/nsarraysynth/main.m

//===-- main.m ------------------------------------------------*- ObjC -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
int main (int argc, const char * argv[]) int main (int argc, const char * argv[])
{ {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
Show All 18 Lines

lldb/test/API/functionalities/data-formatter/nsdictionarysynth/main.m

//===-- main.m ------------------------------------------------*- ObjC -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
int main (int argc, const char * argv[]) int main (int argc, const char * argv[])
{ {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
Show All 13 Lines

lldb/test/API/functionalities/data-formatter/nssetsynth/main.m

//===-- main.m ------------------------------------------------*- ObjC -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
int main (int argc, const char * argv[]) int main (int argc, const char * argv[])
{ {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
NSSet* set = [NSSet setWithArray:@[@1,@"hello",@2,@"world"]]; NSSet* set = [NSSet setWithArray:@[@1,@"hello",@2,@"world"]];
Show All 17 Lines

lldb/test/API/functionalities/data-formatter/ostypeformatting/main.mm

//===-- main.m ------------------------------------------------*- ObjC -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
int main (int argc, const char * argv[]) int main (int argc, const char * argv[])
{ {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
OSType a = 'test'; OSType a = 'test';
OSType b = 'best'; OSType b = 'best';
[pool drain];// Set break point at this line. [pool drain];// Set break point at this line.
return 0; return 0;
} }

lldb/test/API/functionalities/data-formatter/parray/main.cpp

//===-- main.cpp -------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <functional> #include <functional>
#include <stdlib.h> #include <stdlib.h>
template<typename ElemType> template<typename ElemType>
ElemType* alloc(size_t count, std::function<ElemType(size_t)> get) ElemType* alloc(size_t count, std::function<ElemType(size_t)> get)
{ {
ElemType *elems = new ElemType[count]; ElemType *elems = new ElemType[count];
for(size_t i = 0; i < count; i++) for(size_t i = 0; i < count; i++)
Show All 12 Lines

lldb/test/API/functionalities/data-formatter/poarray/main.mm

//===-- main.cpp -------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
struct ThreeObjects struct ThreeObjects
{ {
id one; id one;
id two; id two;
id three; id three;
}; };
Show All 13 Lines

lldb/test/API/functionalities/data-formatter/ptr_ref_typedef/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
typedef int Foo; typedef int Foo;
int main() { int main() {
int lval = 1; int lval = 1;
Foo* x = &lval; Foo* x = &lval;
Foo& y = lval; Foo& y = lval;
Foo&& z = 1; Foo&& z = 1;
return 0; // Set breakpoint here return 0; // Set breakpoint here
} }

lldb/test/API/functionalities/data-formatter/pyobjsynthprovider/main.cpp

//===-- main.cpp -------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
struct Foo struct Foo
{ {
double x; double x;
int y; int y;
Foo() : x(3.1415), y(1234) {} Foo() : x(3.1415), y(1234) {}
}; };
int main() { int main() {
Foo f; Foo f;
return 0; // break here return 0; // break here
} }

lldb/test/API/functionalities/data-formatter/setvaluefromcstring/main.m

//===-- main.m ---------------------------------------------------*- ObjC -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
int main() { int main() {
NSDictionary* dic = @{@1 : @2}; NSDictionary* dic = @{@1 : @2};
NSLog(@"hello world"); //% dic = self.frame().FindVariable("dic") NSLog(@"hello world"); //% dic = self.frame().FindVariable("dic")
//% dic.SetPreferSyntheticValue(True) //% dic.SetPreferSyntheticValue(True)
//% dic.SetPreferDynamicValue(lldb.eDynamicCanRunTarget) //% dic.SetPreferDynamicValue(lldb.eDynamicCanRunTarget)
//% dic.SetValueFromCString("12") //% dic.SetValueFromCString("12")
return 0; //% dic = self.frame().FindVariable("dic") return 0; //% dic = self.frame().FindVariable("dic")
//% self.assertTrue(dic.GetValueAsUnsigned() == 0xC, "failed to read what I wrote") //% self.assertTrue(dic.GetValueAsUnsigned() == 0xC, "failed to read what I wrote")
} }

lldb/test/API/functionalities/data-formatter/stringprinter/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <string> #include <string>
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
std::string stdstring("Hello\t\tWorld\nI am here\t\tto say hello\n"); //%self.addTearDownHook(lambda x: x.runCmd("setting set escape-non-printables true")) std::string stdstring("Hello\t\tWorld\nI am here\t\tto say hello\n"); //%self.addTearDownHook(lambda x: x.runCmd("setting set escape-non-printables true"))
const char* constcharstar = stdstring.c_str(); const char* constcharstar = stdstring.c_str();
std::string longstring( std::string longstring(
"I am a very long string; in fact I am longer than any reasonable length that a string should be; quite long indeed; oh my, so many words; so many letters; this is kind of like writing a poem; except in real life all that is happening" "I am a very long string; in fact I am longer than any reasonable length that a string should be; quite long indeed; oh my, so many words; so many letters; this is kind of like writing a poem; except in real life all that is happening"
Show All 23 Lines

lldb/test/API/functionalities/data-formatter/summary-string-onfail/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
struct contained struct contained
{ {
int first; int first;
int second; int second;
}; };
Show All 13 Lines

lldb/test/API/functionalities/data-formatter/synthupdate/main.m

//===-- main.m ------------------------------------------------*- ObjC -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
int main (int argc, const char * argv[]) int main (int argc, const char * argv[])
{ {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
NSArray* foo = [NSArray arrayWithObjects:@1,@2,@3,@4,@5, nil]; NSArray* foo = [NSArray arrayWithObjects:@1,@2,@3,@4,@5, nil];
NSDictionary *bar = @{@1 : @"one",@2 : @"two", @3 : @"three", @4 : @"four", @5 : @"five", @6 : @"six", @7 : @"seven"}; NSDictionary *bar = @{@1 : @"one",@2 : @"two", @3 : @"three", @4 : @"four", @5 : @"five", @6 : @"six", @7 : @"seven"};
id x = foo; id x = foo;
x = bar; // Set break point at this line. x = bar; // Set break point at this line.
[pool drain]; [pool drain];
return 0; return 0;
} }

lldb/test/API/functionalities/data-formatter/typedef_array/main.cpp

//===-- main.cpp --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
typedef int Foo; typedef int Foo;
int main() { int main() {
// CHECK: (Foo [3]) array = { // CHECK: (Foo [3]) array = {
// CHECK-NEXT: (Foo) [0] = 1 // CHECK-NEXT: (Foo) [0] = 1
// CHECK-NEXT: (Foo) [1] = 2 // CHECK-NEXT: (Foo) [1] = 2
// CHECK-NEXT: (Foo) [2] = 3 // CHECK-NEXT: (Foo) [2] = 3
// CHECK-NEXT: } // CHECK-NEXT: }
Foo array[3] = {1,2,3}; Foo array[3] = {1,2,3};
return 0; //% self.filecheck("frame variable array --show-types --", 'main.cpp') return 0; //% self.filecheck("frame variable array --show-types --", 'main.cpp')
} }

lldb/test/API/functionalities/data-formatter/user-format-vs-summary/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
struct Pair { struct Pair {
int x; int x;
int y; int y;
Pair(int _x, int _y) : x(_x), y(_y) {} Pair(int _x, int _y) : x(_x), y(_y) {}
}; };
int main() { int main() {
Pair p1(3,-3); Pair p1(3,-3);
return p1.x + p1.y; // Set break point at this line. return p1.x + p1.y; // Set break point at this line.
} }

lldb/test/API/functionalities/data-formatter/var-in-aggregate-misuse/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
struct Summarize struct Summarize
{ {
int first; int first;
int second; int second;
}; };
typedef struct Summarize summarize_t; typedef struct Summarize summarize_t;
Show All 24 Lines

lldb/test/API/functionalities/data-formatter/vector-types/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
typedef float float4 __attribute__((ext_vector_type(4))); typedef float float4 __attribute__((ext_vector_type(4)));
typedef unsigned char vec __attribute__((ext_vector_type(16))); typedef unsigned char vec __attribute__((ext_vector_type(16)));
int main() { int main() {
float4 f4 = {1.25, 1.25, 2.50, 2.50}; float4 f4 = {1.25, 1.25, 2.50, 2.50};
vec v = (vec)f4; vec v = (vec)f4;
return 0; // break here return 0; // break here
} }

lldb/test/API/functionalities/dead-strip/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
int f1 (char *s); int f1 (char *s);
int f2 (char *s); int f2 (char *s);
int f3 (char *s); int f3 (char *s);
Show All 37 Lines

lldb/test/API/functionalities/inferior-assert/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <assert.h> #include <assert.h>
const char *hello_world = "Hello, assertion!"; const char *hello_world = "Hello, assertion!";
int main(int argc, const char* argv[]) int main(int argc, const char* argv[])
{ {
int *null_ptr = 0; int *null_ptr = 0;
printf("%s\n", hello_world); printf("%s\n", hello_world);
assert(null_ptr); // Assert here. assert(null_ptr); // Assert here.
} }

lldb/test/API/functionalities/inferior-changed/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
int main(int argc, const char* argv[]) int main(int argc, const char* argv[])
{ {
int *null_ptr = 0; int *null_ptr = 0;
printf("Hello, segfault!\n"); printf("Hello, segfault!\n");
printf("Now crash %d\n", *null_ptr); // Crash here. printf("Now crash %d\n", *null_ptr); // Crash here.
} }

lldb/test/API/functionalities/inferior-changed/main2.c

//===-- main2.c -------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int main(int argc, const char* argv[]) int main(int argc, const char* argv[])
{ {
int *int_ptr = (int *)malloc(sizeof(int)); int *int_ptr = (int *)malloc(sizeof(int));
*int_ptr = 7; *int_ptr = 7;
printf("Hello, world!\n"); printf("Hello, world!\n");
printf("Now not crash %d\n", *int_ptr); // Not crash here. printf("Now not crash %d\n", *int_ptr); // Not crash here.
} }

lldb/test/API/functionalities/inferior-crashing/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
const char *hello_world = "Hello, segfault!"; const char *hello_world = "Hello, segfault!";
int main(int argc, const char* argv[]) int main(int argc, const char* argv[])
{ {
int *null_ptr = 0; int *null_ptr = 0;
printf("%s\n", hello_world); printf("%s\n", hello_world);
printf("Now crash %d\n", *null_ptr); // Crash here. printf("Now crash %d\n", *null_ptr); // Crash here.
} }

lldb/test/API/functionalities/load_unload/a.cpp

//===-- a.c -----------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
extern int b_function (); extern int b_function ();
int a_init() int a_init()
{ {
return 234; return 234;
} }
int a_global = a_init(); int a_global = a_init();
extern "C" int extern "C" int
a_function () a_function ()
{ {
return b_function (); return b_function ();
} }

lldb/test/API/functionalities/load_unload/b.cpp

//===-- b.c -----------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int b_init() int b_init()
{ {
return 345; return 345;
} }
int b_global = b_init(); int b_global = b_init();
int int
b_function () b_function ()
{ {
return 500; return 500;
} }

lldb/test/API/functionalities/load_unload/c.cpp

//===-- c.c -----------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
extern "C" int extern "C" int
c_function () c_function ()
{ {
return 600; return 600;
} }

lldb/test/API/functionalities/load_unload/d.cpp

//===-- c.c -----------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int d_init() int d_init()
{ {
return 123; return 123;
} }
int d_global = d_init(); int d_global = d_init();
int int
d_function () d_function ()
{ // Find this line number within d_dunction(). { // Find this line number within d_dunction().
return 700; return 700;
} }

lldb/test/API/functionalities/load_unload/hidden/d.cpp

//===-- c.c -----------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int d_init() int d_init()
{ {
return 456; return 456;
} }
int d_global = d_init(); int d_global = d_init();
int int
d_function () d_function ()
{ // Find this line number within d_dunction(). { // Find this line number within d_dunction().
return 12345; return 12345;
} }

lldb/test/API/functionalities/load_unload/main.cpp

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <dlfcn.h> #include <dlfcn.h>
#include <limits.h> #include <limits.h>
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
#include <libgen.h> #include <libgen.h>
#include <stdlib.h> #include <stdlib.h>
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

lldb/test/API/functionalities/load_using_paths/hidden/d.cpp

//===-- c.c -----------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int d_init() int d_init()
{ {
return 456; return 456;
} }
int d_global = d_init(); int d_global = d_init();
int int
d_function () d_function ()
{ // Find this line number within d_dunction(). { // Find this line number within d_dunction().
return 12345; return 12345;
} }

lldb/test/API/functionalities/load_using_paths/main.cpp

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
int int
main (int argc, char const *argv[]) main (int argc, char const *argv[])
{ {
printf("Break here to do the load using paths."); printf("Break here to do the load using paths.");
return 0; return 0;
} }

lldb/test/API/functionalities/longjmp/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <setjmp.h> #include <setjmp.h>
#include <stdio.h> #include <stdio.h>
#include <time.h> #include <time.h>
jmp_buf j; jmp_buf j;
void do_jump(void) void do_jump(void)
{ {
Show All 15 Lines

lldb/test/API/functionalities/memory/cache/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int main () int main ()
{ {
int my_ints[] = {0x42}; int my_ints[] = {0x42};
return 0; // Set break point at this line. return 0; // Set break point at this line.
} }

lldb/test/API/functionalities/memory/find/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
const char* stringdata = "hello world; I like to write text in const char pointers"; const char* stringdata = "hello world; I like to write text in const char pointers";
uint8_t bytedata[] = {0xAA,0xBB,0xCC,0xDD,0xEE,0xFF,0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99}; uint8_t bytedata[] = {0xAA,0xBB,0xCC,0xDD,0xEE,0xFF,0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99};
return 0; // break here return 0; // break here
} }

lldb/test/API/functionalities/memory/read/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
char my_string[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 0}; char my_string[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 0};
double my_double = 1234.5678; double my_double = 1234.5678;
int my_ints[] = {2,4,6,8,10,12,14,16,18,20,22}; int my_ints[] = {2,4,6,8,10,12,14,16,18,20,22};
uint64_t my_uint64s[] = {0, 1, 2, 3, 4, 5, 6, 7}; uint64_t my_uint64s[] = {0, 1, 2, 3, 4, 5, 6, 7};
printf("my_string=%s\n", my_string); // Set break point at this line. printf("my_string=%s\n", my_string); // Set break point at this line.
printf("my_double=%g\n", my_double); printf("my_double=%g\n", my_double);
return 0; return 0;
} }

lldb/test/API/functionalities/non-overlapping-index-variable-i/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
class Point { class Point {
public: public:
int x; int x;
int y; int y;
Point(int a, int b): Point(int a, int b):
x(a), x(a),
y(b) y(b)
{} {}
Show All 29 Lines

lldb/test/API/functionalities/plugins/command_plugin/plugin.cpp.template

//===-- plugin.cpp -------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
/* /*
An example plugin for LLDB that provides a new foo command with a child subcommand An example plugin for LLDB that provides a new foo command with a child subcommand
Compile this into a dylib foo.dylib and load by placing in appropriate locations on disk or Compile this into a dylib foo.dylib and load by placing in appropriate locations on disk or
by typing plugin load foo.dylib at the LLDB command line by typing plugin load foo.dylib at the LLDB command line
*/ */
%include_SB_APIs% %include_SB_APIs%
Show All 37 Lines

lldb/test/API/functionalities/postmortem/elf-core/gcore/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// This test verifies the correct handling of child thread exits. // This test verifies the correct handling of child thread exits.
#include "pseudo_barrier.h" #include "pseudo_barrier.h"
#include <thread> #include <thread>
#include <csignal> #include <csignal>
pseudo_barrier_t g_barrier1; pseudo_barrier_t g_barrier1;
pseudo_barrier_t g_barrier2; pseudo_barrier_t g_barrier2;
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

lldb/test/API/functionalities/postmortem/elf-core/thread_crash/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// This test verifies the correct handling of child thread exits. // This test verifies the correct handling of child thread exits.
#include "pseudo_barrier.h" #include "pseudo_barrier.h"
#include <thread> #include <thread>
#include <csignal> #include <csignal>
pseudo_barrier_t g_barrier1; pseudo_barrier_t g_barrier1;
pseudo_barrier_t g_barrier2; pseudo_barrier_t g_barrier2;
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

lldb/test/API/functionalities/ptr_refs/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
struct referent { struct referent {
const char *p; const char *p;
}; };
Show All 10 Lines

lldb/test/API/functionalities/recursion/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdint.h> #include <stdint.h>
struct node; struct node;
struct node { struct node {
int value; int value;
node* next; node* next;
Show All 24 Lines

lldb/test/API/functionalities/tail_call_frames/ambiguous_tail_call_seq1/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
volatile int x; volatile int x;
void __attribute__((noinline)) sink() { void __attribute__((noinline)) sink() {
x++; //% self.filecheck("bt", "main.cpp") x++; //% self.filecheck("bt", "main.cpp")
// CHECK-NOT: func{{[23]}}_amb // CHECK-NOT: func{{[23]}}_amb
} }
void __attribute__((noinline)) func3_amb() { sink(); /* tail */ } void __attribute__((noinline)) func3_amb() { sink(); /* tail */ }
Show All 16 Lines

lldb/test/API/functionalities/tail_call_frames/ambiguous_tail_call_seq2/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
volatile int x; volatile int x;
void __attribute__((noinline)) sink() { void __attribute__((noinline)) sink() {
x++; //% self.filecheck("bt", "main.cpp") x++; //% self.filecheck("bt", "main.cpp")
// CHECK-NOT: func{{[23]}} // CHECK-NOT: func{{[23]}}
} }
void func2(); void func2();
Show All 21 Lines

lldb/test/API/functionalities/tail_call_frames/disambiguate_call_site/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
volatile int x; volatile int x;
void __attribute__((noinline)) sink() { void __attribute__((noinline)) sink() {
x++; //% self.filecheck("bt", "main.cpp", "-implicit-check-not=artificial") x++; //% self.filecheck("bt", "main.cpp", "-implicit-check-not=artificial")
// CHECK: frame #0: 0x{{[0-9a-f]+}} a.out`sink() at main.cpp:[[@LINE-1]]:4 [opt] // CHECK: frame #0: 0x{{[0-9a-f]+}} a.out`sink() at main.cpp:[[@LINE-1]]:4 [opt]
// CHECK-NEXT: func2{{.*}} [opt] [artificial] // CHECK-NEXT: func2{{.*}} [opt] [artificial]
// CHECK-NEXT: main{{.*}} [opt] // CHECK-NEXT: main{{.*}} [opt]
} }
Show All 15 Lines

lldb/test/API/functionalities/tail_call_frames/disambiguate_paths_to_common_sink/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
volatile int x; volatile int x;
void __attribute__((noinline)) sink2() { void __attribute__((noinline)) sink2() {
x++; //% self.filecheck("bt", "main.cpp", "-check-prefix=FROM-FUNC1") x++; //% self.filecheck("bt", "main.cpp", "-check-prefix=FROM-FUNC1")
// FROM-FUNC1: frame #0: 0x{{[0-9a-f]+}} a.out`sink{{.*}} at main.cpp:[[@LINE-1]]:{{.*}} [opt] // FROM-FUNC1: frame #0: 0x{{[0-9a-f]+}} a.out`sink{{.*}} at main.cpp:[[@LINE-1]]:{{.*}} [opt]
// FROM-FUNC1-NEXT: sink({{.*}} [opt] // FROM-FUNC1-NEXT: sink({{.*}} [opt]
// FROM-FUNC1-NEXT: func1{{.*}} [opt] [artificial] // FROM-FUNC1-NEXT: func1{{.*}} [opt] [artificial]
// FROM-FUNC1-NEXT: main{{.*}} [opt] // FROM-FUNC1-NEXT: main{{.*}} [opt]
Show All 21 Lines

lldb/test/API/functionalities/tail_call_frames/disambiguate_tail_call_seq/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
volatile int x; volatile int x;
void __attribute__((noinline)) sink() { void __attribute__((noinline)) sink() {
x++; //% self.filecheck("bt", "main.cpp", "-implicit-check-not=artificial") x++; //% self.filecheck("bt", "main.cpp", "-implicit-check-not=artificial")
// CHECK: frame #0: 0x{{[0-9a-f]+}} a.out`sink() at main.cpp:[[@LINE-1]]:4 [opt] // CHECK: frame #0: 0x{{[0-9a-f]+}} a.out`sink() at main.cpp:[[@LINE-1]]:4 [opt]
// CHECK-NEXT: func3{{.*}} [opt] [artificial] // CHECK-NEXT: func3{{.*}} [opt] [artificial]
// CHECK-NEXT: func1{{.*}} [opt] [artificial] // CHECK-NEXT: func1{{.*}} [opt] [artificial]
// CHECK-NEXT: main{{.*}} [opt] // CHECK-NEXT: main{{.*}} [opt]
Show All 14 Lines

lldb/test/API/functionalities/tail_call_frames/inlining_and_tail_calls/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
volatile int x; volatile int x;
void __attribute__((noinline)) tail_call_sink() { void __attribute__((noinline)) tail_call_sink() {
x++; //% self.filecheck("bt", "main.cpp", "-check-prefix=TAIL-CALL-SINK") x++; //% self.filecheck("bt", "main.cpp", "-check-prefix=TAIL-CALL-SINK")
// TAIL-CALL-SINK: frame #0: 0x{{[0-9a-f]+}} a.out`tail_call_sink() at main.cpp:[[@LINE-1]]:4 [opt] // TAIL-CALL-SINK: frame #0: 0x{{[0-9a-f]+}} a.out`tail_call_sink() at main.cpp:[[@LINE-1]]:4 [opt]
// TAIL-CALL-SINK-NEXT: func3{{.*}} [opt] [artificial] // TAIL-CALL-SINK-NEXT: func3{{.*}} [opt] [artificial]
// TAIL-CALL-SINK-NEXT: main{{.*}} [opt] // TAIL-CALL-SINK-NEXT: main{{.*}} [opt]
Show All 33 Lines

lldb/test/API/functionalities/tail_call_frames/sbapi_support/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
volatile int x; volatile int x;
void __attribute__((noinline)) sink() { void __attribute__((noinline)) sink() {
x++; /* break here */ x++; /* break here */
} }
void __attribute__((noinline)) func3() { sink(); /* tail */ } void __attribute__((noinline)) func3() { sink(); /* tail */ }
void __attribute__((disable_tail_calls, noinline)) func2() { func3(); /* regular */ } void __attribute__((disable_tail_calls, noinline)) func2() { func3(); /* regular */ }
void __attribute__((noinline)) func1() { func2(); /* tail */ } void __attribute__((noinline)) func1() { func2(); /* tail */ }
int __attribute__((disable_tail_calls)) main() { int __attribute__((disable_tail_calls)) main() {
func1(); /* regular */ func1(); /* regular */
return 0; return 0;
} }

lldb/test/API/functionalities/tail_call_frames/thread_step_out_message/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
volatile int x; volatile int x;
void __attribute__((noinline)) sink() { void __attribute__((noinline)) sink() {
x++; //% self.filecheck("finish", "main.cpp", "-implicit-check-not=artificial") x++; //% self.filecheck("finish", "main.cpp", "-implicit-check-not=artificial")
// CHECK: stop reason = step out // CHECK: stop reason = step out
// CHECK-NEXT: Stepped out past: frame #1: 0x{{[0-9a-f]+}} a.out`func3{{.*}} [opt] [artificial] // CHECK-NEXT: Stepped out past: frame #1: 0x{{[0-9a-f]+}} a.out`func3{{.*}} [opt] [artificial]
// CHECK: frame #0: 0x{{[0-9a-f]+}} a.out`func2{{.*}} [opt] // CHECK: frame #0: 0x{{[0-9a-f]+}} a.out`func2{{.*}} [opt]
} }
Show All 11 Lines

lldb/test/API/functionalities/tail_call_frames/thread_step_out_or_return/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
volatile int x; volatile int x;
void __attribute__((noinline)) sink() { void __attribute__((noinline)) sink() {
x++; // break here x++; // break here
} }
void __attribute__((noinline)) func3() { sink(); /* tail */ } void __attribute__((noinline)) func3() { sink(); /* tail */ }
void __attribute__((disable_tail_calls, noinline)) func2() { func3(); /* regular */ } void __attribute__((disable_tail_calls, noinline)) func2() { func3(); /* regular */ }
void __attribute__((noinline)) func1() { func2(); /* tail */ } void __attribute__((noinline)) func1() { func2(); /* tail */ }
int __attribute__((disable_tail_calls)) main() { int __attribute__((disable_tail_calls)) main() {
func1(); /* regular */ func1(); /* regular */
return 0; return 0;
} }

lldb/test/API/functionalities/tail_call_frames/unambiguous_sequence/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
volatile int x; volatile int x;
void __attribute__((noinline)) sink() { void __attribute__((noinline)) sink() {
x++; //% self.filecheck("bt", "main.cpp", "-implicit-check-not=artificial") x++; //% self.filecheck("bt", "main.cpp", "-implicit-check-not=artificial")
// CHECK: frame #0: 0x{{[0-9a-f]+}} a.out`sink() at main.cpp:[[@LINE-1]]:4 [opt] // CHECK: frame #0: 0x{{[0-9a-f]+}} a.out`sink() at main.cpp:[[@LINE-1]]:4 [opt]
// CHECK-NEXT: frame #1: 0x{{[0-9a-f]+}} a.out`func3{{.*}} [opt] [artificial] // CHECK-NEXT: frame #1: 0x{{[0-9a-f]+}} a.out`func3{{.*}} [opt] [artificial]
// CHECK-NEXT: frame #2: 0x{{[0-9a-f]+}} a.out`func2{{.*}} [opt] // CHECK-NEXT: frame #2: 0x{{[0-9a-f]+}} a.out`func2{{.*}} [opt]
// CHECK-NEXT: frame #3: 0x{{[0-9a-f]+}} a.out`func1{{.*}} [opt] [artificial] // CHECK-NEXT: frame #3: 0x{{[0-9a-f]+}} a.out`func1{{.*}} [opt] [artificial]
Show All 13 Lines

lldb/test/API/functionalities/thread/break_after_join/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// This test is intended to create a situation in which one thread will exit // This test is intended to create a situation in which one thread will exit
// while a breakpoint is being handled in another thread. This may not always // while a breakpoint is being handled in another thread. This may not always
// happen because it's possible that the exiting thread will exit before the // happen because it's possible that the exiting thread will exit before the
// breakpoint is hit. The test case should be flexible enough to treat that // breakpoint is hit. The test case should be flexible enough to treat that
// as success. // as success.
#include "pseudo_barrier.h" #include "pseudo_barrier.h"
#include <chrono> #include <chrono>
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

lldb/test/API/functionalities/thread/concurrent_events/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// This test is intended to create a situation in which multiple events // This test is intended to create a situation in which multiple events
// (breakpoints, watchpoints, crashes, and signal generation/delivery) happen // (breakpoints, watchpoints, crashes, and signal generation/delivery) happen
// from multiple threads. The test expects the debugger to set a breakpoint on // from multiple threads. The test expects the debugger to set a breakpoint on
// the main thread (before any worker threads are spawned) and modify variables // the main thread (before any worker threads are spawned) and modify variables
// which control the number of threads that are spawned for each action. // which control the number of threads that are spawned for each action.
#include "pseudo_barrier.h" #include "pseudo_barrier.h"
#include <vector> #include <vector>
▲ Show 20 Lines • Show All 171 Lines • Show Last 20 Lines

lldb/test/API/functionalities/thread/crash_during_step/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
void (*crash)() = nullptr; void (*crash)() = nullptr;
int main() int main()
{ {
crash(); // Set breakpoint here crash(); // Set breakpoint here
return 0; return 0;
} }

lldb/test/API/functionalities/thread/create_during_step/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// This test is intended to create a situation in which one thread will be // This test is intended to create a situation in which one thread will be
// created while the debugger is stepping in another thread. // created while the debugger is stepping in another thread.
#include "pseudo_barrier.h" #include "pseudo_barrier.h"
#include <thread> #include <thread>
#define do_nothing() #define do_nothing()
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

lldb/test/API/functionalities/thread/exit_during_break/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// This test is intended to create a situation in which one thread will exit // This test is intended to create a situation in which one thread will exit
// while a breakpoint is being handled in another thread. This may not always // while a breakpoint is being handled in another thread. This may not always
// happen because it's possible that the exiting thread will exit before the // happen because it's possible that the exiting thread will exit before the
// breakpoint is hit. The test case should be flexible enough to treat that // breakpoint is hit. The test case should be flexible enough to treat that
// as success. // as success.
#include "pseudo_barrier.h" #include "pseudo_barrier.h"
#include <chrono> #include <chrono>
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

lldb/test/API/functionalities/thread/exit_during_step/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// This test is intended to create a situation in which one thread will exit // This test is intended to create a situation in which one thread will exit
// while the debugger is stepping in another thread. // while the debugger is stepping in another thread.
#include "pseudo_barrier.h" #include "pseudo_barrier.h"
#include <thread> #include <thread>
#define do_nothing() #define do_nothing()
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

lldb/test/API/functionalities/thread/jump/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// This test verifies the correct handling of program counter jumps. // This test verifies the correct handling of program counter jumps.
int otherfn(); int otherfn();
template<typename T> template<typename T>
T min(T a, T b) T min(T a, T b)
{ {
if (a < b) if (a < b)
Show All 18 Lines

lldb/test/API/functionalities/thread/jump/other.cpp

//===-- other.cpp -----------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int otherfn() int otherfn()
{ {
return 4; // other marker return 4; // other marker
} }

lldb/test/API/functionalities/thread/multi_break/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// This test is intended to create a situation in which a breakpoint will be // This test is intended to create a situation in which a breakpoint will be
// hit in two threads at nearly the same moment. The expected result is that // hit in two threads at nearly the same moment. The expected result is that
// the breakpoint in the second thread will be hit while the breakpoint handler // the breakpoint in the second thread will be hit while the breakpoint handler
// in the first thread is trying to stop all threads. // in the first thread is trying to stop all threads.
#include "pseudo_barrier.h" #include "pseudo_barrier.h"
#include <thread> #include <thread>
Show All 32 Lines

lldb/test/API/functionalities/thread/state/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// This test is intended to verify that thread states are properly maintained // This test is intended to verify that thread states are properly maintained
// when transitional actions are performed in the debugger. Most of the logic // when transitional actions are performed in the debugger. Most of the logic
// is in the test script. This program merely provides places where the test // is in the test script. This program merely provides places where the test
// can create the intended states. // can create the intended states.
#include <chrono> #include <chrono>
#include <thread> #include <thread>
Show All 28 Lines

lldb/test/API/functionalities/thread/step_out/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// This test is intended to create a situation in which two threads are stopped // This test is intended to create a situation in which two threads are stopped
// at a breakpoint and the debugger issues a step-out command. // at a breakpoint and the debugger issues a step-out command.
#include "pseudo_barrier.h" #include "pseudo_barrier.h"
#include <thread> #include <thread>
pseudo_barrier_t g_barrier; pseudo_barrier_t g_barrier;
Show All 34 Lines

lldb/test/API/functionalities/thread/thread_exit/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// This test verifies the correct handling of child thread exits. // This test verifies the correct handling of child thread exits.
#include "pseudo_barrier.h" #include "pseudo_barrier.h"
#include <thread> #include <thread>
pseudo_barrier_t g_barrier1; pseudo_barrier_t g_barrier1;
pseudo_barrier_t g_barrier2; pseudo_barrier_t g_barrier2;
pseudo_barrier_t g_barrier3; pseudo_barrier_t g_barrier3;
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

lldb/test/API/functionalities/tsan/basic/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
char *pointer; char *pointer;
void *f1(void *p) { void *f1(void *p) {
pointer[0] = 'x'; // thread1 line pointer[0] = 'x'; // thread1 line
Show All 21 Lines

lldb/test/API/functionalities/tsan/cpp_global_location/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h> #include <unistd.h>
long my_global_variable; // global variable long my_global_variable; // global variable
void *f1(void *p) { void *f1(void *p) {
Show All 22 Lines

lldb/test/API/functionalities/tsan/global_location/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h> #include <unistd.h>
long my_global_variable; // global variable long my_global_variable; // global variable
void *f1(void *p) { void *f1(void *p) {
Show All 22 Lines

lldb/test/API/functionalities/tsan/multiple/main.m

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
#import <pthread.h> #import <pthread.h>
long my_global; long my_global;
void *Thread1(void *arg) { void *Thread1(void *arg) {
my_global = 42; my_global = 42;
return NULL; return NULL;
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

lldb/test/API/functionalities/tsan/thread_leak/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
void *f1(void *p) { void *f1(void *p) {
printf("hello\n"); printf("hello\n");
return NULL; return NULL;
} }
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
pthread_t t1; pthread_t t1;
pthread_create(&t1, NULL, f1, NULL); pthread_create(&t1, NULL, f1, NULL);
return 0; return 0;
} }

lldb/test/API/functionalities/tsan/thread_numbers/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <pthread.h> #include <pthread.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h> #include <unistd.h>
char *pointer; char *pointer;
void *nothing(void *p) { void *nothing(void *p) {
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

lldb/test/API/functionalities/type_completion/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <string.h> #include <string.h>
#include <vector> #include <vector>
#include <iostream> #include <iostream>
class CustomString class CustomString
{ {
public: public:
CustomString (const char* buffer) : CustomString (const char* buffer) :
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

lldb/test/API/functionalities/type_lookup/main.mm

//===-- main.mm -----------------------------------------------*- ObjC -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
class MyCPPClass { class MyCPPClass {
public: public:
MyCPPClass(float f) : f(f) {} MyCPPClass(float f) : f(f) {}
float setF(float f) { float setF(float f) {
float oldf = this->f; float oldf = this->f;
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

lldb/test/API/functionalities/unwind/standard/hand_written/divmod.cpp

//===-- divmod.cpp ----------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int int
main(int argc, char const *argv[]) main(int argc, char const *argv[])
{ {
signed long long a = 123456789, b = 12, c = a / b, d = a % b; signed long long a = 123456789, b = 12, c = a / b, d = a % b;
unsigned long long e = 123456789, f = 12, g = e / f, h = e % f; unsigned long long e = 123456789, f = 12, g = e / f, h = e % f;
} }

lldb/test/API/functionalities/unwind/standard/hand_written/fprintf.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <cstdio> #include <cstdio>
int int
main(int argc, char const *argv[]) main(int argc, char const *argv[])
{ {
fprintf(stderr, "%d %p %s\n", argc, argv, argv[0]); fprintf(stderr, "%d %p %s\n", argc, argv, argv[0]);
} }

lldb/test/API/functionalities/unwind/standard/hand_written/new_delete.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int int
main(int argc, char const *argv[]) main(int argc, char const *argv[])
{ {
int* p = new int; int* p = new int;
delete p; delete p;
} }

lldb/test/API/functionalities/value_md5_crash/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
class A { class A {
public: public:
virtual int foo() { return 1; } virtual int foo() { return 1; }
virtual ~A () = default; virtual ~A () = default;
A() = default; A() = default;
}; };
class B : public A { class B : public A {
Show All 12 Lines

lldb/test/API/issue_verification/inline_rerun_inferior.cpp

//===-- main.cpp --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
typedef int Foo; typedef int Foo;
int main() { int main() {
Foo array[3] = {1,2,3}; Foo array[3] = {1,2,3};
return 0; //% self.expect("frame variable array --show-types --", substrs = ['(Foo [3]) wrong_type_here = {','(Foo) [0] = 1','(Foo) [1] = 2','(Foo) [2] = 3']) return 0; //% self.expect("frame variable array --show-types --", substrs = ['(Foo [3]) wrong_type_here = {','(Foo) [0] = 1','(Foo) [1] = 2','(Foo) [2] = 3'])
} }

lldb/test/API/lang/c/array_types/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
struct point_tag { struct point_tag {
int x; int x;
int y; int y;
}; };
struct rect_tag { struct rect_tag {
Show All 35 Lines

lldb/test/API/lang/c/bitfields/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
struct Bits struct Bits
{ {
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

lldb/test/API/lang/c/enum_types/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdio.h> #include <stdio.h>
// Forward declare an enumeration (only works in C, not C++) // Forward declare an enumeration (only works in C, not C++)
typedef enum ops ops; typedef enum ops ops;
struct foo { struct foo {
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

lldb/test/API/lang/c/function_types/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int string_not_empty (const char *s) int string_not_empty (const char *s)
{ {
if (s && s[0]) if (s && s[0])
return 1; return 1;
return 0; return 0;
} }
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
int (*callback)(const char *) = string_not_empty; int (*callback)(const char *) = string_not_empty;
return callback(0); // Set break point at this line. return callback(0); // Set break point at this line.
} }

lldb/test/API/lang/c/global_variables/a.c

//===-- a.c -----------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int g_a = 123; int g_a = 123;
struct Point { struct Point {
int x; int x;
int y; int y;
}; };
struct Point g_marked_spot = { 20, 21 }; struct Point g_marked_spot = { 20, 21 };

lldb/test/API/lang/c/global_variables/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int g_common_1; // Not initialized on purpose to cause it to be undefined external in .o file int g_common_1; // Not initialized on purpose to cause it to be undefined external in .o file
int g_file_global_int = 42; int g_file_global_int = 42;
static const int g_file_static_int = 2; static const int g_file_static_int = 2;
const char *g_file_global_cstr = "g_file_global_cstr"; const char *g_file_global_cstr = "g_file_global_cstr";
static const char *g_file_static_cstr = "g_file_static_cstr"; static const char *g_file_static_cstr = "g_file_static_cstr";
int *g_ptr = &g_file_global_int; int *g_ptr = &g_file_global_int;
extern int g_a; extern int g_a;
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
g_common_1 = g_file_global_int / g_file_static_int; g_common_1 = g_file_global_int / g_file_static_int;
static const char *g_func_static_cstr = "g_func_static_cstr"; static const char *g_func_static_cstr = "g_func_static_cstr";
printf ("%s %s\n", g_file_global_cstr, g_file_static_cstr); printf ("%s %s\n", g_file_global_cstr, g_file_static_cstr);
return *g_file_global_cstr + *g_file_static_cstr + g_file_global_int + g_a + g_common_1 + *g_ptr; // Set break point at this line. //// break $source:$line; continue; var -global g_a -global g_global_int return *g_file_global_cstr + *g_file_static_cstr + g_file_global_int + g_a + g_common_1 + *g_ptr; // Set break point at this line. //// break $source:$line; continue; var -global g_a -global g_global_int
} }

lldb/test/API/lang/c/set_values/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
void set_char(void) void set_char(void)
{ {
char i = 'a'; char i = 'a';
printf("before (char) i = %c\n", i); printf("before (char) i = %c\n", i);
printf("after (char) i = %c\n", i); // Set break point #1. //// break $source:$line printf("after (char) i = %c\n", i); // Set break point #1. //// break $source:$line
} }
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

lldb/test/API/lang/c/stepping/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int a(int); int a(int);
int b(int); int b(int);
int c(int); int c(int);
const char *print_string = "aaaaaaaaaa\n"; const char *print_string = "aaaaaaaaaa\n";
int a(int val) int a(int val)
{ {
int return_value = val; // basic break at the start of b int return_value = val; // basic break at the start of b
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

lldb/test/API/lang/c/strings/main.c

//===-- main.c ----------------------------------------------------*- C -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int main() int main()
{ {
const char a[] = "abcde"; const char a[] = "abcde";
const char *z = "vwxyz"; const char *z = "vwxyz";
return *a + *z; // breakpoint 1 return *a + *z; // breakpoint 1
} }

lldb/test/API/lang/c/struct_types/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
struct things_to_sum { struct things_to_sum {
int a; int a;
int b; int b;
int c; int c;
}; };
int sum_things(struct things_to_sum tts) int sum_things(struct things_to_sum tts)
{ {
Show All 30 Lines

lldb/test/API/lang/c/tls_globals/a.c

//===-- a.c -----------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <unistd.h> #include <unistd.h>
__thread int var_shared = 33; __thread int var_shared = 33;
int int
touch_shared() touch_shared()
{ {
return var_shared; return var_shared;
} }
void shared_check() void shared_check()
{ {
var_shared *= 2; var_shared *= 2;
usleep(1); // shared thread breakpoint usleep(1); // shared thread breakpoint
} }

lldb/test/API/lang/c/tls_globals/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <pthread.h> #include <pthread.h>
#include <unistd.h> #include <unistd.h>
void shared_check(); void shared_check();
// On some OS's (darwin) you must actually access a thread local variable // On some OS's (darwin) you must actually access a thread local variable
// before you can read it // before you can read it
int int
Show All 26 Lines

lldb/test/API/lang/c/typedef/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
void test() void test()
{ {
typedef double * a; typedef double * a;
a b = 0; // Set break point 4. a b = 0; // Set break point 4.
} }
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
typedef float a; typedef float a;
Show All 30 Lines

lldb/test/API/lang/cpp/auto/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int main() int main()
{ {
long foo = 1234; long foo = 1234;
return 0; // break here return 0; // break here
} }

lldb/test/API/lang/cpp/bool/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
int main() int main()
{ {
bool my_bool = false; bool my_bool = false;
printf("%s\n", my_bool ? "true" : "false"); // breakpoint 1 printf("%s\n", my_bool ? "true" : "false"); // breakpoint 1
} }

lldb/test/API/lang/cpp/char1632_t/main.cpp

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <assert.h> #include <assert.h>
#include <string> #include <string>
#define UASZ 64 #define UASZ 64
template<class T, int N> template<class T, int N>
void copy_char_seq (T (&arr)[N], const T* src) void copy_char_seq (T (&arr)[N], const T* src)
{ {
Show All 27 Lines

lldb/test/API/lang/cpp/class-template-parameter-pack/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
template <class T, int... Args> struct C { template <class T, int... Args> struct C {
T member; T member;
bool isSixteenThirtyTwo() { return false; } bool isSixteenThirtyTwo() { return false; }
}; };
template <> struct C<int, 16> { template <> struct C<int, 16> {
int member; int member;
bool isSixteenThirtyTwo() { return false; } bool isSixteenThirtyTwo() { return false; }
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

lldb/test/API/lang/cpp/class_static/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// I made this example after noting that I was unable to display an unsized // I made this example after noting that I was unable to display an unsized
// static class array. It turns out that gcc 4.2 will emit DWARF that correctly // static class array. It turns out that gcc 4.2 will emit DWARF that correctly
// describes the PointType, but it will incorrectly emit debug info for the // describes the PointType, but it will incorrectly emit debug info for the
// "g_points" array where the following things are wrong: // "g_points" array where the following things are wrong:
// - the DW_TAG_array_type won't have a subrange info // - the DW_TAG_array_type won't have a subrange info
// - the DW_TAG_variable for "g_points" won't have a valid byte size, so even // - the DW_TAG_variable for "g_points" won't have a valid byte size, so even
// though we know the size of PointType, we can't infer the actual size // though we know the size of PointType, we can't infer the actual size
// of the array by dividing the size of the variable by the number of // of the array by dividing the size of the variable by the number of
Show All 36 Lines

lldb/test/API/lang/cpp/class_types/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
class Conversion class Conversion
{ {
public: public:
Conversion (int i) : Conversion (int i) :
m_i (i) m_i (i)
{} {}
operator bool() operator bool()
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

lldb/test/API/lang/cpp/const_this/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
class foo { class foo {
public: public:
template <class T> T func(T x) const { template <class T> T func(T x) const {
return x+2; //% self.expect("expr 2+3", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["5"]) return x+2; //% self.expect("expr 2+3", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["5"])
} }
}; };
int i; int i;
int main() { int main() {
return foo().func(i); return foo().func(i);
} }

lldb/test/API/lang/cpp/diamond/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
static int g_next_value = 12345; static int g_next_value = 12345;
class VBase class VBase
{ {
public: public:
VBase() : m_value(g_next_value++) {} VBase() : m_value(g_next_value++) {}
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

lldb/test/API/lang/cpp/dynamic-value/sbvalue-cast.cpp

//===-- sbvalue-cast.cpp ----------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifdef DO_VIRTUAL_INHERITANCE #ifdef DO_VIRTUAL_INHERITANCE
#define VIRTUAL virtual #define VIRTUAL virtual
#else #else
#define VIRTUAL #define VIRTUAL
#endif #endif
#include <stdio.h> #include <stdio.h>
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

lldb/test/API/lang/cpp/enum_types/main.cpp

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
#ifdef SIGNED_ENUM_CLASS_TYPE #ifdef SIGNED_ENUM_CLASS_TYPE
typedef SIGNED_ENUM_CLASS_TYPE enum_integer_t; typedef SIGNED_ENUM_CLASS_TYPE enum_integer_t;
Show All 33 Lines

lldb/test/API/lang/cpp/extern_c/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
extern "C" extern "C"
{ {
int foo(); int foo();
}; };
Show All 12 Lines

lldb/test/API/lang/cpp/frame-var-anon-unions/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int main() { int main() {
union { union {
int i; int i;
char c; char c;
}; };
struct { struct {
int x; int x;
char y; char y;
short z; short z;
} s{3,'B',14}; } s{3,'B',14};
i = 0xFFFFFF00; i = 0xFFFFFF00;
c = 'A'; c = 'A';
return c; // break here return c; // break here
} }

lldb/test/API/lang/cpp/function-template-parameter-pack/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
template <class T> int staticSizeof() { template <class T> int staticSizeof() {
return sizeof(T); return sizeof(T);
} }
template <class T1, class T2, class... Ts> int staticSizeof() { template <class T1, class T2, class... Ts> int staticSizeof() {
return staticSizeof<T2, Ts...>() + sizeof(T1); return staticSizeof<T2, Ts...>() + sizeof(T1);
} }
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
int sz = staticSizeof<long, int, char>(); int sz = staticSizeof<long, int, char>();
return staticSizeof<long, int, char>() != sz; //% self.expect("expression -- sz == staticSizeof<long, int, char>()", "staticSizeof<long, int, char> worked", substrs = ["true"]) return staticSizeof<long, int, char>() != sz; //% self.expect("expression -- sz == staticSizeof<long, int, char>()", "staticSizeof<long, int, char> worked", substrs = ["true"])
//% self.expect("expression -- sz == staticSizeof<long, int>() + sizeof(char)", "staticSizeof<long, int> worked", substrs = ["true"]) //% self.expect("expression -- sz == staticSizeof<long, int>() + sizeof(char)", "staticSizeof<long, int> worked", substrs = ["true"])
//% self.expect("expression -- sz == staticSizeof<long>() + sizeof(int) + sizeof(char)", "staticSizeof<long> worked", substrs = ["true"]) //% self.expect("expression -- sz == staticSizeof<long>() + sizeof(int) + sizeof(char)", "staticSizeof<long> worked", substrs = ["true"])
} }

lldb/test/API/lang/cpp/global_variables/main.cpp

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
namespace abc { namespace abc {
int g_file_global_int = 42; int g_file_global_int = 42;
} }
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
return abc::g_file_global_int; // Set break point at this line. return abc::g_file_global_int; // Set break point at this line.
} }

lldb/test/API/lang/cpp/lambdas/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
printf("Stop here\n"); //% self.runCmd("expression auto $add = [](int first, int second) { return first + second; }") printf("Stop here\n"); //% self.runCmd("expression auto $add = [](int first, int second) { return first + second; }")
//% self.expect("expression $add(2,3)", substrs = ['= 5']) //% self.expect("expression $add(2,3)", substrs = ['= 5'])
return 0; return 0;
} }

lldb/test/API/lang/cpp/llvm-style/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
namespace n { namespace n {
struct D { struct D {
int i; int i;
static int anInt() { return 2; } static int anInt() { return 2; }
int dump() { return i; } int dump() { return i; }
}; };
class C { class C {
Show All 19 Lines

lldb/test/API/lang/cpp/namespace/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <cstdarg> #include <cstdarg>
#include <cstdlib> #include <cstdlib>
#include "ns.h" #include "ns.h"
namespace { namespace {
typedef unsigned int my_uint_t; typedef unsigned int my_uint_t;
int i; // Find the line number for anonymous namespace variable i. int i; // Find the line number for anonymous namespace variable i.
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

lldb/test/API/lang/cpp/namespace/ns.h

//===-- ns.h ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <cstdio> #include <cstdio>
void test_lookup_at_global_scope(); void test_lookup_at_global_scope();
void test_lookup_at_file_scope(); void test_lookup_at_file_scope();
void test_lookup_before_using_directive(); void test_lookup_before_using_directive();
void test_lookup_after_using_directive(); void test_lookup_after_using_directive();
int func(int a); int func(int a);
namespace A { namespace A {
Show All 17 Lines

lldb/test/API/lang/cpp/namespace/ns.cpp

//===-- ns.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "ns.h" #include "ns.h"
int foo() int foo()
{ {
std::printf("global foo()\n"); std::printf("global foo()\n");
return 42; return 42;
} }
int func() int func()
Show All 15 Lines

lldb/test/API/lang/cpp/namespace/ns2.cpp

//===-- ns2.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "ns.h" #include "ns.h"
static int func() static int func()
{ {
std::printf("static m2.cpp func()\n"); std::printf("static m2.cpp func()\n");
return 2; return 2;
} }
void test_lookup_at_file_scope() void test_lookup_at_file_scope()
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

lldb/test/API/lang/cpp/namespace/ns3.cpp

//===-- ns3.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "ns.h" #include "ns.h"
extern int func(); extern int func();
// Note: the following function must be before the using. // Note: the following function must be before the using.
void test_lookup_before_using_directive() void test_lookup_before_using_directive()
{ {
// BP_before_using_directive // BP_before_using_directive
std::printf("before using directive: func() = %d\n", func()); // eval func(), exp: 1 std::printf("before using directive: func() = %d\n", func()); // eval func(), exp: 1
Show All 10 Lines

lldb/test/API/lang/cpp/namespace_conflicts/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
namespace n { namespace n {
struct D { struct D {
int i; int i;
static int anInt() { return 2; } static int anInt() { return 2; }
int dump() { return i; } int dump() { return i; }
}; };
} }
Show All 12 Lines

lldb/test/API/lang/cpp/namespace_definitions/a.cpp

//===-- a.cpp ---------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "foo.h" #include "foo.h"
class ThingInside { class ThingInside {
int a; int a;
}; };
Foo::MyClass a_class; Foo::MyClass a_class;

lldb/test/API/lang/cpp/namespace_definitions/b.cpp

//===-- b.cpp ---------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "foo.h" #include "foo.h"
Foo::MyClass b_class; Foo::MyClass b_class;

lldb/test/API/lang/cpp/namespace_definitions/foo.h

//===-- foo.h ---------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
class ThingInside; class ThingInside;
namespace Foo { namespace Foo {
class MyClass { class MyClass {
ThingInside *thing; ThingInside *thing;
public: public:
MyClass() { } MyClass() { }
}; };
} }

lldb/test/API/lang/cpp/namespace_definitions/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
int int
main (int argc, char const *argv[]) main (int argc, char const *argv[])
{ {
return 0; // Set breakpoint here return 0; // Set breakpoint here
} }

lldb/test/API/lang/cpp/printf/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
class PrintfContainer { class PrintfContainer {
public: public:
int printf() { int printf() {
return 0; return 0;
} }
}; };
int main() { int main() {
PrintfContainer().printf(); //% self.expect("expression -- printf(\"Hello\\n\")", substrs = ['6']) PrintfContainer().printf(); //% self.expect("expression -- printf(\"Hello\\n\")", substrs = ['6'])
return 0; return 0;
} }

lldb/test/API/lang/cpp/signed_types/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
char the_char = 'c'; char the_char = 'c';
short the_short = 'c'; short the_short = 'c';
wchar_t the_wchar_t = 'c'; wchar_t the_wchar_t = 'c';
int the_int = 'c'; int the_int = 'c';
Show All 17 Lines

lldb/test/API/lang/cpp/static_members/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
struct A struct A
{ {
short m_a; short m_a;
static long s_b; static long s_b;
char m_c; char m_c;
static int s_d; static int s_d;
long access() { long access() {
Show All 17 Lines

lldb/test/API/lang/cpp/static_methods/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
class A class A
{ {
public: public:
static int getStaticValue(); static int getStaticValue();
int getMemberValue(); int getMemberValue();
int a; int a;
Show All 21 Lines

lldb/test/API/lang/cpp/stl/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <cstdio> #include <cstdio>
#include <iostream> #include <iostream>
#include <string> #include <string>
#include <map> #include <map>
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
std::string hello_world ("Hello World!"); std::string hello_world ("Hello World!");
std::cout << hello_world << std::endl; std::cout << hello_world << std::endl;
Show All 14 Lines

lldb/test/API/lang/cpp/symbols/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
void *D = 0; void *D = 0;
class D { class D {
static int i; static int i;
}; };
int D::i = 3; int D::i = 3;
Show All 23 Lines

lldb/test/API/lang/cpp/template-function/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
template<typename T> template<typename T>
int foo(T t1) { int foo(T t1) {
return int(t1); return int(t1);
} }
int main() { int main() {
return foo(42); return foo(42);
} }

lldb/test/API/lang/cpp/template/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <tuple> #include <tuple>
template <int Arg> template <int Arg>
class TestObj class TestObj
{ {
public: public:
int getArg() int getArg()
{ {
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

lldb/test/API/lang/cpp/this/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
template <class T> class A template <class T> class A
{ {
public: public:
void accessMember(T a); void accessMember(T a);
T accessMemberConst() const; T accessMemberConst() const;
static int accessStaticMember(); static int accessStaticMember();
Show All 36 Lines

lldb/test/API/lang/cpp/type_lookup/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// In this test, we define struct that exist might exist at the different // In this test, we define struct that exist might exist at the different
// levels in the code and test that we can properly locate these types with // levels in the code and test that we can properly locate these types with
// a varienty of different expressions. // a varienty of different expressions.
namespace nsp_a { namespace nsp_a {
struct namespace_only { struct namespace_only {
int a; int a;
}; };
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

lldb/test/API/lang/cpp/unicode-literals/main.cpp

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
auto cs16 = u"hello world ྒྙྐ"; auto cs16 = u"hello world ྒྙྐ";
auto cs32 = U"hello world ྒྙྐ"; auto cs32 = U"hello world ྒྙྐ";
char16_t *s16 = (char16_t *)u"ﺸﺵۻ"; char16_t *s16 = (char16_t *)u"ﺸﺵۻ";
char32_t *s32 = (char32_t *)U"ЕЙРГЖО"; char32_t *s32 = (char32_t *)U"ЕЙРГЖО";
s32 = nullptr; // Set break point at this line. s32 = nullptr; // Set break point at this line.
s32 = (char32_t *)U"෴"; s32 = (char32_t *)U"෴";
s16 = (char16_t *)u"色ハ匂ヘト散リヌルヲ"; s16 = (char16_t *)u"色ハ匂ヘト散リヌルヲ";
return 0; return 0;
} }

lldb/test/API/lang/cpp/unique-types/main.cpp

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <vector> #include <vector>
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
int main (int argc, char const *argv[], char const *envp[]) int main (int argc, char const *argv[], char const *envp[])
{ {
std::vector<long> longs; std::vector<long> longs;
std::vector<short> shorts; std::vector<short> shorts;
for (int i=0; i<12; i++) for (int i=0; i<12; i++)
{ {
longs.push_back(i); longs.push_back(i);
shorts.push_back(i); shorts.push_back(i);
} }
return 0; // Set breakpoint here to verify that std::vector 'longs' and 'shorts' have unique types. return 0; // Set breakpoint here to verify that std::vector 'longs' and 'shorts' have unique types.
} }

lldb/test/API/lang/cpp/unsigned_types/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
typedef unsigned int uint32_t; typedef unsigned int uint32_t;
unsigned char the_unsigned_char = 'c'; unsigned char the_unsigned_char = 'c';
unsigned short the_unsigned_short = 'c'; unsigned short the_unsigned_short = 'c';
unsigned int the_unsigned_int = 'c'; unsigned int the_unsigned_int = 'c';
unsigned long the_unsigned_long = 'c'; unsigned long the_unsigned_long = 'c';
unsigned long long the_unsigned_long_long = 'c'; unsigned long long the_unsigned_long_long = 'c';
uint32_t the_uint32 = 'c'; uint32_t the_uint32 = 'c';
return the_unsigned_char - the_unsigned_short + // Set break point at this line. return the_unsigned_char - the_unsigned_short + // Set break point at this line.
the_unsigned_int - the_unsigned_long + the_unsigned_int - the_unsigned_long +
the_unsigned_long_long - the_uint32; the_unsigned_long_long - the_uint32;
} }

lldb/test/API/lang/cpp/wchar_t/main.cpp

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <cstring> #include <cstring>
template <typename T> template <typename T>
class Foo class Foo
{ {
public: public:
Foo () : object() {} Foo () : object() {}
Foo (T x) : object(x) {} Foo (T x) : object(x) {}
Show All 18 Lines

lldb/test/API/lang/objc/bitfield_ivars/main.m

//===-- main.m -------------------------------------------*- Objective-C-*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
@interface HasBitfield : NSObject { @interface HasBitfield : NSObject {
@public @public
unsigned field1 : 1; unsigned field1 : 1;
unsigned field2 : 1; unsigned field2 : 1;
}; };
Show All 35 Lines

lldb/test/API/lang/objc/exceptions/TestObjCExceptions.py

Show First 20 Lines • Show All 136 Lines • ▼ Show 20 Lines def test_objc_exceptions_at_abort(self):
# We should be stopped at pthread_kill because of an unhandled exception # We should be stopped at pthread_kill because of an unhandled exception
self.expect("thread list", self.expect("thread list",
substrs=['stopped', 'stop reason = signal SIGABRT']) substrs=['stopped', 'stop reason = signal SIGABRT'])
self.expect('thread exception', substrs=[ self.expect('thread exception', substrs=[
'(NSException *) exception = ', '(NSException *) exception = ',
'"SomeReason"', '"SomeReason"',
'libobjc.A.dylib`objc_exception_throw', 'libobjc.A.dylib`objc_exception_throw',
'a.out`foo', 'at main.mm:24', 'a.out`foo', 'at main.mm:16',
'a.out`rethrow', 'at main.mm:35', 'a.out`rethrow', 'at main.mm:27',
'a.out`main', 'a.out`main',
]) ])
process = self.dbg.GetSelectedTarget().process process = self.dbg.GetSelectedTarget().process
thread = process.GetSelectedThread() thread = process.GetSelectedThread()
# There is an exception being currently processed at this point # There is an exception being currently processed at this point
self.assertTrue(thread.GetCurrentException().IsValid()) self.assertTrue(thread.GetCurrentException().IsValid())
Show All 9 Lines def test_objc_exceptions_at_abort(self):
self.runCmd("run 1") self.runCmd("run 1")
# We should be stopped at pthread_kill because of an unhandled exception # We should be stopped at pthread_kill because of an unhandled exception
self.expect("thread list", self.expect("thread list",
substrs=['stopped', 'stop reason = signal SIGABRT']) substrs=['stopped', 'stop reason = signal SIGABRT'])
self.expect('thread exception', substrs=[ self.expect('thread exception', substrs=[
'(MyCustomException *) exception = ', '(MyCustomException *) exception = ',
'libobjc.A.dylib`objc_exception_throw', 'libobjc.A.dylib`objc_exception_throw',
'a.out`foo', 'at main.mm:26', 'a.out`foo', 'at main.mm:18',
'a.out`rethrow', 'at main.mm:35', 'a.out`rethrow', 'at main.mm:27',
'a.out`main', 'a.out`main',
]) ])
process = self.dbg.GetSelectedTarget().process process = self.dbg.GetSelectedTarget().process
thread = process.GetSelectedThread() thread = process.GetSelectedThread()
history_thread = thread.GetCurrentExceptionBacktrace() history_thread = thread.GetCurrentExceptionBacktrace()
self.assertGreaterEqual(history_thread.num_frames, 4) self.assertGreaterEqual(history_thread.num_frames, 4)
Show All 25 Lines

lldb/test/API/lang/objc/exceptions/main.mm

//===-- main.m ------------------------------------------------*- ObjC -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
#import <exception> #import <exception>
#import <stdexcept> #import <stdexcept>
@interface MyCustomException: NSException @interface MyCustomException: NSException
@end @end
@implementation MyCustomException @implementation MyCustomException
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

lldb/test/API/lang/objc/print-obj/blocked.m

//===-- blocked.m --------------------------------------------------*- ObjC -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// This file is for testing running "print object" in a case where another thread // This file is for testing running "print object" in a case where another thread
// blocks the print object from making progress. Set a breakpoint on the line in // blocks the print object from making progress. Set a breakpoint on the line in
// my_pthread_routine as indicated. Then switch threads to the main thread, and // my_pthread_routine as indicated. Then switch threads to the main thread, and
// do print the lock_me object. Since that will try to get the lock already gotten // do print the lock_me object. Since that will try to get the lock already gotten
// by my_pthread_routime thread, it will have to switch to running all threads, and // by my_pthread_routime thread, it will have to switch to running all threads, and
// that should then succeed. // that should then succeed.
// //
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

lldb/test/API/lang/objc/ptr_refs/main.m

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
@interface MyClass : NSObject { @interface MyClass : NSObject {
}; };
-(void)test; -(void)test;
@end @end
@implementation MyClass @implementation MyClass
Show All 22 Lines

lldb/test/API/lang/objc/self/main.m

//===-- main.m ------------------------------------------*- Objective-C -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
@interface A : NSObject @interface A : NSObject
{ {
int m_a; int m_a;
} }
-(id)init; -(id)init;
-(void)accessMember:(int)a; -(void)accessMember:(int)a;
Show All 37 Lines

lldb/test/API/lang/objc/variadic_methods/main.m

//===-- main.m -------------------------------------------*- Objective-C-*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
@interface VarClass : NSObject @interface VarClass : NSObject
- (id) lottaArgs: (id) first, ...; - (id) lottaArgs: (id) first, ...;
@end @end
@implementation VarClass @implementation VarClass
- (id) lottaArgs: (id) first, ... - (id) lottaArgs: (id) first, ...
Show All 14 Lines

lldb/test/API/linux/builtin_trap/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
void bar(int const *foo) { void bar(int const *foo) {
__builtin_trap(); // Set break point at this line. __builtin_trap(); // Set break point at this line.
} }
int main() { int main() {
int foo = 5; int foo = 5;
bar(&foo); bar(&foo);
} }

lldb/test/API/linux/thread/create_during_instruction_step/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// This file deliberately uses low level linux-specific API for thread creation because: // This file deliberately uses low level linux-specific API for thread creation because:
// - instruction-stepping over thread creation using higher-level functions was very slow // - instruction-stepping over thread creation using higher-level functions was very slow
// - it was also unreliable due to single-stepping bugs unrelated to this test // - it was also unreliable due to single-stepping bugs unrelated to this test
// - some threading libraries do not create or destroy threads when we would expect them to // - some threading libraries do not create or destroy threads when we would expect them to
#include <sched.h> #include <sched.h>
#include <atomic> #include <atomic>
Show All 38 Lines

lldb/test/API/macosx/duplicate-archive-members/a.c

//===-- a.c -----------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int __a_global = 1; int __a_global = 1;
int a(int arg) { int a(int arg) {
int result = arg + __a_global; int result = arg + __a_global;
return result; return result;
} }

lldb/test/API/macosx/duplicate-archive-members/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
extern int a(int); extern int a(int);
extern int b(int); extern int b(int);
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
printf ("a(1) returns %d\n", a(1)); printf ("a(1) returns %d\n", a(1));
printf ("b(2) returns %d\n", b(2)); printf ("b(2) returns %d\n", b(2));
} }

lldb/test/API/macosx/duplicate-archive-members/sub1/a.c

//===-- a.c -----------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
static int __b_global = 2; static int __b_global = 2;
int b(int arg) { int b(int arg) {
int result = arg + __b_global; int result = arg + __b_global;
return result; return result;
} }

lldb/test/API/macosx/nslog/main.m

//===-- main.m --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <Foundation/Foundation.h> #include <Foundation/Foundation.h>
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
printf("About to log\n"); // break here printf("About to log\n"); // break here
NSLog(@"This is a message from NSLog"); NSLog(@"This is a message from NSLog");
return 0; return 0;
} }

lldb/test/API/macosx/order/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
int f1 (char *s); int f1 (char *s);
int f2 (char *s); int f2 (char *s);
int f3 (char *s); int f3 (char *s);
Show All 38 Lines

lldb/test/API/python_api/class_members/main.mm

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
class Base { class Base {
public: public:
int foo(int x, int y) { return 1; } int foo(int x, int y) { return 1; }
char bar(int x, char y) { return 2; } char bar(int x, char y) { return 2; }
void dat() {} void dat() {}
static int sfunc(char, int, float) { return 3; } static int sfunc(char, int, float) { return 3; }
Show All 30 Lines

lldb/test/API/python_api/event/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
// This simple program is to test the lldb Python API related to events. // This simple program is to test the lldb Python API related to events.
int a(int); int a(int);
int b(int); int b(int);
int c(int); int c(int);
Show All 33 Lines

lldb/test/API/python_api/exprpath_synthetic/main.mm

//===-- main.mm --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
#include <vector> #include <vector>
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
std::vector<int> v{1,2,3,4,5}; std::vector<int> v{1,2,3,4,5};
NSArray *a = @[@"Hello",@"World",@"From Me"]; NSArray *a = @[@"Hello",@"World",@"From Me"];
return 0; //% v = self.frame().FindVariable("v"); v0 = v.GetChildAtIndex(0); s = lldb.SBStream(); v0.GetExpressionPath(s); return 0; //% v = self.frame().FindVariable("v"); v0 = v.GetChildAtIndex(0); s = lldb.SBStream(); v0.GetExpressionPath(s);
//% self.runCmd("expr %s = 12" % s.GetData()); self.assertTrue(v0.GetValueAsUnsigned() == 12, "value change via expr failed") //% self.runCmd("expr %s = 12" % s.GetData()); self.assertTrue(v0.GetValueAsUnsigned() == 12, "value change via expr failed")
//% a = self.frame().FindVariable("a"); a1 = a.GetChildAtIndex(1); s = lldb.SBStream(); a1.GetExpressionPath(s); //% a = self.frame().FindVariable("a"); a1 = a.GetChildAtIndex(1); s = lldb.SBStream(); a1.GetExpressionPath(s);
//% self.expect("po %s" % s.GetData(), substrs = ["World"]) //% self.expect("po %s" % s.GetData(), substrs = ["World"])
} }

lldb/test/API/python_api/frame/get-variables/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
int g_global_var = 123; int g_global_var = 123;
static int g_static_var = 123; static int g_static_var = 123;
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
static int static_var = 123; static int static_var = 123;
Show All 13 Lines

lldb/test/API/python_api/frame/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
// This simple program is to test the lldb Python API related to frames. // This simple program is to test the lldb Python API related to frames.
int a(int, char); int a(int, char);
int b(int, char); int b(int, char);
int c(int, char); int c(int, char);
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

lldb/test/API/python_api/function_symbol/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
// This simple program is to test the lldb Python APIs SBTarget, SBFrame, // This simple program is to test the lldb Python APIs SBTarget, SBFrame,
// SBFunction, SBSymbol, and SBAddress. // SBFunction, SBSymbol, and SBAddress.
// //
// When stopped on breakppint 1, we can get the line entry using SBFrame API // When stopped on breakppint 1, we can get the line entry using SBFrame API
// SBFrame.GetLineEntry(). We'll get the start address for the line entry // SBFrame.GetLineEntry(). We'll get the start address for the line entry
// with the SBAddress type, resolve the symbol context using the SBTarget API // with the SBAddress type, resolve the symbol context using the SBTarget API
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

lldb/test/API/python_api/lldbutil/frame/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
int a(int); int a(int);
int b(int); int b(int);
int c(int); int c(int);
int a(int val) int a(int val)
{ {
Show All 31 Lines

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

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// C includes // C includes
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
#include <stdlib.h> #include <stdlib.h>
// C++ includes // C++ includes
#include <chrono> #include <chrono>
#include <mutex> #include <mutex>
▲ Show 20 Lines • Show All 117 Lines • Show Last 20 Lines

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

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
static int foo(int x, int y) { static int foo(int x, int y) {
return x + y; // BREAK HERE return x + y; // BREAK HERE
} }
static int bar(int x) { static int bar(int x) {
return foo(x + 1, x * 2); return foo(x + 1, x * 2);
} }
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
{ {
return bar(argc + 2); return bar(argc + 2);
} }

lldb/test/API/python_api/objc_type/main.m

//===-- main.m ------------------------------------------------*- ObjC -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
@interface Foo: NSObject @interface Foo: NSObject
{} {}
- (id) init; - (id) init;
@end @end
@interface Bar: Foo @interface Bar: Foo
Show All 35 Lines

lldb/test/API/python_api/process/main.cpp

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
// 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.
char my_char = 'u'; char my_char = 'u';
char my_cstring[] = "lldb.SBProcess.ReadCStringFromMemory() works!"; char my_cstring[] = "lldb.SBProcess.ReadCStringFromMemory() works!";
char *my_char_ptr = (char *)"Does it work?"; char *my_char_ptr = (char *)"Does it work?";
Show All 15 Lines

lldb/test/API/python_api/sbdata/main.cpp

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdint.h> #include <stdint.h>
struct foo struct foo
{ {
uint32_t a; uint32_t a;
uint32_t b; uint32_t b;
float c; float c;
foo() : a(0), b(1), c(3.14) {} foo() : a(0), b(1), c(3.14) {}
Show All 27 Lines

lldb/test/API/python_api/sbtype_typeclass/main.m

//===-- main.m --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#import <Foundation/Foundation.h> #import <Foundation/Foundation.h>
@interface ThisClassTestsThings : NSObject @interface ThisClassTestsThings : NSObject
@end @end
@implementation ThisClassTestsThings @implementation ThisClassTestsThings
- (int)doSomething { - (int)doSomething {
Show All 18 Lines

lldb/test/API/python_api/section/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
// This simple program is to test the lldb Python API SBSection. It includes // This simple program is to test the lldb Python API SBSection. It includes
// somes global data, and so the build process produces a DATA section, which // somes global data, and so the build process produces a DATA section, which
// the test code can use to query for the target byte size // the test code can use to query for the target byte size
char my_global_var_of_char_type = 'X'; char my_global_var_of_char_type = 'X';
Show All 12 Lines

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

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <sys/types.h> #include <sys/types.h>
#if defined(_WIN32) #if defined(_WIN32)
#include <windows.h> #include <windows.h>
#else #else
#include <unistd.h> #include <unistd.h>
#include <signal.h> #include <signal.h>
#endif #endif
Show All 12 Lines

lldb/test/API/python_api/symbol-context/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
// This simple program is to test the lldb Python API SBSymbolContext. // This simple program is to test the lldb Python API SBSymbolContext.
// When stopped on a frame, we can get the symbol context using the SBFrame API // When stopped on a frame, we can get the symbol context using the SBFrame API
// SBFrame.GetSymbolContext(). // SBFrame.GetSymbolContext().
int a(int); int a(int);
int b(int); int b(int);
Show All 35 Lines

lldb/test/API/python_api/target/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
// This simple program is to test the lldb Python API SBTarget. // This simple program is to test the lldb Python API SBTarget.
// //
// When stopped on breakppint 1, and then 2, we can get the line entries using // When stopped on breakppint 1, and then 2, we can get the line entries using
// SBFrame API SBFrame.GetLineEntry(). We'll get the start addresses for the // SBFrame API SBFrame.GetLineEntry(). We'll get the start addresses for the
// two line entries; with the start address (of SBAddress type), we can then // two line entries; with the start address (of SBAddress type), we can then
// resolve the symbol context using the SBTarget API // resolve the symbol context using the SBTarget API
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

lldb/test/API/python_api/thread/main.cpp

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
// This simple program is to test the lldb Python API related to thread. // This simple program is to test the lldb Python API related to thread.
char my_char = 'u'; char my_char = 'u';
int my_int = 0; int my_int = 0;
int main (int argc, char const *argv[]) int main (int argc, char const *argv[])
Show All 10 Lines

lldb/test/API/python_api/thread/main2.cpp

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int a(int); int a(int);
int b(int); int b(int);
int c(int); int c(int);
int a(int val) int a(int val)
Show All 38 Lines

lldb/test/API/python_api/type/main.cpp

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
class Task { class Task {
public: public:
int id; int id;
Task *next; Task *next;
enum { enum {
TASK_TYPE_1, TASK_TYPE_1,
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

lldb/test/API/python_api/value/empty_class/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
class Empty {}; class Empty {};
int main (int argc, char const *argv[]) { int main (int argc, char const *argv[]) {
Empty e; Empty e;
Empty* ep = new Empty; Empty* ep = new Empty;
return 0; // Break at this line return 0; // Break at this line
} }

lldb/test/API/python_api/value/linked_list/main.cpp

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
class Task { class Task {
public: public:
int id; int id;
Task *next; Task *next;
Task(int i, Task *n): Task(int i, Task *n):
id(i), id(i),
Show All 40 Lines

lldb/test/API/python_api/value/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
// This simple program is to test the lldb Python API SBValue.GetChildAtIndex(). // This simple program is to test the lldb Python API SBValue.GetChildAtIndex().
int g_my_int = 100; int g_my_int = 100;
const char *days_of_week[7] = { "Sunday", const char *days_of_week[7] = { "Sunday",
Show All 40 Lines

lldb/test/API/python_api/watchpoint/condition/main.cpp

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
int32_t global = 0; // Watchpoint variable declaration. int32_t global = 0; // Watchpoint variable declaration.
static void modify(int32_t &var) { static void modify(int32_t &var) {
++var; ++var;
} }
Show All 12 Lines

lldb/test/API/python_api/watchpoint/main.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
int32_t global = 10; // Watchpoint variable declaration. int32_t global = 10; // Watchpoint variable declaration.
int main(int argc, char** argv) { int main(int argc, char** argv) {
int local = 0; int local = 0;
printf("&global=%p\n", &global); printf("&global=%p\n", &global);
printf("about to write to 'global'...\n"); // Set break point at this line. printf("about to write to 'global'...\n"); // Set break point at this line.
// When stopped, watch 'global' for read&write. // When stopped, watch 'global' for read&write.
global = 20; global = 20;
local += argc; local += argc;
++local; ++local;
printf("local: %d\n", local); printf("local: %d\n", local);
printf("global=%d\n", global); printf("global=%d\n", global);
} }

lldb/test/API/python_api/watchpoint/watchlocation/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <chrono> #include <chrono>
#include <condition_variable> #include <condition_variable>
#include <cstdio> #include <cstdio>
#include <random> #include <random>
#include <thread> #include <thread>
std::default_random_engine g_random_engine{std::random_device{}()}; std::default_random_engine g_random_engine{std::random_device{}()};
std::uniform_int_distribution<> g_distribution{0, 3000000}; std::uniform_int_distribution<> g_distribution{0, 3000000};
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

lldb/test/API/tools/lldb-server/libraries-svr4/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int main(int argc, char **argv) { int main(int argc, char **argv) {
// Perform a null pointer access. // Perform a null pointer access.
int *const null_int_ptr = nullptr; int *const null_int_ptr = nullptr;
*null_int_ptr = 0xDEAD; *null_int_ptr = 0xDEAD;
return 0; return 0;
} }

lldb/test/API/tools/lldb-server/libraries-svr4/svr4lib_a.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int svr4lib_a() { return 42; } int svr4lib_a() { return 42; }

lldb/test/API/tools/lldb-server/libraries-svr4/svr4lib_b_quote.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int svr4lib_b_quote() { return 42; } int svr4lib_b_quote() { return 42; }

lldb/test/API/tools/lldb-server/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <atomic> #include <atomic>
#include <chrono> #include <chrono>
#include <cstdlib> #include <cstdlib>
#include <cstring> #include <cstring>
#include <errno.h> #include <errno.h>
#include <inttypes.h> #include <inttypes.h>
#include <memory> #include <memory>
#include <mutex> #include <mutex>
▲ Show 20 Lines • Show All 354 Lines • Show Last 20 Lines

lldb/test/API/tools/lldb-server/signal-filtering/main.cpp

//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <signal.h> #include <signal.h>
#include <stdio.h> #include <stdio.h>
#include <vector> #include <vector>
static int signal_counter = 0; static int signal_counter = 0;
static void count_signal(int signo) { static void count_signal(int signo) {
++signal_counter; ++signal_counter;
Show All 20 Lines

lldb/test/Shell/ExecControl/StopHook/Inputs/stop-hook-2.lldbinit

target stop-hook add -f stop-hook.c -l 29 -e 34 -o "expr ptr" target stop-hook add -f stop-hook.c -l 21 -e 26 -o "expr ptr"

lldb/test/Shell/ExecControl/StopHook/Inputs/stop-hook-3.lldbinit

target stop-hook add -f stop-hook.c -l 29 -e 34 target stop-hook add -f stop-hook.c -l 21 -e26
expr ptr expr ptr
DONE DONE

lldb/test/Shell/ExecControl/StopHook/Inputs/stop-hook-threads.cpp

//===-- stop-hook-threads.cpp -----------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <chrono> #include <chrono>
#include <cstdio> #include <cstdio>
#include <mutex> #include <mutex>
#include <random> #include <random>
#include <thread> #include <thread>
std::default_random_engine g_random_engine{std::random_device{}()}; std::default_random_engine g_random_engine{std::random_device{}()};
std::uniform_int_distribution<> g_distribution{0, 3000}; std::uniform_int_distribution<> g_distribution{0, 3000};
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

lldb/test/Shell/ExecControl/StopHook/Inputs/stop-hook.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int a(int); int a(int);
int b(int); int b(int);
int c(int); int c(int);
int a(int val) int a(int val)
Show All 38 Lines

lldb/test/Shell/Reproducer/Inputs/GDBRemoteCapture.in

breakpoint set -f simple.c -l 12 breakpoint set -f simple.c -l 4
run run
bt bt
cont cont
reproducer status reproducer status
reproducer generate reproducer generate

lldb/test/Shell/Reproducer/Inputs/GDBRemoteCrashCapture.in

breakpoint set -f simple.c -l 12 breakpoint set -f simple.c -l 4
run run
bt bt
cont cont
reproducer status reproducer status
reproducer xcrash -s SIGSEGV reproducer xcrash -s SIGSEGV

lldb/test/Shell/Reproducer/Inputs/MultipleTargetsCapture.in

target select 0 target select 0
breakpoint set -f simple.c -l 12 breakpoint set -f simple.c -l 4
run run
target select 1 target select 1
breakpoint set -f simple.c -l 16 breakpoint set -f simple.c -l 8
run run
target select 0 target select 0
cont cont
target select 1 target select 1
cont cont
reproducer status reproducer status
reproducer generate reproducer generate

lldb/test/Shell/Reproducer/Inputs/simple.c

//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h> #include <stdio.h>
void foo() { void foo() {
printf("testing\n"); printf("testing\n");
} }
int main (int argc, char const *argv[]) { int main (int argc, char const *argv[]) {
foo(); foo();
return 0; return 0;
} }

lldb/test/Shell/Reproducer/TestMultipleTargets.test

# UNSUPPORTED: system-windows, system-freebsd # UNSUPPORTED: system-windows, system-freebsd
# This tests the replaying with multiple targets. # This tests the replaying with multiple targets.
# RUN: %clang_host %S/Inputs/simple.c -g -o %t.out # RUN: %clang_host %S/Inputs/simple.c -g -o %t.out
# RUN: rm -rf %t.repro # RUN: rm -rf %t.repro
# RUN: %lldb -x -b --capture --capture-path %t.repro -o 'target create %t.out' -o 'target create %t.out' -s %S/Inputs/MultipleTargetsCapture.in | FileCheck %s --check-prefix CHECK --check-prefix CAPTURE # RUN: %lldb -x -b --capture --capture-path %t.repro -o 'target create %t.out' -o 'target create %t.out' -s %S/Inputs/MultipleTargetsCapture.in | FileCheck %s --check-prefix CHECK --check-prefix CAPTURE
# RUN: env FOO=BAR %lldb --replay %t.repro | FileCheck %s --check-prefix CHECK --check-prefix REPLAY # RUN: env FOO=BAR %lldb --replay %t.repro | FileCheck %s --check-prefix CHECK --check-prefix REPLAY
# CHECK: Process [[TARGET0:[0-9]+]] stopped # CHECK: Process [[TARGET0:[0-9]+]] stopped
# CHECK: stop reason = breakpoint 1.1 # CHECK: stop reason = breakpoint 1.1
# CHECK: simple.c:12:5 # CHECK: simple.c:4:5
# CHECK: Process [[TARGET1:[0-9]+]] stopped # CHECK: Process [[TARGET1:[0-9]+]] stopped
# CHECK: stop reason = breakpoint 1.1 # CHECK: stop reason = breakpoint 1.1
# CHECK: simple.c:16:5 # CHECK: simple.c:8:5
# CHECK: Process [[TARGET0]] resuming # CHECK: Process [[TARGET0]] resuming
# CHECK: Process [[TARGET0]] exited # CHECK: Process [[TARGET0]] exited
# CHECK: Process [[TARGET1]] resuming # CHECK: Process [[TARGET1]] resuming
# CHECK: Process [[TARGET1]] exited # CHECK: Process [[TARGET1]] exited
# CAPTURE: Reproducer is in capture mode. # CAPTURE: Reproducer is in capture mode.
# CAPTURE: Reproducer written # CAPTURE: Reproducer written