Implement LLVM Argument, Type(s); Better Function/Instruction represe…

…ntation

OPAL/ll/src/main/scala/org/opalj/ll/llvm/Argument.scala

@@ -0,0 +1,11 @@
+/* BSD 2-Clause License - see OPAL/LICENSE for details. */
+package org.opalj.ll.llvm
+
+import org.bytedeco.llvm.LLVM.LLVMValueRef
+import org.bytedeco.llvm.global.LLVM.{LLVMArgumentValueKind, LLVMGetParamParent, LLVMGetValueKind}
+
+case class Argument(ref: LLVMValueRef) extends Value(ref) {
+    assert(LLVMGetValueKind(ref) == LLVMArgumentValueKind, "ref has to be an argument")
+
+    def parent(): Function = Function(LLVMGetParamParent(ref))
+}

OPAL/ll/src/main/scala/org/opalj/ll/llvm/Function.scala

@@ -2,15 +2,7 @@
 package org.opalj.ll.llvm
 
 import org.bytedeco.llvm.LLVM.{LLVMBasicBlockRef, LLVMValueRef}
-import org.bytedeco.llvm.global.LLVM.{
-    LLVMFunctionValueKind,
-    LLVMGetEntryBasicBlock,
-    LLVMGetFirstBasicBlock,
-    LLVMGetNextBasicBlock,
-    LLVMGetValueKind,
-    LLVMViewFunctionCFG,
-    LLVMViewFunctionCFGOnly
-}
+import org.bytedeco.llvm.global.LLVM.{LLVMFunctionValueKind, LLVMGetEntryBasicBlock, LLVMGetFirstBasicBlock, LLVMGetFirstParam, LLVMGetNextBasicBlock, LLVMGetNextParam, LLVMGetValueKind, LLVMViewFunctionCFG, LLVMViewFunctionCFGOnly}
 import org.opalj.io.writeAndOpen
 
 case class Function(ref: LLVMValueRef) extends Value(ref) {
@@ -20,6 +12,10 @@ case class Function(ref: LLVMValueRef) extends Value(ref) {
         new BasicBlockIterator(LLVMGetFirstBasicBlock(ref))
     }
 
+    def arguments(): ArgumentIterator = {
+        new ArgumentIterator(LLVMGetFirstParam(ref))
+    }
+
     def entryBlock(): BasicBlock = {
         BasicBlock(LLVMGetEntryBasicBlock(ref))
     }
@@ -38,6 +34,9 @@ case class Function(ref: LLVMValueRef) extends Value(ref) {
         }
     }
 
+    override def toString: String = {
+        s"Function(${name()}(${arguments.map(_.typ().repr()).mkString(", ")}))"
+    }
 }
 
 class BasicBlockIterator(var ref: LLVMBasicBlockRef) extends Iterator[BasicBlock] {
@@ -49,3 +48,13 @@ class BasicBlockIterator(var ref: LLVMBasicBlockRef) extends Iterator[BasicBlock
         basicBlock
     }
 }
+
+class ArgumentIterator(var ref: LLVMValueRef) extends Iterator[Argument] {
+    override def hasNext: Boolean = ref != null
+
+    override def next(): Argument = {
+        val argument = Argument(ref)
+        this.ref = LLVMGetNextParam(ref)
+        argument
+    }
+}

OPAL/ll/src/main/scala/org/opalj/ll/llvm/Instruction.scala

@@ -105,10 +105,14 @@ sealed abstract class Instruction(ref: LLVMValueRef) extends Value(ref) {
     def parent(): BasicBlock = BasicBlock(LLVMGetInstructionParent(ref))
     def function(): Function = parent.parent
     def next(): Option[Instruction] = OptionalInstruction(LLVMGetNextInstruction(ref))
+
     /*def successors(): Seq[Instruction] = next match {
         case Some(successor) ⇒ Seq(successor)
         case None            ⇒ Seq()
     }*/
+    override def toString: String = {
+        s"${this.getClass.getSimpleName}(${repr()})"
+    }
 }
 
 case class Ret(ref: LLVMValueRef) extends Instruction(ref) with Terminator

OPAL/ll/src/main/scala/org/opalj/ll/llvm/Type.scala

