Fields

• withArchConstraints :: forall a. (ArchConstraints arch => a) -> a

  Provides the architecture constraints to any computation that needs it.

• archAddrWidth :: !(AddrWidthRepr (ArchAddrWidth arch))

  Architecture address width.

• archEndianness :: !Endianness

  The byte order values are stored in.

• extractBlockPrecond :: !(ArchSegmentOff arch -> AbsBlockState (ArchReg arch) -> Either String (ArchBlockPrecond arch))

  Attempt to use abstract domain information to extract information needed to translate block.

• initialBlockRegs :: !(forall ids. ArchSegmentOff arch -> ArchBlockPrecond arch -> RegState (ArchReg arch) (Value arch ids))

  Create initial registers from address and precondition.

• disassembleFn :: !(DisassembleFn arch)

  Function for disassembling a block.

• mkInitialAbsState :: !(Memory (ArchAddrWidth arch) -> ArchSegmentOff arch -> AbsBlockState (ArchReg arch))

  Creates an abstract block state for representing the beginning of a function.

  The address is the entry point of the function.

• absEvalArchFn :: !(forall ids (tp :: Type). AbsProcessorState (ArchReg arch) ids -> ArchFn arch (Value arch ids) tp -> AbsValue (ArchAddrWidth arch) tp)

  Evaluates an architecture-specific function

• absEvalArchStmt :: !(forall ids. AbsProcessorState (ArchReg arch) ids -> ArchStmt arch (Value arch ids) -> AbsProcessorState (ArchReg arch) ids)

  Evaluates an architecture-specific statement

• identifyCall :: forall ids. Memory (ArchAddrWidth arch) -> Seq (Stmt arch ids) -> RegState (ArchReg arch) (Value arch ids) -> Maybe (Seq (Stmt arch ids), ArchSegmentOff arch)

  Function for recognizing call statements.

  Given a memory state, list of statements, and final register state, the should determine if this is a call, and if so, return the statements with any action to push the return value to the stack removed, and provide the return address that the function should return to.

• archCallParams :: !(CallParams (ArchReg arch))

  Update the abstract state after a function call returns

• checkForReturnAddr :: forall ids. RegState (ArchReg arch) (Value arch ids) -> AbsProcessorState (ArchReg arch) ids -> Bool

  checkForReturnAddr regs s returns true if the location where the return address is normally stored in regs when calling a function does indeed contain the abstract value associated with return addresses.

  For x86 this checks if the address just above the stack is the return address. For ARM, this should check the link register.

  This predicate is invoked when considering if a potential tail call is setup to return to the right location.

• identifyReturn :: forall ids. Seq (Stmt arch ids) -> RegState (ArchReg arch) (Value arch ids) -> AbsProcessorState (ArchReg arch) ids -> Maybe (Seq (Stmt arch ids))

  Identify returns to the classifier.

  Given a list of statements and the final state of the registers, this should return 'Just stmts' if this code looks like a function return. The stmts should be a subset of the statements, but may remove unneeded memory accesses like reading the stack pointer.

• rewriteArchFn :: forall s src tgt (tp :: Type). ArchFn arch (Value arch src) tp -> Rewriter arch s src tgt (Value arch tgt tp)

  This rewrites an architecture specific statement

• rewriteArchStmt :: forall s src tgt. ArchStmt arch (Value arch src) -> Rewriter arch s src tgt ()

  This rewrites an architecture specific statement

• rewriteArchTermStmt :: forall s src tgt. ArchTermStmt arch (Value arch src) -> Rewriter arch s src tgt (ArchTermStmt arch (Value arch tgt))

  This rewrites an architecture specific statement

• archDemandContext :: !(DemandContext arch)

  Provides architecture-specific information for computing which arguments must be evaluated when evaluating a statement.

• postArchTermStmtAbsState :: !(forall ids. Memory (ArchAddrWidth arch) -> AbsProcessorState (ArchReg arch) ids -> IntraJumpBounds arch ids -> RegState (ArchReg arch) (Value arch ids) -> ArchTermStmt arch (Value arch ids) -> Maybe (IntraJumpTarget arch))

  This takes an abstract state from before executing an abs state, and an architecture-specific terminal statement.

  If the statement does not return to this function, this function should return Nothing. Otherwise, it should returns the next address within the procedure that the statement jumps to along with the updated abstract state.

  Note that per their documentation, architecture specific statements may return to at most one location within a function.

• archClassifier :: !(forall ids. BlockClassifier arch ids)

  The block classifier to use for this architecture, which can be customized

Fields

• classifierParseContext :: !(ParseContext arch ids)

  Information needed to construct abstract processor states

• classifierInitRegState :: !(RegState (ArchReg arch) (Value arch ids))

  The (concrete) register state at the beginning of the block

• classifierStmts :: !(Seq (Stmt arch ids))

  The statements of the block (without the terminator)

• classifierBlockSize :: !Int

  Size of block being classified.

• classifierAbsState :: !(AbsProcessorState (ArchReg arch) ids)

  The abstract processor state before the terminator is executed

• classifierJumpBounds :: !(IntraJumpBounds arch ids)

  The relational abstract processor state before the terminator is executed

• classifierWrittenAddrs :: ![ArchSegmentOff arch]

  The addresses of observed memory writes in the block

• classifierFinalRegState :: !(RegState (ArchReg arch) (Value arch ids))

  The final (concrete) register state before the terminator is executed

Fields

• pctxMemory :: !(Memory (ArchAddrWidth arch))
   
• pctxArchInfo :: !(ArchitectureInfo arch)
   
• pctxKnownFnEntries :: !(Map (ArchSegmentOff arch) NoReturnFunStatus)

  Entry addresses for known functions (e.g. from symbol information)

  The discovery process will not create intra-procedural jumps to the entry points of new functions.

• pctxFunAddr :: !(ArchSegmentOff arch)

  Address of function containing this block.

• pctxAddr :: !(ArchSegmentOff arch)

  Address of the current block

• pctxExtResolution :: [(ArchSegmentOff arch, [ArchSegmentOff arch])]

  Externally-provided resolutions for classification failures, which are used in parseFetchAndExecute