1 ========================
2 LLVM Programmer's Manual
3 ========================
9 This is always a work in progress.
16 This document is meant to highlight some of the important classes and interfaces
17 available in the LLVM source-base. This manual is not intended to explain what
18 LLVM is, how it works, and what LLVM code looks like. It assumes that you know
19 the basics of LLVM and are interested in writing transformations or otherwise
20 analyzing or manipulating the code.
22 This document should get you oriented so that you can find your way in the
23 continuously growing source code that makes up the LLVM infrastructure. Note
24 that this manual is not intended to serve as a replacement for reading the
25 source code, so if you think there should be a method in one of these classes to
26 do something, but it's not listed, check the source. Links to the `doxygen
27 <http://llvm.org/doxygen/>`__ sources are provided to make this as easy as
30 The first section of this document describes general information that is useful
31 to know when working in the LLVM infrastructure, and the second describes the
32 Core LLVM classes. In the future this manual will be extended with information
33 describing how to use extension libraries, such as dominator information, CFG
34 traversal routines, and useful utilities like the ``InstVisitor`` (`doxygen
35 <http://llvm.org/doxygen/InstVisitor_8h_source.html>`__) template.
42 This section contains general information that is useful if you are working in
43 the LLVM source-base, but that isn't specific to any particular API.
47 The C++ Standard Template Library
48 ---------------------------------
50 LLVM makes heavy use of the C++ Standard Template Library (STL), perhaps much
51 more than you are used to, or have seen before. Because of this, you might want
52 to do a little background reading in the techniques used and capabilities of the
53 library. There are many good pages that discuss the STL, and several books on
54 the subject that you can get, so it will not be discussed in this document.
56 Here are some useful links:
59 <http://en.cppreference.com/w/>`_ - an excellent
60 reference for the STL and other parts of the standard C++ library.
62 #. `C++ In a Nutshell <http://www.tempest-sw.com/cpp/>`_ - This is an O'Reilly
63 book in the making. It has a decent Standard Library Reference that rivals
64 Dinkumware's, and is unfortunately no longer free since the book has been
67 #. `C++ Frequently Asked Questions <http://www.parashift.com/c++-faq-lite/>`_.
69 #. `SGI's STL Programmer's Guide <http://www.sgi.com/tech/stl/>`_ - Contains a
70 useful `Introduction to the STL
71 <http://www.sgi.com/tech/stl/stl_introduction.html>`_.
73 #. `Bjarne Stroustrup's C++ Page
74 <http://www.research.att.com/%7Ebs/C++.html>`_.
76 #. `Bruce Eckel's Thinking in C++, 2nd ed. Volume 2 Revision 4.0
77 (even better, get the book)
78 <http://www.mindview.net/Books/TICPP/ThinkingInCPP2e.html>`_.
80 You are also encouraged to take a look at the :doc:`LLVM Coding Standards
81 <CodingStandards>` guide which focuses on how to write maintainable code more
82 than where to put your curly braces.
86 Other useful references
87 -----------------------
89 #. `Using static and shared libraries across platforms
90 <http://www.fortran-2000.com/ArnaudRecipes/sharedlib.html>`_
94 Important and useful LLVM APIs
95 ==============================
97 Here we highlight some LLVM APIs that are generally useful and good to know
98 about when writing transformations.
102 The ``isa<>``, ``cast<>`` and ``dyn_cast<>`` templates
103 ------------------------------------------------------
105 The LLVM source-base makes extensive use of a custom form of RTTI. These
106 templates have many similarities to the C++ ``dynamic_cast<>`` operator, but
107 they don't have some drawbacks (primarily stemming from the fact that
108 ``dynamic_cast<>`` only works on classes that have a v-table). Because they are
109 used so often, you must know what they do and how they work. All of these
110 templates are defined in the ``llvm/Support/Casting.h`` (`doxygen
111 <http://llvm.org/doxygen/Casting_8h_source.html>`__) file (note that you very
112 rarely have to include this file directly).
115 The ``isa<>`` operator works exactly like the Java "``instanceof``" operator.
116 It returns true or false depending on whether a reference or pointer points to
117 an instance of the specified class. This can be very useful for constraint
118 checking of various sorts (example below).
121 The ``cast<>`` operator is a "checked cast" operation. It converts a pointer
122 or reference from a base class to a derived class, causing an assertion
123 failure if it is not really an instance of the right type. This should be
124 used in cases where you have some information that makes you believe that
125 something is of the right type. An example of the ``isa<>`` and ``cast<>``
130 static bool isLoopInvariant(const Value *V, const Loop *L) {
131 if (isa<Constant>(V) || isa<Argument>(V) || isa<GlobalValue>(V))
134 // Otherwise, it must be an instruction...
135 return !L->contains(cast<Instruction>(V)->getParent());
138 Note that you should **not** use an ``isa<>`` test followed by a ``cast<>``,
139 for that use the ``dyn_cast<>`` operator.
142 The ``dyn_cast<>`` operator is a "checking cast" operation. It checks to see
143 if the operand is of the specified type, and if so, returns a pointer to it
144 (this operator does not work with references). If the operand is not of the
145 correct type, a null pointer is returned. Thus, this works very much like
146 the ``dynamic_cast<>`` operator in C++, and should be used in the same
147 circumstances. Typically, the ``dyn_cast<>`` operator is used in an ``if``
148 statement or some other flow control statement like this:
152 if (auto *AI = dyn_cast<AllocationInst>(Val)) {
156 This form of the ``if`` statement effectively combines together a call to
157 ``isa<>`` and a call to ``cast<>`` into one statement, which is very
160 Note that the ``dyn_cast<>`` operator, like C++'s ``dynamic_cast<>`` or Java's
161 ``instanceof`` operator, can be abused. In particular, you should not use big
162 chained ``if/then/else`` blocks to check for lots of different variants of
163 classes. If you find yourself wanting to do this, it is much cleaner and more
164 efficient to use the ``InstVisitor`` class to dispatch over the instruction
168 The ``cast_or_null<>`` operator works just like the ``cast<>`` operator,
169 except that it allows for a null pointer as an argument (which it then
170 propagates). This can sometimes be useful, allowing you to combine several
171 null checks into one.
173 ``dyn_cast_or_null<>``:
174 The ``dyn_cast_or_null<>`` operator works just like the ``dyn_cast<>``
175 operator, except that it allows for a null pointer as an argument (which it
176 then propagates). This can sometimes be useful, allowing you to combine
177 several null checks into one.
179 These five templates can be used with any classes, whether they have a v-table
180 or not. If you want to add support for these templates, see the document
181 :doc:`How to set up LLVM-style RTTI for your class hierarchy
182 <HowToSetUpLLVMStyleRTTI>`
186 Passing strings (the ``StringRef`` and ``Twine`` classes)
187 ---------------------------------------------------------
189 Although LLVM generally does not do much string manipulation, we do have several
190 important APIs which take strings. Two important examples are the Value class
191 -- which has names for instructions, functions, etc. -- and the ``StringMap``
192 class which is used extensively in LLVM and Clang.
194 These are generic classes, and they need to be able to accept strings which may
195 have embedded null characters. Therefore, they cannot simply take a ``const
196 char *``, and taking a ``const std::string&`` requires clients to perform a heap
197 allocation which is usually unnecessary. Instead, many LLVM APIs use a
198 ``StringRef`` or a ``const Twine&`` for passing strings efficiently.
202 The ``StringRef`` class
203 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
205 The ``StringRef`` data type represents a reference to a constant string (a
206 character array and a length) and supports the common operations available on
207 ``std::string``, but does not require heap allocation.
209 It can be implicitly constructed using a C style null-terminated string, an
210 ``std::string``, or explicitly with a character pointer and length. For
211 example, the ``StringRef`` find function is declared as:
215 iterator find(StringRef Key);
217 and clients can call it using any one of:
221 Map.find("foo"); // Lookup "foo"
222 Map.find(std::string("bar")); // Lookup "bar"
223 Map.find(StringRef("\0baz", 4)); // Lookup "\0baz"
225 Similarly, APIs which need to return a string may return a ``StringRef``
226 instance, which can be used directly or converted to an ``std::string`` using
227 the ``str`` member function. See ``llvm/ADT/StringRef.h`` (`doxygen
228 <http://llvm.org/doxygen/StringRef_8h_source.html>`__) for more
231 You should rarely use the ``StringRef`` class directly, because it contains
232 pointers to external memory it is not generally safe to store an instance of the
233 class (unless you know that the external storage will not be freed).
234 ``StringRef`` is small and pervasive enough in LLVM that it should always be
240 The ``Twine`` (`doxygen <http://llvm.org/doxygen/classllvm_1_1Twine.html>`__)
241 class is an efficient way for APIs to accept concatenated strings. For example,
242 a common LLVM paradigm is to name one instruction based on the name of another
243 instruction with a suffix, for example:
247 New = CmpInst::Create(..., SO->getName() + ".cmp");
249 The ``Twine`` class is effectively a lightweight `rope
250 <http://en.wikipedia.org/wiki/Rope_(computer_science)>`_ which points to
251 temporary (stack allocated) objects. Twines can be implicitly constructed as
252 the result of the plus operator applied to strings (i.e., a C strings, an
253 ``std::string``, or a ``StringRef``). The twine delays the actual concatenation
254 of strings until it is actually required, at which point it can be efficiently
255 rendered directly into a character array. This avoids unnecessary heap
256 allocation involved in constructing the temporary results of string
257 concatenation. See ``llvm/ADT/Twine.h`` (`doxygen
258 <http://llvm.org/doxygen/Twine_8h_source.html>`__) and :ref:`here <dss_twine>`
259 for more information.
261 As with a ``StringRef``, ``Twine`` objects point to external memory and should
262 almost never be stored or mentioned directly. They are intended solely for use
263 when defining a function which should be able to efficiently accept concatenated
266 .. _formatting_strings:
268 Formatting strings (the ``formatv`` function)
269 ---------------------------------------------
270 While LLVM doesn't necessarily do a lot of string manipulation and parsing, it
271 does do a lot of string formatting. From diagnostic messages, to llvm tool
272 outputs such as ``llvm-readobj`` to printing verbose disassembly listings and
273 LLDB runtime logging, the need for string formatting is pervasive.
275 The ``formatv`` is similar in spirit to ``printf``, but uses a different syntax
276 which borrows heavily from Python and C#. Unlike ``printf`` it deduces the type
277 to be formatted at compile time, so it does not need a format specifier such as
278 ``%d``. This reduces the mental overhead of trying to construct portable format
279 strings, especially for platform-specific types like ``size_t`` or pointer types.
280 Unlike both ``printf`` and Python, it additionally fails to compile if LLVM does
281 not know how to format the type. These two properties ensure that the function
282 is both safer and simpler to use than traditional formatting methods such as
283 the ``printf`` family of functions.
288 A call to ``formatv`` involves a single **format string** consisting of 0 or more
289 **replacement sequences**, followed by a variable length list of **replacement values**.
290 A replacement sequence is a string of the form ``{N[[,align]:style]}``.
292 ``N`` refers to the 0-based index of the argument from the list of replacement
293 values. Note that this means it is possible to reference the same parameter
294 multiple times, possibly with different style and/or alignment options, in any order.
296 ``align`` is an optional string specifying the width of the field to format
297 the value into, and the alignment of the value within the field. It is specified as
298 an optional **alignment style** followed by a positive integral **field width**. The
299 alignment style can be one of the characters ``-`` (left align), ``=`` (center align),
300 or ``+`` (right align). The default is right aligned.
302 ``style`` is an optional string consisting of a type specific that controls the
303 formatting of the value. For example, to format a floating point value as a percentage,
304 you can use the style option ``P``.
309 There are two ways to customize the formatting behavior for a type.
311 1. Provide a template specialization of ``llvm::format_provider<T>`` for your
312 type ``T`` with the appropriate static format method.
318 struct format_provider<MyFooBar> {
319 static void format(const MyFooBar &V, raw_ostream &Stream, StringRef Style) {
320 // Do whatever is necessary to format `V` into `Stream`
325 std::string S = formatv("{0}", X);
329 This is a useful extensibility mechanism for adding support for formatting your own
330 custom types with your own custom Style options. But it does not help when you want
331 to extend the mechanism for formatting a type that the library already knows how to
332 format. For that, we need something else.
334 2. Provide a **format adapter** inheriting from ``llvm::FormatAdapter<T>``.
339 struct format_int_custom : public llvm::FormatAdapter<int> {
340 explicit format_int_custom(int N) : llvm::FormatAdapter<int>(N) {}
341 void format(llvm::raw_ostream &Stream, StringRef Style) override {
342 // Do whatever is necessary to format ``this->Item`` into ``Stream``
348 std::string S = formatv("{0}", anything::format_int_custom(42));
352 If the type is detected to be derived from ``FormatAdapter<T>``, ``formatv``
354 ``format`` method on the argument passing in the specified style. This allows
355 one to provide custom formatting of any type, including one which already has
356 a builtin format provider.
360 Below is intended to provide an incomplete set of examples demonstrating
361 the usage of ``formatv``. More information can be found by reading the
362 doxygen documentation or by looking at the unit test suite.
368 // Simple formatting of basic types and implicit string conversion.
369 S = formatv("{0} ({1:P})", 7, 0.35); // S == "7 (35.00%)"
371 // Out-of-order referencing and multi-referencing
372 outs() << formatv("{0} {2} {1} {0}", 1, "test", 3); // prints "1 3 test 1"
374 // Left, right, and center alignment
375 S = formatv("{0,7}", 'a'); // S == " a";
376 S = formatv("{0,-7}", 'a'); // S == "a ";
377 S = formatv("{0,=7}", 'a'); // S == " a ";
378 S = formatv("{0,+7}", 'a'); // S == " a";
381 S = formatv("{0:N} - {0:x} - {1:E}", 12345, 123908342); // S == "12,345 - 0x3039 - 1.24E8"
384 S = formatv("{0}", fmt_align(42, AlignStyle::Center, 7)); // S == " 42 "
385 S = formatv("{0}", fmt_repeat("hi", 3)); // S == "hihihi"
386 S = formatv("{0}", fmt_pad("hi", 2, 6)); // S == " hi "
389 std::vector<int> V = {8, 9, 10};
390 S = formatv("{0}", make_range(V.begin(), V.end())); // S == "8, 9, 10"
391 S = formatv("{0:$[+]}", make_range(V.begin(), V.end())); // S == "8+9+10"
392 S = formatv("{0:$[ + ]@[x]}", make_range(V.begin(), V.end())); // S == "0x8 + 0x9 + 0xA"
399 Proper error handling helps us identify bugs in our code, and helps end-users
400 understand errors in their tool usage. Errors fall into two broad categories:
401 *programmatic* and *recoverable*, with different strategies for handling and
407 Programmatic errors are violations of program invariants or API contracts, and
408 represent bugs within the program itself. Our aim is to document invariants, and
409 to abort quickly at the point of failure (providing some basic diagnostic) when
410 invariants are broken at runtime.
412 The fundamental tools for handling programmatic errors are assertions and the
413 llvm_unreachable function. Assertions are used to express invariant conditions,
414 and should include a message describing the invariant:
418 assert(isPhysReg(R) && "All virt regs should have been allocated already.");
420 The llvm_unreachable function can be used to document areas of control flow
421 that should never be entered if the program invariants hold:
425 enum { Foo, Bar, Baz } X = foo();
428 case Foo: /* Handle Foo */; break;
429 case Bar: /* Handle Bar */; break;
431 llvm_unreachable("X should be Foo or Bar here");
437 Recoverable errors represent an error in the program's environment, for example
438 a resource failure (a missing file, a dropped network connection, etc.), or
439 malformed input. These errors should be detected and communicated to a level of
440 the program where they can be handled appropriately. Handling the error may be
441 as simple as reporting the issue to the user, or it may involve attempts at
446 While it would be ideal to use this error handling scheme throughout
447 LLVM, there are places where this hasn't been practical to apply. In
448 situations where you absolutely must emit a non-programmatic error and
449 the ``Error`` model isn't workable you can call ``report_fatal_error``,
450 which will call installed error handlers, print a message, and exit the
453 Recoverable errors are modeled using LLVM's ``Error`` scheme. This scheme
454 represents errors using function return values, similar to classic C integer
455 error codes, or C++'s ``std::error_code``. However, the ``Error`` class is
456 actually a lightweight wrapper for user-defined error types, allowing arbitrary
457 information to be attached to describe the error. This is similar to the way C++
458 exceptions allow throwing of user-defined types.
460 Success values are created by calling ``Error::success()``, E.g.:
467 return Error::success();
470 Success values are very cheap to construct and return - they have minimal
471 impact on program performance.
473 Failure values are constructed using ``make_error<T>``, where ``T`` is any class
474 that inherits from the ErrorInfo utility, E.g.:
478 class BadFileFormat : public ErrorInfo<BadFileFormat> {
483 BadFileFormat(StringRef Path) : Path(Path.str()) {}
485 void log(raw_ostream &OS) const override {
486 OS << Path << " is malformed";
489 std::error_code convertToErrorCode() const override {
490 return make_error_code(object_error::parse_failed);
494 char BadFileFormat::ID; // This should be declared in the C++ file.
496 Error printFormattedFile(StringRef Path) {
497 if (<check for valid format>)
498 return make_error<BadFileFormat>(Path);
499 // print file contents.
500 return Error::success();
503 Error values can be implicitly converted to bool: true for error, false for
504 success, enabling the following idiom:
511 if (auto Err = mayFail())
513 // Success! We can proceed.
516 For functions that can fail but need to return a value the ``Expected<T>``
517 utility can be used. Values of this type can be constructed with either a
518 ``T``, or an ``Error``. Expected<T> values are also implicitly convertible to
519 boolean, but with the opposite convention to ``Error``: true for success, false
520 for error. If success, the ``T`` value can be accessed via the dereference
521 operator. If failure, the ``Error`` value can be extracted using the
522 ``takeError()`` method. Idiomatic usage looks like:
526 Expected<FormattedFile> openFormattedFile(StringRef Path) {
527 // If badly formatted, return an error.
528 if (auto Err = checkFormat(Path))
529 return std::move(Err);
530 // Otherwise return a FormattedFile instance.
531 return FormattedFile(Path);
534 Error processFormattedFile(StringRef Path) {
535 // Try to open a formatted file
536 if (auto FileOrErr = openFormattedFile(Path)) {
537 // On success, grab a reference to the file and continue.
538 auto &File = *FileOrErr;
541 // On error, extract the Error value and return it.
542 return FileOrErr.takeError();
545 If an ``Expected<T>`` value is in success mode then the ``takeError()`` method
546 will return a success value. Using this fact, the above function can be
551 Error processFormattedFile(StringRef Path) {
552 // Try to open a formatted file
553 auto FileOrErr = openFormattedFile(Path);
554 if (auto Err = FileOrErr.takeError())
555 // On error, extract the Error value and return it.
557 // On success, grab a reference to the file and continue.
558 auto &File = *FileOrErr;
562 This second form is often more readable for functions that involve multiple
563 ``Expected<T>`` values as it limits the indentation required.
565 All ``Error`` instances, whether success or failure, must be either checked or
566 moved from (via ``std::move`` or a return) before they are destructed.
567 Accidentally discarding an unchecked error will cause a program abort at the
568 point where the unchecked value's destructor is run, making it easy to identify
569 and fix violations of this rule.
571 Success values are considered checked once they have been tested (by invoking
572 the boolean conversion operator):
576 if (auto Err = mayFail(...))
577 return Err; // Failure value - move error to caller.
579 // Safe to continue: Err was checked.
581 In contrast, the following code will always cause an abort, even if ``mayFail``
582 returns a success value:
587 // Program will always abort here, even if mayFail() returns Success, since
588 // the value is not checked.
590 Failure values are considered checked once a handler for the error type has
596 processFormattedFile(...),
597 [](const BadFileFormat &BFF) {
598 report("Unable to process " + BFF.Path + ": bad format");
600 [](const FileNotFound &FNF) {
601 report("File not found " + FNF.Path);
604 The ``handleErrors`` function takes an error as its first argument, followed by
605 a variadic list of "handlers", each of which must be a callable type (a
606 function, lambda, or class with a call operator) with one argument. The
607 ``handleErrors`` function will visit each handler in the sequence and check its
608 argument type against the dynamic type of the error, running the first handler
609 that matches. This is the same decision process that is used decide which catch
610 clause to run for a C++ exception.
612 Since the list of handlers passed to ``handleErrors`` may not cover every error
613 type that can occur, the ``handleErrors`` function also returns an Error value
614 that must be checked or propagated. If the error value that is passed to
615 ``handleErrors`` does not match any of the handlers it will be returned from
616 handleErrors. Idiomatic use of ``handleErrors`` thus looks like:
622 processFormattedFile(...),
623 [](const BadFileFormat &BFF) {
624 report("Unable to process " + BFF.Path + ": bad format");
626 [](const FileNotFound &FNF) {
627 report("File not found " + FNF.Path);
631 In cases where you truly know that the handler list is exhaustive the
632 ``handleAllErrors`` function can be used instead. This is identical to
633 ``handleErrors`` except that it will terminate the program if an unhandled
634 error is passed in, and can therefore return void. The ``handleAllErrors``
635 function should generally be avoided: the introduction of a new error type
636 elsewhere in the program can easily turn a formerly exhaustive list of errors
637 into a non-exhaustive list, risking unexpected program termination. Where
638 possible, use handleErrors and propagate unknown errors up the stack instead.
640 For tool code, where errors can be handled by printing an error message then
641 exiting with an error code, the :ref:`ExitOnError <err_exitonerr>` utility
642 may be a better choice than handleErrors, as it simplifies control flow when
643 calling fallible functions.
645 In situations where it is known that a particular call to a fallible function
646 will always succeed (for example, a call to a function that can only fail on a
647 subset of inputs with an input that is known to be safe) the
648 :ref:`cantFail <err_cantfail>` functions can be used to remove the error type,
649 simplifying control flow.
654 Many kinds of errors have no recovery strategy, the only action that can be
655 taken is to report them to the user so that the user can attempt to fix the
656 environment. In this case representing the error as a string makes perfect
657 sense. LLVM provides the ``StringError`` class for this purpose. It takes two
658 arguments: A string error message, and an equivalent ``std::error_code`` for
663 make_error<StringError>("Bad executable",
664 make_error_code(errc::executable_format_error"));
666 If you're certain that the error you're building will never need to be converted
667 to a ``std::error_code`` you can use the ``inconvertibleErrorCode()`` function:
671 make_error<StringError>("Bad executable", inconvertibleErrorCode());
673 This should be done only after careful consideration. If any attempt is made to
674 convert this error to a ``std::error_code`` it will trigger immediate program
675 termination. Unless you are certain that your errors will not need
676 interoperability you should look for an existing ``std::error_code`` that you
677 can convert to, and even (as painful as it is) consider introducing a new one as
680 Interoperability with std::error_code and ErrorOr
681 """""""""""""""""""""""""""""""""""""""""""""""""
683 Many existing LLVM APIs use ``std::error_code`` and its partner ``ErrorOr<T>``
684 (which plays the same role as ``Expected<T>``, but wraps a ``std::error_code``
685 rather than an ``Error``). The infectious nature of error types means that an
686 attempt to change one of these functions to return ``Error`` or ``Expected<T>``
687 instead often results in an avalanche of changes to callers, callers of callers,
688 and so on. (The first such attempt, returning an ``Error`` from
689 MachOObjectFile's constructor, was abandoned after the diff reached 3000 lines,
690 impacted half a dozen libraries, and was still growing).
692 To solve this problem, the ``Error``/``std::error_code`` interoperability requirement was
693 introduced. Two pairs of functions allow any ``Error`` value to be converted to a
694 ``std::error_code``, any ``Expected<T>`` to be converted to an ``ErrorOr<T>``, and vice
699 std::error_code errorToErrorCode(Error Err);
700 Error errorCodeToError(std::error_code EC);
702 template <typename T> ErrorOr<T> expectedToErrorOr(Expected<T> TOrErr);
703 template <typename T> Expected<T> errorOrToExpected(ErrorOr<T> TOrEC);
706 Using these APIs it is easy to make surgical patches that update individual
707 functions from ``std::error_code`` to ``Error``, and from ``ErrorOr<T>`` to
710 Returning Errors from error handlers
711 """"""""""""""""""""""""""""""""""""
713 Error recovery attempts may themselves fail. For that reason, ``handleErrors``
714 actually recognises three different forms of handler signature:
718 // Error must be handled, no new errors produced:
719 void(UserDefinedError &E);
721 // Error must be handled, new errors can be produced:
722 Error(UserDefinedError &E);
724 // Original error can be inspected, then re-wrapped and returned (or a new
725 // error can be produced):
726 Error(std::unique_ptr<UserDefinedError> E);
728 Any error returned from a handler will be returned from the ``handleErrors``
729 function so that it can be handled itself, or propagated up the stack.
733 Using ExitOnError to simplify tool code
734 """""""""""""""""""""""""""""""""""""""
736 Library code should never call ``exit`` for a recoverable error, however in tool
737 code (especially command line tools) this can be a reasonable approach. Calling
738 ``exit`` upon encountering an error dramatically simplifies control flow as the
739 error no longer needs to be propagated up the stack. This allows code to be
740 written in straight-line style, as long as each fallible call is wrapped in a
741 check and call to exit. The ``ExitOnError`` class supports this pattern by
742 providing call operators that inspect ``Error`` values, stripping the error away
743 in the success case and logging to ``stderr`` then exiting in the failure case.
745 To use this class, declare a global ``ExitOnError`` variable in your program:
749 ExitOnError ExitOnErr;
751 Calls to fallible functions can then be wrapped with a call to ``ExitOnErr``,
752 turning them into non-failing calls:
757 Expected<int> mayFail2();
760 ExitOnErr(mayFail());
761 int X = ExitOnErr(mayFail2());
764 On failure, the error's log message will be written to ``stderr``, optionally
765 preceded by a string "banner" that can be set by calling the setBanner method. A
766 mapping can also be supplied from ``Error`` values to exit codes using the
767 ``setExitCodeMapper`` method:
771 int main(int argc, char *argv[]) {
772 ExitOnErr.setBanner(std::string(argv[0]) + " error:");
773 ExitOnErr.setExitCodeMapper(
774 [](const Error &Err) {
775 if (Err.isA<BadFileFormat>())
780 Use ``ExitOnError`` in your tool code where possible as it can greatly improve
785 Using cantFail to simplify safe callsites
786 """""""""""""""""""""""""""""""""""""""""
788 Some functions may only fail for a subset of their inputs, so calls using known
789 safe inputs can be assumed to succeed.
791 The cantFail functions encapsulate this by wrapping an assertion that their
792 argument is a success value and, in the case of Expected<T>, unwrapping the
797 Error onlyFailsForSomeXValues(int X);
798 Expected<int> onlyFailsForSomeXValues2(int X);
801 cantFail(onlyFailsForSomeXValues(KnownSafeValue));
802 int Y = cantFail(onlyFailsForSomeXValues2(KnownSafeValue));
806 Like the ExitOnError utility, cantFail simplifies control flow. Their treatment
807 of error cases is very different however: Where ExitOnError is guaranteed to
808 terminate the program on an error input, cantFile simply asserts that the result
809 is success. In debug builds this will result in an assertion failure if an error
810 is encountered. In release builds the behavior of cantFail for failure values is
811 undefined. As such, care must be taken in the use of cantFail: clients must be
812 certain that a cantFail wrapped call really can not fail with the given
815 Use of the cantFail functions should be rare in library code, but they are
816 likely to be of more use in tool and unit-test code where inputs and/or
817 mocked-up classes or functions may be known to be safe.
819 Fallible constructors
820 """""""""""""""""""""
822 Some classes require resource acquisition or other complex initialization that
823 can fail during construction. Unfortunately constructors can't return errors,
824 and having clients test objects after they're constructed to ensure that they're
825 valid is error prone as it's all too easy to forget the test. To work around
826 this, use the named constructor idiom and return an ``Expected<T>``:
833 static Expected<Foo> Create(Resource R1, Resource R2) {
837 return std::move(Err);
843 Foo(Resource R1, Resource R2, Error &Err) {
844 ErrorAsOutParameter EAO(&Err);
845 if (auto Err2 = R1.acquire()) {
846 Err = std::move(Err2);
854 Here, the named constructor passes an ``Error`` by reference into the actual
855 constructor, which the constructor can then use to return errors. The
856 ``ErrorAsOutParameter`` utility sets the ``Error`` value's checked flag on entry
857 to the constructor so that the error can be assigned to, then resets it on exit
858 to force the client (the named constructor) to check the error.
860 By using this idiom, clients attempting to construct a Foo receive either a
861 well-formed Foo or an Error, never an object in an invalid state.
863 Propagating and consuming errors based on types
864 """""""""""""""""""""""""""""""""""""""""""""""
866 In some contexts, certain types of error are known to be benign. For example,
867 when walking an archive, some clients may be happy to skip over badly formatted
868 object files rather than terminating the walk immediately. Skipping badly
869 formatted objects could be achieved using an elaborate handler method, but the
870 Error.h header provides two utilities that make this idiom much cleaner: the
871 type inspection method, ``isA``, and the ``consumeError`` function:
875 Error walkArchive(Archive A) {
876 for (unsigned I = 0; I != A.numMembers(); ++I) {
877 auto ChildOrErr = A.getMember(I);
878 if (auto Err = ChildOrErr.takeError()) {
879 if (Err.isA<BadFileFormat>())
880 consumeError(std::move(Err))
884 auto &Child = *ChildOrErr;
888 return Error::success();
891 Concatenating Errors with joinErrors
892 """"""""""""""""""""""""""""""""""""
894 In the archive walking example above ``BadFileFormat`` errors are simply
895 consumed and ignored. If the client had wanted report these errors after
896 completing the walk over the archive they could use the ``joinErrors`` utility:
900 Error walkArchive(Archive A) {
901 Error DeferredErrs = Error::success();
902 for (unsigned I = 0; I != A.numMembers(); ++I) {
903 auto ChildOrErr = A.getMember(I);
904 if (auto Err = ChildOrErr.takeError())
905 if (Err.isA<BadFileFormat>())
906 DeferredErrs = joinErrors(std::move(DeferredErrs), std::move(Err));
909 auto &Child = *ChildOrErr;
916 The ``joinErrors`` routine builds a special error type called ``ErrorList``,
917 which holds a list of user defined errors. The ``handleErrors`` routine
918 recognizes this type and will attempt to handle each of the contained errors in
919 order. If all contained errors can be handled, ``handleErrors`` will return
920 ``Error::success()``, otherwise ``handleErrors`` will concatenate the remaining
921 errors and return the resulting ``ErrorList``.
923 Building fallible iterators and iterator ranges
924 """""""""""""""""""""""""""""""""""""""""""""""
926 The archive walking examples above retrieve archive members by index, however
927 this requires considerable boiler-plate for iteration and error checking. We can
928 clean this up by using ``Error`` with the "fallible iterator" pattern. The usual
929 C++ iterator patterns do not allow for failure on increment, but we can
930 incorporate support for it by having iterators hold an Error reference through
931 which they can report failure. In this pattern, if an increment operation fails
932 the failure is recorded via the Error reference and the iterator value is set to
933 the end of the range in order to terminate the loop. This ensures that the
934 dereference operation is safe anywhere that an ordinary iterator dereference
935 would be safe (i.e. when the iterator is not equal to end). Where this pattern
936 is followed (as in the ``llvm::object::Archive`` class) the result is much
937 cleaner iteration idiom:
942 for (auto &Child : Ar->children(Err)) {
943 // Use Child - we only enter the loop when it's valid
946 // Check Err after the loop to ensure it didn't break due to an error.
952 More information on Error and its related utilities can be found in the
955 Passing functions and other callable objects
956 --------------------------------------------
958 Sometimes you may want a function to be passed a callback object. In order to
959 support lambda expressions and other function objects, you should not use the
960 traditional C approach of taking a function pointer and an opaque cookie:
964 void takeCallback(bool (*Callback)(Function *, void *), void *Cookie);
966 Instead, use one of the following approaches:
971 If you don't mind putting the definition of your function into a header file,
972 make it a function template that is templated on the callable type.
976 template<typename Callable>
977 void takeCallback(Callable Callback) {
981 The ``function_ref`` class template
982 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
985 (`doxygen <http://llvm.org/doxygen/classllvm_1_1function__ref_3_01Ret_07Params_8_8_8_08_4.html>`__) class
986 template represents a reference to a callable object, templated over the type
987 of the callable. This is a good choice for passing a callback to a function,
988 if you don't need to hold onto the callback after the function returns. In this
989 way, ``function_ref`` is to ``std::function`` as ``StringRef`` is to
992 ``function_ref<Ret(Param1, Param2, ...)>`` can be implicitly constructed from
993 any callable object that can be called with arguments of type ``Param1``,
994 ``Param2``, ..., and returns a value that can be converted to type ``Ret``.
999 void visitBasicBlocks(Function *F, function_ref<bool (BasicBlock*)> Callback) {
1000 for (BasicBlock &BB : *F)
1005 can be called using:
1009 visitBasicBlocks(F, [&](BasicBlock *BB) {
1015 Note that a ``function_ref`` object contains pointers to external memory, so it
1016 is not generally safe to store an instance of the class (unless you know that
1017 the external storage will not be freed). If you need this ability, consider
1018 using ``std::function``. ``function_ref`` is small enough that it should always
1023 The ``DEBUG()`` macro and ``-debug`` option
1024 -------------------------------------------
1026 Often when working on your pass you will put a bunch of debugging printouts and
1027 other code into your pass. After you get it working, you want to remove it, but
1028 you may need it again in the future (to work out new bugs that you run across).
1030 Naturally, because of this, you don't want to delete the debug printouts, but
1031 you don't want them to always be noisy. A standard compromise is to comment
1032 them out, allowing you to enable them if you need them in the future.
1034 The ``llvm/Support/Debug.h`` (`doxygen
1035 <http://llvm.org/doxygen/Debug_8h_source.html>`__) file provides a macro named
1036 ``DEBUG()`` that is a much nicer solution to this problem. Basically, you can
1037 put arbitrary code into the argument of the ``DEBUG`` macro, and it is only
1038 executed if '``opt``' (or any other tool) is run with the '``-debug``' command
1043 DEBUG(dbgs() << "I am here!\n");
1045 Then you can run your pass like this:
1047 .. code-block:: none
1049 $ opt < a.bc > /dev/null -mypass
1051 $ opt < a.bc > /dev/null -mypass -debug
1054 Using the ``DEBUG()`` macro instead of a home-brewed solution allows you to not
1055 have to create "yet another" command line option for the debug output for your
1056 pass. Note that ``DEBUG()`` macros are disabled for non-asserts builds, so they
1057 do not cause a performance impact at all (for the same reason, they should also
1058 not contain side-effects!).
1060 One additional nice thing about the ``DEBUG()`` macro is that you can enable or
1061 disable it directly in gdb. Just use "``set DebugFlag=0``" or "``set
1062 DebugFlag=1``" from the gdb if the program is running. If the program hasn't
1063 been started yet, you can always just run it with ``-debug``.
1067 Fine grained debug info with ``DEBUG_TYPE`` and the ``-debug-only`` option
1068 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1070 Sometimes you may find yourself in a situation where enabling ``-debug`` just
1071 turns on **too much** information (such as when working on the code generator).
1072 If you want to enable debug information with more fine-grained control, you
1073 should define the ``DEBUG_TYPE`` macro and use the ``-debug-only`` option as
1078 #define DEBUG_TYPE "foo"
1079 DEBUG(dbgs() << "'foo' debug type\n");
1081 #define DEBUG_TYPE "bar"
1082 DEBUG(dbgs() << "'bar' debug type\n");
1085 Then you can run your pass like this:
1087 .. code-block:: none
1089 $ opt < a.bc > /dev/null -mypass
1091 $ opt < a.bc > /dev/null -mypass -debug
1094 $ opt < a.bc > /dev/null -mypass -debug-only=foo
1096 $ opt < a.bc > /dev/null -mypass -debug-only=bar
1098 $ opt < a.bc > /dev/null -mypass -debug-only=foo,bar
1102 Of course, in practice, you should only set ``DEBUG_TYPE`` at the top of a file,
1103 to specify the debug type for the entire module. Be careful that you only do
1104 this after including Debug.h and not around any #include of headers. Also, you
1105 should use names more meaningful than "foo" and "bar", because there is no
1106 system in place to ensure that names do not conflict. If two different modules
1107 use the same string, they will all be turned on when the name is specified.
1108 This allows, for example, all debug information for instruction scheduling to be
1109 enabled with ``-debug-only=InstrSched``, even if the source lives in multiple
1110 files. The name must not include a comma (,) as that is used to separate the
1111 arguments of the ``-debug-only`` option.
1113 For performance reasons, -debug-only is not available in optimized build
1114 (``--enable-optimized``) of LLVM.
1116 The ``DEBUG_WITH_TYPE`` macro is also available for situations where you would
1117 like to set ``DEBUG_TYPE``, but only for one specific ``DEBUG`` statement. It
1118 takes an additional first parameter, which is the type to use. For example, the
1119 preceding example could be written as:
1123 DEBUG_WITH_TYPE("foo", dbgs() << "'foo' debug type\n");
1124 DEBUG_WITH_TYPE("bar", dbgs() << "'bar' debug type\n");
1128 The ``Statistic`` class & ``-stats`` option
1129 -------------------------------------------
1131 The ``llvm/ADT/Statistic.h`` (`doxygen
1132 <http://llvm.org/doxygen/Statistic_8h_source.html>`__) file provides a class
1133 named ``Statistic`` that is used as a unified way to keep track of what the LLVM
1134 compiler is doing and how effective various optimizations are. It is useful to
1135 see what optimizations are contributing to making a particular program run
1138 Often you may run your pass on some big program, and you're interested to see
1139 how many times it makes a certain transformation. Although you can do this with
1140 hand inspection, or some ad-hoc method, this is a real pain and not very useful
1141 for big programs. Using the ``Statistic`` class makes it very easy to keep
1142 track of this information, and the calculated information is presented in a
1143 uniform manner with the rest of the passes being executed.
1145 There are many examples of ``Statistic`` uses, but the basics of using it are as
1148 Define your statistic like this:
1152 #define DEBUG_TYPE "mypassname" // This goes before any #includes.
1153 STATISTIC(NumXForms, "The # of times I did stuff");
1155 The ``STATISTIC`` macro defines a static variable, whose name is specified by
1156 the first argument. The pass name is taken from the ``DEBUG_TYPE`` macro, and
1157 the description is taken from the second argument. The variable defined
1158 ("NumXForms" in this case) acts like an unsigned integer.
1160 Whenever you make a transformation, bump the counter:
1164 ++NumXForms; // I did stuff!
1166 That's all you have to do. To get '``opt``' to print out the statistics
1167 gathered, use the '``-stats``' option:
1169 .. code-block:: none
1171 $ opt -stats -mypassname < program.bc > /dev/null
1172 ... statistics output ...
1174 Note that in order to use the '``-stats``' option, LLVM must be
1175 compiled with assertions enabled.
1177 When running ``opt`` on a C file from the SPEC benchmark suite, it gives a
1178 report that looks like this:
1180 .. code-block:: none
1182 7646 bitcodewriter - Number of normal instructions
1183 725 bitcodewriter - Number of oversized instructions
1184 129996 bitcodewriter - Number of bitcode bytes written
1185 2817 raise - Number of insts DCEd or constprop'd
1186 3213 raise - Number of cast-of-self removed
1187 5046 raise - Number of expression trees converted
1188 75 raise - Number of other getelementptr's formed
1189 138 raise - Number of load/store peepholes
1190 42 deadtypeelim - Number of unused typenames removed from symtab
1191 392 funcresolve - Number of varargs functions resolved
1192 27 globaldce - Number of global variables removed
1193 2 adce - Number of basic blocks removed
1194 134 cee - Number of branches revectored
1195 49 cee - Number of setcc instruction eliminated
1196 532 gcse - Number of loads removed
1197 2919 gcse - Number of instructions removed
1198 86 indvars - Number of canonical indvars added
1199 87 indvars - Number of aux indvars removed
1200 25 instcombine - Number of dead inst eliminate
1201 434 instcombine - Number of insts combined
1202 248 licm - Number of load insts hoisted
1203 1298 licm - Number of insts hoisted to a loop pre-header
1204 3 licm - Number of insts hoisted to multiple loop preds (bad, no loop pre-header)
1205 75 mem2reg - Number of alloca's promoted
1206 1444 cfgsimplify - Number of blocks simplified
1208 Obviously, with so many optimizations, having a unified framework for this stuff
1209 is very nice. Making your pass fit well into the framework makes it more
1210 maintainable and useful.
1214 Adding debug counters to aid in debugging your code
1215 ---------------------------------------------------
1217 Sometimes, when writing new passes, or trying to track down bugs, it
1218 is useful to be able to control whether certain things in your pass
1219 happen or not. For example, there are times the minimization tooling
1220 can only easily give you large testcases. You would like to narrow
1221 your bug down to a specific transformation happening or not happening,
1222 automatically, using bisection. This is where debug counters help.
1223 They provide a framework for making parts of your code only execute a
1224 certain number of times.
1226 The ``llvm/Support/DebugCounter.h`` (`doxygen
1227 <http://llvm.org/doxygen/DebugCounter_8h_source.html>`__) file
1228 provides a class named ``DebugCounter`` that can be used to create
1229 command line counter options that control execution of parts of your code.
1231 Define your DebugCounter like this:
1235 DEBUG_COUNTER(DeleteAnInstruction, "passname-delete-instruction",
1236 "Controls which instructions get delete");
1238 The ``DEBUG_COUNTER`` macro defines a static variable, whose name
1239 is specified by the first argument. The name of the counter
1240 (which is used on the command line) is specified by the second
1241 argument, and the description used in the help is specified by the
1244 Whatever code you want that control, use ``DebugCounter::shouldExecute`` to control it.
1248 if (DebugCounter::shouldExecute(DeleteAnInstruction))
1249 I->eraseFromParent();
1251 That's all you have to do. Now, using opt, you can control when this code triggers using
1252 the '``--debug-counter``' option. There are two counters provided, ``skip`` and ``count``.
1253 ``skip`` is the number of times to skip execution of the codepath. ``count`` is the number
1254 of times, once we are done skipping, to execute the codepath.
1256 .. code-block:: none
1258 $ opt --debug-counter=passname-delete-instruction-skip=1,passname-delete-instruction-count=2 -passname
1260 This will skip the above code the first time we hit it, then execute it twice, then skip the rest of the executions.
1262 So if executed on the following code:
1264 .. code-block:: llvm
1271 It would delete number ``%2`` and ``%3``.
1273 A utility is provided in `utils/bisect-skip-count` to binary search
1274 skip and count arguments. It can be used to automatically minimize the
1275 skip and count for a debug-counter variable.
1279 Viewing graphs while debugging code
1280 -----------------------------------
1282 Several of the important data structures in LLVM are graphs: for example CFGs
1283 made out of LLVM :ref:`BasicBlocks <BasicBlock>`, CFGs made out of LLVM
1284 :ref:`MachineBasicBlocks <MachineBasicBlock>`, and :ref:`Instruction Selection
1285 DAGs <SelectionDAG>`. In many cases, while debugging various parts of the
1286 compiler, it is nice to instantly visualize these graphs.
1288 LLVM provides several callbacks that are available in a debug build to do
1289 exactly that. If you call the ``Function::viewCFG()`` method, for example, the
1290 current LLVM tool will pop up a window containing the CFG for the function where
1291 each basic block is a node in the graph, and each node contains the instructions
1292 in the block. Similarly, there also exists ``Function::viewCFGOnly()`` (does
1293 not include the instructions), the ``MachineFunction::viewCFG()`` and
1294 ``MachineFunction::viewCFGOnly()``, and the ``SelectionDAG::viewGraph()``
1295 methods. Within GDB, for example, you can usually use something like ``call
1296 DAG.viewGraph()`` to pop up a window. Alternatively, you can sprinkle calls to
1297 these functions in your code in places you want to debug.
1299 Getting this to work requires a small amount of setup. On Unix systems
1300 with X11, install the `graphviz <http://www.graphviz.org>`_ toolkit, and make
1301 sure 'dot' and 'gv' are in your path. If you are running on Mac OS X, download
1302 and install the Mac OS X `Graphviz program
1303 <http://www.pixelglow.com/graphviz/>`_ and add
1304 ``/Applications/Graphviz.app/Contents/MacOS/`` (or wherever you install it) to
1305 your path. The programs need not be present when configuring, building or
1306 running LLVM and can simply be installed when needed during an active debug
1309 ``SelectionDAG`` has been extended to make it easier to locate *interesting*
1310 nodes in large complex graphs. From gdb, if you ``call DAG.setGraphColor(node,
1311 "color")``, then the next ``call DAG.viewGraph()`` would highlight the node in
1312 the specified color (choices of colors can be found at `colors
1313 <http://www.graphviz.org/doc/info/colors.html>`_.) More complex node attributes
1314 can be provided with ``call DAG.setGraphAttrs(node, "attributes")`` (choices can
1315 be found at `Graph attributes <http://www.graphviz.org/doc/info/attrs.html>`_.)
1316 If you want to restart and clear all the current graph attributes, then you can
1317 ``call DAG.clearGraphAttrs()``.
1319 Note that graph visualization features are compiled out of Release builds to
1320 reduce file size. This means that you need a Debug+Asserts or Release+Asserts
1321 build to use these features.
1325 Picking the Right Data Structure for a Task
1326 ===========================================
1328 LLVM has a plethora of data structures in the ``llvm/ADT/`` directory, and we
1329 commonly use STL data structures. This section describes the trade-offs you
1330 should consider when you pick one.
1332 The first step is a choose your own adventure: do you want a sequential
1333 container, a set-like container, or a map-like container? The most important
1334 thing when choosing a container is the algorithmic properties of how you plan to
1335 access the container. Based on that, you should use:
1338 * a :ref:`map-like <ds_map>` container if you need efficient look-up of a
1339 value based on another value. Map-like containers also support efficient
1340 queries for containment (whether a key is in the map). Map-like containers
1341 generally do not support efficient reverse mapping (values to keys). If you
1342 need that, use two maps. Some map-like containers also support efficient
1343 iteration through the keys in sorted order. Map-like containers are the most
1344 expensive sort, only use them if you need one of these capabilities.
1346 * a :ref:`set-like <ds_set>` container if you need to put a bunch of stuff into
1347 a container that automatically eliminates duplicates. Some set-like
1348 containers support efficient iteration through the elements in sorted order.
1349 Set-like containers are more expensive than sequential containers.
1351 * a :ref:`sequential <ds_sequential>` container provides the most efficient way
1352 to add elements and keeps track of the order they are added to the collection.
1353 They permit duplicates and support efficient iteration, but do not support
1354 efficient look-up based on a key.
1356 * a :ref:`string <ds_string>` container is a specialized sequential container or
1357 reference structure that is used for character or byte arrays.
1359 * a :ref:`bit <ds_bit>` container provides an efficient way to store and
1360 perform set operations on sets of numeric id's, while automatically
1361 eliminating duplicates. Bit containers require a maximum of 1 bit for each
1362 identifier you want to store.
1364 Once the proper category of container is determined, you can fine tune the
1365 memory use, constant factors, and cache behaviors of access by intelligently
1366 picking a member of the category. Note that constant factors and cache behavior
1367 can be a big deal. If you have a vector that usually only contains a few
1368 elements (but could contain many), for example, it's much better to use
1369 :ref:`SmallVector <dss_smallvector>` than :ref:`vector <dss_vector>`. Doing so
1370 avoids (relatively) expensive malloc/free calls, which dwarf the cost of adding
1371 the elements to the container.
1375 Sequential Containers (std::vector, std::list, etc)
1376 ---------------------------------------------------
1378 There are a variety of sequential containers available for you, based on your
1379 needs. Pick the first in this section that will do what you want.
1386 The ``llvm::ArrayRef`` class is the preferred class to use in an interface that
1387 accepts a sequential list of elements in memory and just reads from them. By
1388 taking an ``ArrayRef``, the API can be passed a fixed size array, an
1389 ``std::vector``, an ``llvm::SmallVector`` and anything else that is contiguous
1392 .. _dss_fixedarrays:
1397 Fixed size arrays are very simple and very fast. They are good if you know
1398 exactly how many elements you have, or you have a (low) upper bound on how many
1403 Heap Allocated Arrays
1404 ^^^^^^^^^^^^^^^^^^^^^
1406 Heap allocated arrays (``new[]`` + ``delete[]``) are also simple. They are good
1407 if the number of elements is variable, if you know how many elements you will
1408 need before the array is allocated, and if the array is usually large (if not,
1409 consider a :ref:`SmallVector <dss_smallvector>`). The cost of a heap allocated
1410 array is the cost of the new/delete (aka malloc/free). Also note that if you
1411 are allocating an array of a type with a constructor, the constructor and
1412 destructors will be run for every element in the array (re-sizable vectors only
1413 construct those elements actually used).
1415 .. _dss_tinyptrvector:
1417 llvm/ADT/TinyPtrVector.h
1418 ^^^^^^^^^^^^^^^^^^^^^^^^
1420 ``TinyPtrVector<Type>`` is a highly specialized collection class that is
1421 optimized to avoid allocation in the case when a vector has zero or one
1422 elements. It has two major restrictions: 1) it can only hold values of pointer
1423 type, and 2) it cannot hold a null pointer.
1425 Since this container is highly specialized, it is rarely used.
1427 .. _dss_smallvector:
1429 llvm/ADT/SmallVector.h
1430 ^^^^^^^^^^^^^^^^^^^^^^
1432 ``SmallVector<Type, N>`` is a simple class that looks and smells just like
1433 ``vector<Type>``: it supports efficient iteration, lays out elements in memory
1434 order (so you can do pointer arithmetic between elements), supports efficient
1435 push_back/pop_back operations, supports efficient random access to its elements,
1438 The advantage of SmallVector is that it allocates space for some number of
1439 elements (N) **in the object itself**. Because of this, if the SmallVector is
1440 dynamically smaller than N, no malloc is performed. This can be a big win in
1441 cases where the malloc/free call is far more expensive than the code that
1442 fiddles around with the elements.
1444 This is good for vectors that are "usually small" (e.g. the number of
1445 predecessors/successors of a block is usually less than 8). On the other hand,
1446 this makes the size of the SmallVector itself large, so you don't want to
1447 allocate lots of them (doing so will waste a lot of space). As such,
1448 SmallVectors are most useful when on the stack.
1450 SmallVector also provides a nice portable and efficient replacement for
1455 Prefer to use ``SmallVectorImpl<T>`` as a parameter type.
1457 In APIs that don't care about the "small size" (most?), prefer to use
1458 the ``SmallVectorImpl<T>`` class, which is basically just the "vector
1459 header" (and methods) without the elements allocated after it. Note that
1460 ``SmallVector<T, N>`` inherits from ``SmallVectorImpl<T>`` so the
1461 conversion is implicit and costs nothing. E.g.
1465 // BAD: Clients cannot pass e.g. SmallVector<Foo, 4>.
1466 hardcodedSmallSize(SmallVector<Foo, 2> &Out);
1467 // GOOD: Clients can pass any SmallVector<Foo, N>.
1468 allowsAnySmallSize(SmallVectorImpl<Foo> &Out);
1471 SmallVector<Foo, 8> Vec;
1472 hardcodedSmallSize(Vec); // Error.
1473 allowsAnySmallSize(Vec); // Works.
1476 Even though it has "``Impl``" in the name, this is so widely used that
1477 it really isn't "private to the implementation" anymore. A name like
1478 ``SmallVectorHeader`` would be more appropriate.
1485 ``std::vector`` is well loved and respected. It is useful when SmallVector
1486 isn't: when the size of the vector is often large (thus the small optimization
1487 will rarely be a benefit) or if you will be allocating many instances of the
1488 vector itself (which would waste space for elements that aren't in the
1489 container). vector is also useful when interfacing with code that expects
1492 One worthwhile note about std::vector: avoid code like this:
1501 Instead, write this as:
1511 Doing so will save (at least) one heap allocation and free per iteration of the
1519 ``std::deque`` is, in some senses, a generalized version of ``std::vector``.
1520 Like ``std::vector``, it provides constant time random access and other similar
1521 properties, but it also provides efficient access to the front of the list. It
1522 does not guarantee continuity of elements within memory.
1524 In exchange for this extra flexibility, ``std::deque`` has significantly higher
1525 constant factor costs than ``std::vector``. If possible, use ``std::vector`` or
1533 ``std::list`` is an extremely inefficient class that is rarely useful. It
1534 performs a heap allocation for every element inserted into it, thus having an
1535 extremely high constant factor, particularly for small data types.
1536 ``std::list`` also only supports bidirectional iteration, not random access
1539 In exchange for this high cost, std::list supports efficient access to both ends
1540 of the list (like ``std::deque``, but unlike ``std::vector`` or
1541 ``SmallVector``). In addition, the iterator invalidation characteristics of
1542 std::list are stronger than that of a vector class: inserting or removing an
1543 element into the list does not invalidate iterator or pointers to other elements
1551 ``ilist<T>`` implements an 'intrusive' doubly-linked list. It is intrusive,
1552 because it requires the element to store and provide access to the prev/next
1553 pointers for the list.
1555 ``ilist`` has the same drawbacks as ``std::list``, and additionally requires an
1556 ``ilist_traits`` implementation for the element type, but it provides some novel
1557 characteristics. In particular, it can efficiently store polymorphic objects,
1558 the traits class is informed when an element is inserted or removed from the
1559 list, and ``ilist``\ s are guaranteed to support a constant-time splice
1562 These properties are exactly what we want for things like ``Instruction``\ s and
1563 basic blocks, which is why these are implemented with ``ilist``\ s.
1565 Related classes of interest are explained in the following subsections:
1567 * :ref:`ilist_traits <dss_ilist_traits>`
1569 * :ref:`iplist <dss_iplist>`
1571 * :ref:`llvm/ADT/ilist_node.h <dss_ilist_node>`
1573 * :ref:`Sentinels <dss_ilist_sentinel>`
1575 .. _dss_packedvector:
1577 llvm/ADT/PackedVector.h
1578 ^^^^^^^^^^^^^^^^^^^^^^^
1580 Useful for storing a vector of values using only a few number of bits for each
1581 value. Apart from the standard operations of a vector-like container, it can
1582 also perform an 'or' set operation.
1590 FirstCondition = 0x1,
1591 SecondCondition = 0x2,
1596 PackedVector<State, 2> Vec1;
1597 Vec1.push_back(FirstCondition);
1599 PackedVector<State, 2> Vec2;
1600 Vec2.push_back(SecondCondition);
1603 return Vec1[0]; // returns 'Both'.
1606 .. _dss_ilist_traits:
1611 ``ilist_traits<T>`` is ``ilist<T>``'s customization mechanism. ``iplist<T>``
1612 (and consequently ``ilist<T>``) publicly derive from this traits class.
1619 ``iplist<T>`` is ``ilist<T>``'s base and as such supports a slightly narrower
1620 interface. Notably, inserters from ``T&`` are absent.
1622 ``ilist_traits<T>`` is a public base of this class and can be used for a wide
1623 variety of customizations.
1627 llvm/ADT/ilist_node.h
1628 ^^^^^^^^^^^^^^^^^^^^^
1630 ``ilist_node<T>`` implements the forward and backward links that are expected
1631 by the ``ilist<T>`` (and analogous containers) in the default manner.
1633 ``ilist_node<T>``\ s are meant to be embedded in the node type ``T``, usually
1634 ``T`` publicly derives from ``ilist_node<T>``.
1636 .. _dss_ilist_sentinel:
1641 ``ilist``\ s have another specialty that must be considered. To be a good
1642 citizen in the C++ ecosystem, it needs to support the standard container
1643 operations, such as ``begin`` and ``end`` iterators, etc. Also, the
1644 ``operator--`` must work correctly on the ``end`` iterator in the case of
1645 non-empty ``ilist``\ s.
1647 The only sensible solution to this problem is to allocate a so-called *sentinel*
1648 along with the intrusive list, which serves as the ``end`` iterator, providing
1649 the back-link to the last element. However conforming to the C++ convention it
1650 is illegal to ``operator++`` beyond the sentinel and it also must not be
1653 These constraints allow for some implementation freedom to the ``ilist`` how to
1654 allocate and store the sentinel. The corresponding policy is dictated by
1655 ``ilist_traits<T>``. By default a ``T`` gets heap-allocated whenever the need
1656 for a sentinel arises.
1658 While the default policy is sufficient in most cases, it may break down when
1659 ``T`` does not provide a default constructor. Also, in the case of many
1660 instances of ``ilist``\ s, the memory overhead of the associated sentinels is
1661 wasted. To alleviate the situation with numerous and voluminous
1662 ``T``-sentinels, sometimes a trick is employed, leading to *ghostly sentinels*.
1664 Ghostly sentinels are obtained by specially-crafted ``ilist_traits<T>`` which
1665 superpose the sentinel with the ``ilist`` instance in memory. Pointer
1666 arithmetic is used to obtain the sentinel, which is relative to the ``ilist``'s
1667 ``this`` pointer. The ``ilist`` is augmented by an extra pointer, which serves
1668 as the back-link of the sentinel. This is the only field in the ghostly
1669 sentinel which can be legally accessed.
1673 Other Sequential Container options
1674 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1676 Other STL containers are available, such as ``std::string``.
1678 There are also various STL adapter classes such as ``std::queue``,
1679 ``std::priority_queue``, ``std::stack``, etc. These provide simplified access
1680 to an underlying container but don't affect the cost of the container itself.
1684 String-like containers
1685 ----------------------
1687 There are a variety of ways to pass around and use strings in C and C++, and
1688 LLVM adds a few new options to choose from. Pick the first option on this list
1689 that will do what you need, they are ordered according to their relative cost.
1691 Note that it is generally preferred to *not* pass strings around as ``const
1692 char*``'s. These have a number of problems, including the fact that they
1693 cannot represent embedded nul ("\0") characters, and do not have a length
1694 available efficiently. The general replacement for '``const char*``' is
1697 For more information on choosing string containers for APIs, please see
1698 :ref:`Passing Strings <string_apis>`.
1702 llvm/ADT/StringRef.h
1703 ^^^^^^^^^^^^^^^^^^^^
1705 The StringRef class is a simple value class that contains a pointer to a
1706 character and a length, and is quite related to the :ref:`ArrayRef
1707 <dss_arrayref>` class (but specialized for arrays of characters). Because
1708 StringRef carries a length with it, it safely handles strings with embedded nul
1709 characters in it, getting the length does not require a strlen call, and it even
1710 has very convenient APIs for slicing and dicing the character range that it
1713 StringRef is ideal for passing simple strings around that are known to be live,
1714 either because they are C string literals, std::string, a C array, or a
1715 SmallVector. Each of these cases has an efficient implicit conversion to
1716 StringRef, which doesn't result in a dynamic strlen being executed.
1718 StringRef has a few major limitations which make more powerful string containers
1721 #. You cannot directly convert a StringRef to a 'const char*' because there is
1722 no way to add a trailing nul (unlike the .c_str() method on various stronger
1725 #. StringRef doesn't own or keep alive the underlying string bytes.
1726 As such it can easily lead to dangling pointers, and is not suitable for
1727 embedding in datastructures in most cases (instead, use an std::string or
1728 something like that).
1730 #. For the same reason, StringRef cannot be used as the return value of a
1731 method if the method "computes" the result string. Instead, use std::string.
1733 #. StringRef's do not allow you to mutate the pointed-to string bytes and it
1734 doesn't allow you to insert or remove bytes from the range. For editing
1735 operations like this, it interoperates with the :ref:`Twine <dss_twine>`
1738 Because of its strengths and limitations, it is very common for a function to
1739 take a StringRef and for a method on an object to return a StringRef that points
1740 into some string that it owns.
1747 The Twine class is used as an intermediary datatype for APIs that want to take a
1748 string that can be constructed inline with a series of concatenations. Twine
1749 works by forming recursive instances of the Twine datatype (a simple value
1750 object) on the stack as temporary objects, linking them together into a tree
1751 which is then linearized when the Twine is consumed. Twine is only safe to use
1752 as the argument to a function, and should always be a const reference, e.g.:
1756 void foo(const Twine &T);
1760 foo(X + "." + Twine(i));
1762 This example forms a string like "blarg.42" by concatenating the values
1763 together, and does not form intermediate strings containing "blarg" or "blarg.".
1765 Because Twine is constructed with temporary objects on the stack, and because
1766 these instances are destroyed at the end of the current statement, it is an
1767 inherently dangerous API. For example, this simple variant contains undefined
1768 behavior and will probably crash:
1772 void foo(const Twine &T);
1776 const Twine &Tmp = X + "." + Twine(i);
1779 ... because the temporaries are destroyed before the call. That said, Twine's
1780 are much more efficient than intermediate std::string temporaries, and they work
1781 really well with StringRef. Just be aware of their limitations.
1783 .. _dss_smallstring:
1785 llvm/ADT/SmallString.h
1786 ^^^^^^^^^^^^^^^^^^^^^^
1788 SmallString is a subclass of :ref:`SmallVector <dss_smallvector>` that adds some
1789 convenience APIs like += that takes StringRef's. SmallString avoids allocating
1790 memory in the case when the preallocated space is enough to hold its data, and
1791 it calls back to general heap allocation when required. Since it owns its data,
1792 it is very safe to use and supports full mutation of the string.
1794 Like SmallVector's, the big downside to SmallString is their sizeof. While they
1795 are optimized for small strings, they themselves are not particularly small.
1796 This means that they work great for temporary scratch buffers on the stack, but
1797 should not generally be put into the heap: it is very rare to see a SmallString
1798 as the member of a frequently-allocated heap data structure or returned
1806 The standard C++ std::string class is a very general class that (like
1807 SmallString) owns its underlying data. sizeof(std::string) is very reasonable
1808 so it can be embedded into heap data structures and returned by-value. On the
1809 other hand, std::string is highly inefficient for inline editing (e.g.
1810 concatenating a bunch of stuff together) and because it is provided by the
1811 standard library, its performance characteristics depend a lot of the host
1812 standard library (e.g. libc++ and MSVC provide a highly optimized string class,
1813 GCC contains a really slow implementation).
1815 The major disadvantage of std::string is that almost every operation that makes
1816 them larger can allocate memory, which is slow. As such, it is better to use
1817 SmallVector or Twine as a scratch buffer, but then use std::string to persist
1822 Set-Like Containers (std::set, SmallSet, SetVector, etc)
1823 --------------------------------------------------------
1825 Set-like containers are useful when you need to canonicalize multiple values
1826 into a single representation. There are several different choices for how to do
1827 this, providing various trade-offs.
1829 .. _dss_sortedvectorset:
1834 If you intend to insert a lot of elements, then do a lot of queries, a great
1835 approach is to use a vector (or other sequential container) with
1836 std::sort+std::unique to remove duplicates. This approach works really well if
1837 your usage pattern has these two distinct phases (insert then query), and can be
1838 coupled with a good choice of :ref:`sequential container <ds_sequential>`.
1840 This combination provides the several nice properties: the result data is
1841 contiguous in memory (good for cache locality), has few allocations, is easy to
1842 address (iterators in the final vector are just indices or pointers), and can be
1843 efficiently queried with a standard binary search (e.g.
1844 ``std::lower_bound``; if you want the whole range of elements comparing
1845 equal, use ``std::equal_range``).
1852 If you have a set-like data structure that is usually small and whose elements
1853 are reasonably small, a ``SmallSet<Type, N>`` is a good choice. This set has
1854 space for N elements in place (thus, if the set is dynamically smaller than N,
1855 no malloc traffic is required) and accesses them with a simple linear search.
1856 When the set grows beyond N elements, it allocates a more expensive
1857 representation that guarantees efficient access (for most types, it falls back
1858 to :ref:`std::set <dss_set>`, but for pointers it uses something far better,
1859 :ref:`SmallPtrSet <dss_smallptrset>`.
1861 The magic of this class is that it handles small sets extremely efficiently, but
1862 gracefully handles extremely large sets without loss of efficiency. The
1863 drawback is that the interface is quite small: it supports insertion, queries
1864 and erasing, but does not support iteration.
1866 .. _dss_smallptrset:
1868 llvm/ADT/SmallPtrSet.h
1869 ^^^^^^^^^^^^^^^^^^^^^^
1871 ``SmallPtrSet`` has all the advantages of ``SmallSet`` (and a ``SmallSet`` of
1872 pointers is transparently implemented with a ``SmallPtrSet``), but also supports
1873 iterators. If more than N insertions are performed, a single quadratically
1874 probed hash table is allocated and grows as needed, providing extremely
1875 efficient access (constant time insertion/deleting/queries with low constant
1876 factors) and is very stingy with malloc traffic.
1878 Note that, unlike :ref:`std::set <dss_set>`, the iterators of ``SmallPtrSet``
1879 are invalidated whenever an insertion occurs. Also, the values visited by the
1880 iterators are not visited in sorted order.
1884 llvm/ADT/StringSet.h
1885 ^^^^^^^^^^^^^^^^^^^^
1887 ``StringSet`` is a thin wrapper around :ref:`StringMap\<char\> <dss_stringmap>`,
1888 and it allows efficient storage and retrieval of unique strings.
1890 Functionally analogous to ``SmallSet<StringRef>``, ``StringSet`` also supports
1891 iteration. (The iterator dereferences to a ``StringMapEntry<char>``, so you
1892 need to call ``i->getKey()`` to access the item of the StringSet.) On the
1893 other hand, ``StringSet`` doesn't support range-insertion and
1894 copy-construction, which :ref:`SmallSet <dss_smallset>` and :ref:`SmallPtrSet
1895 <dss_smallptrset>` do support.
1902 DenseSet is a simple quadratically probed hash table. It excels at supporting
1903 small values: it uses a single allocation to hold all of the pairs that are
1904 currently inserted in the set. DenseSet is a great way to unique small values
1905 that are not simple pointers (use :ref:`SmallPtrSet <dss_smallptrset>` for
1906 pointers). Note that DenseSet has the same requirements for the value type that
1907 :ref:`DenseMap <dss_densemap>` has.
1911 llvm/ADT/SparseSet.h
1912 ^^^^^^^^^^^^^^^^^^^^
1914 SparseSet holds a small number of objects identified by unsigned keys of
1915 moderate size. It uses a lot of memory, but provides operations that are almost
1916 as fast as a vector. Typical keys are physical registers, virtual registers, or
1917 numbered basic blocks.
1919 SparseSet is useful for algorithms that need very fast clear/find/insert/erase
1920 and fast iteration over small sets. It is not intended for building composite
1923 .. _dss_sparsemultiset:
1925 llvm/ADT/SparseMultiSet.h
1926 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1928 SparseMultiSet adds multiset behavior to SparseSet, while retaining SparseSet's
1929 desirable attributes. Like SparseSet, it typically uses a lot of memory, but
1930 provides operations that are almost as fast as a vector. Typical keys are
1931 physical registers, virtual registers, or numbered basic blocks.
1933 SparseMultiSet is useful for algorithms that need very fast
1934 clear/find/insert/erase of the entire collection, and iteration over sets of
1935 elements sharing a key. It is often a more efficient choice than using composite
1936 data structures (e.g. vector-of-vectors, map-of-vectors). It is not intended for
1937 building composite data structures.
1941 llvm/ADT/FoldingSet.h
1942 ^^^^^^^^^^^^^^^^^^^^^
1944 FoldingSet is an aggregate class that is really good at uniquing
1945 expensive-to-create or polymorphic objects. It is a combination of a chained
1946 hash table with intrusive links (uniqued objects are required to inherit from
1947 FoldingSetNode) that uses :ref:`SmallVector <dss_smallvector>` as part of its ID
1950 Consider a case where you want to implement a "getOrCreateFoo" method for a
1951 complex object (for example, a node in the code generator). The client has a
1952 description of **what** it wants to generate (it knows the opcode and all the
1953 operands), but we don't want to 'new' a node, then try inserting it into a set
1954 only to find out it already exists, at which point we would have to delete it
1955 and return the node that already exists.
1957 To support this style of client, FoldingSet perform a query with a
1958 FoldingSetNodeID (which wraps SmallVector) that can be used to describe the
1959 element that we want to query for. The query either returns the element
1960 matching the ID or it returns an opaque ID that indicates where insertion should
1961 take place. Construction of the ID usually does not require heap traffic.
1963 Because FoldingSet uses intrusive links, it can support polymorphic objects in
1964 the set (for example, you can have SDNode instances mixed with LoadSDNodes).
1965 Because the elements are individually allocated, pointers to the elements are
1966 stable: inserting or removing elements does not invalidate any pointers to other
1974 ``std::set`` is a reasonable all-around set class, which is decent at many
1975 things but great at nothing. std::set allocates memory for each element
1976 inserted (thus it is very malloc intensive) and typically stores three pointers
1977 per element in the set (thus adding a large amount of per-element space
1978 overhead). It offers guaranteed log(n) performance, which is not particularly
1979 fast from a complexity standpoint (particularly if the elements of the set are
1980 expensive to compare, like strings), and has extremely high constant factors for
1981 lookup, insertion and removal.
1983 The advantages of std::set are that its iterators are stable (deleting or
1984 inserting an element from the set does not affect iterators or pointers to other
1985 elements) and that iteration over the set is guaranteed to be in sorted order.
1986 If the elements in the set are large, then the relative overhead of the pointers
1987 and malloc traffic is not a big deal, but if the elements of the set are small,
1988 std::set is almost never a good choice.
1992 llvm/ADT/SetVector.h
1993 ^^^^^^^^^^^^^^^^^^^^
1995 LLVM's ``SetVector<Type>`` is an adapter class that combines your choice of a
1996 set-like container along with a :ref:`Sequential Container <ds_sequential>` The
1997 important property that this provides is efficient insertion with uniquing
1998 (duplicate elements are ignored) with iteration support. It implements this by
1999 inserting elements into both a set-like container and the sequential container,
2000 using the set-like container for uniquing and the sequential container for
2003 The difference between SetVector and other sets is that the order of iteration
2004 is guaranteed to match the order of insertion into the SetVector. This property
2005 is really important for things like sets of pointers. Because pointer values
2006 are non-deterministic (e.g. vary across runs of the program on different
2007 machines), iterating over the pointers in the set will not be in a well-defined
2010 The drawback of SetVector is that it requires twice as much space as a normal
2011 set and has the sum of constant factors from the set-like container and the
2012 sequential container that it uses. Use it **only** if you need to iterate over
2013 the elements in a deterministic order. SetVector is also expensive to delete
2014 elements out of (linear time), unless you use its "pop_back" method, which is
2017 ``SetVector`` is an adapter class that defaults to using ``std::vector`` and a
2018 size 16 ``SmallSet`` for the underlying containers, so it is quite expensive.
2019 However, ``"llvm/ADT/SetVector.h"`` also provides a ``SmallSetVector`` class,
2020 which defaults to using a ``SmallVector`` and ``SmallSet`` of a specified size.
2021 If you use this, and if your sets are dynamically smaller than ``N``, you will
2022 save a lot of heap traffic.
2024 .. _dss_uniquevector:
2026 llvm/ADT/UniqueVector.h
2027 ^^^^^^^^^^^^^^^^^^^^^^^
2029 UniqueVector is similar to :ref:`SetVector <dss_setvector>` but it retains a
2030 unique ID for each element inserted into the set. It internally contains a map
2031 and a vector, and it assigns a unique ID for each value inserted into the set.
2033 UniqueVector is very expensive: its cost is the sum of the cost of maintaining
2034 both the map and vector, it has high complexity, high constant factors, and
2035 produces a lot of malloc traffic. It should be avoided.
2037 .. _dss_immutableset:
2039 llvm/ADT/ImmutableSet.h
2040 ^^^^^^^^^^^^^^^^^^^^^^^
2042 ImmutableSet is an immutable (functional) set implementation based on an AVL
2043 tree. Adding or removing elements is done through a Factory object and results
2044 in the creation of a new ImmutableSet object. If an ImmutableSet already exists
2045 with the given contents, then the existing one is returned; equality is compared
2046 with a FoldingSetNodeID. The time and space complexity of add or remove
2047 operations is logarithmic in the size of the original set.
2049 There is no method for returning an element of the set, you can only check for
2054 Other Set-Like Container Options
2055 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
2057 The STL provides several other options, such as std::multiset and the various
2058 "hash_set" like containers (whether from C++ TR1 or from the SGI library). We
2059 never use hash_set and unordered_set because they are generally very expensive
2060 (each insertion requires a malloc) and very non-portable.
2062 std::multiset is useful if you're not interested in elimination of duplicates,
2063 but has all the drawbacks of :ref:`std::set <dss_set>`. A sorted vector
2064 (where you don't delete duplicate entries) or some other approach is almost
2069 Map-Like Containers (std::map, DenseMap, etc)
2070 ---------------------------------------------
2072 Map-like containers are useful when you want to associate data to a key. As
2073 usual, there are a lot of different ways to do this. :)
2075 .. _dss_sortedvectormap:
2080 If your usage pattern follows a strict insert-then-query approach, you can
2081 trivially use the same approach as :ref:`sorted vectors for set-like containers
2082 <dss_sortedvectorset>`. The only difference is that your query function (which
2083 uses std::lower_bound to get efficient log(n) lookup) should only compare the
2084 key, not both the key and value. This yields the same advantages as sorted
2089 llvm/ADT/StringMap.h
2090 ^^^^^^^^^^^^^^^^^^^^
2092 Strings are commonly used as keys in maps, and they are difficult to support
2093 efficiently: they are variable length, inefficient to hash and compare when
2094 long, expensive to copy, etc. StringMap is a specialized container designed to
2095 cope with these issues. It supports mapping an arbitrary range of bytes to an
2096 arbitrary other object.
2098 The StringMap implementation uses a quadratically-probed hash table, where the
2099 buckets store a pointer to the heap allocated entries (and some other stuff).
2100 The entries in the map must be heap allocated because the strings are variable
2101 length. The string data (key) and the element object (value) are stored in the
2102 same allocation with the string data immediately after the element object.
2103 This container guarantees the "``(char*)(&Value+1)``" points to the key string
2106 The StringMap is very fast for several reasons: quadratic probing is very cache
2107 efficient for lookups, the hash value of strings in buckets is not recomputed
2108 when looking up an element, StringMap rarely has to touch the memory for
2109 unrelated objects when looking up a value (even when hash collisions happen),
2110 hash table growth does not recompute the hash values for strings already in the
2111 table, and each pair in the map is store in a single allocation (the string data
2112 is stored in the same allocation as the Value of a pair).
2114 StringMap also provides query methods that take byte ranges, so it only ever
2115 copies a string if a value is inserted into the table.
2117 StringMap iteration order, however, is not guaranteed to be deterministic, so
2118 any uses which require that should instead use a std::map.
2122 llvm/ADT/IndexedMap.h
2123 ^^^^^^^^^^^^^^^^^^^^^
2125 IndexedMap is a specialized container for mapping small dense integers (or
2126 values that can be mapped to small dense integers) to some other type. It is
2127 internally implemented as a vector with a mapping function that maps the keys
2128 to the dense integer range.
2130 This is useful for cases like virtual registers in the LLVM code generator: they
2131 have a dense mapping that is offset by a compile-time constant (the first
2132 virtual register ID).
2139 DenseMap is a simple quadratically probed hash table. It excels at supporting
2140 small keys and values: it uses a single allocation to hold all of the pairs
2141 that are currently inserted in the map. DenseMap is a great way to map
2142 pointers to pointers, or map other small types to each other.
2144 There are several aspects of DenseMap that you should be aware of, however.
2145 The iterators in a DenseMap are invalidated whenever an insertion occurs,
2146 unlike map. Also, because DenseMap allocates space for a large number of
2147 key/value pairs (it starts with 64 by default), it will waste a lot of space if
2148 your keys or values are large. Finally, you must implement a partial
2149 specialization of DenseMapInfo for the key that you want, if it isn't already
2150 supported. This is required to tell DenseMap about two special marker values
2151 (which can never be inserted into the map) that it needs internally.
2153 DenseMap's find_as() method supports lookup operations using an alternate key
2154 type. This is useful in cases where the normal key type is expensive to
2155 construct, but cheap to compare against. The DenseMapInfo is responsible for
2156 defining the appropriate comparison and hashing methods for each alternate key
2164 ValueMap is a wrapper around a :ref:`DenseMap <dss_densemap>` mapping
2165 ``Value*``\ s (or subclasses) to another type. When a Value is deleted or
2166 RAUW'ed, ValueMap will update itself so the new version of the key is mapped to
2167 the same value, just as if the key were a WeakVH. You can configure exactly how
2168 this happens, and what else happens on these two events, by passing a ``Config``
2169 parameter to the ValueMap template.
2171 .. _dss_intervalmap:
2173 llvm/ADT/IntervalMap.h
2174 ^^^^^^^^^^^^^^^^^^^^^^
2176 IntervalMap is a compact map for small keys and values. It maps key intervals
2177 instead of single keys, and it will automatically coalesce adjacent intervals.
2178 When the map only contains a few intervals, they are stored in the map object
2179 itself to avoid allocations.
2181 The IntervalMap iterators are quite big, so they should not be passed around as
2182 STL iterators. The heavyweight iterators allow a smaller data structure.
2189 std::map has similar characteristics to :ref:`std::set <dss_set>`: it uses a
2190 single allocation per pair inserted into the map, it offers log(n) lookup with
2191 an extremely large constant factor, imposes a space penalty of 3 pointers per
2192 pair in the map, etc.
2194 std::map is most useful when your keys or values are very large, if you need to
2195 iterate over the collection in sorted order, or if you need stable iterators
2196 into the map (i.e. they don't get invalidated if an insertion or deletion of
2197 another element takes place).
2201 llvm/ADT/MapVector.h
2202 ^^^^^^^^^^^^^^^^^^^^
2204 ``MapVector<KeyT,ValueT>`` provides a subset of the DenseMap interface. The
2205 main difference is that the iteration order is guaranteed to be the insertion
2206 order, making it an easy (but somewhat expensive) solution for non-deterministic
2207 iteration over maps of pointers.
2209 It is implemented by mapping from key to an index in a vector of key,value
2210 pairs. This provides fast lookup and iteration, but has two main drawbacks:
2211 the key is stored twice and removing elements takes linear time. If it is
2212 necessary to remove elements, it's best to remove them in bulk using
2215 .. _dss_inteqclasses:
2217 llvm/ADT/IntEqClasses.h
2218 ^^^^^^^^^^^^^^^^^^^^^^^
2220 IntEqClasses provides a compact representation of equivalence classes of small
2221 integers. Initially, each integer in the range 0..n-1 has its own equivalence
2222 class. Classes can be joined by passing two class representatives to the
2223 join(a, b) method. Two integers are in the same class when findLeader() returns
2224 the same representative.
2226 Once all equivalence classes are formed, the map can be compressed so each
2227 integer 0..n-1 maps to an equivalence class number in the range 0..m-1, where m
2228 is the total number of equivalence classes. The map must be uncompressed before
2229 it can be edited again.
2231 .. _dss_immutablemap:
2233 llvm/ADT/ImmutableMap.h
2234 ^^^^^^^^^^^^^^^^^^^^^^^
2236 ImmutableMap is an immutable (functional) map implementation based on an AVL
2237 tree. Adding or removing elements is done through a Factory object and results
2238 in the creation of a new ImmutableMap object. If an ImmutableMap already exists
2239 with the given key set, then the existing one is returned; equality is compared
2240 with a FoldingSetNodeID. The time and space complexity of add or remove
2241 operations is logarithmic in the size of the original map.
2245 Other Map-Like Container Options
2246 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
2248 The STL provides several other options, such as std::multimap and the various
2249 "hash_map" like containers (whether from C++ TR1 or from the SGI library). We
2250 never use hash_set and unordered_set because they are generally very expensive
2251 (each insertion requires a malloc) and very non-portable.
2253 std::multimap is useful if you want to map a key to multiple values, but has all
2254 the drawbacks of std::map. A sorted vector or some other approach is almost
2259 Bit storage containers (BitVector, SparseBitVector)
2260 ---------------------------------------------------
2262 Unlike the other containers, there are only two bit storage containers, and
2263 choosing when to use each is relatively straightforward.
2265 One additional option is ``std::vector<bool>``: we discourage its use for two
2266 reasons 1) the implementation in many common compilers (e.g. commonly
2267 available versions of GCC) is extremely inefficient and 2) the C++ standards
2268 committee is likely to deprecate this container and/or change it significantly
2269 somehow. In any case, please don't use it.
2276 The BitVector container provides a dynamic size set of bits for manipulation.
2277 It supports individual bit setting/testing, as well as set operations. The set
2278 operations take time O(size of bitvector), but operations are performed one word
2279 at a time, instead of one bit at a time. This makes the BitVector very fast for
2280 set operations compared to other containers. Use the BitVector when you expect
2281 the number of set bits to be high (i.e. a dense set).
2283 .. _dss_smallbitvector:
2288 The SmallBitVector container provides the same interface as BitVector, but it is
2289 optimized for the case where only a small number of bits, less than 25 or so,
2290 are needed. It also transparently supports larger bit counts, but slightly less
2291 efficiently than a plain BitVector, so SmallBitVector should only be used when
2292 larger counts are rare.
2294 At this time, SmallBitVector does not support set operations (and, or, xor), and
2295 its operator[] does not provide an assignable lvalue.
2297 .. _dss_sparsebitvector:
2302 The SparseBitVector container is much like BitVector, with one major difference:
2303 Only the bits that are set, are stored. This makes the SparseBitVector much
2304 more space efficient than BitVector when the set is sparse, as well as making
2305 set operations O(number of set bits) instead of O(size of universe). The
2306 downside to the SparseBitVector is that setting and testing of random bits is
2307 O(N), and on large SparseBitVectors, this can be slower than BitVector. In our
2308 implementation, setting or testing bits in sorted order (either forwards or
2309 reverse) is O(1) worst case. Testing and setting bits within 128 bits (depends
2310 on size) of the current bit is also O(1). As a general statement,
2311 testing/setting bits in a SparseBitVector is O(distance away from last set bit).
2318 A handful of `GDB pretty printers
2319 <https://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html>`__ are
2320 provided for some of the core LLVM libraries. To use them, execute the
2321 following (or add it to your ``~/.gdbinit``)::
2323 source /path/to/llvm/src/utils/gdb-scripts/prettyprinters.py
2325 It also might be handy to enable the `print pretty
2326 <http://ftp.gnu.org/old-gnu/Manuals/gdb/html_node/gdb_57.html>`__ option to
2327 avoid data structures being printed as a big block of text.
2331 Helpful Hints for Common Operations
2332 ===================================
2334 This section describes how to perform some very simple transformations of LLVM
2335 code. This is meant to give examples of common idioms used, showing the
2336 practical side of LLVM transformations.
2338 Because this is a "how-to" section, you should also read about the main classes
2339 that you will be working with. The :ref:`Core LLVM Class Hierarchy Reference
2340 <coreclasses>` contains details and descriptions of the main classes that you
2345 Basic Inspection and Traversal Routines
2346 ---------------------------------------
2348 The LLVM compiler infrastructure have many different data structures that may be
2349 traversed. Following the example of the C++ standard template library, the
2350 techniques used to traverse these various data structures are all basically the
2351 same. For a enumerable sequence of values, the ``XXXbegin()`` function (or
2352 method) returns an iterator to the start of the sequence, the ``XXXend()``
2353 function returns an iterator pointing to one past the last valid element of the
2354 sequence, and there is some ``XXXiterator`` data type that is common between the
2357 Because the pattern for iteration is common across many different aspects of the
2358 program representation, the standard template library algorithms may be used on
2359 them, and it is easier to remember how to iterate. First we show a few common
2360 examples of the data structures that need to be traversed. Other data
2361 structures are traversed in very similar ways.
2363 .. _iterate_function:
2365 Iterating over the ``BasicBlock`` in a ``Function``
2366 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
2368 It's quite common to have a ``Function`` instance that you'd like to transform
2369 in some way; in particular, you'd like to manipulate its ``BasicBlock``\ s. To
2370 facilitate this, you'll need to iterate over all of the ``BasicBlock``\ s that
2371 constitute the ``Function``. The following is an example that prints the name
2372 of a ``BasicBlock`` and the number of ``Instruction``\ s it contains:
2376 Function &Func = ...
2377 for (BasicBlock &BB : Func)
2378 // Print out the name of the basic block if it has one, and then the
2379 // number of instructions that it contains
2380 errs() << "Basic block (name=" << BB.getName() << ") has "
2381 << BB.size() << " instructions.\n";
2383 .. _iterate_basicblock:
2385 Iterating over the ``Instruction`` in a ``BasicBlock``
2386 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
2388 Just like when dealing with ``BasicBlock``\ s in ``Function``\ s, it's easy to
2389 iterate over the individual instructions that make up ``BasicBlock``\ s. Here's
2390 a code snippet that prints out each instruction in a ``BasicBlock``:
2394 BasicBlock& BB = ...
2395 for (Instruction &I : BB)
2396 // The next statement works since operator<<(ostream&,...)
2397 // is overloaded for Instruction&
2398 errs() << I << "\n";
2401 However, this isn't really the best way to print out the contents of a
2402 ``BasicBlock``! Since the ostream operators are overloaded for virtually
2403 anything you'll care about, you could have just invoked the print routine on the
2404 basic block itself: ``errs() << BB << "\n";``.
2406 .. _iterate_insiter:
2408 Iterating over the ``Instruction`` in a ``Function``
2409 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
2411 If you're finding that you commonly iterate over a ``Function``'s
2412 ``BasicBlock``\ s and then that ``BasicBlock``'s ``Instruction``\ s,
2413 ``InstIterator`` should be used instead. You'll need to include
2414 ``llvm/IR/InstIterator.h`` (`doxygen
2415 <http://llvm.org/doxygen/InstIterator_8h.html>`__) and then instantiate
2416 ``InstIterator``\ s explicitly in your code. Here's a small example that shows
2417 how to dump all instructions in a function to the standard error stream:
2421 #include "llvm/IR/InstIterator.h"
2423 // F is a pointer to a Function instance
2424 for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I)
2425 errs() << *I << "\n";
2427 Easy, isn't it? You can also use ``InstIterator``\ s to fill a work list with
2428 its initial contents. For example, if you wanted to initialize a work list to
2429 contain all instructions in a ``Function`` F, all you would need to do is
2434 std::set<Instruction*> worklist;
2435 // or better yet, SmallPtrSet<Instruction*, 64> worklist;
2437 for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I)
2438 worklist.insert(&*I);
2440 The STL set ``worklist`` would now contain all instructions in the ``Function``
2443 .. _iterate_convert:
2445 Turning an iterator into a class pointer (and vice-versa)
2446 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
2448 Sometimes, it'll be useful to grab a reference (or pointer) to a class instance
2449 when all you've got at hand is an iterator. Well, extracting a reference or a
2450 pointer from an iterator is very straight-forward. Assuming that ``i`` is a
2451 ``BasicBlock::iterator`` and ``j`` is a ``BasicBlock::const_iterator``:
2455 Instruction& inst = *i; // Grab reference to instruction reference
2456 Instruction* pinst = &*i; // Grab pointer to instruction reference
2457 const Instruction& inst = *j;
2459 However, the iterators you'll be working with in the LLVM framework are special:
2460 they will automatically convert to a ptr-to-instance type whenever they need to.
2461 Instead of dereferencing the iterator and then taking the address of the result,
2462 you can simply assign the iterator to the proper pointer type and you get the
2463 dereference and address-of operation as a result of the assignment (behind the
2464 scenes, this is a result of overloading casting mechanisms). Thus the second
2465 line of the last example,
2469 Instruction *pinst = &*i;
2471 is semantically equivalent to
2475 Instruction *pinst = i;
2477 It's also possible to turn a class pointer into the corresponding iterator, and
2478 this is a constant time operation (very efficient). The following code snippet
2479 illustrates use of the conversion constructors provided by LLVM iterators. By
2480 using these, you can explicitly grab the iterator of something without actually
2481 obtaining it via iteration over some structure:
2485 void printNextInstruction(Instruction* inst) {
2486 BasicBlock::iterator it(inst);
2487 ++it; // After this line, it refers to the instruction after *inst
2488 if (it != inst->getParent()->end()) errs() << *it << "\n";
2491 Unfortunately, these implicit conversions come at a cost; they prevent these
2492 iterators from conforming to standard iterator conventions, and thus from being
2493 usable with standard algorithms and containers. For example, they prevent the
2494 following code, where ``B`` is a ``BasicBlock``, from compiling:
2498 llvm::SmallVector<llvm::Instruction *, 16>(B->begin(), B->end());
2500 Because of this, these implicit conversions may be removed some day, and
2501 ``operator*`` changed to return a pointer instead of a reference.
2503 .. _iterate_complex:
2505 Finding call sites: a slightly more complex example
2506 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
2508 Say that you're writing a FunctionPass and would like to count all the locations
2509 in the entire module (that is, across every ``Function``) where a certain
2510 function (i.e., some ``Function *``) is already in scope. As you'll learn
2511 later, you may want to use an ``InstVisitor`` to accomplish this in a much more
2512 straight-forward manner, but this example will allow us to explore how you'd do
2513 it if you didn't have ``InstVisitor`` around. In pseudo-code, this is what we
2516 .. code-block:: none
2518 initialize callCounter to zero
2519 for each Function f in the Module
2520 for each BasicBlock b in f
2521 for each Instruction i in b
2522 if (i is a CallInst and calls the given function)
2523 increment callCounter
2525 And the actual code is (remember, because we're writing a ``FunctionPass``, our
2526 ``FunctionPass``-derived class simply has to override the ``runOnFunction``
2531 Function* targetFunc = ...;
2533 class OurFunctionPass : public FunctionPass {
2535 OurFunctionPass(): callCounter(0) { }
2537 virtual runOnFunction(Function& F) {
2538 for (BasicBlock &B : F) {
2539 for (Instruction &I: B) {
2540 if (auto *CallInst = dyn_cast<CallInst>(&I)) {
2541 // We know we've encountered a call instruction, so we
2542 // need to determine if it's a call to the
2543 // function pointed to by m_func or not.
2544 if (CallInst->getCalledFunction() == targetFunc)
2552 unsigned callCounter;
2555 .. _calls_and_invokes:
2557 Treating calls and invokes the same way
2558 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
2560 You may have noticed that the previous example was a bit oversimplified in that
2561 it did not deal with call sites generated by 'invoke' instructions. In this,
2562 and in other situations, you may find that you want to treat ``CallInst``\ s and
2563 ``InvokeInst``\ s the same way, even though their most-specific common base
2564 class is ``Instruction``, which includes lots of less closely-related things.
2565 For these cases, LLVM provides a handy wrapper class called ``CallSite``
2566 (`doxygen <http://llvm.org/doxygen/classllvm_1_1CallSite.html>`__) It is
2567 essentially a wrapper around an ``Instruction`` pointer, with some methods that
2568 provide functionality common to ``CallInst``\ s and ``InvokeInst``\ s.
2570 This class has "value semantics": it should be passed by value, not by reference
2571 and it should not be dynamically allocated or deallocated using ``operator new``
2572 or ``operator delete``. It is efficiently copyable, assignable and
2573 constructable, with costs equivalents to that of a bare pointer. If you look at
2574 its definition, it has only a single pointer member.
2578 Iterating over def-use & use-def chains
2579 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
2581 Frequently, we might have an instance of the ``Value`` class (`doxygen
2582 <http://llvm.org/doxygen/classllvm_1_1Value.html>`__) and we want to determine
2583 which ``User`` s use the ``Value``. The list of all ``User``\ s of a particular
2584 ``Value`` is called a *def-use* chain. For example, let's say we have a
2585 ``Function*`` named ``F`` to a particular function ``foo``. Finding all of the
2586 instructions that *use* ``foo`` is as simple as iterating over the *def-use*
2593 for (User *U : F->users()) {
2594 if (Instruction *Inst = dyn_cast<Instruction>(U)) {
2595 errs() << "F is used in instruction:\n";
2596 errs() << *Inst << "\n";
2599 Alternatively, it's common to have an instance of the ``User`` Class (`doxygen
2600 <http://llvm.org/doxygen/classllvm_1_1User.html>`__) and need to know what
2601 ``Value``\ s are used by it. The list of all ``Value``\ s used by a ``User`` is
2602 known as a *use-def* chain. Instances of class ``Instruction`` are common
2603 ``User`` s, so we might want to iterate over all of the values that a particular
2604 instruction uses (that is, the operands of the particular ``Instruction``):
2608 Instruction *pi = ...;
2610 for (Use &U : pi->operands()) {
2615 Declaring objects as ``const`` is an important tool of enforcing mutation free
2616 algorithms (such as analyses, etc.). For this purpose above iterators come in
2617 constant flavors as ``Value::const_use_iterator`` and
2618 ``Value::const_op_iterator``. They automatically arise when calling
2619 ``use/op_begin()`` on ``const Value*``\ s or ``const User*``\ s respectively.
2620 Upon dereferencing, they return ``const Use*``\ s. Otherwise the above patterns
2625 Iterating over predecessors & successors of blocks
2626 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
2628 Iterating over the predecessors and successors of a block is quite easy with the
2629 routines defined in ``"llvm/IR/CFG.h"``. Just use code like this to
2630 iterate over all predecessors of BB:
2634 #include "llvm/IR/CFG.h"
2635 BasicBlock *BB = ...;
2637 for (BasicBlock *Pred : predecessors(BB)) {
2641 Similarly, to iterate over successors use ``successors``.
2645 Making simple changes
2646 ---------------------
2648 There are some primitive transformation operations present in the LLVM
2649 infrastructure that are worth knowing about. When performing transformations,
2650 it's fairly common to manipulate the contents of basic blocks. This section
2651 describes some of the common methods for doing so and gives example code.
2653 .. _schanges_creating:
2655 Creating and inserting new ``Instruction``\ s
2656 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
2658 *Instantiating Instructions*
2660 Creation of ``Instruction``\ s is straight-forward: simply call the constructor
2661 for the kind of instruction to instantiate and provide the necessary parameters.
2662 For example, an ``AllocaInst`` only *requires* a (const-ptr-to) ``Type``. Thus:
2666 auto *ai = new AllocaInst(Type::Int32Ty);
2668 will create an ``AllocaInst`` instance that represents the allocation of one
2669 integer in the current stack frame, at run time. Each ``Instruction`` subclass
2670 is likely to have varying default parameters which change the semantics of the
2671 instruction, so refer to the `doxygen documentation for the subclass of
2672 Instruction <http://llvm.org/doxygen/classllvm_1_1Instruction.html>`_ that
2673 you're interested in instantiating.
2677 It is very useful to name the values of instructions when you're able to, as
2678 this facilitates the debugging of your transformations. If you end up looking
2679 at generated LLVM machine code, you definitely want to have logical names
2680 associated with the results of instructions! By supplying a value for the
2681 ``Name`` (default) parameter of the ``Instruction`` constructor, you associate a
2682 logical name with the result of the instruction's execution at run time. For
2683 example, say that I'm writing a transformation that dynamically allocates space
2684 for an integer on the stack, and that integer is going to be used as some kind
2685 of index by some other code. To accomplish this, I place an ``AllocaInst`` at
2686 the first point in the first ``BasicBlock`` of some ``Function``, and I'm
2687 intending to use it within the same ``Function``. I might do:
2691 auto *pa = new AllocaInst(Type::Int32Ty, 0, "indexLoc");
2693 where ``indexLoc`` is now the logical name of the instruction's execution value,
2694 which is a pointer to an integer on the run time stack.
2696 *Inserting instructions*
2698 There are essentially three ways to insert an ``Instruction`` into an existing
2699 sequence of instructions that form a ``BasicBlock``:
2701 * Insertion into an explicit instruction list
2703 Given a ``BasicBlock* pb``, an ``Instruction* pi`` within that ``BasicBlock``,
2704 and a newly-created instruction we wish to insert before ``*pi``, we do the
2709 BasicBlock *pb = ...;
2710 Instruction *pi = ...;
2711 auto *newInst = new Instruction(...);
2713 pb->getInstList().insert(pi, newInst); // Inserts newInst before pi in pb
2715 Appending to the end of a ``BasicBlock`` is so common that the ``Instruction``
2716 class and ``Instruction``-derived classes provide constructors which take a
2717 pointer to a ``BasicBlock`` to be appended to. For example code that looked
2722 BasicBlock *pb = ...;
2723 auto *newInst = new Instruction(...);
2725 pb->getInstList().push_back(newInst); // Appends newInst to pb
2731 BasicBlock *pb = ...;
2732 auto *newInst = new Instruction(..., pb);
2734 which is much cleaner, especially if you are creating long instruction
2737 * Insertion into an implicit instruction list
2739 ``Instruction`` instances that are already in ``BasicBlock``\ s are implicitly
2740 associated with an existing instruction list: the instruction list of the
2741 enclosing basic block. Thus, we could have accomplished the same thing as the
2742 above code without being given a ``BasicBlock`` by doing:
2746 Instruction *pi = ...;
2747 auto *newInst = new Instruction(...);
2749 pi->getParent()->getInstList().insert(pi, newInst);
2751 In fact, this sequence of steps occurs so frequently that the ``Instruction``
2752 class and ``Instruction``-derived classes provide constructors which take (as
2753 a default parameter) a pointer to an ``Instruction`` which the newly-created
2754 ``Instruction`` should precede. That is, ``Instruction`` constructors are
2755 capable of inserting the newly-created instance into the ``BasicBlock`` of a
2756 provided instruction, immediately before that instruction. Using an
2757 ``Instruction`` constructor with a ``insertBefore`` (default) parameter, the
2762 Instruction* pi = ...;
2763 auto *newInst = new Instruction(..., pi);
2765 which is much cleaner, especially if you're creating a lot of instructions and
2766 adding them to ``BasicBlock``\ s.
2768 * Insertion using an instance of ``IRBuilder``
2770 Inserting several ``Instruction``\ s can be quite laborious using the previous
2771 methods. The ``IRBuilder`` is a convenience class that can be used to add
2772 several instructions to the end of a ``BasicBlock`` or before a particular
2773 ``Instruction``. It also supports constant folding and renaming named
2774 registers (see ``IRBuilder``'s template arguments).
2776 The example below demonstrates a very simple use of the ``IRBuilder`` where
2777 three instructions are inserted before the instruction ``pi``. The first two
2778 instructions are Call instructions and third instruction multiplies the return
2779 value of the two calls.
2783 Instruction *pi = ...;
2784 IRBuilder<> Builder(pi);
2785 CallInst* callOne = Builder.CreateCall(...);
2786 CallInst* callTwo = Builder.CreateCall(...);
2787 Value* result = Builder.CreateMul(callOne, callTwo);
2789 The example below is similar to the above example except that the created
2790 ``IRBuilder`` inserts instructions at the end of the ``BasicBlock`` ``pb``.
2794 BasicBlock *pb = ...;
2795 IRBuilder<> Builder(pb);
2796 CallInst* callOne = Builder.CreateCall(...);
2797 CallInst* callTwo = Builder.CreateCall(...);
2798 Value* result = Builder.CreateMul(callOne, callTwo);
2800 See :doc:`tutorial/LangImpl03` for a practical use of the ``IRBuilder``.
2803 .. _schanges_deleting:
2805 Deleting Instructions
2806 ^^^^^^^^^^^^^^^^^^^^^
2808 Deleting an instruction from an existing sequence of instructions that form a
2809 BasicBlock_ is very straight-forward: just call the instruction's
2810 ``eraseFromParent()`` method. For example:
2814 Instruction *I = .. ;
2815 I->eraseFromParent();
2817 This unlinks the instruction from its containing basic block and deletes it. If
2818 you'd just like to unlink the instruction from its containing basic block but
2819 not delete it, you can use the ``removeFromParent()`` method.
2821 .. _schanges_replacing:
2823 Replacing an Instruction with another Value
2824 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
2826 Replacing individual instructions
2827 """""""""""""""""""""""""""""""""
2829 Including "`llvm/Transforms/Utils/BasicBlockUtils.h
2830 <http://llvm.org/doxygen/BasicBlockUtils_8h_source.html>`_" permits use of two
2831 very useful replace functions: ``ReplaceInstWithValue`` and
2832 ``ReplaceInstWithInst``.
2834 .. _schanges_deleting_sub:
2836 Deleting Instructions
2837 """""""""""""""""""""
2839 * ``ReplaceInstWithValue``
2841 This function replaces all uses of a given instruction with a value, and then
2842 removes the original instruction. The following example illustrates the
2843 replacement of the result of a particular ``AllocaInst`` that allocates memory
2844 for a single integer with a null pointer to an integer.
2848 AllocaInst* instToReplace = ...;
2849 BasicBlock::iterator ii(instToReplace);
2851 ReplaceInstWithValue(instToReplace->getParent()->getInstList(), ii,
2852 Constant::getNullValue(PointerType::getUnqual(Type::Int32Ty)));
2854 * ``ReplaceInstWithInst``
2856 This function replaces a particular instruction with another instruction,
2857 inserting the new instruction into the basic block at the location where the
2858 old instruction was, and replacing any uses of the old instruction with the
2859 new instruction. The following example illustrates the replacement of one
2860 ``AllocaInst`` with another.
2864 AllocaInst* instToReplace = ...;
2865 BasicBlock::iterator ii(instToReplace);
2867 ReplaceInstWithInst(instToReplace->getParent()->getInstList(), ii,
2868 new AllocaInst(Type::Int32Ty, 0, "ptrToReplacedInt"));
2871 Replacing multiple uses of Users and Values
2872 """""""""""""""""""""""""""""""""""""""""""
2874 You can use ``Value::replaceAllUsesWith`` and ``User::replaceUsesOfWith`` to
2875 change more than one use at a time. See the doxygen documentation for the
2876 `Value Class <http://llvm.org/doxygen/classllvm_1_1Value.html>`_ and `User Class
2877 <http://llvm.org/doxygen/classllvm_1_1User.html>`_, respectively, for more
2880 .. _schanges_deletingGV:
2882 Deleting GlobalVariables
2883 ^^^^^^^^^^^^^^^^^^^^^^^^
2885 Deleting a global variable from a module is just as easy as deleting an
2886 Instruction. First, you must have a pointer to the global variable that you
2887 wish to delete. You use this pointer to erase it from its parent, the module.
2892 GlobalVariable *GV = .. ;
2894 GV->eraseFromParent();
2902 In generating IR, you may need some complex types. If you know these types
2903 statically, you can use ``TypeBuilder<...>::get()``, defined in
2904 ``llvm/Support/TypeBuilder.h``, to retrieve them. ``TypeBuilder`` has two forms
2905 depending on whether you're building types for cross-compilation or native
2906 library use. ``TypeBuilder<T, true>`` requires that ``T`` be independent of the
2907 host environment, meaning that it's built out of types from the ``llvm::types``
2908 (`doxygen <http://llvm.org/doxygen/namespacellvm_1_1types.html>`__) namespace
2909 and pointers, functions, arrays, etc. built of those. ``TypeBuilder<T, false>``
2910 additionally allows native C types whose size may depend on the host compiler.
2915 FunctionType *ft = TypeBuilder<types::i<8>(types::i<32>*), true>::get();
2917 is easier to read and write than the equivalent
2921 std::vector<const Type*> params;
2922 params.push_back(PointerType::getUnqual(Type::Int32Ty));
2923 FunctionType *ft = FunctionType::get(Type::Int8Ty, params, false);
2925 See the `class comment
2926 <http://llvm.org/doxygen/TypeBuilder_8h_source.html#l00001>`_ for more details.
2933 This section describes the interaction of the LLVM APIs with multithreading,
2934 both on the part of client applications, and in the JIT, in the hosted
2937 Note that LLVM's support for multithreading is still relatively young. Up
2938 through version 2.5, the execution of threaded hosted applications was
2939 supported, but not threaded client access to the APIs. While this use case is
2940 now supported, clients *must* adhere to the guidelines specified below to ensure
2941 proper operation in multithreaded mode.
2943 Note that, on Unix-like platforms, LLVM requires the presence of GCC's atomic
2944 intrinsics in order to support threaded operation. If you need a
2945 multhreading-capable LLVM on a platform without a suitably modern system
2946 compiler, consider compiling LLVM and LLVM-GCC in single-threaded mode, and
2947 using the resultant compiler to build a copy of LLVM with multithreading
2952 Ending Execution with ``llvm_shutdown()``
2953 -----------------------------------------
2955 When you are done using the LLVM APIs, you should call ``llvm_shutdown()`` to
2956 deallocate memory used for internal structures.
2960 Lazy Initialization with ``ManagedStatic``
2961 ------------------------------------------
2963 ``ManagedStatic`` is a utility class in LLVM used to implement static
2964 initialization of static resources, such as the global type tables. In a
2965 single-threaded environment, it implements a simple lazy initialization scheme.
2966 When LLVM is compiled with support for multi-threading, however, it uses
2967 double-checked locking to implement thread-safe lazy initialization.
2971 Achieving Isolation with ``LLVMContext``
2972 ----------------------------------------
2974 ``LLVMContext`` is an opaque class in the LLVM API which clients can use to
2975 operate multiple, isolated instances of LLVM concurrently within the same
2976 address space. For instance, in a hypothetical compile-server, the compilation
2977 of an individual translation unit is conceptually independent from all the
2978 others, and it would be desirable to be able to compile incoming translation
2979 units concurrently on independent server threads. Fortunately, ``LLVMContext``
2980 exists to enable just this kind of scenario!
2982 Conceptually, ``LLVMContext`` provides isolation. Every LLVM entity
2983 (``Module``\ s, ``Value``\ s, ``Type``\ s, ``Constant``\ s, etc.) in LLVM's
2984 in-memory IR belongs to an ``LLVMContext``. Entities in different contexts
2985 *cannot* interact with each other: ``Module``\ s in different contexts cannot be
2986 linked together, ``Function``\ s cannot be added to ``Module``\ s in different
2987 contexts, etc. What this means is that is is safe to compile on multiple
2988 threads simultaneously, as long as no two threads operate on entities within the
2991 In practice, very few places in the API require the explicit specification of a
2992 ``LLVMContext``, other than the ``Type`` creation/lookup APIs. Because every
2993 ``Type`` carries a reference to its owning context, most other entities can
2994 determine what context they belong to by looking at their own ``Type``. If you
2995 are adding new entities to LLVM IR, please try to maintain this interface
3003 LLVM's "eager" JIT compiler is safe to use in threaded programs. Multiple
3004 threads can call ``ExecutionEngine::getPointerToFunction()`` or
3005 ``ExecutionEngine::runFunction()`` concurrently, and multiple threads can run
3006 code output by the JIT concurrently. The user must still ensure that only one
3007 thread accesses IR in a given ``LLVMContext`` while another thread might be
3008 modifying it. One way to do that is to always hold the JIT lock while accessing
3009 IR outside the JIT (the JIT *modifies* the IR by adding ``CallbackVH``\ s).
3010 Another way is to only call ``getPointerToFunction()`` from the
3011 ``LLVMContext``'s thread.
3013 When the JIT is configured to compile lazily (using
3014 ``ExecutionEngine::DisableLazyCompilation(false)``), there is currently a `race
3015 condition <https://bugs.llvm.org/show_bug.cgi?id=5184>`_ in updating call sites
3016 after a function is lazily-jitted. It's still possible to use the lazy JIT in a
3017 threaded program if you ensure that only one thread at a time can call any
3018 particular lazy stub and that the JIT lock guards any IR access, but we suggest
3019 using only the eager JIT in threaded programs.
3026 This section describes some of the advanced or obscure API's that most clients
3027 do not need to be aware of. These API's tend manage the inner workings of the
3028 LLVM system, and only need to be accessed in unusual circumstances.
3032 The ``ValueSymbolTable`` class
3033 ------------------------------
3035 The ``ValueSymbolTable`` (`doxygen
3036 <http://llvm.org/doxygen/classllvm_1_1ValueSymbolTable.html>`__) class provides
3037 a symbol table that the :ref:`Function <c_Function>` and Module_ classes use for
3038 naming value definitions. The symbol table can provide a name for any Value_.
3040 Note that the ``SymbolTable`` class should not be directly accessed by most
3041 clients. It should only be used when iteration over the symbol table names
3042 themselves are required, which is very special purpose. Note that not all LLVM
3043 Value_\ s have names, and those without names (i.e. they have an empty name) do
3044 not exist in the symbol table.
3046 Symbol tables support iteration over the values in the symbol table with
3047 ``begin/end/iterator`` and supports querying to see if a specific name is in the
3048 symbol table (with ``lookup``). The ``ValueSymbolTable`` class exposes no
3049 public mutator methods, instead, simply call ``setName`` on a value, which will
3050 autoinsert it into the appropriate symbol table.
3054 The ``User`` and owned ``Use`` classes' memory layout
3055 -----------------------------------------------------
3057 The ``User`` (`doxygen <http://llvm.org/doxygen/classllvm_1_1User.html>`__)
3058 class provides a basis for expressing the ownership of ``User`` towards other
3059 `Value instance <http://llvm.org/doxygen/classllvm_1_1Value.html>`_\ s. The
3060 ``Use`` (`doxygen <http://llvm.org/doxygen/classllvm_1_1Use.html>`__) helper
3061 class is employed to do the bookkeeping and to facilitate *O(1)* addition and
3066 Interaction and relationship between ``User`` and ``Use`` objects
3067 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
3069 A subclass of ``User`` can choose between incorporating its ``Use`` objects or
3070 refer to them out-of-line by means of a pointer. A mixed variant (some ``Use``
3071 s inline others hung off) is impractical and breaks the invariant that the
3072 ``Use`` objects belonging to the same ``User`` form a contiguous array.
3074 We have 2 different layouts in the ``User`` (sub)classes:
3078 The ``Use`` object(s) are inside (resp. at fixed offset) of the ``User``
3079 object and there are a fixed number of them.
3083 The ``Use`` object(s) are referenced by a pointer to an array from the
3084 ``User`` object and there may be a variable number of them.
3086 As of v2.4 each layout still possesses a direct pointer to the start of the
3087 array of ``Use``\ s. Though not mandatory for layout a), we stick to this
3088 redundancy for the sake of simplicity. The ``User`` object also stores the
3089 number of ``Use`` objects it has. (Theoretically this information can also be
3090 calculated given the scheme presented below.)
3092 Special forms of allocation operators (``operator new``) enforce the following
3095 * Layout a) is modelled by prepending the ``User`` object by the ``Use[]``
3098 .. code-block:: none
3100 ...---.---.---.---.-------...
3101 | P | P | P | P | User
3102 '''---'---'---'---'-------'''
3104 * Layout b) is modelled by pointing at the ``Use[]`` array.
3106 .. code-block:: none
3117 *(In the above figures* '``P``' *stands for the* ``Use**`` *that is stored in
3118 each* ``Use`` *object in the member* ``Use::Prev`` *)*
3122 The waymarking algorithm
3123 ^^^^^^^^^^^^^^^^^^^^^^^^
3125 Since the ``Use`` objects are deprived of the direct (back)pointer to their
3126 ``User`` objects, there must be a fast and exact method to recover it. This is
3127 accomplished by the following scheme:
3129 A bit-encoding in the 2 LSBits (least significant bits) of the ``Use::Prev``
3130 allows to find the start of the ``User`` object:
3132 * ``00`` --- binary digit 0
3134 * ``01`` --- binary digit 1
3136 * ``10`` --- stop and calculate (``s``)
3138 * ``11`` --- full stop (``S``)
3140 Given a ``Use*``, all we have to do is to walk till we get a stop and we either
3141 have a ``User`` immediately behind or we have to walk to the next stop picking
3142 up digits and calculating the offset:
3144 .. code-block:: none
3146 .---.---.---.---.---.---.---.---.---.---.---.---.---.---.---.---.----------------
3147 | 1 | s | 1 | 0 | 1 | 0 | s | 1 | 1 | 0 | s | 1 | 1 | s | 1 | S | User (or User*)
3148 '---'---'---'---'---'---'---'---'---'---'---'---'---'---'---'---'----------------
3149 |+15 |+10 |+6 |+3 |+1
3152 | | | ______________________>
3153 | | ______________________________________>
3154 | __________________________________________________________>
3156 Only the significant number of bits need to be stored between the stops, so that
3157 the *worst case is 20 memory accesses* when there are 1000 ``Use`` objects
3158 associated with a ``User``.
3162 Reference implementation
3163 ^^^^^^^^^^^^^^^^^^^^^^^^
3165 The following literate Haskell fragment demonstrates the concept:
3167 .. code-block:: haskell
3169 > import Test.QuickCheck
3171 > digits :: Int -> [Char] -> [Char]
3172 > digits 0 acc = '0' : acc
3173 > digits 1 acc = '1' : acc
3174 > digits n acc = digits (n `div` 2) $ digits (n `mod` 2) acc
3176 > dist :: Int -> [Char] -> [Char]
3179 > dist 1 acc = let r = dist 0 acc in 's' : digits (length r) r
3180 > dist n acc = dist (n - 1) $ dist 1 acc
3182 > takeLast n ss = reverse $ take n $ reverse ss
3184 > test = takeLast 40 $ dist 20 []
3187 Printing <test> gives: ``"1s100000s11010s10100s1111s1010s110s11s1S"``
3189 The reverse algorithm computes the length of the string just by examining a
3192 .. code-block:: haskell
3194 > pref :: [Char] -> Int
3196 > pref ('s':'1':rest) = decode 2 1 rest
3197 > pref (_:rest) = 1 + pref rest
3199 > decode walk acc ('0':rest) = decode (walk + 1) (acc * 2) rest
3200 > decode walk acc ('1':rest) = decode (walk + 1) (acc * 2 + 1) rest
3201 > decode walk acc _ = walk + acc
3204 Now, as expected, printing <pref test> gives ``40``.
3206 We can *quickCheck* this with following property:
3208 .. code-block:: haskell
3210 > testcase = dist 2000 []
3211 > testcaseLength = length testcase
3213 > identityProp n = n > 0 && n <= testcaseLength ==> length arr == pref arr
3214 > where arr = takeLast n testcase
3217 As expected <quickCheck identityProp> gives:
3221 *Main> quickCheck identityProp
3222 OK, passed 100 tests.
3224 Let's be a bit more exhaustive:
3226 .. code-block:: haskell
3229 > deepCheck p = check (defaultConfig { configMaxTest = 500 }) p
3232 And here is the result of <deepCheck identityProp>:
3236 *Main> deepCheck identityProp
3237 OK, passed 500 tests.
3241 Tagging considerations
3242 ^^^^^^^^^^^^^^^^^^^^^^
3244 To maintain the invariant that the 2 LSBits of each ``Use**`` in ``Use`` never
3245 change after being set up, setters of ``Use::Prev`` must re-tag the new
3246 ``Use**`` on every modification. Accordingly getters must strip the tag bits.
3248 For layout b) instead of the ``User`` we find a pointer (``User*`` with LSBit
3249 set). Following this pointer brings us to the ``User``. A portable trick
3250 ensures that the first bytes of ``User`` (if interpreted as a pointer) never has
3251 the LSBit set. (Portability is relying on the fact that all known compilers
3252 place the ``vptr`` in the first word of the instances.)
3256 Designing Type Hiercharies and Polymorphic Interfaces
3257 -----------------------------------------------------
3259 There are two different design patterns that tend to result in the use of
3260 virtual dispatch for methods in a type hierarchy in C++ programs. The first is
3261 a genuine type hierarchy where different types in the hierarchy model
3262 a specific subset of the functionality and semantics, and these types nest
3263 strictly within each other. Good examples of this can be seen in the ``Value``
3264 or ``Type`` type hierarchies.
3266 A second is the desire to dispatch dynamically across a collection of
3267 polymorphic interface implementations. This latter use case can be modeled with
3268 virtual dispatch and inheritance by defining an abstract interface base class
3269 which all implementations derive from and override. However, this
3270 implementation strategy forces an **"is-a"** relationship to exist that is not
3271 actually meaningful. There is often not some nested hierarchy of useful
3272 generalizations which code might interact with and move up and down. Instead,
3273 there is a singular interface which is dispatched across a range of
3276 The preferred implementation strategy for the second use case is that of
3277 generic programming (sometimes called "compile-time duck typing" or "static
3278 polymorphism"). For example, a template over some type parameter ``T`` can be
3279 instantiated across any particular implementation that conforms to the
3280 interface or *concept*. A good example here is the highly generic properties of
3281 any type which models a node in a directed graph. LLVM models these primarily
3282 through templates and generic programming. Such templates include the
3283 ``LoopInfoBase`` and ``DominatorTreeBase``. When this type of polymorphism
3284 truly needs **dynamic** dispatch you can generalize it using a technique
3285 called *concept-based polymorphism*. This pattern emulates the interfaces and
3286 behaviors of templates using a very limited form of virtual dispatch for type
3287 erasure inside its implementation. You can find examples of this technique in
3288 the ``PassManager.h`` system, and there is a more detailed introduction to it
3289 by Sean Parent in several of his talks and papers:
3291 #. `Inheritance Is The Base Class of Evil
3292 <http://channel9.msdn.com/Events/GoingNative/2013/Inheritance-Is-The-Base-Class-of-Evil>`_
3293 - The GoingNative 2013 talk describing this technique, and probably the best
3295 #. `Value Semantics and Concepts-based Polymorphism
3296 <http://www.youtube.com/watch?v=_BpMYeUFXv8>`_ - The C++Now! 2012 talk
3297 describing this technique in more detail.
3298 #. `Sean Parent's Papers and Presentations
3299 <http://github.com/sean-parent/sean-parent.github.com/wiki/Papers-and-Presentations>`_
3300 - A Github project full of links to slides, video, and sometimes code.
3302 When deciding between creating a type hierarchy (with either tagged or virtual
3303 dispatch) and using templates or concepts-based polymorphism, consider whether
3304 there is some refinement of an abstract base class which is a semantically
3305 meaningful type on an interface boundary. If anything more refined than the
3306 root abstract interface is meaningless to talk about as a partial extension of
3307 the semantic model, then your use case likely fits better with polymorphism and
3308 you should avoid using virtual dispatch. However, there may be some exigent
3309 circumstances that require one technique or the other to be used.
3311 If you do need to introduce a type hierarchy, we prefer to use explicitly
3312 closed type hierarchies with manual tagged dispatch and/or RTTI rather than the
3313 open inheritance model and virtual dispatch that is more common in C++ code.
3314 This is because LLVM rarely encourages library consumers to extend its core
3315 types, and leverages the closed and tag-dispatched nature of its hierarchies to
3316 generate significantly more efficient code. We have also found that a large
3317 amount of our usage of type hierarchies fits better with tag-based pattern
3318 matching rather than dynamic dispatch across a common interface. Within LLVM we
3319 have built custom helpers to facilitate this design. See this document's
3320 section on :ref:`isa and dyn_cast <isa>` and our :doc:`detailed document
3321 <HowToSetUpLLVMStyleRTTI>` which describes how you can implement this
3322 pattern for use with the LLVM helpers.
3324 .. _abi_breaking_checks:
3329 Checks and asserts that alter the LLVM C++ ABI are predicated on the
3330 preprocessor symbol `LLVM_ENABLE_ABI_BREAKING_CHECKS` -- LLVM
3331 libraries built with `LLVM_ENABLE_ABI_BREAKING_CHECKS` are not ABI
3332 compatible LLVM libraries built without it defined. By default,
3333 turning on assertions also turns on `LLVM_ENABLE_ABI_BREAKING_CHECKS`
3334 so a default +Asserts build is not ABI compatible with a
3335 default -Asserts build. Clients that want ABI compatibility
3336 between +Asserts and -Asserts builds should use the CMake or autoconf
3337 build systems to set `LLVM_ENABLE_ABI_BREAKING_CHECKS` independently
3338 of `LLVM_ENABLE_ASSERTIONS`.
3342 The Core LLVM Class Hierarchy Reference
3343 =======================================
3345 ``#include "llvm/IR/Type.h"``
3347 header source: `Type.h <http://llvm.org/doxygen/Type_8h_source.html>`_
3349 doxygen info: `Type Clases <http://llvm.org/doxygen/classllvm_1_1Type.html>`_
3351 The Core LLVM classes are the primary means of representing the program being
3352 inspected or transformed. The core LLVM classes are defined in header files in
3353 the ``include/llvm/IR`` directory, and implemented in the ``lib/IR``
3354 directory. It's worth noting that, for historical reasons, this library is
3355 called ``libLLVMCore.so``, not ``libLLVMIR.so`` as you might expect.
3359 The Type class and Derived Types
3360 --------------------------------
3362 ``Type`` is a superclass of all type classes. Every ``Value`` has a ``Type``.
3363 ``Type`` cannot be instantiated directly but only through its subclasses.
3364 Certain primitive types (``VoidType``, ``LabelType``, ``FloatType`` and
3365 ``DoubleType``) have hidden subclasses. They are hidden because they offer no
3366 useful functionality beyond what the ``Type`` class offers except to distinguish
3367 themselves from other subclasses of ``Type``.
3369 All other types are subclasses of ``DerivedType``. Types can be named, but this
3370 is not a requirement. There exists exactly one instance of a given shape at any
3371 one time. This allows type equality to be performed with address equality of
3372 the Type Instance. That is, given two ``Type*`` values, the types are identical
3373 if the pointers are identical.
3377 Important Public Methods
3378 ^^^^^^^^^^^^^^^^^^^^^^^^
3380 * ``bool isIntegerTy() const``: Returns true for any integer type.
3382 * ``bool isFloatingPointTy()``: Return true if this is one of the five
3383 floating point types.
3385 * ``bool isSized()``: Return true if the type has known size. Things
3386 that don't have a size are abstract types, labels and void.
3390 Important Derived Types
3391 ^^^^^^^^^^^^^^^^^^^^^^^
3394 Subclass of DerivedType that represents integer types of any bit width. Any
3395 bit width between ``IntegerType::MIN_INT_BITS`` (1) and
3396 ``IntegerType::MAX_INT_BITS`` (~8 million) can be represented.
3398 * ``static const IntegerType* get(unsigned NumBits)``: get an integer
3399 type of a specific bit width.
3401 * ``unsigned getBitWidth() const``: Get the bit width of an integer type.
3404 This is subclassed by ArrayType and VectorType.
3406 * ``const Type * getElementType() const``: Returns the type of each
3407 of the elements in the sequential type.
3409 * ``uint64_t getNumElements() const``: Returns the number of elements
3410 in the sequential type.
3413 This is a subclass of SequentialType and defines the interface for array
3417 Subclass of Type for pointer types.
3420 Subclass of SequentialType for vector types. A vector type is similar to an
3421 ArrayType but is distinguished because it is a first class type whereas
3422 ArrayType is not. Vector types are used for vector operations and are usually
3423 small vectors of an integer or floating point type.
3426 Subclass of DerivedTypes for struct types.
3431 Subclass of DerivedTypes for function types.
3433 * ``bool isVarArg() const``: Returns true if it's a vararg function.
3435 * ``const Type * getReturnType() const``: Returns the return type of the
3438 * ``const Type * getParamType (unsigned i)``: Returns the type of the ith
3441 * ``const unsigned getNumParams() const``: Returns the number of formal
3446 The ``Module`` class
3447 --------------------
3449 ``#include "llvm/IR/Module.h"``
3451 header source: `Module.h <http://llvm.org/doxygen/Module_8h_source.html>`_
3453 doxygen info: `Module Class <http://llvm.org/doxygen/classllvm_1_1Module.html>`_
3455 The ``Module`` class represents the top level structure present in LLVM
3456 programs. An LLVM module is effectively either a translation unit of the
3457 original program or a combination of several translation units merged by the
3458 linker. The ``Module`` class keeps track of a list of :ref:`Function
3459 <c_Function>`\ s, a list of GlobalVariable_\ s, and a SymbolTable_.
3460 Additionally, it contains a few helpful member functions that try to make common
3465 Important Public Members of the ``Module`` class
3466 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
3468 * ``Module::Module(std::string name = "")``
3470 Constructing a Module_ is easy. You can optionally provide a name for it
3471 (probably based on the name of the translation unit).
3473 * | ``Module::iterator`` - Typedef for function list iterator
3474 | ``Module::const_iterator`` - Typedef for const_iterator.
3475 | ``begin()``, ``end()``, ``size()``, ``empty()``
3477 These are forwarding methods that make it easy to access the contents of a
3478 ``Module`` object's :ref:`Function <c_Function>` list.
3480 * ``Module::FunctionListType &getFunctionList()``
3482 Returns the list of :ref:`Function <c_Function>`\ s. This is necessary to use
3483 when you need to update the list or perform a complex action that doesn't have
3484 a forwarding method.
3488 * | ``Module::global_iterator`` - Typedef for global variable list iterator
3489 | ``Module::const_global_iterator`` - Typedef for const_iterator.
3490 | ``global_begin()``, ``global_end()``, ``global_size()``, ``global_empty()``
3492 These are forwarding methods that make it easy to access the contents of a
3493 ``Module`` object's GlobalVariable_ list.
3495 * ``Module::GlobalListType &getGlobalList()``
3497 Returns the list of GlobalVariable_\ s. This is necessary to use when you
3498 need to update the list or perform a complex action that doesn't have a
3503 * ``SymbolTable *getSymbolTable()``
3505 Return a reference to the SymbolTable_ for this ``Module``.
3509 * ``Function *getFunction(StringRef Name) const``
3511 Look up the specified function in the ``Module`` SymbolTable_. If it does not
3512 exist, return ``null``.
3514 * ``Function *getOrInsertFunction(const std::string &Name, const FunctionType
3517 Look up the specified function in the ``Module`` SymbolTable_. If it does not
3518 exist, add an external declaration for the function and return it.
3520 * ``std::string getTypeName(const Type *Ty)``
3522 If there is at least one entry in the SymbolTable_ for the specified Type_,
3523 return it. Otherwise return the empty string.
3525 * ``bool addTypeName(const std::string &Name, const Type *Ty)``
3527 Insert an entry in the SymbolTable_ mapping ``Name`` to ``Ty``. If there is
3528 already an entry for this name, true is returned and the SymbolTable_ is not
3536 ``#include "llvm/IR/Value.h"``
3538 header source: `Value.h <http://llvm.org/doxygen/Value_8h_source.html>`_
3540 doxygen info: `Value Class <http://llvm.org/doxygen/classllvm_1_1Value.html>`_
3542 The ``Value`` class is the most important class in the LLVM Source base. It
3543 represents a typed value that may be used (among other things) as an operand to
3544 an instruction. There are many different types of ``Value``\ s, such as
3545 Constant_\ s, Argument_\ s. Even Instruction_\ s and :ref:`Function
3546 <c_Function>`\ s are ``Value``\ s.
3548 A particular ``Value`` may be used many times in the LLVM representation for a
3549 program. For example, an incoming argument to a function (represented with an
3550 instance of the Argument_ class) is "used" by every instruction in the function
3551 that references the argument. To keep track of this relationship, the ``Value``
3552 class keeps a list of all of the ``User``\ s that is using it (the User_ class
3553 is a base class for all nodes in the LLVM graph that can refer to ``Value``\ s).
3554 This use list is how LLVM represents def-use information in the program, and is
3555 accessible through the ``use_*`` methods, shown below.
3557 Because LLVM is a typed representation, every LLVM ``Value`` is typed, and this
3558 Type_ is available through the ``getType()`` method. In addition, all LLVM
3559 values can be named. The "name" of the ``Value`` is a symbolic string printed
3562 .. code-block:: llvm
3568 The name of this instruction is "foo". **NOTE** that the name of any value may
3569 be missing (an empty string), so names should **ONLY** be used for debugging
3570 (making the source code easier to read, debugging printouts), they should not be
3571 used to keep track of values or map between them. For this purpose, use a
3572 ``std::map`` of pointers to the ``Value`` itself instead.
3574 One important aspect of LLVM is that there is no distinction between an SSA
3575 variable and the operation that produces it. Because of this, any reference to
3576 the value produced by an instruction (or the value available as an incoming
3577 argument, for example) is represented as a direct pointer to the instance of the
3578 class that represents this value. Although this may take some getting used to,
3579 it simplifies the representation and makes it easier to manipulate.
3583 Important Public Members of the ``Value`` class
3584 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
3586 * | ``Value::use_iterator`` - Typedef for iterator over the use-list
3587 | ``Value::const_use_iterator`` - Typedef for const_iterator over the
3589 | ``unsigned use_size()`` - Returns the number of users of the value.
3590 | ``bool use_empty()`` - Returns true if there are no users.
3591 | ``use_iterator use_begin()`` - Get an iterator to the start of the
3593 | ``use_iterator use_end()`` - Get an iterator to the end of the use-list.
3594 | ``User *use_back()`` - Returns the last element in the list.
3596 These methods are the interface to access the def-use information in LLVM.
3597 As with all other iterators in LLVM, the naming conventions follow the
3598 conventions defined by the STL_.
3600 * ``Type *getType() const``
3601 This method returns the Type of the Value.
3603 * | ``bool hasName() const``
3604 | ``std::string getName() const``
3605 | ``void setName(const std::string &Name)``
3607 This family of methods is used to access and assign a name to a ``Value``, be
3608 aware of the :ref:`precaution above <nameWarning>`.
3610 * ``void replaceAllUsesWith(Value *V)``
3612 This method traverses the use list of a ``Value`` changing all User_\ s of the
3613 current value to refer to "``V``" instead. For example, if you detect that an
3614 instruction always produces a constant value (for example through constant
3615 folding), you can replace all uses of the instruction with the constant like
3620 Inst->replaceAllUsesWith(ConstVal);
3627 ``#include "llvm/IR/User.h"``
3629 header source: `User.h <http://llvm.org/doxygen/User_8h_source.html>`_
3631 doxygen info: `User Class <http://llvm.org/doxygen/classllvm_1_1User.html>`_
3635 The ``User`` class is the common base class of all LLVM nodes that may refer to
3636 ``Value``\ s. It exposes a list of "Operands" that are all of the ``Value``\ s
3637 that the User is referring to. The ``User`` class itself is a subclass of
3640 The operands of a ``User`` point directly to the LLVM ``Value`` that it refers
3641 to. Because LLVM uses Static Single Assignment (SSA) form, there can only be
3642 one definition referred to, allowing this direct connection. This connection
3643 provides the use-def information in LLVM.
3647 Important Public Members of the ``User`` class
3648 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
3650 The ``User`` class exposes the operand list in two ways: through an index access
3651 interface and through an iterator based interface.
3653 * | ``Value *getOperand(unsigned i)``
3654 | ``unsigned getNumOperands()``
3656 These two methods expose the operands of the ``User`` in a convenient form for
3659 * | ``User::op_iterator`` - Typedef for iterator over the operand list
3660 | ``op_iterator op_begin()`` - Get an iterator to the start of the operand
3662 | ``op_iterator op_end()`` - Get an iterator to the end of the operand list.
3664 Together, these methods make up the iterator based interface to the operands
3670 The ``Instruction`` class
3671 -------------------------
3673 ``#include "llvm/IR/Instruction.h"``
3675 header source: `Instruction.h
3676 <http://llvm.org/doxygen/Instruction_8h_source.html>`_
3678 doxygen info: `Instruction Class
3679 <http://llvm.org/doxygen/classllvm_1_1Instruction.html>`_
3681 Superclasses: User_, Value_
3683 The ``Instruction`` class is the common base class for all LLVM instructions.
3684 It provides only a few methods, but is a very commonly used class. The primary
3685 data tracked by the ``Instruction`` class itself is the opcode (instruction
3686 type) and the parent BasicBlock_ the ``Instruction`` is embedded into. To
3687 represent a specific type of instruction, one of many subclasses of
3688 ``Instruction`` are used.
3690 Because the ``Instruction`` class subclasses the User_ class, its operands can
3691 be accessed in the same way as for other ``User``\ s (with the
3692 ``getOperand()``/``getNumOperands()`` and ``op_begin()``/``op_end()`` methods).
3693 An important file for the ``Instruction`` class is the ``llvm/Instruction.def``
3694 file. This file contains some meta-data about the various different types of
3695 instructions in LLVM. It describes the enum values that are used as opcodes
3696 (for example ``Instruction::Add`` and ``Instruction::ICmp``), as well as the
3697 concrete sub-classes of ``Instruction`` that implement the instruction (for
3698 example BinaryOperator_ and CmpInst_). Unfortunately, the use of macros in this
3699 file confuses doxygen, so these enum values don't show up correctly in the
3700 `doxygen output <http://llvm.org/doxygen/classllvm_1_1Instruction.html>`_.
3704 Important Subclasses of the ``Instruction`` class
3705 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
3709 * ``BinaryOperator``
3711 This subclasses represents all two operand instructions whose operands must be
3712 the same type, except for the comparison instructions.
3717 This subclass is the parent of the 12 casting instructions. It provides
3718 common operations on cast instructions.
3724 This subclass respresents the two comparison instructions,
3725 `ICmpInst <LangRef.html#i_icmp>`_ (integer opreands), and
3726 `FCmpInst <LangRef.html#i_fcmp>`_ (floating point operands).
3730 * ``TerminatorInst``
3732 This subclass is the parent of all terminator instructions (those which can
3737 Important Public Members of the ``Instruction`` class
3738 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
3740 * ``BasicBlock *getParent()``
3742 Returns the BasicBlock_ that this
3743 ``Instruction`` is embedded into.
3745 * ``bool mayWriteToMemory()``
3747 Returns true if the instruction writes to memory, i.e. it is a ``call``,
3748 ``free``, ``invoke``, or ``store``.
3750 * ``unsigned getOpcode()``
3752 Returns the opcode for the ``Instruction``.
3754 * ``Instruction *clone() const``
3756 Returns another instance of the specified instruction, identical in all ways
3757 to the original except that the instruction has no parent (i.e. it's not
3758 embedded into a BasicBlock_), and it has no name.
3762 The ``Constant`` class and subclasses
3763 -------------------------------------
3765 Constant represents a base class for different types of constants. It is
3766 subclassed by ConstantInt, ConstantArray, etc. for representing the various
3767 types of Constants. GlobalValue_ is also a subclass, which represents the
3768 address of a global variable or function.
3772 Important Subclasses of Constant
3773 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
3775 * ConstantInt : This subclass of Constant represents an integer constant of
3778 * ``const APInt& getValue() const``: Returns the underlying
3779 value of this constant, an APInt value.
3781 * ``int64_t getSExtValue() const``: Converts the underlying APInt value to an
3782 int64_t via sign extension. If the value (not the bit width) of the APInt
3783 is too large to fit in an int64_t, an assertion will result. For this
3784 reason, use of this method is discouraged.
3786 * ``uint64_t getZExtValue() const``: Converts the underlying APInt value
3787 to a uint64_t via zero extension. IF the value (not the bit width) of the
3788 APInt is too large to fit in a uint64_t, an assertion will result. For this
3789 reason, use of this method is discouraged.
3791 * ``static ConstantInt* get(const APInt& Val)``: Returns the ConstantInt
3792 object that represents the value provided by ``Val``. The type is implied
3793 as the IntegerType that corresponds to the bit width of ``Val``.
3795 * ``static ConstantInt* get(const Type *Ty, uint64_t Val)``: Returns the
3796 ConstantInt object that represents the value provided by ``Val`` for integer
3799 * ConstantFP : This class represents a floating point constant.
3801 * ``double getValue() const``: Returns the underlying value of this constant.
3803 * ConstantArray : This represents a constant array.
3805 * ``const std::vector<Use> &getValues() const``: Returns a vector of
3806 component constants that makeup this array.
3808 * ConstantStruct : This represents a constant struct.
3810 * ``const std::vector<Use> &getValues() const``: Returns a vector of
3811 component constants that makeup this array.
3813 * GlobalValue : This represents either a global variable or a function. In
3814 either case, the value is a constant fixed address (after linking).
3818 The ``GlobalValue`` class
3819 -------------------------
3821 ``#include "llvm/IR/GlobalValue.h"``
3823 header source: `GlobalValue.h
3824 <http://llvm.org/doxygen/GlobalValue_8h_source.html>`_
3826 doxygen info: `GlobalValue Class
3827 <http://llvm.org/doxygen/classllvm_1_1GlobalValue.html>`_
3829 Superclasses: Constant_, User_, Value_
3831 Global values ( GlobalVariable_\ s or :ref:`Function <c_Function>`\ s) are the
3832 only LLVM values that are visible in the bodies of all :ref:`Function
3833 <c_Function>`\ s. Because they are visible at global scope, they are also
3834 subject to linking with other globals defined in different translation units.
3835 To control the linking process, ``GlobalValue``\ s know their linkage rules.
3836 Specifically, ``GlobalValue``\ s know whether they have internal or external
3837 linkage, as defined by the ``LinkageTypes`` enumeration.
3839 If a ``GlobalValue`` has internal linkage (equivalent to being ``static`` in C),
3840 it is not visible to code outside the current translation unit, and does not
3841 participate in linking. If it has external linkage, it is visible to external
3842 code, and does participate in linking. In addition to linkage information,
3843 ``GlobalValue``\ s keep track of which Module_ they are currently part of.
3845 Because ``GlobalValue``\ s are memory objects, they are always referred to by
3846 their **address**. As such, the Type_ of a global is always a pointer to its
3847 contents. It is important to remember this when using the ``GetElementPtrInst``
3848 instruction because this pointer must be dereferenced first. For example, if
3849 you have a ``GlobalVariable`` (a subclass of ``GlobalValue)`` that is an array
3850 of 24 ints, type ``[24 x i32]``, then the ``GlobalVariable`` is a pointer to
3851 that array. Although the address of the first element of this array and the
3852 value of the ``GlobalVariable`` are the same, they have different types. The
3853 ``GlobalVariable``'s type is ``[24 x i32]``. The first element's type is
3854 ``i32.`` Because of this, accessing a global value requires you to dereference
3855 the pointer with ``GetElementPtrInst`` first, then its elements can be accessed.
3856 This is explained in the `LLVM Language Reference Manual
3857 <LangRef.html#globalvars>`_.
3861 Important Public Members of the ``GlobalValue`` class
3862 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
3864 * | ``bool hasInternalLinkage() const``
3865 | ``bool hasExternalLinkage() const``
3866 | ``void setInternalLinkage(bool HasInternalLinkage)``
3868 These methods manipulate the linkage characteristics of the ``GlobalValue``.
3870 * ``Module *getParent()``
3872 This returns the Module_ that the
3873 GlobalValue is currently embedded into.
3877 The ``Function`` class
3878 ----------------------
3880 ``#include "llvm/IR/Function.h"``
3882 header source: `Function.h <http://llvm.org/doxygen/Function_8h_source.html>`_
3884 doxygen info: `Function Class
3885 <http://llvm.org/doxygen/classllvm_1_1Function.html>`_
3887 Superclasses: GlobalValue_, Constant_, User_, Value_
3889 The ``Function`` class represents a single procedure in LLVM. It is actually
3890 one of the more complex classes in the LLVM hierarchy because it must keep track
3891 of a large amount of data. The ``Function`` class keeps track of a list of
3892 BasicBlock_\ s, a list of formal Argument_\ s, and a SymbolTable_.
3894 The list of BasicBlock_\ s is the most commonly used part of ``Function``
3895 objects. The list imposes an implicit ordering of the blocks in the function,
3896 which indicate how the code will be laid out by the backend. Additionally, the
3897 first BasicBlock_ is the implicit entry node for the ``Function``. It is not
3898 legal in LLVM to explicitly branch to this initial block. There are no implicit
3899 exit nodes, and in fact there may be multiple exit nodes from a single
3900 ``Function``. If the BasicBlock_ list is empty, this indicates that the
3901 ``Function`` is actually a function declaration: the actual body of the function
3902 hasn't been linked in yet.
3904 In addition to a list of BasicBlock_\ s, the ``Function`` class also keeps track
3905 of the list of formal Argument_\ s that the function receives. This container
3906 manages the lifetime of the Argument_ nodes, just like the BasicBlock_ list does
3907 for the BasicBlock_\ s.
3909 The SymbolTable_ is a very rarely used LLVM feature that is only used when you
3910 have to look up a value by name. Aside from that, the SymbolTable_ is used
3911 internally to make sure that there are not conflicts between the names of
3912 Instruction_\ s, BasicBlock_\ s, or Argument_\ s in the function body.
3914 Note that ``Function`` is a GlobalValue_ and therefore also a Constant_. The
3915 value of the function is its address (after linking) which is guaranteed to be
3920 Important Public Members of the ``Function``
3921 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
3923 * ``Function(const FunctionType *Ty, LinkageTypes Linkage,
3924 const std::string &N = "", Module* Parent = 0)``
3926 Constructor used when you need to create new ``Function``\ s to add the
3927 program. The constructor must specify the type of the function to create and
3928 what type of linkage the function should have. The FunctionType_ argument
3929 specifies the formal arguments and return value for the function. The same
3930 FunctionType_ value can be used to create multiple functions. The ``Parent``
3931 argument specifies the Module in which the function is defined. If this
3932 argument is provided, the function will automatically be inserted into that
3933 module's list of functions.
3935 * ``bool isDeclaration()``
3937 Return whether or not the ``Function`` has a body defined. If the function is
3938 "external", it does not have a body, and thus must be resolved by linking with
3939 a function defined in a different translation unit.
3941 * | ``Function::iterator`` - Typedef for basic block list iterator
3942 | ``Function::const_iterator`` - Typedef for const_iterator.
3943 | ``begin()``, ``end()``, ``size()``, ``empty()``
3945 These are forwarding methods that make it easy to access the contents of a
3946 ``Function`` object's BasicBlock_ list.
3948 * ``Function::BasicBlockListType &getBasicBlockList()``
3950 Returns the list of BasicBlock_\ s. This is necessary to use when you need to
3951 update the list or perform a complex action that doesn't have a forwarding
3954 * | ``Function::arg_iterator`` - Typedef for the argument list iterator
3955 | ``Function::const_arg_iterator`` - Typedef for const_iterator.
3956 | ``arg_begin()``, ``arg_end()``, ``arg_size()``, ``arg_empty()``
3958 These are forwarding methods that make it easy to access the contents of a
3959 ``Function`` object's Argument_ list.
3961 * ``Function::ArgumentListType &getArgumentList()``
3963 Returns the list of Argument_. This is necessary to use when you need to
3964 update the list or perform a complex action that doesn't have a forwarding
3967 * ``BasicBlock &getEntryBlock()``
3969 Returns the entry ``BasicBlock`` for the function. Because the entry block
3970 for the function is always the first block, this returns the first block of
3973 * | ``Type *getReturnType()``
3974 | ``FunctionType *getFunctionType()``
3976 This traverses the Type_ of the ``Function`` and returns the return type of
3977 the function, or the FunctionType_ of the actual function.
3979 * ``SymbolTable *getSymbolTable()``
3981 Return a pointer to the SymbolTable_ for this ``Function``.
3985 The ``GlobalVariable`` class
3986 ----------------------------
3988 ``#include "llvm/IR/GlobalVariable.h"``
3990 header source: `GlobalVariable.h
3991 <http://llvm.org/doxygen/GlobalVariable_8h_source.html>`_
3993 doxygen info: `GlobalVariable Class
3994 <http://llvm.org/doxygen/classllvm_1_1GlobalVariable.html>`_
3996 Superclasses: GlobalValue_, Constant_, User_, Value_
3998 Global variables are represented with the (surprise surprise) ``GlobalVariable``
3999 class. Like functions, ``GlobalVariable``\ s are also subclasses of
4000 GlobalValue_, and as such are always referenced by their address (global values
4001 must live in memory, so their "name" refers to their constant address). See
4002 GlobalValue_ for more on this. Global variables may have an initial value
4003 (which must be a Constant_), and if they have an initializer, they may be marked
4004 as "constant" themselves (indicating that their contents never change at
4007 .. _m_GlobalVariable:
4009 Important Public Members of the ``GlobalVariable`` class
4010 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
4012 * ``GlobalVariable(const Type *Ty, bool isConstant, LinkageTypes &Linkage,
4013 Constant *Initializer = 0, const std::string &Name = "", Module* Parent = 0)``
4015 Create a new global variable of the specified type. If ``isConstant`` is true
4016 then the global variable will be marked as unchanging for the program. The
4017 Linkage parameter specifies the type of linkage (internal, external, weak,
4018 linkonce, appending) for the variable. If the linkage is InternalLinkage,
4019 WeakAnyLinkage, WeakODRLinkage, LinkOnceAnyLinkage or LinkOnceODRLinkage, then
4020 the resultant global variable will have internal linkage. AppendingLinkage
4021 concatenates together all instances (in different translation units) of the
4022 variable into a single variable but is only applicable to arrays. See the
4023 `LLVM Language Reference <LangRef.html#modulestructure>`_ for further details
4024 on linkage types. Optionally an initializer, a name, and the module to put
4025 the variable into may be specified for the global variable as well.
4027 * ``bool isConstant() const``
4029 Returns true if this is a global variable that is known not to be modified at
4032 * ``bool hasInitializer()``
4034 Returns true if this ``GlobalVariable`` has an intializer.
4036 * ``Constant *getInitializer()``
4038 Returns the initial value for a ``GlobalVariable``. It is not legal to call
4039 this method if there is no initializer.
4043 The ``BasicBlock`` class
4044 ------------------------
4046 ``#include "llvm/IR/BasicBlock.h"``
4048 header source: `BasicBlock.h
4049 <http://llvm.org/doxygen/BasicBlock_8h_source.html>`_
4051 doxygen info: `BasicBlock Class
4052 <http://llvm.org/doxygen/classllvm_1_1BasicBlock.html>`_
4056 This class represents a single entry single exit section of the code, commonly
4057 known as a basic block by the compiler community. The ``BasicBlock`` class
4058 maintains a list of Instruction_\ s, which form the body of the block. Matching
4059 the language definition, the last element of this list of instructions is always
4060 a terminator instruction (a subclass of the TerminatorInst_ class).
4062 In addition to tracking the list of instructions that make up the block, the
4063 ``BasicBlock`` class also keeps track of the :ref:`Function <c_Function>` that
4064 it is embedded into.
4066 Note that ``BasicBlock``\ s themselves are Value_\ s, because they are
4067 referenced by instructions like branches and can go in the switch tables.
4068 ``BasicBlock``\ s have type ``label``.
4072 Important Public Members of the ``BasicBlock`` class
4073 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
4075 * ``BasicBlock(const std::string &Name = "", Function *Parent = 0)``
4077 The ``BasicBlock`` constructor is used to create new basic blocks for
4078 insertion into a function. The constructor optionally takes a name for the
4079 new block, and a :ref:`Function <c_Function>` to insert it into. If the
4080 ``Parent`` parameter is specified, the new ``BasicBlock`` is automatically
4081 inserted at the end of the specified :ref:`Function <c_Function>`, if not
4082 specified, the BasicBlock must be manually inserted into the :ref:`Function
4085 * | ``BasicBlock::iterator`` - Typedef for instruction list iterator
4086 | ``BasicBlock::const_iterator`` - Typedef for const_iterator.
4087 | ``begin()``, ``end()``, ``front()``, ``back()``,
4088 ``size()``, ``empty()``
4089 STL-style functions for accessing the instruction list.
4091 These methods and typedefs are forwarding functions that have the same
4092 semantics as the standard library methods of the same names. These methods
4093 expose the underlying instruction list of a basic block in a way that is easy
4094 to manipulate. To get the full complement of container operations (including
4095 operations to update the list), you must use the ``getInstList()`` method.
4097 * ``BasicBlock::InstListType &getInstList()``
4099 This method is used to get access to the underlying container that actually
4100 holds the Instructions. This method must be used when there isn't a
4101 forwarding function in the ``BasicBlock`` class for the operation that you
4102 would like to perform. Because there are no forwarding functions for
4103 "updating" operations, you need to use this if you want to update the contents
4104 of a ``BasicBlock``.
4106 * ``Function *getParent()``
4108 Returns a pointer to :ref:`Function <c_Function>` the block is embedded into,
4109 or a null pointer if it is homeless.
4111 * ``TerminatorInst *getTerminator()``
4113 Returns a pointer to the terminator instruction that appears at the end of the
4114 ``BasicBlock``. If there is no terminator instruction, or if the last
4115 instruction in the block is not a terminator, then a null pointer is returned.
4119 The ``Argument`` class
4120 ----------------------
4122 This subclass of Value defines the interface for incoming formal arguments to a
4123 function. A Function maintains a list of its formal arguments. An argument has
4124 a pointer to the parent Function.