# Class: com.pnfsoftware.jeb.core.units.code.asm.decompiler.AbstractConverter

Skeleton class for code converters. A converter is implemented as part of a decompiler plugin. It provides routines to translate low\-level machine code to a `gendec` intermediate representation.

## Protected Constructor: AbstractConverter
- parameter: `proc`, type: `com.pnfsoftware.jeb.core.units.code.asm.processor.IProcessor<InsnType>`


## Protected Constructor: AbstractConverter
- parameter: `proc`, type: `com.pnfsoftware.jeb.core.units.code.asm.processor.IProcessor<InsnType>`
- parameter: `registerBitsize`, type: `int`


## Protected Constructor: AbstractConverter
- parameter: `proc`, type: `com.pnfsoftware.jeb.core.units.code.asm.processor.IProcessor<InsnType>`
- parameter: `registerBitsize`, type: `int`
- parameter: `addressBitsize`, type: `int`


## Protected Constructor: AbstractConverter
- parameter: `nctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.INativeContext`


## Protected Field: ctx
Type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
Description: Per\-routine data \- works because convert\(\) is not re\-entrant \(same found in X86ConvXxx helper classes\).
 Should be set before converting a routine, and reset to null after it's done.

## Protected Field: doNotGenerateNops
Type: `boolean`

## Protected Field: gCtx
Type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IEGlobalContext`

## Protected Field: methodConversionCountFailure
Type: `int`

## Protected Field: methodConversionCountSuccess
Type: `int`

## Protected Field: nctx
Type: `com.pnfsoftware.jeb.core.units.code.asm.INativeContext`

## Protected Field: parameterRegistersForAllCC
Type: `java.util.Set<java.lang.Long>`

## Protected Field: proc
Type: `com.pnfsoftware.jeb.core.units.code.asm.processor.IProcessor<InsnType>`

## Protected Field: regNormalBitsize
Type: `int`

## Protected Field: spoiledRegistersForAllCC
Type: `java.util.Set<java.lang.Long>`

## Protected Method: attemptCallInliningByExtension
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ConverterInstructionEntry<InsnType>`
- parameter: `target`, type: `long`
- return type: `boolean`


## Protected Method: attemptConversionByExtension
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ConverterInstructionEntry<InsnType>`
- return type: `boolean`


## Method: autoConvert
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ConverterInstructionEntry<InsnType>`
- parameter: `acs`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ACS`
- return type: `boolean`


## Method: buildFailsafePrototype
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `stm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardPrototype`

Description: The default implementation provides a no\-arg/no\-return prototype: "void \_\_defaultCC \(\)". 

 Custom implementations may return something more suitable to a given architecture

## Method: canCreateCalls
- return type: `boolean`

Description: The default implementation returns true.

## Method: convert
- parameter: `routine`, type: `com.pnfsoftware.jeb.core.units.code.asm.items.INativeMethodItem`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`

Description: Convert the blocks of the native routine's CFG after the other. The blocks' edges are not considered. 

 The default implementation works as follows: 
 
