Clang 8.0.0:
Major New Features
* Clang supports use of a profile remapping file, which permits profile data captured for one version of a program to be applied when building another version where symbols have changed (for example, due to renaming a class or namespace). See the UsersManual for details.
* Clang has new options to initialize automatic variables with a pattern. The default is still that automatic variables are uninitialized. This isn’t meant to change the semantics of C and C++. Rather, it’s meant to be a last resort when programmers inadvertently have some undefined behavior in their code. These options aim to make undefined behavior hurt less, which security-minded people will be very happy about.
* Improvements to Clang’s diagnostics
Non-comprehensive list of changes in this release
* The experimental feature Pretokenized Headers (PTH) was removed in its entirely from Clang. The feature did not properly work with about 1/3 of the possible tokens available and was unmaintained.
* The internals of libc++ include directory detection on MacOS have changed. Instead of running a search based on the -resource-dir flag, the search is now based on the path of the compiler in the filesystem. The default behaviour should not change. However, if you override -resource-dir manually and rely on the old behaviour you will need to add appropriate compiler flags for finding the corresponding libc++ include directory.
* The integrated assembler is used now by default for all MIPS targets.
* Improved support for MIPS N32 ABI and MIPS R6 target triples.
* Clang now includes builtin functions for bitwise rotation of common value sizes, such as: __builtin_rotateleft32
* Improved optimization for the corresponding MSVC compatibility builtins such as _rotl().
LLVM 7.0.0 Release
The release contains the work on trunk up to SVN revision 338536 plus
work on the release branch. It is the result of the community's work
over the past six months, including: function multiversioning in Clang
with the 'target' attribute for ELF-based x86/x86_64 targets, improved
PCH support in clang-cl, preliminary DWARF v5 support, basic support
for OpenMP 4.5 offloading to NVPTX, OpenCL C++ support, MSan, X-Ray
and libFuzzer support for FreeBSD, early UBSan, X-Ray and libFuzzer
support for OpenBSD, UBSan checks for implicit conversions, many
long-tail compatibility issues fixed in lld which is now production
ready for ELF, COFF and MinGW, new tools llvm-exegesis, llvm-mca and
diagtool. And as usual, many optimizations, improved diagnostics, and
bug fixes.
For more details, see the release notes:
https://llvm.org/releases/7.0.0/docs/ReleaseNotes.htmlhttps://llvm.org/releases/7.0.0/tools/clang/docs/ReleaseNotes.htmlhttps://llvm.org/releases/7.0.0/tools/clang/tools/extra/docs/ReleaseNotes.htmlhttps://llvm.org/releases/7.0.0/tools/lld/docs/ReleaseNotes.html
While it is debatable whether we want to have this definition upstream,
this is very necessary in the package for the purpose of building
www/firefox once it is updated to 63.0.
This is because netbsd's base libstdc++ has some __float128 in headers
and otherwise we get fatal errors in clang builds, or in firefox's case,
when generating bindings for Rust via clang.
PR toolchain/53679
Bump PKGREVISION.
The minimum compiler version required for building LLVM has been raised to 4.8 for GCC and 2015 for Visual Studio.
The C API functions LLVMAddFunctionAttr, LLVMGetFunctionAttr, LLVMRemoveFunctionAttr, LLVMAddAttribute, LLVMRemoveAttribute, LLVMGetAttribute, LLVMAddInstrAttribute and LLVMRemoveInstrAttribute have been removed.
The C API enum LLVMAttribute has been deleted.
The definition and uses of LLVM_ATRIBUTE_UNUSED_RESULT in the LLVM source were replaced with LLVM_NODISCARD, which matches the C++17 [[nodiscard]] semantics rather than gcc’s __attribute__((warn_unused_result)).
The Timer related APIs now expect a Name and Description. When upgrading code the previously used names should become descriptions and a short name in the style of a programming language identifier should be added.
LLVM now handles invariant.group across different basic blocks, which makes it possible to devirtualize virtual calls inside loops.
The aggressive dead code elimination phase (“adce”) now removes branches which do not effect program behavior. Loops are retained by default since they may be infinite but these can also be removed with LLVM option -adce-remove-loops when the loop body otherwise has no live operations.
The llvm-cov tool can now export coverage data as json. Its html output mode has also improved.
Packaged in pkgsrc-wip by myself and Kamil.
Remove stale pkgsrc/SunOS bread crumbs that were difficult to merge
following the build framework switch. Needs to be redone. (Sorry!)
Summary of significant changes in LLVM:
- switch build framework from autoconf to CMake
- llvm-ar now supports thin archives.
- llvm doesn t produce .data.rel.ro.local or .data.rel sections anymore.
- opional support for linking clang and the LLVM tools with a single
libLLVM shared library
pkgsrc note: we have this library in lang/libLLVM, but we don't currently
use it. We may do so in the future if/when the API matures.
- The optimization to move the prologue and epilogue of functions in colder
code path (shrink-wrapping) is now enabled by default
- new target-independent gcc-compatible emulated Thread Local Storage mode
- various target specific optimizations
Summary of significant changes in Clang:
- new compiler flags for tuning what DWARF information is included
- better strict alignment handling
- better support for __builtin_object_size
* Support for AuroraUX has been removed.
* Added support for a native object file-based bitcode wrapper format.
* Added support for MSVC’s __vectorcall calling convention as x86_vectorcallcc.
* Prefix data rework
* Metadata is not a Value
* Alias syntax change
* The old JIT has been removed
* object::Binary doesn’t own the file buffer
* IR in object files is now supported
* The gold plugin has been rewritten
Background:
LLVM 3.6 upstream added support for being a native toolchain on NetBSD.
This changed the default C++ runtime library from libstdc++ to libc++.
Patch this in pkgsrc's clang so we continue to use libstdc++ (for now)
Proper support for libc++ should be added later (perhaps w/ PKG_OPTIONs).
Thanks to Joerg for explaining the problem.
I will spin this off to a libLLVM package when we have a ready use case for it.
Packages that may want to use libLLVM are for example MesaLib and OpenJDK.
Non-comprehensive list of changes in this release:
- Support for AuroraUX has been removed.
- Added support for a native object file-based bitcode wrapper format.
- Added support for MSVC?s __vectorcall calling convention as x86_vectorcallcc.
All backends have been changed to use the MC asm printer and support for the non MC one has been removed.
Clang can now successfully self-host itself on Linux/Sparc64 and on FreeBSD/Sparc64.
LLVM now assumes the assembler supports .loc for generating debug line numbers. The old support for printing the debug line info directly was only used by llc and has been removed.
All inline assembly is parsed by the integrated assembler when it is enabled. Previously this was only the case for object-file output. It is now the case for assembly output as well. The integrated assembler can be disabled with the -no-integrated-as option.
llvm-ar now handles IR files like regular object files. In particular, a regular symbol table is created for symbols defined in IR files, including those in file scope inline assembly.
LLVM now always uses cfi directives for producing most stack unwinding information.
The prefix for loop vectorizer hint metadata has been changed from llvm.vectorizer to llvm.loop.vectorize. In addition, llvm.vectorizer.unroll metadata has been renamed llvm.loop.interleave.count.
Some backends previously implemented Atomic NAND(x,y) as x & ~y. Now all backends implement it as ~(x & y), matching the semantics of GCC 4.4 and later.
All backends have been changed to use the MC asm printer and support for the non MC one has been removed.
Clang can now successfully self-host itself on Linux/Sparc64 and on FreeBSD/Sparc64.
LLVM now assumes the assembler supports .loc for generating debug line numbers. The old support for printing the debug line info directly was only used by llc and has been removed.
All inline assembly is parsed by the integrated assembler when it is enabled. Previously this was only the case for object-file output. It is now the case for assembly output as well. The integrated assembler can be disabled with the -no-integrated-as option.
llvm-ar now handles IR files like regular object files. In particular, a regular symbol table is created for symbols defined in IR files, including those in file scope inline assembly.
LLVM now always uses cfi directives for producing most stack unwinding information.
The prefix for loop vectorizer hint metadata has been changed from llvm.vectorizer to llvm.loop.vectorize. In addition, llvm.vectorizer.unroll metadata has been renamed llvm.loop.interleave.count.
Some backends previously implemented Atomic NAND(x,y) as x & ~y. Now all backends implement it as ~(x & y), matching the semantics of GCC 4.4 and later.
* Tested under NetBSD/amd64 6.99.28 and Debian GNU/Linux/amd64 7.3
Changelog:
From: http://llvm.org/svn/llvm-project/llvm/tags/RELEASE_34/final/docs/ReleaseNotes.rst
Non-comprehensive list of changes in this release
=================================================
* This is expected to be the last release of LLVM which compiles using a C++98
toolchain. We expect to start using some C++11 features in LLVM and other
sub-projects starting after this release. That said, we are committed to
supporting a reasonable set of modern C++ toolchains as the host compiler on
all of the platforms. This will at least include Visual Studio 2012 on
Windows, and Clang 3.1 or GCC 4.7.x on Mac and Linux. The final set of
compilers (and the C++11 features they support) is not set in stone, but we
wanted users of LLVM to have a heads up that the next release will involve
a substantial change in the host toolchain requirements.
* The regression tests now fail if any command in a pipe fails. To disable it in
a directory, just add ``config.pipefail = False`` to its ``lit.local.cfg``.
See :doc:`Lit <CommandGuide/lit>` for the details.
* Support for exception handling has been removed from the old JIT. Use MCJIT
if you need EH support.
* The R600 backend is not marked experimental anymore and is built by default.
* ``APFloat::isNormal()`` was renamed to ``APFloat::isFiniteNonZero()`` and
``APFloat::isIEEENormal()`` was renamed to ``APFloat::isNormal()``. This
ensures that ``APFloat::isNormal()`` conforms to IEEE-754R-2008.
* The library call simplification pass has been removed. Its functionality
has been integrated into the instruction combiner and function attribute
marking passes.
* Support for building using Visual Studio 2008 has been dropped. Use VS 2010
or later instead. For more information, see the `Getting Started using Visual
Studio <GettingStartedVS.html>`_ page.
* The Loop Vectorizer that was previously enabled for ``-O3`` is now enabled
for ``-Os`` and ``-O2``.
* The new SLP Vectorizer is now enabled by default.
* ``llvm-ar`` now uses the new Object library and produces archives and
symbol tables in the gnu format.
* FileCheck now allows specifing ``-check-prefix`` multiple times. This
helps reduce duplicate check lines when using multiple RUN lines.
* The bitcast instruction no longer allows casting between pointers
with different address spaces. To achieve this, use the new addrspacecast
instruction.
* Different sized pointers for different address spaces should now
generally work. This is primarily useful for GPU targets.
* OCaml bindings have been significantly extended to cover almost all of the
LLVM libraries.
Mips Target
-----------
Support for the MIPS SIMD Architecture (MSA) has been added. MSA is supported
through inline assembly, intrinsics with the prefix '``__builtin_msa``', and
normal code generation.
For more information on MSA (including documentation for the instruction set),
see the `MIPS SIMD page at Imagination Technologies
<http://imgtec.com/mips/mips-simd.asp>`_
PowerPC Target
--------------
Changes in the PowerPC backend include:
* fast-isel support (for faster ``-O0`` code generation)
* many improvements to the builtin assembler
* support for generating unaligned (Altivec) vector loads
* support for generating the fcpsgn instruction
* generate ``frin`` for ``round()`` (not ``nearbyint()`` and ``rint()``, which
had been done only in fast-math mode)
* improved instruction scheduling for embedded cores (such as the A2)
* improved prologue/epilogue generation (especially in 32-bit mode)
* support for dynamic stack alignment (and dynamic stack allocations with large alignments)
* improved generation of counter-register-based loops
* bug fixes
SPARC Target
------------
The SPARC backend got many improvements, namely
* experimental SPARC V9 backend
* JIT support for SPARC
* fp128 support
* exception handling
* TLS support
* leaf functions optimization
* bug fixes
SystemZ/s390x Backend
---------------------
LLVM and clang can now optimize for zEnterprise z196 and zEnterprise EC12
targets. In clang these targets are selected using ``-march=z196`` and
``-march=zEC12`` respectively.
From: http://llvm.org/svn/llvm-project/cfe/tags/RELEASE_34/final/docs/ReleaseNotes.rst
What's New in Clang 3.4?
========================
Some of the major new features and improvements to Clang are listed here.
Generic improvements to Clang as a whole or to its underlying infrastructure
are described first, followed by language-specific sections with improvements
to Clang's support for those languages.
Last release which will build as C++98
--------------------------------------
This is expected to be the last release of Clang which compiles using a C++98
toolchain. We expect to start using some C++11 features in Clang starting after
this release. That said, we are committed to supporting a reasonable set of
modern C++ toolchains as the host compiler on all of the platforms. This will
at least include Visual Studio 2012 on Windows, and Clang 3.1 or GCC 4.7.x on
Mac and Linux. The final set of compilers (and the C++11 features they support)
is not set in stone, but we wanted users of Clang to have a heads up that the
next release will involve a substantial change in the host toolchain
requirements.
Note that this change is part of a change for the entire LLVM project, not just
Clang.
Major New Features
------------------
Improvements to Clang's diagnostics
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Clang's diagnostics are constantly being improved to catch more issues, explain
them more clearly, and provide more accurate source information about them. The
improvements since the 3.3 release include:
- -Wheader-guard warns on mismatches between the #ifndef and #define lines
in a header guard.
.. code-block:: c
#ifndef multiple
#define multi
#endif
returns
`warning: 'multiple' is used as a header guard here, followed by #define of a different macro [-Wheader-guard]`
- -Wlogical-not-parentheses warns when a logical not ('!') only applies to the
left-hand side of a comparison. This warning is part of -Wparentheses.
.. code-block:: c++
int i1 = 0, i2 = 1;
bool ret;
ret = !i1 == i2;
returns
`warning: logical not is only applied to the left hand side of this comparison [-Wlogical-not-parentheses]`
- Boolean increment, a deprecated feature, has own warning flag
-Wdeprecated-increment-bool, and is still part of -Wdeprecated.
- Clang errors on builtin enum increments and decrements.
.. code-block:: c++
enum A { A1, A2 };
void test() {
A a;
a++;
}
returns
`error: must use 'enum' tag to refer to type 'A'`
- -Wloop-analysis now warns on for-loops which have the same increment or
decrement in the loop header as the last statement in the loop.
.. code-block:: c
void foo(char *a, char *b, unsigned c) {
for (unsigned i = 0; i < c; ++i) {
a[i] = b[i];
++i;
}
}
returns
`warning: variable 'i' is incremented both in the loop header and in the loop body [-Wloop-analysis]`
- -Wuninitialized now performs checking across field initializers to detect
when one field in used uninitialized in another field initialization.
.. code-block:: c++
class A {
int x;
int y;
A() : x(y) {}
};
returns
`warning: field 'y' is uninitialized when used here [-Wuninitialized]`
- Clang can detect initializer list use inside a macro and suggest parentheses
if possible to fix.
- Many improvements to Clang's typo correction facilities, such as:
+ Adding global namespace qualifiers so that corrections can refer to shadowed
or otherwise ambiguous or unreachable namespaces.
+ Including accessible class members in the set of typo correction candidates,
so that corrections requiring a class name in the name specifier are now
possible.
+ Allowing typo corrections that involve removing a name specifier.
+ In some situations, correcting function names when a function was given the
wrong number of arguments, including situations where the original function
name was correct but was shadowed by a lexically closer function with the
same name yet took a different number of arguments.
+ Offering typo suggestions for 'using' declarations.
+ Providing better diagnostics and fixit suggestions in more situations when
a '->' was used instead of '.' or vice versa.
+ Providing more relevant suggestions for typos followed by '.' or '='.
+ Various performance improvements when searching for typo correction
candidates.
- `LeakSanitizer <LeakSanitizer.html>`_ is an experimental memory leak detector
which can be combined with AddressSanitizer.
New Compiler Flags
------------------
- Clang no longer special cases -O4 to enable lto. Explicitly pass -flto to
enable it.
- Clang no longer fails on >= -O5. These flags are mapped to -O3 instead.
- Command line "clang -O3 -flto a.c -c" and "clang -emit-llvm a.c -c"
are no longer equivalent.
- Clang now errors on unknown -m flags (``-munknown-to-clang``),
unknown -f flags (``-funknown-to-clang``) and unknown
options (``-what-is-this``).
C Language Changes in Clang
---------------------------
- Added new checked arithmetic builtins for security critical applications.
C++ Language Changes in Clang
-----------------------------
- Fixed an ABI regression, introduced in Clang 3.2, which affected
member offsets for classes inheriting from certain classes with tail padding.
See Bug16537.
- Clang 3.4 supports the 2013-08-28 draft of the ISO WG21 SG10 feature test
macro recommendations. These aim to provide a portable method to determine
whether a compiler supports a language feature, much like Clang's
|has_feature macro|_.
.. |has_feature macro| replace:: ``__has_feature`` macro
.. _has_feature macro: LanguageExtensions.html#has-feature-and-has-extension
C++1y Feature Support
^^^^^^^^^^^^^^^^^^^^^
Clang 3.4 supports all the features in the current working draft of the
upcoming C++ standard, provisionally named C++1y. Support for the following
major new features has been added since Clang 3.3:
- Generic lambdas and initialized lambda captures.
- Deduced function return types (``auto f() { return 0; }``).
- Generalized ``constexpr`` support (variable mutation and loops).
- Variable templates and static data member templates.
- Use of ``'`` as a digit separator in numeric literals.
- Support for sized ``::operator delete`` functions.
In addition, ``[[deprecated]]`` is now accepted as a synonym for Clang's
existing ``deprecated`` attribute.
Use ``-std=c++1y`` to enable C++1y mode.
OpenCL C Language Changes in Clang
----------------------------------
- OpenCL C "long" now always has a size of 64 bit, and all OpenCL C
types are aligned as specified in the OpenCL C standard. Also,
"char" is now always signed.
Internal API Changes
--------------------
These are major API changes that have happened since the 3.3 release of
Clang. If upgrading an external codebase that uses Clang as a library,
this section should help get you past the largest hurdles of upgrading.
Wide Character Types
^^^^^^^^^^^^^^^^^^^^
The ASTContext class now keeps track of two different types for wide character
types: WCharTy and WideCharTy. WCharTy represents the built-in wchar_t type
available in C++. WideCharTy is the type used for wide character literals; in
C++ it is the same as WCharTy, but in C99, where wchar_t is a typedef, it is an
integer type.
Static Analyzer
---------------
The static analyzer has been greatly improved. This impacts the overall analyzer quality and reduces a number of false positives.
In particular, this release provides enhanced C++ support, reasoning about initializer lists, zeroing constructors, noreturn destructors and modeling of destructor calls on calls to delete.
Clang Format
------------
Clang now includes a new tool ``clang-format`` which can be used to
automatically format C, C++ and Objective-C source code. ``clang-format``
automatically chooses linebreaks and indentation and can be easily integrated
into editors, IDEs and version control systems. It supports several pre-defined
styles as well as precise style control using a multitude of formatting
options. ``clang-format`` itself is just a thin wrapper around a library which
can also be used directly from code refactoring and code translation tools.
More information can be found on `Clang Format's
site <http://clang.llvm.org/docs/ClangFormat.html>`_.
The CellSPU port has been removed. It can still be found in older versions.
The IR-level extended linker APIs (for example, to link bitcode files out of archives) have been removed. Any existing clients of these features should move to using a linker with integrated LTO support.
LLVM and Clang’s documentation has been migrated to the Sphinx documentation generation system which uses easy-to-write reStructuredText. See llvm/docs/README.txt for more information.
TargetTransformInfo (TTI) is a new interface that can be used by IR-level passes to obtain target-specific information, such as the costs of instructions. Only “Lowering” passes such as LSR and the vectorizer are allowed to use the TTI infrastructure.
We’ve improved the X86 and ARM cost model.
The Attributes classes have been completely rewritten and expanded. They now support not only enumerated attributes and alignments, but “string” attributes, which are useful for passing information to code generation. See How To Use Attributes for more details.
TableGen’s syntax for instruction selection patterns has been simplified. Instead of specifying types indirectly with register classes, you should now specify types directly in the input patterns. See SparcInstrInfo.td for examples of the new syntax. The old syntax using register classes still works, but it will be removed in a future LLVM release.
MCJIT now supports exception handling. Support for it in the old jit will be removed in the 3.4 release.
Command line options can now be grouped into categories which are shown in the output of -help. See Grouping options into categories.
The appearance of command line options in -help that are inherited by linking with libraries that use the LLVM Command line support library can now be modified at runtime. See The cl::getRegisteredOptions function.
1) Don't pass both gcc 4.4 and gcc 4.7 paths to the driver. Detect
if gcc47 is available and use those paths, otherwise fall back to
gcc44.
2) Add support for exception handling
3) Add rdynamic support
4) Add gnu-hash style support
5) Fix (!!) crtstuff (This was obsolete, include PIE support)
6) Remove rpath-link
7) Remove unneeded duplicate libgcc handling
8) Make libgcc handling match gcc specs (different for gcc 4.4 and 4.7)
9) Update dragonfly driver test
Clang was hardwired to search for crt* stuff and libstdc++ at
/usr/lib/gcc41. This worked for most people even when DragonFly
moved to gcc 4.4 as the primary base compiler since gcc 4.1 was
usually also on the system.
With the release of DragonFly 3.2, gcc 4.7 replaced gcc 4.1 and
clang stopped compiling due to not being able to find libraries and
crt* objects. The new patches make clang driver first look for
gcc 4.7 and failing to find that: gcc 4.4.
The other patches were "de-fuzzed".
Revision bump was necessary because clang did build, it just didn't
work.
Patches submitted upstream:
http://llvm.org/bugs/show_bug.cgi?id=14417
For some reason, LLVM is using autoconf files from 2003 which is before
DragonFly even existed. I submitted a bug report #12944 at llvm.org's
bugzilla to request they use versions from 2012.
Also, installation fails at document generation without some extra tools.
No need to revbump, either built or it didn't without these packages.
* Major New Features
- AddressSanitizer, a fast memory error detector.
- MachineInstr Bundles, Support to model instruction bundling / packing.
- ARM Integrated Assembler, A full featured assembler and direct-to-object
support for ARM.
- Basic Block Placement Probability driven basic block placement.
* LLVM IR and Core Improvements
- A new type representing 16 bit half floating point values has been added.
- IR now supports vectors of pointers, including vector GEPs.
- Module flags have been introduced. They convey information about the module
as a whole to LLVM subsystems. This is currently used to encode Objective C
ABI information.
- Loads can now have range metadata attached to them to describe the possible
values being loaded.
- The llvm.ctlz and llvm.cttz intrinsics now have an additional argument which
indicates whether the behavior of the intrinsic is undefined on a zero
input. This can be used to generate more efficient code on platforms that
only have instructions which don't return the type size when counting bits
in 0.
* Optimizer Improvements
- The loop unroll pass now is able to unroll loops with run-time trip counts.
This feature is turned off by default, and is enabled with the
-unroll-runtime flag.
- A new basic-block autovectorization pass is available. Pass -vectorize to
run this pass along with some associated post-vectorization cleanup passes.
For more information, see the EuroLLVM 2012 slides: Autovectorization with
LLVM.
- Inline cost heuristics have been completely overhauled and now closely model
constant propagation through call sites, disregard trivially dead code
costs, and can model C++ STL iterator patterns.
* llvm-gcc is no longer supported, and not included in the release. We recommend
switching to Clang or DragonEgg.
* The linear scan register allocator has been replaced with a new "greedy"
register allocator, enabling live range splitting and many other optimizations that lead to better code quality. Please see its blog post or its talk at the
Developer Meeting for more information.
* LLVM IR now includes full support for atomics memory operations intended to
support the C++'11 and C'1x memory models. This includes atomic load and
store, compare and exchange, and read/modify/write instructions as well as
a full set of memory ordering constraints. Please see the Atomics Guide for
more information.
* The LLVM IR exception handling representation has been redesigned and
reimplemented, making it more elegant, fixing a huge number of bugs, and
enabling inlining and other optimizations. Please see its blog post and the
Exception Handling documentation for more information.
* The LLVM IR Type system has been redesigned and reimplemented, making it
faster and solving some long-standing problems. Please see its blog post for
more information.
* The MIPS backend has made major leaps in this release, going from an
experimental target to being virtually production quality and supporting
a wide variety of MIPS subtargets. See the MIPS section below for more
information.
* The optimizer and code generator now supports gprof and gcov-style coverage
and profiling information, and includes a new llvm-cov tool (but also works
with gcov). Clang exposes coverage and profiling through GCC-compatible
command line options.
* Type Based Alias Analysis (TBAA) is now implemented and turned on by default
in Clang. This allows substantially better load/store optimization in some
cases. TBAA can be disabled by passing -fno-strict-aliasing.
* This release has seen a continued focus on quality of debug information. LLVM
now generates much higher fidelity debug information, particularly when
debugging optimized code.
* Inline assembly now supports multiple alternative constraints.
* A new backend for the NVIDIA PTX virtual ISA (used to target its GPUs) is
under rapid development. It is not generally useful in 2.9, but is making
rapid progress.
* libc++ and LLDB are major new additions to the LLVM collective.
* LLVM 2.8 now has pretty decent support for debugging optimized code.
You should be able to reliably get debug info for function arguments,
assuming that the value is actually available where you have stopped.
* A new 'llvm-diff' tool is available that does a semantic diff of .ll files.
* The MC subproject has made major progress in this release. Direct .o file
writing support for darwin/x86[-64] is now reliable and support for other
targets and object file formats are in progress.
* The memcpy, memmove, and memset intrinsics now take address space qualified
pointers and a bit to indicate whether the transfer is "volatile" or not.
* Per-instruction debug info metadata is much faster and uses less memory by
using the new DebugLoc class.
* LLVM IR now has a more formalized concept of "trap values", which allow the
optimizer to optimize more aggressively in the presence of undefined behavior,
while still producing predictable results.
* LLVM IR now supports two new linkage types (linker_private_weak and
linker_private_weak_def_auto) which map onto some obscure MachO concepts.
* The optimizer now has support for updating debug information as it goes.
A key aspect of this is the new llvm.dbg.value intrinsic. This intrinsic
represents debug info for variables that are promoted to SSA values
(typically by mem2reg or the -scalarrepl passes).
* The JumpThreading pass is now much more aggressive about implied value
relations, allowing it to thread conditions like "a == 4" when a is known to
be 13 in one of the predecessors of a block. It does this in conjunction with
the new LazyValueInfo analysis pass.
* The new RegionInfo analysis pass identifies single-entry single-exit regions
in the CFG. You can play with it with the "opt -regions analyze" or "opt
-view-regions" commands.
* The loop optimizer has significantly improved strength reduction and analysis
capabilities. Notably it is able to build on the trap value and signed
integer overflow information to optimize <= and >= loops.
* The CallGraphSCCPassManager now has some basic support for iterating within
an SCC when a optimizer devirtualizes a function call. This allows inlining
through indirect call sites that are devirtualized by store-load forwarding
and other optimizations.
* The new -loweratomic pass is available to lower atomic instructions into
their non-atomic form. This can be useful to optimize generic code that
expects to run in a single-threaded environment.
PR pkg/43237 by NAKAJIMA Yoshihiro.
This isn't too useful yet due to an incompatibility (apparently
a bug in gcc-4.1) which will be fixed soon.
bump PKGREVISION
