
Show HN: C to Go Assembly - krishnasrinivas
https://github.com/minio/c2goasm
======
justinclift
Probably worth mentioning the blog post too: [https://blog.minio.io/c2goasm-c-
to-go-assembly-bb723d2f777f](https://blog.minio.io/c2goasm-c-to-go-assembly-
bb723d2f777f)

Out of curiosity, any idea how well does Go asm works with Delve (the Go
debugger)?

~~~
akavel
Haven't tried it personally, but based on a recent article shared at r/golang
([https://rakyll.org/coredumps/](https://rakyll.org/coredumps/), via
[https://www.reddit.com/r/golang/comments/6cvtd6/debugging_go...](https://www.reddit.com/r/golang/comments/6cvtd6/debugging_go_core_dumps_with_delve/)),
delve seems to show the contents of an .s file allright.

~~~
justinclift
Thanks, that's a useful article.

Just wish core dumping Go programs worked on OSX. Hopefully one day. :)

------
theparanoid
Go needs another option other than assembly. Either compiler intrinsics like
C/C++ or something, _anything_ , else.

~~~
tankenmate
It does, cgo.

------
mhh__
So, is go assembly the IR inside the Go compiler?

~~~
fwessels
No, it is not an IR code such as in Java or .Net. At compile time it is
translated into opcodes for the corresponding architecture that you are
compiling for.

~~~
chrisseaton
I disagree. I think saying that it's the lowered intermediate representation
in the Go compiler pipeline is a really good description. It's equivalent to
the LIR in Java's C2 compiler. I'm not sure what the equivalent is in .net.

Fundamentally, it's a representation and it's intermediate isn't it?

~~~
uluyol
No, not really. Go's assembly might be considered somewhat higher level than
regular assembly code, but it's certainly architecture specific. The examples
highlighted use x86 SIMD instructions unavailable on other architectures.

Freedoms taken by the go assemblers also seem to be decreasing as the compiler
becomes smarter. E.g. instruction reordering is no longer performed
([https://github.com/golang/go/issues/15837](https://github.com/golang/go/issues/15837)).

You can read about the assemblers here:
[https://golang.org/doc/asm](https://golang.org/doc/asm)

~~~
chrisseaton
Yes I know it's architecture specific. Many lowered IRs are. The equivalent I
gave, Java's C2 IR, is also architecture specific, which is why I used it.