- call [preRoutineConversion](#preRoutineConversion(INativeMethodItem, IERoutineContext, List))
-  
- for each block: 
 
  - call [preBlockConversion](#preBlockConversion(CFG, BasicBlock, List))
  -  
  - call [convertBlock](#convertBlock(BasicBlock, List))
  -  
  - call [postBlockConversion](#postBlockConversion(CFG, BasicBlock, List, int))
  -  

 
-  
- call [postRoutineConversion](#postRoutineConversion(INativeMethodItem, IERoutineContext)) once
-  

  It is recommended to use the default implementation.

## Protected Method: convertBlock
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.BasicBlock<InsnType>`
- parameter: `interlist`, type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`

Description: Convert a basic block. This method may be overridden. The lower\-level addresses are set on [IEStatement](IEStatement) if they are not present.
parameter: b: block to be converted
parameter: interlist: output list of converted IR statements

## Method: convertBlockForTest
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.BasicBlock<InsnType>`
- return type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`

Description: Reserved for testing.
parameter: b: 
return: 

## Method: convertInstruction
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ConverterInstructionEntry<InsnType>`

Description: This method is called by [#convertBlock(BasicBlock, List)](#convertBlock(BasicBlock, List)). If this method is **not** overridden, the methods [#convertInstructionFirstChance(ConverterInstructionEntry, String, boolean)](#convertInstructionFirstChance(ConverterInstructionEntry, String, boolean)) and [#convertInstructionLastChance(ConverterInstructionEntry)](#convertInstructionLastChance(ConverterInstructionEntry)) must be implemented. If this method is overridden, the two aforementioned methods can be ignored.
parameter: e: 

## Protected Method: convertInstructionFirstChance
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ConverterInstructionEntry<InsnType>`
- parameter: `mn`, type: `java.lang.String`
- parameter: `allowRecurse`, type: `boolean`
- return type: `boolean`


## Protected Method: convertInstructionLastChance
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ConverterInstructionEntry<InsnType>`
- return type: `boolean`


## Protected Method: convertOperand
- parameter: `insnAddress`, type: `long`
- parameter: `insn`, type: `InsnType`
- parameter: `opndIndex`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: This method is called by the [AutoConverter](AutoConverter). If the auto\-converter is used, it must be implemented.
parameter: insnAddress: 
parameter: insn: 
parameter: opndIndex: 
return: 

## Method: convertParameterExpressions
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `prototype`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardPrototype`
- parameter: `targetRoutine`, type: `com.pnfsoftware.jeb.core.units.code.asm.items.INativeMethodItem`
- parameter: `varArgTypes`, type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType>`
- return type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric>`


## Method: convertReturnExpressions
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `prototype`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardPrototype`
- parameter: `targetRoutine`, type: `com.pnfsoftware.jeb.core.units.code.asm.items.INativeMethodItem`
- parameter: `varArgTypes`, type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType>`
- parameter: `outSpoiled`, type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric>`
- return type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric>`


## Method: convertReturnLocation
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `prototype`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardPrototype`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`


## Method: createStackMemoryAccess
- parameter: `address`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `bitsize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEMem`

Description: The default implementation assumes a segment\-less memory model. \(The EMem segment component is set to null.\)

## Method: customInitStateRegisters
- parameter: `state`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EState`
- parameter: `optionalNativeProgramCounter`, type: `java.lang.Long`

Description: The default implementation does nothing.

## Method: defaultPCConversion
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- return type: `int`


## Method: determineStackBytesUsedByCall
- parameter: `prototype`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardPrototype`
- parameter: `varArgTypes`, type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType>`
- return type: `java.lang.Integer`


## Method: determineStackPointerDeltaAfterIRCall
- parameter: `prototype`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardPrototype`
- parameter: `varArgTypes`, type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType>`
- return type: `java.lang.Integer`


## Method: determineStackPointerDeltaFromSimulation
- parameter: `simuinfo`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.SimulationPointInformation`
- return type: `java.lang.Integer`

Description: The default implementation returns null.

## Method: evaluateUntranslatedIR
- parameter: `insn`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEUntranslatedInstruction`
- parameter: `ectx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `state`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EState`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`

Description: The default implementation returns null.

## Method: formatStatistics
- return type: `java.lang.String`

Description: The default implementation formats basic details about the number of converted methods.

## Method: generateASTForUntranslatedIR
- parameter: `insn`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEUntranslatedInstruction`
- parameter: `ectx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `cctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ast.ICMethod`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ast.ICStatement`

Description: The default implementation returns null.

## Method: getAddressBitsize
- return type: `int`

Description: The default implementation returns the size of the program counter.

## Method: getDecompiler
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.INativeDecompilerContext`


## Method: getDefaultBranchToRoutineSideEffects
- parameter: `optionalRoutine`, type: `com.pnfsoftware.jeb.core.units.code.asm.items.INativeMethodItem`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEBranchDetails`

Description: The default implementation returns a basic branch detail object specifying nothing \(no def, no use, no spoils, etc.\). 

 Converters should override this method.

## Method: getFPRegister
- parameter: `index`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar`


## Method: getGPRegister
- parameter: `index`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar`


## Method: getGlobalContext
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IEGlobalContext`


## Method: getInputVariableByIndex
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `i`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar`

Description: The default implementation returns null.

## Method: getNativeContext
- return type: `com.pnfsoftware.jeb.core.units.code.asm.INativeContext`


## Method: getNativeRegisterIdFromRegisterVariable
- parameter: `regVar`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar`
- parameter: `shortForm`, type: `boolean`
- return type: `long`

Description: The default implementation attempts to resolve the register variable by querying the associated processor's register bank layout. It throws if the resolution fails.

## Method: getNativeRegisterIdFromRegisterVariable
- parameter: `regVar`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar`
- return type: `long`


## Method: getOutputVariableByIndex
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `i`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar`

Description: The default implementation returns null.

## Method: getPrototypeHandler
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEPrototypeHandler`


## Method: getRegister
- parameter: `name`, type: `java.lang.String`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`


## Method: getRegister
- parameter: `name`, type: `java.lang.String`
- parameter: `loc`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.ELocation`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: The default implementation forwards to [IEGlobalContext#getVariableByName(String)](IEGlobalContext#getVariableByName(String)).

## Method: getRegisterBitsize
- return type: `int`

Description: The default implementation returns the address bitsize.

## Method: getRegisterVariableFromNativeRegisterId
- parameter: `nativeRegId`, type: `long`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`


## Method: getRegisterVariableFromNativeRegisterId
- parameter: `nativeRegId`, type: `long`
- parameter: `loc`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.ELocation`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: The default implementation attempts to resolve the native register id or number by querying the associated processor's register bank layout. It throws if the resolution fails.

## Method: getReturnAddressRegister
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar`

Description: The default implementation considers that there is no specific Return Address Register. Override if one exists.

## Method: getSlicedRegisterName
- parameter: `registerName`, type: `java.lang.String`
- parameter: `bitstart`, type: `int`
- parameter: `bitend`, type: `int`
- return type: `java.lang.String`


## Method: getStackSlotSize
- return type: `int`


## Method: getStateProcessorMode
- parameter: `state`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EState`
- return type: `int`


## Method: getTempRegister
- parameter: `index`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar`


## Method: getWildcardTypeManagerDefaultResolutionGroup
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType.Group`

Description: The default implementation returns [Group#INTEGER](Group#INTEGER).

## Method: initialize


## Method: initializeStateRegisters
- parameter: `state`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EState`
- parameter: `optionalNativeProgramCounter`, type: `java.lang.Long`

Description: This method initializes and sets all physical registers declared by this converter to 0, except for the ones possibly used as arguments that are kept undefined \(see [#isPossibleParameterRegisterForProcessorCallingConventions(long)](#isPossibleParameterRegisterForProcessorCallingConventions(long))\). After this is done, [#customInitStateRegisters(EState, Long)](#customInitStateRegisters(EState, Long)) is invoked.

## Protected Method: insertOptionalEntryPointTrampoline
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `irlist`, type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`
- return type: `boolean`

Description: For native routines that have their entry point in\-the\-middle \(i.e., not at their lowest address\), insert a synthetic [IEJump](IEJump) as the first instruction of the converted method. 

 That ensures that native routines that have their entry\-point in the middle of their code can be converted to IR routines with an entry\-point always set to offset 0 \(the beginning of the IR code\). The reason is that this helps with graph manipulation passes that come later on, in the AST phases.
parameter: ctx: translation context
parameter: irlist: the current list of converted IR statements, which should be empty when this            method is called
return: true if a trampoline was inserted, false if it was not needed \(and therefore, not         inserted\)

## Method: insertReturns
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- return type: `int`


## Method: isDoNotGenerateNops
- return type: `boolean`


## Protected Method: isPCRightValueCompatibleReturnValue
- parameter: `dfa`, type: `com.pnfsoftware.jeb.core.units.code.IDFA<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.BasicBlock<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`
- parameter: `PCRightVal`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `expectedReturnAddress`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Can be overridden by implementors when complex return expression matching is needed.
parameter: dfa: current DFA
parameter: b: [BasicBlock](BasicBlock) containing the PC assign instruction \(last one of the block\)
parameter: PCRightVal: right Value of the PC assign instruction
parameter: expectedReturnAddress: expected return expression \(should be an IEVar\) per the selected calling convention
return: true if right value is equivalent to a return instruction

## Method: isPossibleParameterRegisterForProcessorCallingConventions
- parameter: `nativeRegId`, type: `long`
- return type: `boolean`

Description: Check if a native register id corresponds to a register that can possibly be used as a routine parameter on this processor. 

 To do so, the given id is compared against all input registers for all known calling conventions for the current processor. In particular, this method does not rely on the routine prototype and calling convention being defined, and can therefore be used early on during decompilation.
parameter: nativeRegId: native register id
return: true if the provided register id corresponds to a register that can be used as a         parameter, false otherwise

## Method: isPossibleSpoiledRegistersForProcessorCallingConventions
- parameter: `nativeRegId`, type: `long`
- return type: `boolean`

Description: Check if a native register id corresponds to a physical register that can possibly be spoiled by a routine call on this processor. 

 To do so, the given id is compared against all spoiled registers for all known calling conventions for the current processor. In particular, this method does not rely on the routine prototype and calling convention being defined, and can therefore be used early on during decompilation.
parameter: nativeRegId: native register id
return: true if the provided a native register id is a register that can be spoiled by a         routine call, false otherwise

## Method: isSegmentEMemReferencingPrimaryMemory
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEMem`
- return type: `java.lang.Boolean`

Description: The default implementation returns true: by default, all EMem are assumed to reference bytes in the primary VM.

## Method: normalizeBranchingExpression
- parameter: `dfa`, type: `com.pnfsoftware.jeb.core.units.code.IDFA<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.BasicBlock<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`
- parameter: `target`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `expectedTarget`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`


## Protected Method: postBlockConversion
- parameter: `cfg`, type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.CFG<InsnType>`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.BasicBlock<InsnType>`
- parameter: `interlist`, type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`
- parameter: `cnt`, type: `int`

Description: This method is called after [#convertBlock(BasicBlock, List)](#convertBlock(BasicBlock, List)) is called. The default implementation sanitizes fake calls, i.e. it switches call\-to\-sub\-PC\-assigns to regular PC\-assigns if the underlying analyzer detected that what looked like a call\-to\-sub is not.
parameter: cfg: the native CFG of the method being converted
parameter: b: the native basic block that was just converted
parameter: interlist: the current list of IR statements for the routine \(not only for the provided            block\!\); the last IR statements in that list are those of the routine that was            just converted
parameter: cnt: the number of IR statements that correspond to the conversion of the provided            native block

## Protected Method: postRoutineConversion
- parameter: `routine`, type: `com.pnfsoftware.jeb.core.units.code.asm.items.INativeMethodItem`
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`

Description: Executed by [convert](#convert(INativeMethodItem)) after converting the blocks. The default implementation does nothing.
parameter: routine: 
parameter: ctx: 

## Protected Method: preBlockConversion
- parameter: `cfg`, type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.CFG<InsnType>`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.BasicBlock<InsnType>`
- parameter: `interlist`, type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.BasicBlock<InsnType>`

Description: This method is called before [#convertBlock(BasicBlock, List)](#convertBlock(BasicBlock, List)) is called. It can be overridden. Sub\-classes do not need to call the default implementation. The default implementation returns the provided input block.
parameter: cfg: the CFG
parameter: b: block about to be converted
parameter: interlist: 
return: the provided input block or a new block

## Protected Method: preRoutineConversion
- parameter: `routine`, type: `com.pnfsoftware.jeb.core.units.code.asm.items.INativeMethodItem`
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `irlist`, type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`

Description: Executed by [convert](#convert(INativeMethodItem)) before converting the blocks. The default implementation simply calls [#insertOptionalEntryPointTrampoline(IERoutineContext, List)](#insertOptionalEntryPointTrampoline(IERoutineContext, List)).
parameter: routine: 
parameter: ctx: 

## Method: resolveCustomCalls
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- return type: `boolean`


## Method: sanitizeNativeAddress
- parameter: `address`, type: `long`
- return type: `long`

Description: The default implementation truncates the provided value to accomodate [#getAddressBitsize()](#getAddressBitsize()).

## Method: setCurrentContext
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`

Description: setup the helper converter classes

## Method: setDecompiler
- parameter: `decompiler`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.INativeDecompilerContext`

Description: Reserved.
parameter: decompiler: 

## Method: setDoNotGenerateNops
- parameter: `doNotGenerateNops`, type: `boolean`


## Method: setNativeContext
- parameter: `nctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.INativeContext`


