LLVM Programmer's Mannual---阅读笔记



The isa<>, cast<> and dyn_cast<> templates
The LLVM source-base makes extensive use of a custom form of RTTI. 
RTTI (Run-Time Type Identification)

The isa<> operator works exactly like the Java "instanceof" operator. It returns true or false depending on whether a reference or pointer points to an instance of the specified class.


The cast<> operator is a "checked cast" operation. It converts a pointer or reference from a base class to a derived class, causing an assertion failure if it is not really an instance of the right type.


The dyn_cast<> operator is a "checking cast" operation. It checks to see if the operand is of the specified type, and if so, returns a pointer to it (this operator does not work with references). If the operand is not of the correct type, a null pointer is returned.

Passing strings(the StringRef and Twine classes)
Instead, many LLVM APIs use a StringRef or a const Twine& for passing strings efficiently.
The StringRef class
The StringRef data type represents a reference to a constant string (a character array and a length) and supports the common operations available on std:string, but does not require heap allocation.
The Twine class
The Twine class is an efficient way for APIs to accept concatenated strings.

The DEBUG() macro and -debug option
The Statistic class & -stats option
The "llvm/ADT/Statistic.h" file provides a class named Statistic that is used as a unified way to keep track of what the LLVM compiler is doing and how effective various optimizations  are. It is useful to see what optimizations are contributing to making a particular program run faster.

Turning an iterator into a class pointer (and vice-versa)

Instead of dereferencing the iterator and then taking the address of the result, you can simply assign the iterator to the proper pointer type and you get the dereference and address-of operation as a result of the assignment (behind the scenes, this is a result of overloading casting mechanisms). It's also possible to turn a class pointer into the corresponding iterator, and this is a constant time operation (very efficient).

Iterating over def-use & use-def chains
Function *F = ...;

for (Value::use_iterator i = F->use_begin(), e = F->use_end(); i != e; ++i)
  if (Instruction *Inst = dyn_cast<Instruction>(*i)) {
    errs() << "F is used in instruction:\n";
    errs() << *Inst << "\n";

Instruction *pi = ...;

for (User::op_iterator i = pi->op_begin(), e = pi->op_end(); i != e; ++i) {
  Value *v = *i;
  // ...



©️2019 CSDN 皮肤主题: 技术工厂 设计师: CSDN官方博客