add methods for LLVMTargetDataRef

Tests/LLVMSharp.UnitTests/TargetData.cs

@@ -0,0 +1,67 @@
+using LLVMSharp.Interop;
+using NUnit.Framework;
+
+namespace LLVMSharp.UnitTests
+{
+    class TargetData
+    {
+        [Test]
+        public void OffsetTest()
+        {
+            LLVMModuleRef m = LLVMModuleRef.CreateWithName("netscripten");
+            LLVMExecutionEngineRef engineRef = m.CreateExecutionEngine();
+            LLVMTargetDataRef target = engineRef.TargetData;
+            LLVMTypeRef testStruct = LLVMTypeRef.CreateStruct(
+                new[]
+                {
+                    LLVMTypeRef.Int16,
+                    LLVMTypeRef.Int32
+                }, true);
+
+            Assert.AreEqual(0, target.OffsetOfElement(testStruct, 0));
+            Assert.AreEqual(2, target.OffsetOfElement(testStruct, 1));
+
+            Assert.AreEqual(target.ElementAtOffset(testStruct, 0), 0);
+            Assert.AreEqual(target.ElementAtOffset(testStruct, 2), 1);
+        }
+
+        [Test]
+        public void SizeTest()
+        {
+            LLVMModuleRef m = LLVMModuleRef.CreateWithName("netscripten");
+            LLVMExecutionEngineRef engineRef = m.CreateExecutionEngine();
+            LLVMTargetDataRef target = engineRef.TargetData;
+            LLVMTypeRef testStruct = LLVMTypeRef.CreateStruct(
+                new[]
+                {
+                    LLVMTypeRef.Int16,
+                    LLVMTypeRef.Int32
+                }, true);
+
+            Assert.AreEqual(48, target.SizeOfTypeInBits(testStruct));
+            Assert.AreEqual(6, target.StoreSizeOfType(testStruct));
+            Assert.AreEqual(6, target.ABISizeOfType(testStruct));
+        }
+
+        [Test]
+        public void AlignmentTest()
+        {
+            LLVMModuleRef m = LLVMModuleRef.CreateWithName("netscripten");
+            LLVMExecutionEngineRef engineRef = m.CreateExecutionEngine();
+            LLVMTargetDataRef target = engineRef.TargetData;
+            LLVMTypeRef testStruct = LLVMTypeRef.CreateStruct(
+                new[]
+                {
+                    LLVMTypeRef.Int16,
+                    LLVMTypeRef.Int32
+                }, true);
+
+            Assert.AreEqual(1, target.ABIAlignmentOfType(testStruct));
+            Assert.AreEqual(1, target.CallFrameAlignmentOfType(testStruct));
+            Assert.AreEqual(8, target.PreferredAlignmentOfType(testStruct));
+
+            LLVMValueRef global = m.AddGlobal(LLVMTypeRef.CreatePointer(LLVMTypeRef.Int8, 0), "someGlobal");
+            Assert.AreEqual(8, target.PreferredAlignmentOfGlobal(global));
+        }
+    }
+}

sources/LLVMSharp/Interop.Extensions/LLVMTargetDataRef.cs

@@ -32,5 +32,50 @@ public static implicit operator LLVMTargetDataRef(LLVMOpaqueTargetData* TargetDa
         public bool Equals(LLVMTargetDataRef other) => Handle == other.Handle;
 
         public override int GetHashCode() => Handle.GetHashCode();
+
+        public ulong OffsetOfElement(LLVMTypeRef type, uint element)
+        {
+            return LLVM.OffsetOfElement(this, type, element);
+        }
+
+        public ulong ElementAtOffset(LLVMTypeRef type, ulong offset)
+        {
+            return LLVM.ElementAtOffset(this, type, offset);
+        }
+
+        public ulong SizeOfTypeInBits(LLVMTypeRef type)
+        {
+            return LLVM.SizeOfTypeInBits(this, type);
+        }
+
+        public ulong StoreSizeOfType(LLVMTypeRef type)
+        {
+            return LLVM.StoreSizeOfType(this, type);
+        }
+
+        public ulong ABISizeOfType(LLVMTypeRef type)
+        {
+            return LLVM.ABISizeOfType(this, type);
+        }
+
+        public uint ABIAlignmentOfType(LLVMTypeRef type)
+        {
+            return LLVM.ABIAlignmentOfType(this, type);
+        }
+
+        public uint CallFrameAlignmentOfType(LLVMTypeRef type)
+        {
+            return LLVM.CallFrameAlignmentOfType(this, type);
+        }
+
+        public uint PreferredAlignmentOfType(LLVMTypeRef type)
+        {
+            return LLVM.PreferredAlignmentOfType(this, type);
+        }
+
+        public uint PreferredAlignmentOfGlobal(LLVMValueRef globalVar)
+        {
+            return LLVM.PreferredAlignmentOfGlobal(this, globalVar);
+        }
     }
 }

sources/LLVMSharp/LLVMTargetData.cs

@@ -0,0 +1,59 @@
+using LLVMSharp.Interop;
+
+namespace LLVMSharp
+{
+    public class LLVMTargetData
+    {
+        private readonly LLVMTargetDataRef _llvmTargetDataRef;
+
+        public LLVMTargetData(LLVMTargetDataRef llvmTargetDataRef)
+        {
+            _llvmTargetDataRef = llvmTargetDataRef;
+        }
+
+        public ulong OffsetOfElement(LLVMTypeRef type, uint element)
+        {
+            return _llvmTargetDataRef.OffsetOfElement(type, element);
+        }
+
+        public ulong ElementAtOffset(LLVMTypeRef type, ulong offset)
+        {
+            return _llvmTargetDataRef.ElementAtOffset(type, offset);
+        }
+
+        public ulong SizeOfTypeInBits(LLVMTypeRef type)
+        {
+            return _llvmTargetDataRef.SizeOfTypeInBits(type);
+        }
+
+        public ulong StoreSizeOfType(LLVMTypeRef type)
+        {
+            return _llvmTargetDataRef.StoreSizeOfType(type);
+        }
+
+        public ulong ABISizeOfType(LLVMTypeRef type)
+        {
+            return _llvmTargetDataRef.ABISizeOfType(type);
+        }
+
+        public uint ABIAlignmentOfType(LLVMTypeRef type)
+        {
+            return _llvmTargetDataRef.ABIAlignmentOfType(type);
+        }
+
+        public uint CallFrameAlignmentOfType(LLVMTypeRef type)
+        {
+            return _llvmTargetDataRef.CallFrameAlignmentOfType(type);
+        }
+
+        public uint PreferredAlignmentOfType(LLVMTypeRef type)
+        {
+            return _llvmTargetDataRef.PreferredAlignmentOfType(type);
+        }
+
+        public uint PreferredAlignmentOfGlobal(LLVMValueRef globalVar)
+        {
+            return _llvmTargetDataRef.PreferredAlignmentOfGlobal(globalVar);
+        }
+    }
+}