# 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>`

Description: Create a converter for a processor.
parameter: proc: processor

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

Description: Create a converter for a processor and register bitsize.
parameter: proc: processor
parameter: registerBitsize: general\-purpose register bitsize

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

Description: Create a converter for a processor, register bitsize, and address bitsize.
parameter: proc: processor
parameter: registerBitsize: general\-purpose register bitsize
parameter: addressBitsize: address bitsize

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

Description: Create a converter for a native context.
parameter: nctx: native context

## 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`
Description: True to suppress generated NOP statements.

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

## Protected Field: methodConversionCountFailure
Type: `int`
Description: Number of routine conversions that failed.

## Protected Field: methodConversionCountSuccess
Type: `int`
Description: Number of routine conversions that completed successfully.

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

## Protected Field: parameterRegistersForAllCC
Type: `java.util.Set<java.lang.Long>`
Description: Parameter registers for all calling conventions, using native register ids.

## Protected Field: proc
Type: `com.pnfsoftware.jeb.core.units.code.asm.processor.IProcessor<InsnType>`
Description: Processor used by this converter.

## Protected Field: regNormalBitsize
Type: `int`
Description: Standard register size, in bits.

## Protected Field: spoiledRegistersForAllCC
Type: `java.util.Set<java.lang.Long>`
Description: Spoiled registers for all calling conventions, using native register ids.

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

Description: Attempt call inlining through registered extensions.
parameter: e: instruction entry to convert
parameter: target: call target address
return: true if an extension inlined the call

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

Description: Attempt instruction conversion through registered extensions.
parameter: e: instruction entry to convert
return: true if an extension converted the instruction

## 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`

Description: Apply an auto\-conversion semantic description to an instruction entry.
parameter: e: instruction entry to convert
parameter: acs: auto\-conversion semantic description
return: true if conversion succeeded

## 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: native basic block to convert
return: converted IR statements

## 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: instruction entry to convert

## 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`

Description: Attempt a first\-chance instruction conversion.
parameter: e: instruction entry to convert
parameter: mn: instruction mnemonic
parameter: allowRecurse: true if recursive conversion is allowed
return: true if the instruction was converted

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

Description: Attempt a last\-chance instruction conversion.
parameter: e: instruction entry to convert
return: true if the instruction was converted

## 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: native instruction address
parameter: insn: native instruction
parameter: opndIndex: operand index
return: converted operand expression

## 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`

Description: Determine whether generated NOP statements are suppressed.
return: true if generated NOP statements are suppressed

## 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: native routine being converted
parameter: ctx: routine conversion context

## 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: destination list for converted IR statements
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: native routine being converted
parameter: ctx: routine conversion context
parameter: irlist: current list of converted IR statements

## 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: Set the current routine conversion context used by helper converter classes.
parameter: ctx: current routine context

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

Description: Reserved.
parameter: decompiler: owning decompiler context

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

Description: Set whether generated NOP statements should be suppressed.
parameter: doNotGenerateNops: true to suppress generated NOP statements

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

Description: Set the native context used by this converter.
parameter: nctx: native context