6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-07-22 09:29:31 +00:00
Code Issues Projects Releases Wiki Activity

Revert accidentally-committed files.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@208034 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Richard Smith 2014-05-06 01:46:26 +00:00
parent 36ecb2ee9d
commit 2efa833c4e
2 changed files with 0 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
docs/CodingStandards.rst
View File

@ -108,8 +108,6 @@ unlikely to be supported by our host compilers.
* Lambdas: N2927_
* But *not* ``std::function``, until Clang implements `MSVC-compatible RTTI`_.
In many cases, you may be able to use ``llvm::function_ref`` instead, and it
is a superior choice in those cases.
* And *not* lambdas with default arguments.
* ``decltype``: N2343_

72
docs/ProgrammersManual.rst
View File

@ -263,78 +263,6 @@ almost never be stored or mentioned directly. They are intended solely for use
when defining a function which should be able to efficiently accept concatenated
strings.
.. _function_apis:
Passing functions and other callable objects
--------------------------------------------
Sometimes you may want a function to be passed a callback object. In order to
support lambda expressions and other function objects, you should not use the
traditional C approach of taking a function pointer and an opaque cookie:
.. code-block:: c++
void takeCallback(bool (*Callback)(Function *, void *), void *Cookie);
Instead, use one of the following approaches:
Function template
^^^^^^^^^^^^^^^^^
If you don't mind putting the definition of your function into a header file,
make it a function template that is templated on the callable type.
.. code-block:: c++
template<typename Callable>
void takeCallback(Callable Callback) {
Callback(1, 2, 3);
}
The ``function_ref`` class template
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The ``function_ref``
(`doxygen <http://llvm.org/doxygen/classllvm_1_1function_ref.html>`__) class
template represents a reference to a callable object, templated over the type
of the callable. This is a good choice for passing a callback to a function,
if you don't need to hold onto the callback after the function returns.
``function_ref<Ret(Param1, Param2, ...)>`` can be implicitly constructed from
any callable object that can be called with arguments of type ``Param1``,
``Param2``, ..., and returns a value that can be converted to type ``Ret``.
For example:
.. code-block:: c++
void visitBasicBlocks(Function *F, function_ref<bool (BasicBlock*)> Callback) {
for (BasicBlock &BB : *F)
if (Callback(&BB))
return;
}
can be called using:
.. code-block:: c++
visitBasicBlocks(F, [&](BasicBlock *BB) {
if (process(BB))
return isEmpty(BB);
return false;
});
Note that a ``function_ref`` object contains pointers to external memory, so
it is not generally safe to store an instance of the class (unless you know
that the external storage will not be freed).
``function_ref`` is small enough that it should always be passed by value.
``std::function``
^^^^^^^^^^^^^^^^^
You cannot use ``std::function`` within LLVM code, because it is not supported
by all our target toolchains.
.. _DEBUG:
The ``DEBUG()`` macro and ``-debug`` option