C Integer Types

Author: tothambrus11

.devcontainer/devcontainer.json

@@ -36,14 +36,16 @@
             },
             // Add the IDs of extensions you want installed when the container is created.
             "extensions": [
-                "sswg.swift-lang"
+                "sswg.swift-lang",
+                "swiftlang.swift-vscode"
             ]
         }
     },
     // Use 'forwardPorts' to make a list of ports inside the container available locally.
     // "forwardPorts": [],
     "containerEnv": {
-        "HYLO_LLVM_BUILD_TYPE": "${localEnv:HYLO_LLVM_BUILD_TYPE:MinSizeRel}"
+        "HYLO_LLVM_BUILD_TYPE": "${localEnv:HYLO_LLVM_BUILD_TYPE:MinSizeRel}",
+        "HYLO_USE_BUILTIN_STDLIB": "true" // point standard library diagnostics to the sources
     },
     "remoteEnv": {
         "PATH": "/opt/llvm-${containerEnv:HYLO_LLVM_BUILD_TYPE}/bin:${containerEnv:PATH}"

Package.resolved

@@ -79,10 +79,13 @@ struct ConcreteTypeLayout {
       self.init(size: 8, alignment: 8)
     case .float128:
       self.init(size: 16, alignment: 8)
+    case .cNumeric(let cType):
+      self.init(size: cType.size, alignment: cType.alignment)
     case .module:
       notLLVMRepresentable(^t)
     }
     checkInvariant()
   }
 
 }
+

Sources/CodeGen/LLVM/ConcreteTypeLayout.swift

