mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-15 04:31:49 +08:00
42a4f53d2b
This commit applies all changes made after running the gdb/copyright.py script. Note that one file was flagged by the script, due to an invalid copyright header (gdb/unittests/basic_string_view/element_access/char/empty.cc). As the file was copied from GCC's libstdc++-v3 testsuite, this commit leaves this file untouched for the time being; a patch to fix the header was sent to gcc-patches first. gdb/ChangeLog: Update copyright year range in all GDB files.
387 lines
7.1 KiB
C++
387 lines
7.1 KiB
C++
/* This testcase is part of GDB, the GNU debugger.
|
|
|
|
Copyright 2017-2019 Free Software Foundation, Inc.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
/* Code for the all-param-prefixes test. */
|
|
|
|
void
|
|
param_prefixes_test_long (long)
|
|
{}
|
|
|
|
void
|
|
param_prefixes_test_intp_intr (int *, int&)
|
|
{}
|
|
|
|
/* Code for the overload test. */
|
|
|
|
void
|
|
overload_ambiguous_test (long)
|
|
{}
|
|
|
|
void
|
|
overload_ambiguous_test (int, int)
|
|
{}
|
|
|
|
void
|
|
overload_ambiguous_test (int, long)
|
|
{}
|
|
|
|
/* Code for the overload-2 test. */
|
|
|
|
/* Generate functions/methods all with the same name, in different
|
|
scopes, but all with different parameters. */
|
|
|
|
struct overload2_arg1 {};
|
|
struct overload2_arg2 {};
|
|
struct overload2_arg3 {};
|
|
struct overload2_arg4 {};
|
|
struct overload2_arg5 {};
|
|
struct overload2_arg6 {};
|
|
struct overload2_arg7 {};
|
|
struct overload2_arg8 {};
|
|
struct overload2_arg9 {};
|
|
struct overload2_arga {};
|
|
|
|
#define GEN_OVERLOAD2_FUNCTIONS(ARG1, ARG2) \
|
|
void \
|
|
overload2_function (ARG1) \
|
|
{} \
|
|
\
|
|
struct struct_overload2_test \
|
|
{ \
|
|
void overload2_function (ARG2); \
|
|
}; \
|
|
\
|
|
void \
|
|
struct_overload2_test::overload2_function (ARG2) \
|
|
{}
|
|
|
|
/* In the global namespace. */
|
|
GEN_OVERLOAD2_FUNCTIONS( overload2_arg1, overload2_arg2)
|
|
|
|
namespace
|
|
{
|
|
/* In an anonymous namespace. */
|
|
GEN_OVERLOAD2_FUNCTIONS (overload2_arg3, overload2_arg4)
|
|
}
|
|
|
|
namespace ns_overload2_test
|
|
{
|
|
/* In a namespace. */
|
|
GEN_OVERLOAD2_FUNCTIONS (overload2_arg5, overload2_arg6)
|
|
|
|
namespace
|
|
{
|
|
/* In a nested anonymous namespace. */
|
|
GEN_OVERLOAD2_FUNCTIONS (overload2_arg7, overload2_arg8)
|
|
|
|
namespace ns_overload2_test
|
|
{
|
|
/* In a nested namespace. */
|
|
GEN_OVERLOAD2_FUNCTIONS (overload2_arg9, overload2_arga)
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Code for the overload-3 test. */
|
|
|
|
#define GEN_OVERLOAD3_FUNCTIONS(ARG1, ARG2) \
|
|
void \
|
|
overload3_function (ARG1) \
|
|
{} \
|
|
void \
|
|
overload3_function (ARG2) \
|
|
{} \
|
|
\
|
|
struct struct_overload3_test \
|
|
{ \
|
|
void overload3_function (ARG1); \
|
|
void overload3_function (ARG2); \
|
|
}; \
|
|
\
|
|
void \
|
|
struct_overload3_test::overload3_function (ARG1) \
|
|
{} \
|
|
void \
|
|
struct_overload3_test::overload3_function (ARG2) \
|
|
{}
|
|
|
|
/* In the global namespace. */
|
|
GEN_OVERLOAD3_FUNCTIONS (int, long)
|
|
|
|
namespace
|
|
{
|
|
/* In an anonymous namespace. */
|
|
GEN_OVERLOAD3_FUNCTIONS (int, long)
|
|
}
|
|
|
|
namespace ns_overload3_test
|
|
{
|
|
/* In a namespace. */
|
|
GEN_OVERLOAD3_FUNCTIONS (int, long)
|
|
|
|
namespace
|
|
{
|
|
/* In a nested anonymous namespace. */
|
|
GEN_OVERLOAD3_FUNCTIONS (int, long)
|
|
|
|
namespace ns_overload3_test
|
|
{
|
|
/* In a nested namespace. */
|
|
GEN_OVERLOAD3_FUNCTIONS (int, long)
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Code for the template-overload tests. */
|
|
|
|
template <typename T>
|
|
struct template_struct
|
|
{
|
|
T template_overload_fn (T);
|
|
};
|
|
|
|
template <typename T>
|
|
T template_struct<T>::template_overload_fn (T t)
|
|
{
|
|
return t;
|
|
}
|
|
|
|
template_struct<int> template_struct_int;
|
|
template_struct<long> template_struct_long;
|
|
|
|
/* Code for the template2-ret-type tests. */
|
|
|
|
template <typename T>
|
|
struct template2_ret_type {};
|
|
|
|
template <typename T>
|
|
struct template2_struct
|
|
{
|
|
template <typename T2, typename T3>
|
|
T template2_fn (T = T (), T2 t2 = T2 (), T3 t3 = T3 ());
|
|
};
|
|
|
|
template <typename T>
|
|
template <typename T2, typename T3>
|
|
T template2_struct<T>::template2_fn (T t, T2 t2, T3 t3)
|
|
{
|
|
return T ();
|
|
}
|
|
|
|
template2_struct<template2_ret_type<int> > template2_struct_inst;
|
|
|
|
/* Code for the const-overload tests. */
|
|
|
|
struct struct_with_const_overload
|
|
{
|
|
void const_overload_fn ();
|
|
void const_overload_fn () const;
|
|
};
|
|
|
|
void
|
|
struct_with_const_overload::const_overload_fn ()
|
|
{}
|
|
|
|
void
|
|
struct_with_const_overload::const_overload_fn () const
|
|
{}
|
|
|
|
void
|
|
not_overloaded_fn ()
|
|
{}
|
|
|
|
/* Code for the incomplete-scope-colon tests. */
|
|
|
|
struct struct_incomplete_scope_colon_test
|
|
{
|
|
void incomplete_scope_colon_test ();
|
|
};
|
|
|
|
void
|
|
struct_incomplete_scope_colon_test::incomplete_scope_colon_test ()
|
|
{}
|
|
|
|
namespace ns_incomplete_scope_colon_test
|
|
{
|
|
void incomplete_scope_colon_test () {}
|
|
}
|
|
|
|
namespace ns2_incomplete_scope_colon_test
|
|
{
|
|
struct struct_in_ns2_incomplete_scope_colon_test
|
|
{
|
|
void incomplete_scope_colon_test ();
|
|
};
|
|
|
|
void
|
|
struct_in_ns2_incomplete_scope_colon_test::incomplete_scope_colon_test ()
|
|
{}
|
|
}
|
|
|
|
/* Code for the anon-ns tests. */
|
|
|
|
namespace
|
|
{
|
|
void anon_ns_function ()
|
|
{}
|
|
|
|
struct anon_ns_struct
|
|
{
|
|
void anon_ns_function ();
|
|
};
|
|
|
|
void
|
|
anon_ns_struct::anon_ns_function ()
|
|
{}
|
|
}
|
|
|
|
namespace the_anon_ns_wrapper_ns
|
|
{
|
|
|
|
namespace
|
|
{
|
|
void anon_ns_function ()
|
|
{}
|
|
|
|
struct anon_ns_struct
|
|
{
|
|
void anon_ns_function ();
|
|
};
|
|
|
|
void
|
|
anon_ns_struct::anon_ns_function ()
|
|
{}
|
|
}
|
|
|
|
} /* the_anon_ns_wrapper_ns */
|
|
|
|
/* Code for the global-ns-scope-op tests. */
|
|
|
|
void global_ns_scope_op_function ()
|
|
{
|
|
}
|
|
|
|
/* Add a function with the same name to a namespace. We want to test
|
|
that "b ::global_ns_function" does NOT select it. */
|
|
namespace the_global_ns_scope_op_ns
|
|
{
|
|
void global_ns_scope_op_function ()
|
|
{
|
|
}
|
|
}
|
|
|
|
/* Code for the ambiguous-prefix tests. */
|
|
|
|
/* Create a few functions/methods with the same "ambiguous_prefix_"
|
|
prefix. They in different scopes, but "b ambiguous_prefix_<tab>"
|
|
should list them all, and figure out the LCD is
|
|
ambiguous_prefix_. */
|
|
|
|
void ambiguous_prefix_global_func ()
|
|
{
|
|
}
|
|
|
|
namespace the_ambiguous_prefix_ns
|
|
{
|
|
void ambiguous_prefix_ns_func ()
|
|
{
|
|
}
|
|
}
|
|
|
|
struct the_ambiguous_prefix_struct
|
|
{
|
|
void ambiguous_prefix_method ();
|
|
};
|
|
|
|
void
|
|
the_ambiguous_prefix_struct::ambiguous_prefix_method ()
|
|
{
|
|
}
|
|
|
|
/* Code for the function-labels test. */
|
|
|
|
int
|
|
function_with_labels (int i)
|
|
{
|
|
if (i > 0)
|
|
{
|
|
label1:
|
|
return i + 20;
|
|
}
|
|
else
|
|
{
|
|
label2:
|
|
return i + 10;
|
|
}
|
|
}
|
|
|
|
/* Code for the no-data-symbols and if-expression tests. */
|
|
|
|
int code_data = 0;
|
|
|
|
int another_data = 0;
|
|
|
|
/* A function that has a same "code" prefix as the global above. We
|
|
want to ensure that completing on "b code" doesn't offer the data
|
|
symbol. */
|
|
void
|
|
code_function ()
|
|
{
|
|
}
|
|
|
|
/* Code for the operator< tests. */
|
|
|
|
enum foo_enum
|
|
{
|
|
foo_value
|
|
};
|
|
|
|
bool operator<(foo_enum lhs, foo_enum rhs)
|
|
{
|
|
label1:
|
|
return false;
|
|
}
|
|
|
|
/* Code for the in-source-file-unconstrained /
|
|
in-source-file-ambiguous tests. */
|
|
|
|
int
|
|
file_constrained_test_cpls_function (int i)
|
|
{
|
|
if (i > 0)
|
|
{
|
|
label1:
|
|
return i + 20;
|
|
}
|
|
else
|
|
{
|
|
label2:
|
|
return i + 10;
|
|
}
|
|
}
|
|
|
|
|
|
int
|
|
main ()
|
|
{
|
|
template2_struct_inst.template2_fn<int, int> ();
|
|
template_struct_int.template_overload_fn(0);
|
|
template_struct_long.template_overload_fn(0);
|
|
|
|
return 0;
|
|
}
|