cpg-language-llvm/de.fraunhofer.aisec.cpg.frontends.llvm/LLVMIRLanguageFrontend

LLVMIRLanguageFrontend

class LLVMIRLanguageFrontend(language: Language<LLVMIRLanguageFrontend>, config: TranslationConfiguration, scopeManager: ScopeManager) : LanguageFrontend

Constructors

fun LLVMIRLanguageFrontend(language: Language<LLVMIRLanguageFrontend>, config: TranslationConfiguration, scopeManager: ScopeManager)

Types

Companion

object Companion

Functions

build

fun build(init: LanguageFrontend.() -> TranslationUnitDeclaration): TranslationUnitDeclaration

cleanup

open fun cleanup()

clearProcessed

fun clearProcessed()

getCodeFromRawNode

open override fun <T> getCodeFromRawNode(astNode: T): String?

getCodeOfSubregion

fun getCodeOfSubregion(node: Node, nodeRegion: Region, subRegion: Region): String

getLocationFromRawNode

open override fun <T> getLocationFromRawNode(astNode: T): PhysicalLocation?

getNameOf

fun getNameOf(valueRef: LLVMValueRef): Pair<String, String>

Returns a pair of the name and symbol name of valueRef.

getNewLineType

fun getNewLineType(node: Node): String

getOperandValueAtIndex

fun getOperandValueAtIndex(instr: LLVMValueRef, idx: Int): Expression

guessSlotNumber

fun guessSlotNumber(valueRef: LLVMValueRef): String

isKnownStructTypeName

fun isKnownStructTypeName(name: String): Boolean

Determines if a struct with name exists in the scope.

mergeRegions

fun mergeRegions(regionOne: Region, regionTwo: Region): Region

parse

open override fun parse(file: File): TranslationUnitDeclaration

parseAll

fun parseAll(): List<TranslationUnitDeclaration>

process

open fun process(from: Any, to: Node)

registerObjectListener

open fun registerObjectListener(from: Any, biConsumer: BiConsumer<Any, Node>)

registerPredicateListener

open fun registerPredicateListener(predicate: BiPredicate<Any, Node>, biConsumer: BiConsumer<Any, Node>)

setCodeAndLocation

open override fun <N, S> setCodeAndLocation(cpgNode: N, astNode: S?)

setComment

open override fun <S, T> setComment(s: S, ctx: T)

typeOf

fun typeOf(valueRef: LLVMValueRef): Type

Properties

bindingsCache

var bindingsCache: MutableMap<String, Declaration>

This contains a cache binding between an LLVMValueRef (representing a variable) and its Declaration in the graph. We need this, because this way we can look up and connect a DeclaredReferenceExpression to its Declaration already in the language frontend. This in turn is needed because of the local/global system we cannot rely on the VariableUsageResolver.

config

val config: TranslationConfiguration

ctx

var ctx: LLVMContextRef? = null

currentTU

var currentTU: TranslationUnitDeclaration?

declarationHandler

val declarationHandler: DeclarationHandler

expressionHandler

val expressionHandler: ExpressionHandler

language