Add named equivalents of operators for overflow behavior specification

Author: CodaFi

Sources/LLVM/Constant.swift

@@ -39,6 +39,22 @@ public struct Constant<Repr: ConstantRepresentation>: IRValue {
     }
   }
 
+  // MARK: Arithmetic Operations
+
+  public static func neg(_ lhs: Constant<Signed>, overflowBehavior: OverflowBehavior = .default) -> Constant<Signed> {
+    precondition(lhs.repr == .signed, "Invalid representation")
+
+    let lhsVal = lhs.asLLVM()
+    switch overflowBehavior {
+    case .noSignedWrap:
+      return Constant<Signed>(llvm: LLVMConstNSWNeg(lhsVal))
+    case .noUnsignedWrap:
+      return Constant<Signed>(llvm: LLVMConstNUWNeg(lhsVal))
+    case .default:
+      return Constant<Signed>(llvm: LLVMConstNeg(lhsVal))
+    }
+  }
+
   public static prefix func -(lhs: Constant<Signed>) -> Constant<Signed> {
     precondition(lhs.repr == .signed, "Invalid representation")
     return Constant<Signed>(llvm: LLVMConstNeg(lhs.llvm))
@@ -49,6 +65,27 @@ public struct Constant<Repr: ConstantRepresentation>: IRValue {
     return Constant<Floating>(llvm: LLVMConstFNeg(lhs.llvm))
   }
 
+  public static func add(_ lhs: Constant, _ rhs: Constant, overflowBehavior: OverflowBehavior = .default) -> Constant {
+    precondition(lhs.repr == rhs.repr, "Mixed-representation constant operations are disallowed")
+
+    let lhsVal = lhs.asLLVM()
+    let rhsVal = rhs.asLLVM()
+    switch lhs.repr {
+    case .signed: fallthrough
+    case .unsigned:
+      switch overflowBehavior {
+      case .noSignedWrap:
+        return Constant(llvm: LLVMConstNSWAdd(lhsVal, rhsVal))
+      case .noUnsignedWrap:
+        return Constant(llvm: LLVMConstNUWAdd(lhsVal, rhsVal))
+      case .default:
+        return lhs + rhs
+      }
+    case .floating:
+      return Constant(llvm: LLVMConstFAdd(lhsVal, rhsVal))
+    }
+  }
+
   public static func +(lhs: Constant, rhs: Constant) -> Constant {
     precondition(lhs.repr == rhs.repr, "Mixed-representation constant operations are disallowed")
 
@@ -61,6 +98,27 @@ public struct Constant<Repr: ConstantRepresentation>: IRValue {
     }
   }
 
+  public static func sub(_ lhs: Constant, _ rhs: Constant, overflowBehavior: OverflowBehavior = .default) -> Constant {
+    precondition(lhs.repr == rhs.repr, "Mixed-representation constant operations are disallowed")
+
+    let lhsVal = lhs.asLLVM()
+    let rhsVal = rhs.asLLVM()
+    switch lhs.repr {
+    case .signed: fallthrough
+    case .unsigned:
+      switch overflowBehavior {
+      case .noSignedWrap:
+        return Constant(llvm: LLVMConstNSWSub(lhsVal, rhsVal))
+      case .noUnsignedWrap:
+        return Constant(llvm: LLVMConstNUWSub(lhsVal, rhsVal))
+      case .default:
+        return lhs - rhs
+      }
+    case .floating:
+      return lhs - rhs
+    }
+  }
+
   public static func -(lhs: Constant, rhs: Constant) -> Constant {
     precondition(lhs.repr == rhs.repr, "Mixed-representation constant operations are disallowed")
 
@@ -73,6 +131,27 @@ public struct Constant<Repr: ConstantRepresentation>: IRValue {
     }
   }
 
+  public static func mul(_ lhs: Constant, _ rhs: Constant, overflowBehavior: OverflowBehavior = .default) -> Constant {
+    precondition(lhs.repr == rhs.repr, "Mixed-representation constant operations are disallowed")
+
+    let lhsVal = lhs.asLLVM()
+    let rhsVal = rhs.asLLVM()
+    switch lhs.repr {
+    case .signed: fallthrough
+    case .unsigned:
+      switch overflowBehavior {
+      case .noSignedWrap:
+        return Constant(llvm: LLVMConstNSWMul(lhsVal, rhsVal))
+      case .noUnsignedWrap:
+        return Constant(llvm: LLVMConstNUWMul(lhsVal, rhsVal))
+      case .default:
+        return lhs * rhs
+      }
+    case .floating:
+      return lhs * rhs
+    }
+  }
+
   public static func *(lhs: Constant, rhs: Constant) -> Constant {
     precondition(lhs.repr == rhs.repr, "Mixed-representation constant operations are disallowed")
 
@@ -111,6 +190,8 @@ public struct Constant<Repr: ConstantRepresentation>: IRValue {
     }
   }
 
+  // MARK: Comparison Operations
+
   public static func ==(lhs: Constant, rhs: Constant) -> Constant {
     precondition(lhs.repr == rhs.repr, "Mixed-representation constant operations are disallowed")
 
@@ -169,6 +250,8 @@ public struct Constant<Repr: ConstantRepresentation>: IRValue {
     }
   }
 
+  // MARK: Logical Operations
+
   public static prefix func ! <T: IntegralConstantRepresentation>(lhs: Constant<T>) -> Constant<T> {
     precondition(lhs.repr == .signed || lhs.repr == .unsigned, "Invalid representation")
     return Constant<T>(llvm: LLVMConstNeg(lhs.llvm))
@@ -192,6 +275,8 @@ public struct Constant<Repr: ConstantRepresentation>: IRValue {
     return Constant(llvm: LLVMConstXor(lhs.llvm, rhs.llvm))
   }
 
+  // MARK: Shifts
+
   public static func >> <T: IntegralConstantRepresentation, U: IntegralConstantRepresentation>(lhs: Constant<T>, rhs: Constant<U>) -> Constant<T> {
     precondition(lhs.repr == rhs.repr, "Mixed-representation constant operations are disallowed")