Misc fixes

c0lorw0lf · Nov 14, 2017 · 49ec967 · 49ec967
1 parent d796833
commit 49ec967
Show file tree

Hide file tree

Showing 2 changed files with 10 additions and 12 deletions.
diff --git a/docs/analyses.md b/docs/analyses.md
@@ -1,24 +1,23 @@
 # Analyses
 
 angr's goal is to make it easy to carry out useful analyses on binary programs.
-This section will discuss how to run and create these analyses.
+To this end, angr allows you to package analysis code in a common format that can be easily applied to any project.
+We will cover writing your own analyses [later](analysis_writing.md), but the idea is that all the analyses appear under `project.analyses` (for example, `project.analyses.CFGFast()`) and can be called as functions, returning analysis result instances.
 
 ## Built-in Analyses
 
-angr comes with several built-in analyses:
-
 | Name                                        | Description                                                                                                                               |
 | --------                                    | -------------                                                                                                                             |
-| CFGFast                                     | Constructs a fast *Control Flow Graph* of the program. `b.analyses.CFG()` is what you want.                                               |
-| [CFGAccurate](analyses/cfg_accurate.md)     | Constructs an accurate *Control Flow Graph* of the program. The simple way to do is via `b.analyses.CFGAccurate()`.                       |
-| VFG                                         | Performs VSA on every function of the program, creating a *Value Flow Graph* and detecting stack variables.                               |
-| DDG                                         | Calculates a data dependency graph, allowing one to determine what statements a given value depends on.                                   |
+| CFGFast                                     | Constructs a fast *Control Flow Graph* of the program                                                                                     |
+| [CFGAccurate](analyses/cfg_accurate.md)     | Constructs an accurate *Control Flow Graph* of the program                                                                                |
+| VFG                                         | Performs VSA on every function of the program, creating a *Value Flow Graph* and detecting stack variables                                |
+| DDG                                         | Calculates a *Data Dependency Graph*, allowing one to determine what statements a given value depends on                                  |
 | [DFG](analyses/dfg.md)                      | Constructs a *Data Flow Graph* for each basic block present in the CFG                                                                    |
-| [BackwardSlice](analyses/backward_slice.md) | Computes a backward slice of a program w.r.t. a certain target.                                                                           |
-| [Identifier](analyses/identifier.md)        | Identifies common library functions in CGC binaries. |
+| [BackwardSlice](analyses/backward_slice.md) | Computes a *Backward Slice* of a program with respect to a certain target                                                                 |
+| [Identifier](analyses/identifier.md)        | Identifies common library functions in CGC binaries                                                                                       |
 | More!                                       | angr has quite a few analyses, most of which work! If you'd like to know how to use one, please submit an issue requesting documentation. |
 
-### Resilience
+## Resilience
 
 Analyses can be written to be resilient, and catch and log basically any error.
 These errors, depending on how they're caught, are logged to the `errors` or `named_errors` attribute of the analysis.

diff --git a/docs/toplevel.md b/docs/toplevel.md
@@ -173,7 +173,7 @@ If a state lets us represent a program at a given point in time, there must be a
 First, we create the simulation manager we're going to be using. The constructor can take a state or a list of states.
 
 ```python
->>> simgr = proj.factory.simgr(state) # TODO: change name before merge
+>>> simgr = proj.factory.simulation_manager(state)
 <SimulationManager with 1 active>
 >>> simgr.active
 [<SimState @ 0x401670>]
@@ -241,4 +241,3 @@ A couple of these are documented later in this book, but in general, if you want
 ## Now what?
 
 Having read this page, you should now be aquainted with several important angr concepts: basic blocks, states, bitvectors, simulation managers, and analyses. You can't really do anything interesting besides just use angr as a glorified debugger, though! Keep reading, and you will unlock deeper powers...
-