Calling a Function Defined in Assembly from Swift

calling a function defined in assembly from swift

Create the bridge header.h file and put the prototype of the function in that file.

For example your assembly code:

.globl _add // make it global so that others can find this symbol
....
_add: // int add(int a, int b)
  movl %esi, %eax
  addl %edi, %eax
  ret

Then in bridging header.h file

int add(int a, int b);

OR

define this at the top of the swift module

@_silgen_name("add") func add(a: Int32, b: Int32) -> Int32

Then in swift you can use it:

let a = add(1, 2);

How call assembly function from Swift

Just call your function like any other C function...
Something like this should help you straightforward:
How to call C from Swift?

Is it possible to write inline assembly in Swift?

To expand on what Robert Levy said, you can just use the Swift/Obj-C interop feature, and write an Obj-C class that does the ASM stuff, which you can then call from Swift.

It's an annoying workaround, but it should work nonetheless.

You can read more about how to do it [here]

How to call C from Swift?

Yes, you can of course interact with Apple's C libraries. Here is explained how.

Basically, the C types, C pointers, etc., are translated into Swift objects, for example a C int in Swift is a CInt.

I've built a tiny example, for another question, which can be used as a little explanation, on how to bridge between C and Swift:

main.swift

import Foundation

var output: CInt = 0
getInput(&output)

println(output)

UserInput.c

#include <stdio.h>

void getInput(int *output) {
    scanf("%i", output);
}

cliinput-Bridging-Header.h

void getInput(int *output);

Here is the original answer.

Swift 2: How to discriminate between a local var and a defined function?

If now() is a global function, then you can create the qualified name by prefixing the name of your module:

e.g. MyProject.now(). The name of your module is usually the name of your project.

func now() -> CGFloat {
    return CGFloat(NSDate.timeIntervalSinceReferenceDate())
}

class Issue {
    static func cleanUp() {
        let now = MyProject.now()
    }
}

Can programming languages have their own calling conventions?

Of course, they can. The residual problem will be the interaction with the API/the OS where you have to abide the OS way of doing things.

Overall, the main point will probably be the cost/benefit relation.

But for special purposes, this is possible and may even be superior (why else would you even want to do it?).

Also, take into account possible side effects on OS-specific things like the red-zone.

How are function parameters passed when calling symbols in assembly?

The calling convention of the System V AMD64 ABI is followed on Solaris, Linux, FreeBSD, OS X,[16] and is the de facto standard among Unix and Unix-like operating systems. The first six integer or pointer arguments are passed in registers RDI, RSI, RDX, RCX (R10 in the Linux kernel interface[17]:124), R8, and R9, while XMM0, XMM1, XMM2, XMM3, XMM4, XMM5, XMM6 and XMM7 are used for certain floating point arguments.

Source: https://en.wikipedia.org/wiki/X86_calling_conventions

Where does SWIFT ABI come into picture?

There is a nice description of the role of ABI in ABI Stability Manifesto.

In summary, ABI is about the communication layer between compiled application modules during linking and runtime. For example the application and a compiled static library. Or the application and the standard library (Swift runtime).

ABI answers the questions like:

• how is a function stored? how is the name stored? how are its parameters stored? How are default parameter values stored? how are attributes (e.g. availability) stored?, how are generics stored? Where do you find the machine instructions for a function?

• how to put parameters on the calling stack before starting executing function machine instructions (that is, how to pass parameters and self to a function?). This is what the calling conventions is.

If you have two versions of a Swift compiler and each uses a different format, they cannot call each other because they don't know how to interpret the information in the files. That's why ABI stability is needed. It stabilizes the way code is stored. Note that machine instructions are the body of functions but all the other metadata has to be stored too.

Assembly has no role in ABI stability. Assembly is just another low level programming language which is not used in Swift.

---

Related Topics