# Class: com.pnfsoftware.jeb.core.units.code.asm.decompiler.AbstractConverter
- Type Parameter: InsnType extends `com.pnfsoftware.jeb.core.units.code.IInstruction`

- Super class: `java.lang.Object`
- Super interfaces: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IEConverter<InsnType>`

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

## Final 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](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement.md) if they are not present.
parameter: b: block to be converted
parameter: interlist: output list of converted IR statements

## Final 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](com.pnfsoftware.jeb.core.units.code.asm.decompiler.AbstractConverter.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.

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


## Final 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.

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


## Final 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 Final 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](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEJump.md) 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 Final 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](com.pnfsoftware.jeb.core.units.code.asm.cfg.BasicBlock.md) 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