projects/ldc: gen/naked.cpp annotate

annotate gen/naked.cpp @ 1047:6bb04dbee21f

Some calling convention work for x86-64: - Implement x86-64 extern(C), hopefully correctly. - Tried to be a bit smarter about extern(D) while I was there. Interestingly, this code seems to be generating more efficient code than gcc and llvm-gcc in some edge cases, like returning a `{ [7 x i8] }` loaded from a stack slot from an extern(C) function. (gcc generates 7 1-byte loads, while this code generates a 4-byte, a 2-byte and a 1-byte load) I also added some changes to make sure structs being returned from functions or passed in as parameters are stored in memory where the rest of the backend seems to expect them to be. These should be removed when support for first-class aggregates improves.

author	Frits van Bommel <fvbommel wxs.nl>
date	Fri, 06 Mar 2009 16:00:47 +0100
parents	474d7dd54d43
children	dbe4af57b240

rev	line source
920 545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	1 #include "gen/llvm.h"
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	2
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	3 #include "expression.h"
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	4 #include "statement.h"
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	5 #include "declaration.h"
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	6
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	7 #include <cassert>
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	8
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	9 #include "gen/logger.h"
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	10 #include "gen/irstate.h"
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	11 #include "gen/llvmhelpers.h"
945 03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	12 #include "gen/tollvm.h"
920 545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	13
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	14 //////////////////////////////////////////////////////////////////////////////////////////
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	15
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	16 void Statement::toNakedIR(IRState *p)
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	17 {
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	18 error("not allowed in naked function");
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	19 }
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	20
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	21 //////////////////////////////////////////////////////////////////////////////////////////
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	22
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	23 void CompoundStatement::toNakedIR(IRState *p)
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	24 {
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	25 Logger::println("CompoundStatement::toNakedIR(): %s", loc.toChars());
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	26 LOG_SCOPE;
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	27
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	28 if (statements)
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	29 for (unsigned i = 0; i < statements->dim; i++)
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	30 {
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	31 Statement* s = (Statement*)statements->data[i];
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	32 if (s) s->toNakedIR(p);
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	33 }
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	34 }
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	35
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	36 //////////////////////////////////////////////////////////////////////////////////////////
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	37
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	38 void ExpStatement::toNakedIR(IRState *p)
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	39 {
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	40 Logger::println("ExpStatement::toNakedIR(): %s", loc.toChars());
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	41 LOG_SCOPE;
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	42
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	43 // only expstmt supported in declarations
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	44 if (exp->op != TOKdeclaration)
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	45 {
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	46 Statement::toNakedIR(p);
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	47 return;
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	48 }
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	49
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	50 DeclarationExp* d = (DeclarationExp*)exp;
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	51 VarDeclaration* vd = d->declaration->isVarDeclaration();
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	52 FuncDeclaration* fd = d->declaration->isFuncDeclaration();
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	53 EnumDeclaration* ed = d->declaration->isEnumDeclaration();
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	54
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	55 // and only static variable/function declaration
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	56 // no locals or nested stuffies!
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	57 if (!vd && !fd && !ed)
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	58 {
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	59 Statement::toNakedIR(p);
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	60 return;
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	61 }
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	62 else if (vd && !vd->isDataseg())
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	63 {
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	64 error("non-static variable '%s' not allowed in naked function", vd->toChars());
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	65 return;
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	66 }
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	67 else if (fd && !fd->isStatic())
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	68 {
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	69 error("non-static nested function '%s' not allowed in naked function", fd->toChars());
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	70 return;
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	71 }
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	72 // enum decls should always be safe
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	73
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	74 // make sure the symbols gets processed
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	75 d->declaration->toObjFile(0);
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	76 }
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	77
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	78 //////////////////////////////////////////////////////////////////////////////////////////
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	79
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	80 void LabelStatement::toNakedIR(IRState *p)
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	81 {
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	82 Logger::println("LabelStatement::toNakedIR(): %s", loc.toChars());
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	83 LOG_SCOPE;
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	84
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	85 p->nakedAsm << p->func()->decl->mangle() << "_" << ident->toChars() << ":";
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	86
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	87 if (statement)
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	88 statement->toNakedIR(p);
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	89 }
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	90
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	91 //////////////////////////////////////////////////////////////////////////////////////////
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	92
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	93 void DtoDefineNakedFunction(FuncDeclaration* fd)
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	94 {
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	95 Logger::println("DtoDefineNakedFunction(%s)", fd->mangle());
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	96 LOG_SCOPE;
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	97
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	98 assert(fd->ir.irFunc);
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	99 gIR->functions.push_back(fd->ir.irFunc);
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	100
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	101 // we need to do special processing on the body, since we only want
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	102 // to allow actual inline asm blocks to reach the final asm output
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	103
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	104 std::ostringstream& asmstr = gIR->nakedAsm;
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	105
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	106 // build function header
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	107
923 9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	108 // FIXME: could we perhaps use llvm asmwriter to give us these details ?
920 545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	109
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	110 const char* mangle = fd->mangle();
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	111 std::ostringstream tmpstr;
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	112
923 9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	113 // osx is different
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	114 // also mangling has an extra underscore prefixed
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	115 if (global.params.os == OSMacOSX)
920 545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	116 {
923 9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	117 std::string section = "text";
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	118 bool weak = false;
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	119 if (DtoIsTemplateInstance(fd))
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	120 {
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	121 tmpstr << "section\t__TEXT,__textcoal_nt,coalesced,pure_instructions";
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	122 section = tmpstr.str();
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	123 weak = true;
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	124 }
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	125 asmstr << "\t." << section << std::endl;
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	126 asmstr << "\t.align\t4,0x90" << std::endl;
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	127 asmstr << "\t.globl\t_" << mangle << std::endl;
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	128 if (weak)
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	129 {
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	130 asmstr << "\t.weak_definition\t_" << mangle << std::endl;
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	131 }
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	132 asmstr << "_" << mangle << ":" << std::endl;
920 545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	133 }
923 9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	134 // this works on linux x86 32 and 64 bit
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	135 // assume it works everywhere else as well for now
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	136 else
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	137 {
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	138 const char* linkage = "globl";
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	139 std::string section = "text";
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	140 if (DtoIsTemplateInstance(fd))
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	141 {
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	142 linkage = "weak";
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	143 tmpstr << "section\t.gnu.linkonce.t." << mangle << ",\"ax\",@progbits";
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	144 section = tmpstr.str();
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	145 }
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	146 asmstr << "\t." << section << std::endl;
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	147 asmstr << "\t.align\t16" << std::endl;
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	148 asmstr << "\t." << linkage << "\t" << mangle << std::endl;
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	149 asmstr << "\t.type\t" << mangle << ",@function" << std::endl;
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	150 asmstr << mangle << ":" << std::endl;
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	151 }
920 545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	152
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	153 // emit body
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	154 fd->fbody->toNakedIR(gIR);
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	155
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	156 // emit size after body
923 9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	157 // llvm does this on linux, but not on osx
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	158 if (global.params.os != OSMacOSX)
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	159 {
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	160 asmstr << "\t.size\t" << mangle << ", .-" << mangle << std::endl << std::endl;
9bab304ed531 Added support for naked asm on OSX. (hopefully!) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 920 diff changeset	161 }
920 545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	162
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	163 gIR->module->appendModuleInlineAsm(asmstr.str());
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	164 asmstr.str("");
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	165
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	166 gIR->functions.pop_back();
545f54041d91 Implemented proper support for naked asm using llvm module level asm. Still not 100% complete, but already 1000 times better that what we had before. Don's BignumX86 implementation from Tango (when turned into a standalone unittest) seems to fully work with no changes, and great performance :) Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: diff changeset	167 }
945 03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	168
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	169 //////////////////////////////////////////////////////////////////////////////////////////
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	170
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	171 void emitABIReturnAsmStmt(IRAsmBlock* asmblock, Loc loc, FuncDeclaration* fdecl)
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	172 {
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	173 Logger::println("emitABIReturnAsmStmt(%s)", fdecl->mangle());
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	174 LOG_SCOPE;
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	175
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	176 IRAsmStmt* as = new IRAsmStmt;
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	177
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	178 const LLType* llretTy = DtoType(fdecl->type->nextOf());
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	179 asmblock->retty = llretTy;
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	180 asmblock->retn = 1;
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	181
1047 6bb04dbee21f Some calling convention work for x86-64: Frits van Bommel <fvbommel wxs.nl> parents: 1020 diff changeset	182 // FIXME: This should probably be handled by the TargetABI somehow.
6bb04dbee21f Some calling convention work for x86-64: Frits van Bommel <fvbommel wxs.nl> parents: 1020 diff changeset	183 // It should be able to do this for a greater variety of types.
6bb04dbee21f Some calling convention work for x86-64: Frits van Bommel <fvbommel wxs.nl> parents: 1020 diff changeset	184
959 7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	185 // x86
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	186 if (global.params.cpu == ARCHx86)
945 03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	187 {
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	188 LINK l = fdecl->linkage;
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	189 assert((l == LINKd \|\| l == LINKc \|\| l == LINKwindows) && "invalid linkage for asm implicit return");
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	190
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	191 Type* rt = fdecl->type->nextOf()->toBasetype();
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	192 if (rt->isintegral() \|\| rt->ty == Tpointer \|\| rt->ty == Tclass \|\| rt->ty == Taarray)
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	193 {
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	194 if (rt->size() == 8) {
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	195 as->out_c = "=A,";
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	196 } else {
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	197 as->out_c = "={ax},";
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	198 }
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	199 }
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	200 else if (rt->isfloating())
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	201 {
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	202 if (rt->iscomplex()) {
1018 e8c6dbcd33d1 - Fixed x86-32 C ABI for complex number return values. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 1002 diff changeset	203 if (fdecl->linkage == LINKd) {
e8c6dbcd33d1 - Fixed x86-32 C ABI for complex number return values. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 1002 diff changeset	204 // extern(D) always returns on the FPU stack
e8c6dbcd33d1 - Fixed x86-32 C ABI for complex number return values. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 1002 diff changeset	205 as->out_c = "={st},={st(1)},";
e8c6dbcd33d1 - Fixed x86-32 C ABI for complex number return values. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 1002 diff changeset	206 asmblock->retn = 2;
e8c6dbcd33d1 - Fixed x86-32 C ABI for complex number return values. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 1002 diff changeset	207 } else if (rt->ty == Tcomplex32) {
e8c6dbcd33d1 - Fixed x86-32 C ABI for complex number return values. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 1002 diff changeset	208 // extern(C) cfloat is return as i64
e8c6dbcd33d1 - Fixed x86-32 C ABI for complex number return values. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 1002 diff changeset	209 as->out_c = "=A,";
e8c6dbcd33d1 - Fixed x86-32 C ABI for complex number return values. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 1002 diff changeset	210 asmblock->retty = LLType::Int64Ty;
e8c6dbcd33d1 - Fixed x86-32 C ABI for complex number return values. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 1002 diff changeset	211 } else {
e8c6dbcd33d1 - Fixed x86-32 C ABI for complex number return values. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 1002 diff changeset	212 // cdouble and creal extern(C) are returned in pointer
e8c6dbcd33d1 - Fixed x86-32 C ABI for complex number return values. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 1002 diff changeset	213 // don't add anything!
1020 474d7dd54d43 Remember to set asm type back to void and n=0 when rewriting to sret asm return. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 1019 diff changeset	214 asmblock->retty = LLType::VoidTy;
474d7dd54d43 Remember to set asm type back to void and n=0 when rewriting to sret asm return. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 1019 diff changeset	215 asmblock->retn = 0;
1018 e8c6dbcd33d1 - Fixed x86-32 C ABI for complex number return values. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 1002 diff changeset	216 return;
e8c6dbcd33d1 - Fixed x86-32 C ABI for complex number return values. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 1002 diff changeset	217 }
945 03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	218 } else {
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	219 as->out_c = "={st},";
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	220 }
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	221 }
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	222 else if (rt->ty == Tarray \|\| rt->ty == Tdelegate)
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	223 {
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	224 as->out_c = "={ax},={dx},";
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	225 asmblock->retn = 2;
954 e048e36bc155 Added support for using a temporary to implement emulated ABI return from inline asm, could be easier to use, but I think this will do. It's so extremely target dependent in any case that doing a completely generic approach seems hard. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 949 diff changeset	226 #if 0
e048e36bc155 Added support for using a temporary to implement emulated ABI return from inline asm, could be easier to use, but I think this will do. It's so extremely target dependent in any case that doing a completely generic approach seems hard. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 949 diff changeset	227 // this is to show how to allocate a temporary for the return value
e048e36bc155 Added support for using a temporary to implement emulated ABI return from inline asm, could be easier to use, but I think this will do. It's so extremely target dependent in any case that doing a completely generic approach seems hard. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 949 diff changeset	228 // in case the appropriate multi register constraint isn't supported.
e048e36bc155 Added support for using a temporary to implement emulated ABI return from inline asm, could be easier to use, but I think this will do. It's so extremely target dependent in any case that doing a completely generic approach seems hard. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 949 diff changeset	229 // this way abi return from inline asm can still be emulated.
988 2667e3a145be - Fixed LLVM style CL args for D2. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 959 diff changeset	230 // note that "$<<out0>>" etc in the asm will translate to the correct
2667e3a145be - Fixed LLVM style CL args for D2. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 959 diff changeset	231 // numbered output when the asm block in finalized
954 e048e36bc155 Added support for using a temporary to implement emulated ABI return from inline asm, could be easier to use, but I think this will do. It's so extremely target dependent in any case that doing a completely generic approach seems hard. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 949 diff changeset	232
e048e36bc155 Added support for using a temporary to implement emulated ABI return from inline asm, could be easier to use, but I think this will do. It's so extremely target dependent in any case that doing a completely generic approach seems hard. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 949 diff changeset	233 // generate asm
e048e36bc155 Added support for using a temporary to implement emulated ABI return from inline asm, could be easier to use, but I think this will do. It's so extremely target dependent in any case that doing a completely generic approach seems hard. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 949 diff changeset	234 as->out_c = "=m,=m,";
e048e36bc155 Added support for using a temporary to implement emulated ABI return from inline asm, could be easier to use, but I think this will do. It's so extremely target dependent in any case that doing a completely generic approach seems hard. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 949 diff changeset	235 LLValue* tmp = DtoAlloca(llretTy, ".tmp_asm_ret");
e048e36bc155 Added support for using a temporary to implement emulated ABI return from inline asm, could be easier to use, but I think this will do. It's so extremely target dependent in any case that doing a completely generic approach seems hard. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 949 diff changeset	236 as->out.push_back( tmp );
e048e36bc155 Added support for using a temporary to implement emulated ABI return from inline asm, could be easier to use, but I think this will do. It's so extremely target dependent in any case that doing a completely generic approach seems hard. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 949 diff changeset	237 as->out.push_back( DtoGEPi(tmp, 0,1) );
e048e36bc155 Added support for using a temporary to implement emulated ABI return from inline asm, could be easier to use, but I think this will do. It's so extremely target dependent in any case that doing a completely generic approach seems hard. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 949 diff changeset	238 as->code = "movd %eax, $<<out0>>" "\n\t" "mov %edx, $<<out1>>";
e048e36bc155 Added support for using a temporary to implement emulated ABI return from inline asm, could be easier to use, but I think this will do. It's so extremely target dependent in any case that doing a completely generic approach seems hard. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 949 diff changeset	239
e048e36bc155 Added support for using a temporary to implement emulated ABI return from inline asm, could be easier to use, but I think this will do. It's so extremely target dependent in any case that doing a completely generic approach seems hard. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 949 diff changeset	240 // fix asmblock
e048e36bc155 Added support for using a temporary to implement emulated ABI return from inline asm, could be easier to use, but I think this will do. It's so extremely target dependent in any case that doing a completely generic approach seems hard. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 949 diff changeset	241 asmblock->retn = 0;
e048e36bc155 Added support for using a temporary to implement emulated ABI return from inline asm, could be easier to use, but I think this will do. It's so extremely target dependent in any case that doing a completely generic approach seems hard. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 949 diff changeset	242 asmblock->retemu = true;
e048e36bc155 Added support for using a temporary to implement emulated ABI return from inline asm, could be easier to use, but I think this will do. It's so extremely target dependent in any case that doing a completely generic approach seems hard. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 949 diff changeset	243 asmblock->asmBlock->abiret = tmp;
e048e36bc155 Added support for using a temporary to implement emulated ABI return from inline asm, could be easier to use, but I think this will do. It's so extremely target dependent in any case that doing a completely generic approach seems hard. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 949 diff changeset	244
988 2667e3a145be - Fixed LLVM style CL args for D2. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 959 diff changeset	245 // add "ret" stmt at the end of the block
954 e048e36bc155 Added support for using a temporary to implement emulated ABI return from inline asm, could be easier to use, but I think this will do. It's so extremely target dependent in any case that doing a completely generic approach seems hard. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 949 diff changeset	246 asmblock->s.push_back(as);
e048e36bc155 Added support for using a temporary to implement emulated ABI return from inline asm, could be easier to use, but I think this will do. It's so extremely target dependent in any case that doing a completely generic approach seems hard. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 949 diff changeset	247
e048e36bc155 Added support for using a temporary to implement emulated ABI return from inline asm, could be easier to use, but I think this will do. It's so extremely target dependent in any case that doing a completely generic approach seems hard. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 949 diff changeset	248 // done, we don't want anything pushed in the front of the block
e048e36bc155 Added support for using a temporary to implement emulated ABI return from inline asm, could be easier to use, but I think this will do. It's so extremely target dependent in any case that doing a completely generic approach seems hard. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 949 diff changeset	249 return;
e048e36bc155 Added support for using a temporary to implement emulated ABI return from inline asm, could be easier to use, but I think this will do. It's so extremely target dependent in any case that doing a completely generic approach seems hard. Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 949 diff changeset	250 #endif
945 03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	251 }
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	252 else
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	253 {
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	254 error(loc, "unimplemented return type '%s' for implicit abi return", rt->toChars());
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	255 fatal();
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	256 }
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	257 }
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	258
959 7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	259 // x86_64
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	260 else if (global.params.cpu == ARCHx86_64)
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	261 {
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	262 LINK l = fdecl->linkage;
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	263 /* TODO: Check if this works with extern(Windows), completely untested.
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	264 * In particular, returning cdouble may not work with
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	265 * extern(Windows) since according to X86CallingConv.td it
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	266 * doesn't allow XMM1 to be used.
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	267 * (So is extern(C), but that should be fine as the calling convention
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	268 * is identical to that of extern(D))
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	269 */
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	270 assert((l == LINKd \|\| l == LINKc \|\| l == LINKwindows) && "invalid linkage for asm implicit return");
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	271
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	272 Type* rt = fdecl->type->nextOf()->toBasetype();
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	273 if (rt->isintegral() \|\| rt->ty == Tpointer \|\| rt->ty == Tclass \|\| rt->ty == Taarray)
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	274 {
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	275 as->out_c = "={ax},";
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	276 }
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	277 else if (rt->isfloating())
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	278 {
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	279 if (rt == Type::tcomplex80) {
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	280 // On x87 stack, re=st, im=st(1)
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	281 as->out_c = "={st},={st(1)},";
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	282 asmblock->retn = 2;
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	283 } else if (rt == Type::tfloat80 \|\| rt == Type::timaginary80) {
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	284 // On x87 stack
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	285 as->out_c = "={st},";
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	286 } else if (l != LINKd && rt == Type::tcomplex32) {
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	287 // LLVM and GCC disagree on how to return {float, float}.
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	288 // For compatibility, use the GCC/LLVM-GCC way for extern(C/Windows)
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	289 // extern(C) cfloat -> %xmm0 (extract two floats)
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	290 as->out_c = "={xmm0},";
1002 c749648ed2b8 Fix cfloat return on x86_64: only perform ABI transformation for non-extern(D) Frits van Bommel <fvbommel wxs.nl> parents: 988 diff changeset	291 asmblock->retty = LLType::DoubleTy;
959 7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	292 } else if (rt->iscomplex()) {
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	293 // cdouble and extern(D) cfloat -> re=%xmm0, im=%xmm1
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	294 as->out_c = "={xmm0},={xmm1},";
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	295 asmblock->retn = 2;
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	296 } else {
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	297 // Plain float/double/ifloat/idouble
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	298 as->out_c = "={xmm0},";
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	299 }
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	300 }
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	301 else if (rt->ty == Tarray \|\| rt->ty == Tdelegate)
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	302 {
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	303 as->out_c = "={ax},={dx},";
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	304 asmblock->retn = 2;
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	305 }
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	306 else
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	307 {
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	308 error(loc, "unimplemented return type '%s' for implicit abi return", rt->toChars());
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	309 fatal();
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	310 }
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	311 }
7e669954db7d Implement implicit return after inline asm on x86_64 Frits van Bommel <fvbommel wxs.nl> parents: 954 diff changeset	312
945 03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	313 // unsupported
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	314 else
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	315 {
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	316 error(loc, "this target (%s) does not implement inline asm falling off the end of the function", global.params.targetTriple);
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	317 fatal();
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	318 }
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	319
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	320 // return values always go in the front
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	321 asmblock->s.push_front(as);
03d7c4aac654 SWITCHED TO LLVM 2.5 ! Tomas Lindquist Olsen <tomas.l.olsen@gmail.com> parents: 923 diff changeset	322 }

Mercurial > projects > ldc

annotate gen/naked.cpp @ 1047:6bb04dbee21f