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 1114fa0f21173bfc7e2f0a40778703374c7b15a3..1d5a52f21b3fa6029f532dbad25295a0c0aaacf3 100644 (file)
--- a/docs/WritingAnLLVMPass.rst
+++ b/docs/WritingAnLLVMPass.rst
@@ -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;


@@ -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:
 


@@ -457,7 +455,7 @@ To be explicit, ``FunctionPass`` subclasses are not allowed to:
 #. 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``.
 #. 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``.

-#. 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();
   }