@@ -0,0 +1,84 @@
+/* BSD 2-Clause License - see OPAL/LICENSE for details. */
+package org.opalj.ll.llvm
+
+import org.bytedeco.llvm.LLVM.LLVMTypeRef
+import org.bytedeco.llvm.global.LLVM._
+
+object Type {
+    def apply(ref: LLVMTypeRef): Type = {
+        LLVMGetTypeKind(ref) match {
+            case LLVMVoidTypeKind           ⇒ VoidType(ref)
+            case LLVMHalfTypeKind           ⇒ HalfType(ref)
+            case LLVMFloatTypeKind          ⇒ FloatType(ref)
+            case LLVMDoubleTypeKind         ⇒ DoubleType(ref)
+            case LLVMX86_FP80TypeKind       ⇒ X86_FP80Type(ref)
+            case LLVMFP128TypeKind          ⇒ FP128Type(ref)
+            case LLVMPPC_FP128TypeKind      ⇒ PPC_FP128Type(ref)
+            case LLVMLabelTypeKind          ⇒ LabelType(ref)
+            case LLVMIntegerTypeKind        ⇒ IntegerType(ref)
+            case LLVMFunctionTypeKind       ⇒ FunctionType(ref)
+            case LLVMStructTypeKind         ⇒ StructType(ref)
+            case LLVMArrayTypeKind          ⇒ ArrayType(ref)
+            case LLVMPointerTypeKind        ⇒ PointerType(ref)
+            case LLVMVectorTypeKind         ⇒ VectorType(ref)
+            case LLVMMetadataTypeKind       ⇒ MetadataType(ref)
+            case LLVMX86_MMXTypeKind        ⇒ X86_MMXType(ref)
+            case LLVMTokenTypeKind          ⇒ TokenType(ref)
+            case LLVMScalableVectorTypeKind ⇒ ScalableVectorType(ref)
+            case LLVMBFloatTypeKind         ⇒ FloatType(ref)
+            case typeKind                   ⇒ throw new IllegalArgumentException("unknown type kind: "+typeKind)
+        }
+    }
+}
+
+sealed abstract class Type(ref: LLVMTypeRef) {
+    def repr(): String = {
+        val bytePointer = LLVMPrintTypeToString(ref)
+        val string = bytePointer.getString
+        LLVMDisposeMessage(bytePointer)
+        string
+    }
+
+  override def toString: String = s"Type(${repr()})"
+}
+
+/** type with no size */
+case class VoidType(ref: LLVMTypeRef) extends Type(ref)
+/** 16 bit floating point type */
+case class HalfType(ref: LLVMTypeRef) extends Type(ref)
+/** 32 bit floating point type */
+case class FloatType(ref: LLVMTypeRef) extends Type(ref)
+/** 64 bit floating point type */
+case class DoubleType(ref: LLVMTypeRef) extends Type(ref)
+/** 80 bit floating point type (X87) */
+case class X86_FP80Type(ref: LLVMTypeRef) extends Type(ref)
+/** 128 bit floating point type (112-bit mantissa) */
+case class FP128Type(ref: LLVMTypeRef) extends Type(ref)
+/** 128 bit floating point type (two 64-bits) */
+case class PPC_FP128Type(ref: LLVMTypeRef) extends Type(ref)
+/** Labels */
+case class LabelType(ref: LLVMTypeRef) extends Type(ref)
+/** Arbitrary bit width integers */
+case class IntegerType(ref: LLVMTypeRef) extends Type(ref)
+/** Functions */
+case class FunctionType(ref: LLVMTypeRef) extends Type(ref) {
+   def returnType(): Type = Type(LLVMGetReturnType(ref))
+}
+/** Structures */
+case class StructType(ref: LLVMTypeRef) extends Type(ref)
+/** Arrays */
+case class ArrayType(ref: LLVMTypeRef) extends Type(ref)
+/** Pointers */
+case class PointerType(ref: LLVMTypeRef) extends Type(ref)
+/** Fixed width SIMD vector type */
+case class VectorType(ref: LLVMTypeRef) extends Type(ref)
+/** Metadata */
+case class MetadataType(ref: LLVMTypeRef) extends Type(ref)
+/** X86 MMX */
+case class X86_MMXType(ref: LLVMTypeRef) extends Type(ref)
+/** Tokens */
+case class TokenType(ref: LLVMTypeRef) extends Type(ref)
+/** Scalable SIMD vector type */
+case class ScalableVectorType(ref: LLVMTypeRef) extends Type(ref)
+/** 16 bit brain floating point type */
+case class BFloatType(ref: LLVMTypeRef) extends Type(ref)

OPAL/ll/src/main/scala/org/opalj/ll/llvm/Value.scala

@@ -17,6 +17,8 @@ class Value(ref: LLVMValueRef) extends OptionalValue {
     def name(): String = {
         LLVMGetValueName(ref).getString
     }
+
+    def typ(): Type = Type(LLVMTypeOf(ref))
 }
 
 case class NullValue() extends OptionalValue