[libc++abi][ItaniumDemangle] Demangle DF16b as std::bfloat16_t (#120109)

This mangling is official in the Itanium C++ ABI specification and is
already supported by clang.

NFC: clang-format test_demangle.pass.cpp but keep test "lines"

Add clang-format on/off around test "lines"

Run clang-format without breaking string literals:
clang-format --style='{BasedOnStyle: ll

NFC: clang-format test_demangle.pass.cpp but keep test "lines"

Add clang-format on/off around test "lines"

Run clang-format without breaking string literals:
clang-format --style='{BasedOnStyle: llvm, BreakStringLiterals: false}'
-i test_demangle.pass.cpp

Add clang-format on/off on fp_literal_cases

Fixups: Split UNSUPPORTED to next line; xfail_cases trailing comma

Replace physical tab

show more ...

[libc++abi] Enable demangling of `cp` expression production (#114882)

See itanium-cxx-abi/cxx-abi#196

[demangler] Enhance demangling in llvm-cxxfilt for fixed-point types. (#114257)

This patch adds support for fixed-point type in demanger.

Closes #114090.

[runtimes] Run backdeployment CI on Github hosted runners (#109984)

This removes the need for macOS nodes in Buildkite. It also moves to the
proper way of testing backdeployment, which is to actual

[runtimes] Run backdeployment CI on Github hosted runners (#109984)

This removes the need for macOS nodes in Buildkite. It also moves to the
proper way of testing backdeployment, which is to actually run on the
target OS itself, instead of using packaged dylibs from previous OS
versions and trying to emulate backdeployment with DYLD_LIBRARY_PATH.

As a drive-by change, also fix a few back-deployment annotations that
were incorrect and add support for minor versions in the Lit feature
determining availability from the target triple.

show more ...

[clang][ItaniumMangle] Mangle friend function templates with a constr… (#110247)

…aint that depends on a template parameter from an enclosing template as
members of the enclosing class.

Such fun

[clang][ItaniumMangle] Mangle friend function templates with a constr… (#110247)

…aint that depends on a template parameter from an enclosing template as
members of the enclosing class.

Such function templates should be considered member-like constrained
friends per [temp.friend]p9 and
https://github.com/itanium-cxx-abi/cxx-abi/issues/24#issuecomment-934977198).

show more ...

[ItaniumDemangle] Add template name to the substitutions list during demangling (#108538)

When demangling a template template parameter (`method<bool,
Bar>(Bar<bool> b)`), the current demangler ver

[ItaniumDemangle] Add template name to the substitutions list during demangling (#108538)

When demangling a template template parameter (`method<bool,
Bar>(Bar<bool> b)`), the current demangler version first enters the
template argument (`bool`) into the substitutions list, then the whole
template specialization (`Bar<bool>`). The template name (`Bar`) never
becomes a substitution candidate on its own.

This is different when mangling. Mangling `method<bool, Bar>(Bar<bool>
b, Bar<int> i)` substitutes the `Bar` in the second parameter with the
substitution for `TemplateTemplateParmDecl`.

This leads to a discrepancy between mangler and demangler, see
https://github.com/llvm/llvm-project/issues/108009.

show more ...

[demangle] Represent a char array initializer as a string literal. (#109021)

This improves the demangling for non-type template arguments that
contain string literals. Previously we'd produce

[demangle] Represent a char array initializer as a string literal. (#109021)

This improves the demangling for non-type template arguments that
contain string literals. Previously we'd produce

char [4]{(char)65, (char)66, (char)67}

(which isn't valid C or C++), and now we produce `"ABC"`.

The new demangling is always shorter, even when using an escape sequence
for every character, and much more readable when the char array contains
text.

show more ...

[ItaniumDemangle] Set `InConstraintExpr` to `true` when demangling a constraint expression (#107385)

This prevents demangler failures until the TODO in the
[demangler](https://github.com/llvm/llvm-

[ItaniumDemangle] Set `InConstraintExpr` to `true` when demangling a constraint expression (#107385)

This prevents demangler failures until the TODO in the
[demangler](https://github.com/llvm/llvm-project/blob/3e070906eff720dc44aee86e533e12aafc8bb14b/llvm/include/llvm/Demangle/ItaniumDemangle.h#L5678)
is implemented.

This is a temporary fix for
[#89914](https://github.com/llvm/llvm-project/issues/89914).

show more ...

[libcxx] [test] Detect the UCRT printf("%a") formatting bug (#99846)

This fixes testing with MinGW, if built without
__USE_MINGW_ANSI_STDIO=1.

On x86 MinGW, such a configuration fails printf tes

[libcxx] [test] Detect the UCRT printf("%a") formatting bug (#99846)

This fixes testing with MinGW, if built without
__USE_MINGW_ANSI_STDIO=1.

On x86 MinGW, such a configuration fails printf tests with long doubles
due to mismatches between 80 and 64 bit long doubles - but on ARM,
there's no such issue, so building without __USE_MINGW_ANSI_STDIO=1 is
perfectly valid there.

Add another similar XFAIL to a libcxxabi test; this test isn't executed
in MSVC environments, so no XFAIL has been needed so far.

show more ...

[libc++] Clean up and update deployment target features (#96312)

This patch removes many annotations that are not relevant anymore since
we don't support or test back-deploying to macOS < 10.13. It

[libc++] Clean up and update deployment target features (#96312)

This patch removes many annotations that are not relevant anymore since
we don't support or test back-deploying to macOS < 10.13. It also cleans
up raw usage of target triples to identify versions of dylibs shipped on
prior versions of macOS, and uses the target-agnostic Lit features
instead. Finally, it reorders both the Lit backdeployment features and
the corresponding availability macros in the library in a way that makes
more sense, and reformulates the Lit backdeployment features in terms of
when a version of LLVM was introduced instead of encoding the system
versions on which it hasn't been introduced yet. Although one can be
derived from the other, encoding the negative form is extremely
error-prone.

Fixes #80901

show more ...

[libc++] Fix deployment target Lit features (#94791)

We were not making any distinction between e.g. the "Apple-flavored"
libc++ built from trunk and the system-provided standard library on
Apple

[libc++] Fix deployment target Lit features (#94791)

We were not making any distinction between e.g. the "Apple-flavored"
libc++ built from trunk and the system-provided standard library on
Apple platforms. For example, any test that would be XFAILed on a
back-deployment target would unexpectedly pass when run on that
deployment target against the tip of trunk Apple-flavored libc++. In
reality, that test would be expected to pass because we're running
against the latest libc++, even if it is Apple-flavored.

To solve this issue, we introduce a new feature that describes whether
the Standard Library in use is the one provided by the system by
default, and that notion is different from the underlying standard
library flavor. We also refactor the existing Lit features to make a
distinction between availability markup and the library we're running
against at runtime, which otherwise limit the flexibility of what we can
express in the test suite. Finally, we refactor some of the
back-deployment versions that were incorrect (such as thinking that LLVM
10 was introduced in macOS 11, when in reality macOS 11 was synced with
LLVM 11).

Fixes #82107

show more ...

[ItaniumDemangle] reject A-F in FP literals (#82864)

The Itanium C++ ABI specifies that FP literals are encoded using a
lowercase hexadecimal string. Previously, libc++abi allowed uppercase
A-F ch

[ItaniumDemangle] reject A-F in FP literals (#82864)

The Itanium C++ ABI specifies that FP literals are encoded using a
lowercase hexadecimal string. Previously, libc++abi allowed uppercase
A-F characters but decoded them by subtracting 'a' from them, producing
negative digit values. It is especially confusing to accept an 'E' digit
because 'E' marks the end of the FP literal.

show more ...

[libc++] Add initial support for picolibc

Picolibc is a C Standard Library that is commonly used in embedded
environments. This patch adds initial support for this configuration
along with pre-commi

[libc++] Add initial support for picolibc

Picolibc is a C Standard Library that is commonly used in embedded
environments. This patch adds initial support for this configuration
along with pre-commit CI. As of this patch, the test suite only builds
the tests and nothing is run. A follow-up patch will make the test suite
actually run the tests.

Differential Revision: https://reviews.llvm.org/D154246

show more ...

[libcxxabi][ItaniumDemangle] Demangle explicitly named object parameters (#72881)

The mangling for an explicitly named object was introduced in
https://reviews.llvm.org/D140828

See following dis

[libcxxabi][ItaniumDemangle] Demangle explicitly named object parameters (#72881)

The mangling for an explicitly named object was introduced in
https://reviews.llvm.org/D140828

See following discussion for why a new mangling had to be introduced:
https://github.com/itanium-cxx-abi/cxx-abi/issues/148

Since clang started emitting names with the new mangling, this patch
implements support for demangling such names.

The approach this patch takes is to add a new `ExplicitObjectParameter`
node that will print the first parameter of a function declaration with
a `this ` prefix, to reflect what was spelled out in source.

Example:
```
void MyClass::func(this MyClass const& self); // _ZNH7MyClass4funcERKS_
```
With this patch, the above demangles to:
```
_ZNH7MyClass4funcERKS_ -> MyClass::func(this MyClass const&)
```

Note that `func` is not marked as `const &`, since the
function-qualifiers are now encoded as part of the explicit `this`. C++
doesn't allow specifying the function-qualifiers in the presence of an
explicit object parameter, so this demangling is consistent with the
source spelling.

show more ...

[libcxxabi][test][NFC] Turn off clang-format for demangler test-case array (#73503)

Adding test-cases to the `cases` array causes `git clang-format` to
split the strings of many of the existing tes

[libcxxabi][test][NFC] Turn off clang-format for demangler test-case array (#73503)

Adding test-cases to the `cases` array causes `git clang-format` to
split the strings of many of the existing test-cases, making them harder
to read/work with in most cases.

This patch disables `clang-format` for the `cases` array so it doesn't
catch anyone off-guard in the future.

show more ...

Revert recent changes to test_demangle.pass.cpp

These tests do not need to be updated when making changes to the API.

[clang][NFC] Refactor `VectorType::VectorKind`

This patch moves `VectorKind` to namespace scope, and make it complete at the point its bit-field is declared. It also converts it to a scoped enum.

[clang][NFC] Follow up to ArraySizeModifier refactoring

This addresses issues found by https://lab.llvm.org/buildbot/#/builders/68/builds/62599 introduced in d71ac4b05bcf2804368ec7217a13c2c47fce7479

[libc++][Android] Mark tests XFAIL/UNSUPPORTED (#69271)

Mark tests as necessary to accommodate Android L (5.0 / API 21) and up.

Add three Android lit features:
- android
- android-device-api=

[libc++][Android] Mark tests XFAIL/UNSUPPORTED (#69271)

Mark tests as necessary to accommodate Android L (5.0 / API 21) and up.

Add three Android lit features:
- android
- android-device-api=(21,22,23,...)
- LIBCXX-ANDROID-FIXME (for failures that need follow-up work)

Enable an AIX workaround in filesystem_test_helper.h for the broken
chmod on older Android devices.

Mark failing test with XFAIL or UNSUPPORTED:
- Mark modules tests as UNSUPPORTED, matching other configurations.
- Mark a gdb test as UNSUPPORTED.
- XFAIL tests for old devices that lack an API (fmemopen).
- XFAIL various FS tests (because SELinux blocks FIFO and hard linking,
because fchmodat is broken on old devices).
- XFAIL various locale tests (because Bionic has limited locale
support). (Also XFAIL an re.traits test.)
- XFAIL some print.fun tests because the error exception has no system
error string.
- Mark std::{cin,wcin} tests UNSUPPORTED because they hang with
adb_run.py on old devices.
- Mark a few tests UNSUPPORTED because they allocate too much memory.
- notify_one.pass.cpp is flaky on Android.
- XFAIL libc++abi demangler test because of Android's special long
double on x86[-64].

N.B. The `__ANDROID_API__` macro specifies a minimum required API level
at build-time, whereas the android-device-api lit feature is the
detected API level of the device at run-time. The android-device-api
value will be >= `__ANDROID_API__`.

This commit was split out from https://reviews.llvm.org/D139147.

Fixes: https://github.com/llvm/llvm-project/issues/69270

show more ...

[Demangle] demangle builtin type transformations (#65902)

Fixed: https://github.com/llvm/llvm-project/issues/62127
https://reviews.llvm.org/D116203 introduced several compiler builtin
equivalents

[Demangle] demangle builtin type transformations (#65902)

Fixed: https://github.com/llvm/llvm-project/issues/62127
https://reviews.llvm.org/D116203 introduced several compiler builtin
equivalents of the unary type traits. In some cases (e.g. template)
those builtin will be dependent and need to be mangle.
This patch add the check for `u{builtin}I{type}E` to demangle it.

Reviewed By: rjmccall

Differential Revision: https://reviews.llvm.org/D148465

show more ...

Implement mangling rules for C++20 concepts and requires-expressions.

This implements proposals from:

- https://github.com/itanium-cxx-abi/cxx-abi/issues/24: mangling for
constraints, requires-cl

Implement mangling rules for C++20 concepts and requires-expressions.

This implements proposals from:

- https://github.com/itanium-cxx-abi/cxx-abi/issues/24: mangling for
constraints, requires-clauses, requires-expressions.
- https://github.com/itanium-cxx-abi/cxx-abi/issues/31: requires-clauses and
template parameters in a lambda expression are mangled into the <lambda-sig>.
- https://github.com/itanium-cxx-abi/cxx-abi/issues/47 (STEP 3): mangling for
template argument is prefixed by mangling of template parameter declaration
if it's not "obvious", for example because the template parameter is
constrained (we already implemented STEP 1 and STEP 2).

This changes the manglings for a few cases:

- Functions and function templates with constraints.
- Function templates with template parameters with deduced types:
`typename<auto N> void f();`
- Function templates with template template parameters where the argument has a
different template-head:
`template<template<typename...T>> void f(); f<std::vector>();`

In each case where a mangling changed, the change fixes a mangling collision.

Note that only function templates are affected, not class templates or variable
templates, and only new constructs (template parameters with deduced types,
constrained templates) and esoteric constructs (templates with template
template parameters with non-matching template template arguments, most of
which Clang still does not accept by default due to
`-frelaxed-template-template-args` not being enabled by default), so the risk
to ABI stability from this change is relatively low. Nonetheless,
`-fclang-abi-compat=17` can be used to restore the old manglings for cases
which we could successfully but incorrectly mangle before.

Fixes #48216, #49884, #61273

Reviewed By: erichkeane, #libc_abi

Differential Revision: https://reviews.llvm.org/D147655

show more ...

Revert "[Demangle] demangle builtin type transformations"

This reverts commit 31cc069b5f4cb1b120c72f4dcbaa1b5a212120df.

[Demangle] demangle builtin type transformations

Fixed: https://github.com/llvm/llvm-project/issues/62127
https://reviews.llvm.org/D116203 introduced several compiler builtin
equivalents of the unar

[Demangle] demangle builtin type transformations

Fixed: https://github.com/llvm/llvm-project/issues/62127
https://reviews.llvm.org/D116203 introduced several compiler builtin
equivalents of the unary type traits. In some cases (e.g. template) those
builtin will be dependent and need to be mangle.
This patch add the check for `u{builtin}I{type}E` to demangle it.

Reviewed By: rjmccall

Differential Revision: https://reviews.llvm.org/D148465

show more ...

[libc++] Use the stdlib=<LIB> Lit feature instead of use_system_cxx_lib

The use_system_cxx_lib Lit feature was only used for back-deployment
testing. However, one immense hole in that setup was that

[libc++] Use the stdlib=<LIB> Lit feature instead of use_system_cxx_lib

The use_system_cxx_lib Lit feature was only used for back-deployment
testing. However, one immense hole in that setup was that we didn't
have a proper way to test Apple's own libc++ outside of back-deployment,
which was embodied by the fact that we needed to define _LIBCPP_DISABLE_AVAILABILITY
when testing (see change in libcxx/utils/libcxx/test/params.py).

This led to the apple-system testing configuration not checking for
availability markup, which is obviously quite bad since the library
we ship actually has availability markup.

Using stdlib=<VENDOR>-libc++ instead to encode back-deployment restrictions
on tests is simpler and it makes it possible to naturally support tests
such as availability markup checking even in the tip-of-trunk Apple-libc++
configuration.

Differential Revision: https://reviews.llvm.org/D146366

show more ...