AArch64: use a different means to determine whether to byte swap relocations.

[oota-llvm.git] / docs / WritingAnLLVMPass.rst

diff --git a/docs/WritingAnLLVMPass.rst b/docs/WritingAnLLVMPass.rst
index b10d98f87e2ba1599d91445d0b4187f838e2637a..1d5a52f21b3fa6029f532dbad25295a0c0aaacf3 100644 (file)
--- a/docs/WritingAnLLVMPass.rst
+++ b/docs/WritingAnLLVMPass.rst
@@ -96,7 +96,7 @@ Start out with:
 .. code-block:: c++
 
   #include "llvm/Pass.h"
 .. code-block:: c++
 
   #include "llvm/Pass.h"

-  #include "llvm/Function.h"
+  #include "llvm/IR/Function.h"

   #include "llvm/Support/raw_ostream.h"
 
 Which are needed because we are writing a `Pass
   #include "llvm/Support/raw_ostream.h"
 
 Which are needed because we are writing a `Pass


@@ -131,7 +131,7 @@ Next, we declare our pass itself:
 
   struct Hello : public FunctionPass {
 
 
   struct Hello : public FunctionPass {
 

-This declares a "``Hello``" class that is a subclass of `FunctionPass
+This declares a "``Hello``" class that is a subclass of :ref:`FunctionPass

 <writing-an-llvm-pass-FunctionPass>`.  The different builtin pass subclasses
 are described in detail :ref:`later <writing-an-llvm-pass-pass-classes>`, but
 for now, know that ``FunctionPass`` operates on a function at a time.
 <writing-an-llvm-pass-FunctionPass>`.  The different builtin pass subclasses
 are described in detail :ref:`later <writing-an-llvm-pass-pass-classes>`, but
 for now, know that ``FunctionPass`` operates on a function at a time.


@@ -146,7 +146,7 @@ to avoid using expensive C++ runtime information.
 
 .. code-block:: c++
 
 
 .. code-block:: c++
 

-      virtual bool runOnFunction(Function &F) {
+      bool runOnFunction(Function &F) override {

         errs() << "Hello: ";
         errs().write_escaped(F.getName()) << "\n";
         return false;
         errs() << "Hello: ";
         errs().write_escaped(F.getName()) << "\n";
         return false;


@@ -184,7 +184,7 @@ As a whole, the ``.cpp`` file looks like:
 .. code-block:: c++
 
     #include "llvm/Pass.h"
 .. code-block:: c++
 
     #include "llvm/Pass.h"

-    #include "llvm/Function.h"
+    #include "llvm/IR/Function.h"

     #include "llvm/Support/raw_ostream.h"
 
     using namespace llvm;
     #include "llvm/Support/raw_ostream.h"
 
     using namespace llvm;


@@ -194,7 +194,7 @@ As a whole, the ``.cpp`` file looks like:
         static char ID;
         Hello() : FunctionPass(ID) {}
 
         static char ID;
         Hello() : FunctionPass(ID) {}
 

-        virtual bool runOnFunction(Function &F) {
+        bool runOnFunction(Function &F) override {

           errs() << "Hello: ";
           errs().write_escaped(F.getName()) << '\n';
           return false;
           errs() << "Hello: ";
           errs().write_escaped(F.getName()) << '\n';
           return false;


@@ -259,7 +259,6 @@ To see what happened to the other string you registered, try running
       -hello                    - Hello World Pass
       -indvars                  - Induction Variable Simplification
       -inline                   - Function Integration/Inlining
       -hello                    - Hello World Pass
       -indvars                  - Induction Variable Simplification
       -inline                   - Function Integration/Inlining

-      -insert-edge-profiling    - Insert instrumentation for edge profiling

   ...
 
 The pass name gets added as the information string for your pass, giving some
   ...
 
 The pass name gets added as the information string for your pass, giving some


@@ -435,9 +434,8 @@ The ``doFinalization(CallGraph &)`` method
   virtual bool doFinalization(CallGraph &CG);
 
 The ``doFinalization`` method is an infrequently used method that is called
   virtual bool doFinalization(CallGraph &CG);
 
 The ``doFinalization`` method is an infrequently used method that is called

-when the pass framework has finished calling :ref:`runOnFunction
-<writing-an-llvm-pass-runOnFunction>` for every function in the program being
-compiled.
+when the pass framework has finished calling :ref:`runOnSCC
+<writing-an-llvm-pass-runOnSCC>` for every SCC in the program being compiled.

 
 .. _writing-an-llvm-pass-FunctionPass:
 
 
 .. _writing-an-llvm-pass-FunctionPass:
 


@@ -454,10 +452,10 @@ external functions.
 
 To be explicit, ``FunctionPass`` subclasses are not allowed to:
 
 
 To be explicit, ``FunctionPass`` subclasses are not allowed to:
 

-#. Modify a ``Function`` other than the one currently being processed.
+#. Inspect or modify a ``Function`` other than the one currently being processed.

 #. Add or remove ``Function``\ s from the current ``Module``.
 #. Add or remove global variables from the current ``Module``.
 #. Add or remove ``Function``\ s from the current ``Module``.
 #. Add or remove global variables from the current ``Module``.

-#. Maintain state across invocations of:ref:`runOnFunction
+#. Maintain state across invocations of :ref:`runOnFunction

    <writing-an-llvm-pass-runOnFunction>` (including global data).
 
 Implementing a ``FunctionPass`` is usually straightforward (See the :ref:`Hello
    <writing-an-llvm-pass-runOnFunction>` (including global data).
 
 Implementing a ``FunctionPass`` is usually straightforward (See the :ref:`Hello


@@ -855,7 +853,7 @@ Example implementations of ``getAnalysisUsage``
   // This example modifies the program, but does not modify the CFG
   void LICM::getAnalysisUsage(AnalysisUsage &AU) const {
     AU.setPreservesCFG();
   // This example modifies the program, but does not modify the CFG
   void LICM::getAnalysisUsage(AnalysisUsage &AU) const {
     AU.setPreservesCFG();

-    AU.addRequired<LoopInfo>();
+    AU.addRequired<LoopInfoWrapperPass>();

   }
 
 .. _writing-an-llvm-pass-getAnalysis:
   }
 
 .. _writing-an-llvm-pass-getAnalysis:


@@ -872,7 +870,7 @@ you want, and returns a reference to that pass.  For example:
 .. code-block:: c++
 
   bool LICM::runOnFunction(Function &F) {
 .. code-block:: c++
 
   bool LICM::runOnFunction(Function &F) {

-    LoopInfo &LI = getAnalysis<LoopInfo>();
+    LoopInfo &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();

     //...
   }
 
     //...
   }
 


@@ -1164,7 +1162,7 @@ all!  To fix this, we need to add the following :ref:`getAnalysisUsage
 .. code-block:: c++
 
   // We don't modify the program, so we preserve all analyses
 .. code-block:: c++
 
   // We don't modify the program, so we preserve all analyses

-  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+  void getAnalysisUsage(AnalysisUsage &AU) const override {

     AU.setPreservesAll();
   }
 
     AU.setPreservesAll();
   }