Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## avrora.stack
Interface AnalyzerPolicy

All Known Implementing Classes:
  Analyzer.ContextSensitivePolicy

public interface AnalyzerPolicy

The `Policy` interface allows for more modular, composable analysis. An instance of this class is passed to the `AbstractInterpreter` and that instance determines how to handle calls, returns, indirect jumps, and stack operations in the abstract interpretation. Thus, multiple anlayses can share the same core abstract interpreter in a clean way.

See Also:
  `AbstractInterpreter`

Method Summary
`MutableState` | `call(MutableState s, int target_address)` The `call()` method is called by the abstract interpreter when it encounters a call instruction within the program.
`MutableState` | `indirectCall(MutableState s, char addr_low, char addr_hi)` The `indirectCall()` method is called by the abstract interpreter when it encounters an indirect call within the program.
`MutableState` | `indirectCall(MutableState s, char addr_low, char addr_hi, char ext)` The `indirectCall()` method is called by the abstract interpreter when it encounters an indirect call within the program.
`MutableState` | `indirectJump(MutableState s, char addr_low, char addr_hi)` The `indirectJump()` method is called by the abstract interpreter when it encounters an indirect jump within the program.
`MutableState` | `indirectJump(MutableState s, char addr_low, char addr_hi, char ext)` The `indirectJump()` method is called by the abstract interpreter when it encounters an indirect jump within the program.
`MutableState` | `interrupt(MutableState s, int num)` The `interrupt()` is called by the abstract interrupt when it encounters a place in the program when an interrupt might occur.
`char` | `pop(MutableState s)` The `pop()` method is called by the abstract interpreter when a pop from the stack is ecountered in the program.
`void` | `push(MutableState s, char val)` The `push()` method is called by the abstract interpreter when a push to the stack is encountered in the program.
`void` | `pushState(MutableState newState)` The `pushState` method is called by the abstract interpreter when a state is forked by the abstract interpreter (for example when a branch condition is not known and both branches must be taken.
`MutableState` | `ret(MutableState s)` The `ret()` method is called by the abstract interpreter when it encounters a return within the program.
`MutableState` | `reti(MutableState s)` The `reti()` method is called by the abstract interpreter when it encounters a return from an interrupt within the program.

Method Detail

### call

    public MutableState call(MutableState s,
                             int target_address)

  The `call()` method is called by the abstract interpreter when it encounters a call instruction within the program. Different policies may handle calls differently. For example, a context-sensitive analysis might fork and start analysis the called method in this context, which a context insensitive analsysis may just merge the current state into the entrance state for that address and then reanalyze that code.

  Parameters:
    `s` - the current calling abstract state
    `target_address` - the concrete target address of the call
  Returns:
    the state of the program after the call, null if there is no next state

### interrupt

    public MutableState interrupt(MutableState s,
                                  int num)

  The `interrupt()` is called by the abstract interrupt when it encounters a place in the program when an interrupt might occur.

  Parameters:
    `s` - the abstract state just before interrupt
    `num` - the interrupt number that might occur
  Returns:
    the state of the program after the interrupt, null if there is no next state

### ret

    public MutableState ret(MutableState s)

  The `ret()` method is called by the abstract interpreter when it encounters a return within the program.

  Parameters:
    `s` - the current abstract state
  Returns:
    the state of the program after the call, null if there is no next state

### reti

    public MutableState reti(MutableState s)

  The `reti()` method is called by the abstract interpreter when it encounters a return from an interrupt within the program.

  Parameters:
    `s` - the current abstract state
  Returns:
    the state of the program after the call, null if there is no next state

### indirectCall

    public MutableState indirectCall(MutableState s,
                                     char addr_low,
                                     char addr_hi)

  The `indirectCall()` method is called by the abstract interpreter when it encounters an indirect call within the program. The abstract values of the address are given as parameters, so that a policy can choose to compute possible targets or be conservative or whatever it so chooses.

  Parameters:
    `s` - the current abstract state
    `addr_low` - the (abstract) low byte of the address
    `addr_hi` - the (abstract) high byte of the address
  Returns:
    the state of the program after the call, null if there is no next state

### indirectJump

    public MutableState indirectJump(MutableState s,
                                     char addr_low,
                                     char addr_hi)

  The `indirectJump()` method is called by the abstract interpreter when it encounters an indirect jump within the program. The abstract values of the address are given as parameters, so that a policy can choose to compute possible targets or be conservative or whatever it so chooses.

  Parameters:
    `s` - the current abstract state
    `addr_low` - the (abstract) low byte of the address
    `addr_hi` - the (abstract) high byte of the address
  Returns:
    the state of the program after the call, null if there is no next state

### indirectCall

    public MutableState indirectCall(MutableState s,
                                     char addr_low,
                                     char addr_hi,
                                     char ext)

  The `indirectCall()` method is called by the abstract interpreter when it encounters an indirect call within the program. The abstract values of the address are given as parameters, so that a policy can choose to compute possible targets or be conservative or whatever it so chooses.

  Parameters:
    `s` - the current abstract state
    `addr_low` - the (abstract) low byte of the address
    `addr_hi` - the (abstract) high byte of the address
    `ext` - the (abstract) extended part of the address
  Returns:
    the state of the program after the call, null if there is no next state

### indirectJump

    public MutableState indirectJump(MutableState s,
                                     char addr_low,
                                     char addr_hi,
                                     char ext)

  The `indirectJump()` method is called by the abstract interpreter when it encounters an indirect jump within the program. The abstract values of the address are given as parameters, so that a policy can choose to compute possible targets or be conservative or whatever it so chooses.

  Parameters:
    `s` - the current abstract state
    `addr_low` - the (abstract) low byte of the address
    `addr_hi` - the (abstract) high byte of the address
    `ext` - the (abstract) extended part of the address
  Returns:
    the state of the program after the call, null if there is no next state

### push

    public void push(MutableState s,
                     char val)

  The `push()` method is called by the abstract interpreter when a push to the stack is encountered in the program. The policy can then choose what outgoing and/or modelling of the stack needs to be done.

  Parameters:
    `s` - the current abstract state
    `val` - the abstract value to push onto the stack

### pop

    public char pop(MutableState s)

  The `pop()` method is called by the abstract interpreter when a pop from the stack is ecountered in the program. The policy can then choose to either return whatever information it has about the stack contents, or return an UNKNOWN value.

  Parameters:
    `s` - the current abstract state
  Returns:
    the abstract value popped from the stack

### pushState

    public void pushState(MutableState newState)

  The `pushState` method is called by the abstract interpreter when a state is forked by the abstract interpreter (for example when a branch condition is not known and both branches must be taken.

  Parameters:
    `newState` - the new state created

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD