Implementation of standard operators + - / *

dave0706 · February 16, 2024, 2:04am

After learning how some basic types (Bool, Int etc) are implemented in Swift, I ended up down a bit of a rabbit hole and I started wondering how the basic operators such as + - / * themselves are implemented in Swift. I can't find a file in the source code anywhere in the Standard Library, despite looking for hours. My guess is that the operators are 'built in' to the language/compiler itself, somewhere in the parser files perhaps, maybe even lower. I doubt very much they would be implemented in Swift itself. But I can’t see them at all. Curiosity has got the better of me so I apologise if this is a stupid question.

xwu · February 16, 2024, 5:05am

They are implemented by calling built-in functions in turn, but they themselves are actual Swift functions.

It's just hard to find in the repository because the source code lives in a gyb file ("generate your boilerplate"), which is a templating system that allows repetitive source code which is nearly identical for Int8, Int16, etc. to be written once. This also means that you won't find static func +, static func -, etc., written out verbatim separately, since it's all generated from a single template static func ${x.operator}.

The operators +, -, etc. are implemented here in terms of the corresponding assignment operators, which are implemented here.

dave0706 · February 16, 2024, 5:14am

Amazing. Thank you so much for your detailed reply. No wonder I couldn’t find it. Very surprised to see they are Swift functions. Thanks once again.

AlexanderM · February 16, 2024, 5:36am

Well they're not exactly. Those functions are just wrappers for the underlying built-ins, like Builtin.int_sadd_with_overflow_Int16.

github.com

apple/swift/blob/f66b57c7fb1046f699068e7ca0ae960dc424e94c/include/swift/AST/Builtins.def#L53-L141


      
          /// Binary operations have type (T,T) -> T.
          ///
          /// We define two different sorts of operations varying when T is static,
          /// specifically:
          ///
          /// 1. Overloaded statically typed operations. E.x:
          ///
          ///       builtin "add_Vec4xInt32"(Vec4xInt32, Vec4xInt32) : Vec4xInt32.
          ///
          /// 2. Polymorphic typed operations that are valid only in raw SIL. By the time
          ///    diagnostic constant propagation runs, these must have as its operand a
          ///    fully specialized type. If the builtin has a type that is not one of its
          ///    overloaded types, diagnostic constant propagation will emit a diagnostic
          ///    saying the builtin's type has not been fully resolved. Otherwise,
          ///    diagnostic constant propagation will transform the builtin to the
          ///    relevant static overloaded builtin form. E.x.:
          ///
          ///       builtin "add"(Self, Self) : Self // *error*
          ///
          ///         OR

This file has been truncated. show original

dave0706 · February 16, 2024, 6:02am

Thanks Alexander. I won’t lie this is going to take me a while to work through, thanks for the pointers of where to start.