@@ -1126,6 +1126,15 @@ extension SwiftyLLVM.Module {
         let source = llvm(s.operands[0])
         register[.register(i)] = insertPtrToInt(source, to: target, at: insertionPoint)
 
+      case .fromcint(let cIntType, let targetType):
+        insertTruncateOrExtend(
+          sourceType: .cNumeric(cIntType), targetType: targetType, sourceValue: llvm(s.operands[0]),
+          isSourceTypeSigned: cIntType.signedInteger, for: i)
+      case .tocint(let hyloIntegerType, let targetCType, let sourceTypeSigned):
+        insertTruncateOrExtend(
+          sourceType: hyloIntegerType, targetType: .cNumeric(targetCType),
+          sourceValue: llvm(s.operands[0]),
+          isSourceTypeSigned: sourceTypeSigned, for: i)
       case .fadd:
         let l = llvm(s.operands[0])
         let r = llvm(s.operands[1])
@@ -1606,6 +1615,32 @@ extension SwiftyLLVM.Module {
       register[.register(i)] = ptr.null
     }
 
+    /// Inserts a truncation/extension from source to target type.
+    func insertTruncateOrExtend(
+      sourceType: BuiltinType, targetType: BuiltinType, sourceValue: IRValue,
+      isSourceTypeSigned: Bool,
+      for i: IR.InstructionID
+    ) {
+
+      let targetLLVMType = context.ir.llvm(builtinType: targetType, in: &self)
+      let sourceTypeSize = ConcreteTypeLayout(of: sourceType, forUseIn: &self)
+      let targetTypeSize = ConcreteTypeLayout(of: targetType, forUseIn: &self)
+
+      if sourceTypeSize.size == targetTypeSize.size {
+        // just copy the value
+        register[.register(i)] = sourceValue
+      } else if sourceTypeSize.size > targetTypeSize.size {
+        // Truncate the value. Negative values are correctly truncated also due to two's complement.
+        register[.register(i)] = insertTrunc(sourceValue, to: targetLLVMType, at: insertionPoint)
+      } else if isSourceTypeSigned {
+        register[.register(i)] = insertSignExtend(
+          sourceValue, to: targetLLVMType, at: insertionPoint)
+      } else {
+        register[.register(i)] = insertZeroExtend(
+          sourceValue, to: targetLLVMType, at: insertionPoint)
+      }
+    }
+
     /// Inserts the transpilation of `i` at `insertionPoint`.
     func insert(load i: IR.InstructionID) {
       let s = context.source[i] as! Load

Sources/CodeGen/LLVM/Transpilation.swift

@@ -74,6 +74,8 @@ extension IR.Program {
       return SwiftyLLVM.FloatingPointType.fp128(in: &module)
     case .ptr:
       return module.ptr
+    case .cNumeric(let cType):
+      return SwiftyLLVM.IntegerType(cType.size*8, in: &module)
     case .module:
       notLLVMRepresentable(t)
     }

Sources/CodeGen/LLVM/TypeLowering.swift

@@ -102,6 +102,13 @@ public enum BuiltinFunction: Hashable {
 
   case ptrtoint(BuiltinType)
 
+  /// Truncates/extends from the given C integer type to the given built-in integer type.
+  case fromcint(cIntType: BuiltinCNumericType, targetType: BuiltinType)
+
+  /// Truncates/extends from the given Hylo integer type to the given C type.
+  case tocint(
+    hyloIntegerType: BuiltinType, targetCType: BuiltinCNumericType, sourceTypeSigned: Bool)
+
   case fadd(MathFlags, BuiltinType)
 
   case fsub(MathFlags, BuiltinType)
@@ -371,7 +378,6 @@ public enum BuiltinFunction: Hashable {
 
   case atomic_singlethreadfence_seqcst
 
-
   /// A set of customizations to the behavior of floating point operations.
   ///
   /// The meaning of each customization is given by the LLVM option of the same name.
@@ -481,6 +487,10 @@ extension BuiltinFunction {
       return .init(^t, to: .builtin(.ptr))
     case .ptrtoint(let t):
       return .init(.builtin(.ptr), to: ^t)
+    case .fromcint(let cIntType, let targetType):
+      return .init(.builtin(.cNumeric(cIntType)), to: .builtin(targetType))
+    case .tocint(let hyloIntegerType, let targetCType, _):
+      return .init(.builtin(hyloIntegerType), to: .builtin(.cNumeric(targetCType)))
     case .fadd(_, let t):
       return .init(^t, ^t, to: ^t)
     case .fsub(_, let t):
@@ -818,6 +828,11 @@ extension BuiltinFunction: CustomStringConvertible {
       return "inttoptr_\(t)"
     case .ptrtoint(let t):
       return "ptrtoint_\(t)"
+    case .fromcint(let cIntType, let targetType):
+      return "fromcint_\(cIntType)_\(targetType)"
+    case .tocint(let hyloIntegerType, let targtCIntType, let isSigned):
+      let signed = isSigned ? "s" : "u"
+      return "tocint_\(signed)_\(hyloIntegerType)_\(targtCIntType)"
     case .fadd(let f, let t):
       return f.isEmpty ? "fadd_\(t)" : "fadd_\(f)_\(t)"
     case .fsub(let f, let t):
@@ -1109,7 +1124,6 @@ extension BuiltinFunction.MathFlags: CustomStringConvertible {
 
 }
 
-
 // MARK: Parsing
 
 extension BuiltinFunction {
@@ -1243,6 +1257,36 @@ extension BuiltinFunction {
       guard let t = builtinType(&tokens) else { return nil }
       self = .ptrtoint(t)
 
+    case "fromcint":
+      guard
+        let fromCType = builtinType(&tokens),
+        case .cNumeric(let cIntType) = fromCType,
+        cIntType.isInteger
+      else { return nil }
+
+      guard let targetIntType = builtinType(&tokens), targetIntType.isInteger
+      else { return nil }
+
+      self = .fromcint(cIntType: cIntType, targetType: targetIntType)
+
+    case "tocint":
+      guard let isSized = tokens.popFirst(),
+        isSized == "u" || isSized == "s"
+      else { return nil }
+
+      guard
+        let fromType = builtinType(&tokens),
+        fromType.isInteger
+      else { return nil }
+
+      guard let targetType = builtinType(&tokens),
+        case .cNumeric(let cIntType) = targetType,
+        cIntType.isInteger
+      else { return nil }
+
+      self = .tocint(
+        hyloIntegerType: fromType, targetCType: cIntType, sourceTypeSigned: isSized == "s")
+
     case "fadd":
       guard let (p, t) = floatingPointArithmeticTail(&tokens) else { return nil }
       self = .fadd(p, t)

Sources/FrontEnd/BuiltinFunction.swift

@@ -4,7 +4,7 @@ public enum BuiltinType: TypeProtocol {
   /// A built-in integer type.
   ///
   /// This type represents the target's integer types. A built-in integer may be of any bit width
-  /// and does not specify signedness.
+  /// multiple of 8 and does not specify signedness.
   case i(Int)
 
   /// An alias for `.i(n)` where `n` is the width of `.ptr`.
@@ -25,6 +25,9 @@ public enum BuiltinType: TypeProtocol {
   /// A built-in opaque pointer.
   case ptr
 
+  /// C Equivalent types (size, alignment and signedness may vary per platform).
+  case cNumeric(BuiltinCNumericType)
+
   /// The type of the built-in module.
   case module
 
@@ -45,8 +48,35 @@ public enum BuiltinType: TypeProtocol {
 
 }
 
-extension BuiltinType: CustomStringConvertible {
+public enum BuiltinCNumericType: UInt8 {
+  case cChar
+  case cUChar
+  case cSChar
+  case cShort
+  case cUShort
+  case cInt
+  case cUInt
+  case cLong
+  case cULong
+  case cLongLong
+  case cULongLong
+  case cFloat
+  case cDouble
+  case cLongDouble
+
+  var isInteger: Bool {
+    switch self {
+    case .cChar, .cUChar, .cSChar, .cShort, .cUShort, .cInt, .cUInt, .cLong, .cULong, .cLongLong,
+      .cULongLong:
+      return true
+    case .cFloat, .cDouble, .cLongDouble:
+      return false
+    }
+  }
+}
 
+extension BuiltinType: CustomStringConvertible {
+  /// The source identifier of `self`.
   public var description: String {
     switch self {
     case .i(let bitWidth):
@@ -63,6 +93,37 @@ extension BuiltinType: CustomStringConvertible {
       return "float128"
     case .ptr:
       return "ptr"
+    case .cNumeric(let type):
+      switch type {
+      case .cChar:
+        return "cchar"
+      case .cUChar:
+        return "cuchar"
+      case .cSChar:
+        return "cschar"
+      case .cShort:
+        return "cshort"
+      case .cUShort:
+        return "cushort"
+      case .cInt:
+        return "cint"
+      case .cUInt:
+        return "cuint"
+      case .cLong:
+        return "clong"
+      case .cULong:
+        return "culong"
+      case .cLongLong:
+        return "clonglong"
+      case .cULongLong:
+        return "culonglong"
+      case .cFloat:
+        return "cfloat"
+      case .cDouble:
+        return "cdouble"
+      case .cLongDouble:
+        return "clongdouble"
+      }
     case .module:
       return "Builtin"
     }
@@ -72,6 +133,7 @@ extension BuiltinType: CustomStringConvertible {
 
 extension BuiltinType: LosslessStringConvertible {
 
+  /// Parses a source identifier into a `BuiltinType`.
   public init?<S: StringProtocol>(_ description: S) {
     switch description {
     case "word":
@@ -86,6 +148,34 @@ extension BuiltinType: LosslessStringConvertible {
       self = .float128
     case "ptr":
       self = .ptr
+    case "cchar":
+      self = .cNumeric(.cChar)
+    case "cuchar":
+      self = .cNumeric(.cUChar)
+    case "cschar":
+      self = .cNumeric(.cSChar)
+    case "cshort":
+      self = .cNumeric(.cShort)
+    case "cushort":
+      self = .cNumeric(.cUShort)
+    case "cint":
+      self = .cNumeric(.cInt)
+    case "cuint":
+      self = .cNumeric(.cUInt)
+    case "clong":
+      self = .cNumeric(.cLong)
+    case "culong":
+      self = .cNumeric(.cULong)
+    case "clonglong":
+      self = .cNumeric(.cLongLong)
+    case "culonglong":
+      self = .cNumeric(.cULongLong)
+    case "cfloat":
+      self = .cNumeric(.cFloat)
+    case "cdouble":
+      self = .cNumeric(.cDouble)
+    case "clongdouble":
+      self = .cNumeric(.cLongDouble)
     case "Builtin":
       self = .module