[thirdparty/openssl.git] / crypto / perlasm / x86_64-xlate.pl

#!/usr/bin/env perl

# Ascetic x86_64 AT&T to MASM assembler translator by <appro>.
#
# Why AT&T to MASM and not vice versa? Several reasons. Because AT&T
# format is way easier to parse. Because it's simpler to "gear" from
# Unix ABI to Windows one [see cross-reference "card" at the end of
# file]. Because Linux targets were available first...
#
# In addition the script also "distills" code suitable for GNU
# assembler, so that it can be compiled with more rigid assemblers,
# such as Solaris /usr/ccs/bin/as.
#
# This translator is not designed to convert *arbitrary* assembler
# code from AT&T format to MASM one. It's designed to convert just
# enough to provide for dual-ABI OpenSSL modules development...
# There *are* limitations and you might have to modify your assembler
# code or this script to achieve the desired result...
#
# Currently recognized limitations:
#
# - can't use multiple ops per line;
# - indirect calls and jumps are not supported;
#
# Dual-ABI styling rules.
#
# 1. Adhere to Unix register and stack layout [see the end for
#    explanation].
# 2. Forget about "red zone," stick to more traditional blended
#    stack frame allocation. If volatile storage is actually required
#    that is. If not, just leave the stack as is.
# 3. Functions tagged with ".type name,@function" get crafted with
#    unified Win64 prologue and epilogue automatically. If you want
#    to take care of ABI differences yourself, tag functions as
#    ".type name,@abi-omnipotent" instead.
# 4. To optimize the Win64 prologue you can specify number of input
#    arguments as ".type name,@function,N." Keep in mind that if N is
#    larger than 6, then you *have to* write "abi-omnipotent" code,
#    because >6 cases can't be addressed with unified prologue.
# 5. Name local labels as .L*, do *not* use dynamic labels such as 1:
#    (sorry about latter).
# 6. Don't use [or hand-code with .byte] "rep ret." "ret" mnemonic is
#    required to identify the spots, where to inject Win64 epilogue!
#    But on the pros, it's then prefixed with rep automatically:-)
# 7. Due to MASM limitations [and certain general counter-intuitivity
#    of ip-relative addressing] generation of position-independent
#    code is assisted by synthetic directive, .picmeup, which puts
#    address of the *next* instruction into target register.
#
#    Example 1:
#		.picmeup	%rax
#		lea		.Label-.(%rax),%rax
#    Example 2:
#		.picmeup	%rcx
#	.Lpic_point:
#		...
#		lea		.Label-.Lpic_point(%rcx),%rbp

my $output = shift;

{ my ($stddev,$stdino,@junk)=stat(STDOUT);
  my ($outdev,$outino,@junk)=stat($output);

    open STDOUT,">$output" || die "can't open $output: $!"
	if ($stddev!=$outdev || $stdino!=$outino);
}

my $masmref=8 + 50727*2**-32;	# 8.00.50727 shipped with VS2005
my $masm=$masmref if ($output =~ /\.asm/);
if ($masm && `ml64 2>&1` =~ m/Version ([0-9]+)\.([0-9]+)(\.([0-9]+))?/)
{   $masm=$1 + $2*2**-16 + $4*2**-32;   }

my $current_segment;
my $current_function;

{ package opcode;	# pick up opcodes
    sub re {
	my	$self = shift;	# single instance in enough...
	local	*line = shift;
	undef	$ret;

	if ($line =~ /^([a-z][a-z0-9]*)/i) {
	    $self->{op} = $1;
	    $ret = $self;
	    $line = substr($line,@+[0]); $line =~ s/^\s+//;

	    undef $self->{sz};
	    if ($self->{op} =~ /^(movz)b.*/) {	# movz is pain...
		$self->{op} = $1;
		$self->{sz} = "b";
	    } elsif ($self->{op} =~ /call/) {
		$self->{sz} = ""
	    } elsif ($self->{op} =~ /([a-z]{3,})([qlwb])$/) {
		$self->{op} = $1;
		$self->{sz} = $2;
	    }
	}
	$ret;
    }
    sub size {
	my $self = shift;
	my $sz   = shift;
	$self->{sz} = $sz if (defined($sz) && !defined($self->{sz}));
	$self->{sz};
    }
    sub out {
	my $self = shift;
	if (!$masm) {
	    if ($self->{op} eq "movz") {	# movz is pain...
		sprintf "%s%s%s",$self->{op},$self->{sz},shift;
	    } elsif ($self->{op} =~ /^set/) { 
		"$self->{op}";
	    } elsif ($self->{op} eq "ret") {
	    	".byte	0xf3,0xc3";
	    } else {
		"$self->{op}$self->{sz}";
	    }
	} else {
	    $self->{op} =~ s/^movz/movzx/;
	    if ($self->{op} eq "ret") {
		$self->{op} = "";
		if ($current_function->{abi} eq "svr4") {
		    $self->{op} = "mov	rdi,QWORD PTR 8[rsp]\t;WIN64 epilogue\n\t".
				  "mov	rsi,QWORD PTR 16[rsp]\n\t";
	    	}
		$self->{op} .= "DB\t0F3h,0C3h\t\t;repret";
	    }
	    $self->{op};
	}
    }
}
{ package const;	# pick up constants, which start with $
    sub re {
	my	$self = shift;	# single instance in enough...
	local	*line = shift;
	undef	$ret;

	if ($line =~ /^\$([^,]+)/) {
	    $self->{value} = $1;
	    $ret = $self;
	    $line = substr($line,@+[0]); $line =~ s/^\s+//;
	}
	$ret;
    }
    sub out {
    	my $self = shift;

	if (!$masm) {
	    # Solaris /usr/ccs/bin/as can't handle multiplications
	    # in $self->{value}
	    $self->{value} =~ s/(?<![0-9a-f])(0[x0-9a-f]+)/oct($1)/egi;
	    $self->{value} =~ s/([0-9]+\s*[\*\/\%]\s*[0-9]+)/eval($1)/eg;
	    sprintf "\$%s",$self->{value};
	} else {
	    $self->{value} =~ s/0x([0-9a-f]+)/0$1h/ig;
	    sprintf "%s",$self->{value};
	}
    }
}
{ package ea;		# pick up effective addresses: expr(%reg,%reg,scale)
    sub re {
	my	$self = shift;	# single instance in enough...
	local	*line = shift;
	undef	$ret;

	if ($line =~ /^([^\(,]*)\(([%\w,]+)\)/) {
	    $self->{label} = $1;
	    ($self->{base},$self->{index},$self->{scale})=split(/,/,$2);
	    $self->{scale} = 1 if (!defined($self->{scale}));
	    $ret = $self;
	    $line = substr($line,@+[0]); $line =~ s/^\s+//;

	    $self->{base}  =~ s/^%//;
	    $self->{index} =~ s/^%// if (defined($self->{index}));
	}
	$ret;
    }
    sub size {}
    sub out {
    	my $self = shift;
	my $sz = shift;

	# Silently convert all EAs to 64-bit. This is required for
	# elder GNU assembler and results in more compact code,
	# *but* most importantly AES module depends on this feature!
	$self->{index} =~ s/^[er](.?[0-9xpi])[d]?$/r\1/;
	$self->{base}  =~ s/^[er](.?[0-9xpi])[d]?$/r\1/;

	if (!$masm) {
	    # Solaris /usr/ccs/bin/as can't handle multiplications
	    # in $self->{label}
	    $self->{label} =~ s/(?<![0-9a-f])(0[x0-9a-f]+)/oct($1)/egi;
	    $self->{label} =~ s/([0-9]+\s*[\*\/\%]\s*[0-9]+)/eval($1)/eg;

	    if (defined($self->{index})) {
		sprintf "%s(%%%s,%%%s,%d)",
					$self->{label},$self->{base},
					$self->{index},$self->{scale};
	    } else {
		sprintf "%s(%%%s)",	$self->{label},$self->{base};
	    }
	} else {
	    %szmap = ( b=>"BYTE", w=>"WORD", l=>"DWORD", q=>"QWORD" );

	    $self->{label} =~ s/\./\$/g;
	    $self->{label} =~ s/0x([0-9a-f]+)/0$1h/ig;
	    $self->{label} = "($self->{label})" if ($self->{label} =~ /[\*\+\-\/]/);

	    if (defined($self->{index})) {
		sprintf "%s PTR %s[%s*%d+%s]",$szmap{$sz},
					$self->{label},
					$self->{index},$self->{scale},
					$self->{base};
	    } elsif ($self->{base} eq "rip") {
		sprintf "%s PTR %s",$szmap{$sz},$self->{label};
	    } else {
		sprintf "%s PTR %s[%s]",$szmap{$sz},
					$self->{label},$self->{base};
	    }
	}
    }
}
{ package register;	# pick up registers, which start with %.
    sub re {
	my	$class = shift;	# muliple instances...
	my	$self = {};
	local	*line = shift;
	undef	$ret;

	if ($line =~ /^%(\w+)/) {
	    bless $self,$class;
	    $self->{value} = $1;
	    $ret = $self;
	    $line = substr($line,@+[0]); $line =~ s/^\s+//;
	}
	$ret;
    }
    sub size {
	my	$self = shift;
	undef	$ret;

	if    ($self->{value} =~ /^r[\d]+b$/i)	{ $ret="b"; }
	elsif ($self->{value} =~ /^r[\d]+w$/i)	{ $ret="w"; }
	elsif ($self->{value} =~ /^r[\d]+d$/i)	{ $ret="l"; }
	elsif ($self->{value} =~ /^r[\w]+$/i)	{ $ret="q"; }
	elsif ($self->{value} =~ /^[a-d][hl]$/i){ $ret="b"; }
	elsif ($self->{value} =~ /^[\w]{2}l$/i)	{ $ret="b"; }
	elsif ($self->{value} =~ /^[\w]{2}$/i)	{ $ret="w"; }
	elsif ($self->{value} =~ /^e[a-z]{2}$/i){ $ret="l"; }

	$ret;
    }
    sub out {
    	my $self = shift;
	sprintf $masm?"%s":"%%%s",$self->{value};
    }
}
{ package label;	# pick up labels, which end with :
    sub re {
	my	$self = shift;	# single instance is enough...
	local	*line = shift;
	undef	$ret;

	if ($line =~ /(^[\.\w]+\:)/) {
	    $self->{value} = $1;
	    $ret = $self;
	    $line = substr($line,@+[0]); $line =~ s/^\s+//;

	    $self->{value} =~ s/\.L/\$L/ if ($masm);
	}
	$ret;
    }
    sub out {
	my $self = shift;

	if (!$masm) {
	    $self->{value};
	} elsif ($self->{value} ne "$current_function->{name}:") {
	    $self->{value};
	} elsif ($current_function->{abi} eq "svr4") {
	    my $func =	"$current_function->{name}	PROC\n".
			"	mov	QWORD PTR 8[rsp],rdi\t;WIN64 prologue\n".
			"	mov	QWORD PTR 16[rsp],rsi\n";
	    my $narg = $current_function->{narg};
	    $narg=6 if (!defined($narg));
	    $func .= "	mov	rdi,rcx\n" if ($narg>0);
	    $func .= "	mov	rsi,rdx\n" if ($narg>1);
	    $func .= "	mov	rdx,r8\n"  if ($narg>2);
	    $func .= "	mov	rcx,r9\n"  if ($narg>3);
	    $func .= "	mov	r8,QWORD PTR 40[rsp]\n" if ($narg>4);
	    $func .= "	mov	r9,QWORD PTR 48[rsp]\n" if ($narg>5);
	    $func .= "\n";
	} else {
	   "$current_function->{name}	PROC";
	}
    }
}
{ package expr;		# pick up expressioins
    sub re {
	my	$self = shift;	# single instance is enough...
	local	*line = shift;
	undef	$ret;

	if ($line =~ /(^[^,]+)/) {
	    $self->{value} = $1;
	    $ret = $self;
	    $line = substr($line,@+[0]); $line =~ s/^\s+//;

	    $self->{value} =~ s/\.L/\$L/g if ($masm);
	}
	$ret;
    }
    sub out {
	my $self = shift;
	$self->{value};
    }
}
{ package directive;	# pick up directives, which start with .
    sub re {
	my	$self = shift;	# single instance is enough...
	local	*line = shift;
	undef	$ret;
	my	$dir;
	my	%opcode =	# lea 2f-1f(%rip),%dst; 1: nop; 2:
		(	"%rax"=>0x01058d48,	"%rcx"=>0x010d8d48,
			"%rdx"=>0x01158d48,	"%rbx"=>0x011d8d48,
			"%rsp"=>0x01258d48,	"%rbp"=>0x012d8d48,
			"%rsi"=>0x01358d48,	"%rdi"=>0x013d8d48,
			"%r8" =>0x01058d4c,	"%r9" =>0x010d8d4c,
			"%r10"=>0x01158d4c,	"%r11"=>0x011d8d4c,
			"%r12"=>0x01258d4c,	"%r13"=>0x012d8d4c,
			"%r14"=>0x01358d4c,	"%r15"=>0x013d8d4c	);

	if ($line =~ /^\s*(\.\w+)/) {
	    if (!$masm) {
		$self->{value} = $1;
		$line =~ s/\@abi\-omnipotent/\@function/;
		$line =~ s/\@function.*/\@function/;
		if ($line =~ /\.picmeup\s+(%r[\w]+)/i) {
		    $self->{value} = sprintf "\t.long\t0x%x,0x90000000",$opcode{$1};
		} elsif ($line =~ /\.asciz\s+"(.*)"$/) {
		    $self->{value} = ".byte\t".join(",",unpack("C*",$1),0);
		} elsif ($line =~ /\.extern/) {
		    $self->{value} = ""; # swallow extern
		} else {
		    $self->{value} = $line;
		}
		$line = "";
		return $self;
	    }

	    $dir = $1;
	    $ret = $self;
	    undef $self->{value};
	    $line = substr($line,@+[0]); $line =~ s/^\s+//;
	    SWITCH: for ($dir) {
		/\.(text)/
			    && do { my $v=undef;
				    $v="$current_segment\tENDS\n" if ($current_segment);
				    $current_segment = "_$1\$";
				    $current_segment =~ tr/[a-z]/[A-Z]/;
				    $v.="$current_segment\tSEGMENT ";
				    $v.=$masm>=$masmref ? "ALIGN(64)" : "PAGE";
				    $v.=" 'CODE'";
				    $self->{value} = $v;
				    last;
				  };
		/\.extern/  && do { $self->{value} = "EXTRN\t".$line.":BYTE"; last;  };
		/\.globl/   && do { $self->{value} = "PUBLIC\t".$line; last; };
		/\.type/    && do { ($sym,$type,$narg) = split(',',$line);
				    if ($type eq "\@function") {
					undef $current_function;
					$current_function->{name} = $sym;
					$current_function->{abi}  = "svr4";
					$current_function->{narg} = $narg;
				    } elsif ($type eq "\@abi-omnipotent") {
					undef $current_function;
					$current_function->{name} = $sym;
				    }
				    last;
				  };
		/\.size/    && do { if (defined($current_function)) {
					$self->{value}="$current_function->{name}\tENDP";
					undef $current_function;
				    }
				    last;
				  };
		/\.align/   && do { $self->{value} = "ALIGN\t".$line; last; };
		/\.(byte|value|long|quad)/
			    && do { my @arr = split(',',$line);
				    my $sz  = substr($1,0,1);
				    my $last = pop(@arr);
				    my $conv = sub  {	my $var=shift;
							if ($var=~s/0x([0-9a-f]+)/0$1h/i) { $var; }
							else { sprintf"0%Xh",$var; }
						    };  

				    $sz =~ tr/bvlq/BWDQ/;
				    $self->{value} = "\tD$sz\t";
				    for (@arr) { $self->{value} .= &$conv($_).","; }
				    $self->{value} .= &$conv($last);
				    last;
				  };
		/\.picmeup/ && do { $self->{value} = sprintf"\tDD\t 0%Xh,090000000h",$opcode{$line};
				    last;
				  };
		/\.asciz/   && do { if ($line =~ /^"(.*)"$/) {
					my @str=unpack("C*",$1);
					push @str,0;
					while ($#str>15) {
					    $self->{value}.="DB\t"
						.join(",",@str[0..15])."\n";
					    foreach (0..15) { shift @str; }
					}
					$self->{value}.="DB\t"
						.join(",",@str) if (@str);
				    }
				    last;
				  };
	    }
	    $line = "";
	}

	$ret;
    }
    sub out {
	my $self = shift;
	$self->{value};
    }
}

while($line=<>) {

    chomp($line);

    $line =~ s|[#!].*$||;	# get rid of asm-style comments...
    $line =~ s|/\*.*\*/||;	# ... and C-style comments...
    $line =~ s|^\s+||;		# ... and skip white spaces in beginning

    undef $label;
    undef $opcode;
    undef $dst;
    undef $src;
    undef $sz;

    if ($label=label->re(\$line))	{ print $label->out(); }

    if (directive->re(\$line)) {
	printf "%s",directive->out();
    } elsif ($opcode=opcode->re(\$line)) { ARGUMENT: {

	if ($src=register->re(\$line))	{ opcode->size($src->size()); }
	elsif ($src=const->re(\$line))	{ }
	elsif ($src=ea->re(\$line))	{ }
	elsif ($src=expr->re(\$line))	{ }

	last ARGUMENT if ($line !~ /^,/);

	$line = substr($line,1); $line =~ s/^\s+//;

	if ($dst=register->re(\$line))	{ opcode->size($dst->size()); }
	elsif ($dst=const->re(\$line))	{ }
	elsif ($dst=ea->re(\$line))	{ }

	} # ARGUMENT:

	$sz=opcode->size();

	if (defined($dst)) {
	    if (!$masm) {
		printf "\t%s\t%s,%s",	$opcode->out($dst->size()),
					$src->out($sz),$dst->out($sz);
	    } else {
		printf "\t%s\t%s,%s",	$opcode->out(),
					$dst->out($sz),$src->out($sz);
	    }
	} elsif (defined($src)) {
	    printf "\t%s\t%s",$opcode->out(),$src->out($sz);
	} else {
	    printf "\t%s",$opcode->out();
	}
    }

    print $line,"\n";
}

print "\n$current_segment\tENDS\nEND\n" if ($masm);

close STDOUT;

#################################################
# Cross-reference x86_64 ABI "card"
#
# 		Unix		Win64
# %rax		*		*
# %rbx		-		-
# %rcx		#4		#1
# %rdx		#3		#2
# %rsi		#2		-
# %rdi		#1		-
# %rbp		-		-
# %rsp		-		-
# %r8		#5		#3
# %r9		#6		#4
# %r10		*		*
# %r11		*		*
# %r12		-		-
# %r13		-		-
# %r14		-		-
# %r15		-		-
# 
# (*)	volatile register
# (-)	preserved by callee
# (#)	Nth argument, volatile
#
# In Unix terms top of stack is argument transfer area for arguments
# which could not be accomodated in registers. Or in other words 7th
# [integer] argument resides at 8(%rsp) upon function entry point.
# 128 bytes above %rsp constitute a "red zone" which is not touched
# by signal handlers and can be used as temporal storage without
# allocating a frame.
#
# In Win64 terms N*8 bytes on top of stack is argument transfer area,
# which belongs to/can be overwritten by callee. N is the number of
# arguments passed to callee, *but* not less than 4! This means that
# upon function entry point 5th argument resides at 40(%rsp), as well
# as that 32 bytes from 8(%rsp) can always be used as temporal
# storage [without allocating a frame]. One can actually argue that
# one can assume a "red zone" above stack pointer under Win64 as well.
# Point is that at apparently no occasion Windows kernel would alter
# the area above user stack pointer in true asynchronous manner...
#
# All the above means that if assembler programmer adheres to Unix
# register and stack layout, but disregards the "red zone" existense,
# it's possible to use following prologue and epilogue to "gear" from
# Unix to Win64 ABI in leaf functions with not more than 6 arguments.
#
# omnipotent_function:
# ifdef WIN64
#	movq	%rdi,8(%rsp)
#	movq	%rsi,16(%rsp)
#	movq	%rcx,%rdi	; if 1st argument is actually present
#	movq	%rdx,%rsi	; if 2nd argument is actually ...
#	movq	%r8,%rdx	; if 3rd argument is ...
#	movq	%r9,%rcx	; if 4th argument ...
#	movq	40(%rsp),%r8	; if 5th ...
#	movq	48(%rsp),%r9	; if 6th ...
# endif
#	...
# ifdef WIN64
#	movq	8(%rsp),%rdi
#	movq	16(%rsp),%rsi
# endif
#	ret
Commit	Line	Data
1cfd258e AP	1	#!/usr/bin/env perl
	2
	3	# Ascetic x86_64 AT&T to MASM assembler translator by <appro>.
	4	#
	5	# Why AT&T to MASM and not vice versa? Several reasons. Because AT&T
	6	# format is way easier to parse. Because it's simpler to "gear" from
	7	# Unix ABI to Windows one [see cross-reference "card" at the end of
	8	# file]. Because Linux targets were available first...
	9	#
	10	# In addition the script also "distills" code suitable for GNU
	11	# assembler, so that it can be compiled with more rigid assemblers,
	12	# such as Solaris /usr/ccs/bin/as.
	13	#
	14	# This translator is not designed to convert arbitrary assembler
	15	# code from AT&T format to MASM one. It's designed to convert just
	16	# enough to provide for dual-ABI OpenSSL modules development...
	17	# There are limitations and you might have to modify your assembler
	18	# code or this script to achieve the desired result...
	19	#
	20	# Currently recognized limitations:
	21	#
	22	# - can't use multiple ops per line;
	23	# - indirect calls and jumps are not supported;
	24	#
	25	# Dual-ABI styling rules.
	26	#
	27	# 1. Adhere to Unix register and stack layout [see the end for
	28	# explanation].
	29	# 2. Forget about "red zone," stick to more traditional blended
	30	# stack frame allocation. If volatile storage is actually required
	31	# that is. If not, just leave the stack as is.
	32	# 3. Functions tagged with ".type name,@function" get crafted with
4b450519	33	# unified Win64 prologue and epilogue automatically. If you want
1cfd258e	34	# to take care of ABI differences yourself, tag functions as
4b450519 AP	35	# ".type name,@abi-omnipotent" instead.
	36	# 4. To optimize the Win64 prologue you can specify number of input
	37	# arguments as ".type name,@function,N." Keep in mind that if N is
	38	# larger than 6, then you have to write "abi-omnipotent" code,
	39	# because >6 cases can't be addressed with unified prologue.
	40	# 5. Name local labels as .L, do not* use dynamic labels such as 1:
	41	# (sorry about latter).
	42	# 6. Don't use [or hand-code with .byte] "rep ret." "ret" mnemonic is
	43	# required to identify the spots, where to inject Win64 epilogue!
	44	# But on the pros, it's then prefixed with rep automatically:-)
5d0d60e2 AP	45	# 7. Due to MASM limitations [and certain general counter-intuitivity
	46	# of ip-relative addressing] generation of position-independent
	47	# code is assisted by synthetic directive, .picmeup, which puts
	48	# address of the next instruction into target register.
	49	#
	50	# Example 1:
	51	# .picmeup %rax
	52	# lea .Label-.(%rax),%rax
	53	# Example 2:
	54	# .picmeup %rcx
	55	# .Lpic_point:
	56	# ...
	57	# lea .Label-.Lpic_point(%rcx),%rbp
1cfd258e AP	58
1cfd258e AP	59	my $output = shift;
5f121183 AP	60
	61	{ my ($stddev,$stdino,@junk)=stat(STDOUT);
	62	my ($outdev,$outino,@junk)=stat($output);
	63
	64	open STDOUT,">$output" \|\| die "can't open $output: $!"
	65	if ($stddev!=$outdev \|\| $stdino!=$outino);
	66	}
1cfd258e	67
85a752e8 AP	68	my $masmref=8 + 507272*-32; # 8.00.50727 shipped with VS2005
	69	my $masm=$masmref if ($output =~ /\.asm/);
	70	if ($masm && `ml64 2>&1` =~ m/Version ([0-9]+)\.([0-9]+)(\.([0-9]+))?/)
	71	{ $masm=$1 + $22-16 + $42**-32; }
1cfd258e AP	72
	73	my $current_segment;
	74	my $current_function;
	75
	76	{ package opcode; # pick up opcodes
	77	sub re {
	78	my $self = shift; # single instance in enough...
	79	local *line = shift;
	80	undef $ret;
	81
5f121183	82	if ($line =~ /^([a-z][a-z0-9]*)/i) {
1cfd258e AP	83	$self->{op} = $1;
	84	$ret = $self;
	85	$line = substr($line,@+[0]); $line =~ s/^\s+//;
	86
	87	undef $self->{sz};
85a752e8	88	if ($self->{op} =~ /^(movz)b.*/) { # movz is pain...
1cfd258e AP	89	$self->{op} = $1;
1cfd258e AP	90	$self->{sz} = "b";
76108ba7 AP	91	} elsif ($self->{op} =~ /call/) {
76108ba7 AP	92	$self->{sz} = ""
85a752e8	93	} elsif ($self->{op} =~ /([a-z]{3,})([qlwb])$/) {
1cfd258e AP	94	$self->{op} = $1;
	95	$self->{sz} = $2;
	96	}
	97	}
	98	$ret;
	99	}
	100	sub size {
	101	my $self = shift;
	102	my $sz = shift;
	103	$self->{sz} = $sz if (defined($sz) && !defined($self->{sz}));
	104	$self->{sz};
	105	}
	106	sub out {
	107	my $self = shift;
	108	if (!$masm) {
5f121183	109	if ($self->{op} eq "movz") { # movz is pain...
1cfd258e	110	sprintf "%s%s%s",$self->{op},$self->{sz},shift;
5f121183 AP	111	} elsif ($self->{op} =~ /^set/) {
5f121183 AP	112	"$self->{op}";
1cfd258e AP	113	} elsif ($self->{op} eq "ret") {
	114	".byte 0xf3,0xc3";
	115	} else {
	116	"$self->{op}$self->{sz}";
	117	}
	118	} else {
85a752e8	119	$self->{op} =~ s/^movz/movzx/;
1cfd258e AP	120	if ($self->{op} eq "ret") {
	121	$self->{op} = "";
	122	if ($current_function->{abi} eq "svr4") {
	123	$self->{op} = "mov rdi,QWORD PTR 8[rsp]\t;WIN64 epilogue\n\t".
	124	"mov rsi,QWORD PTR 16[rsp]\n\t";
	125	}
	126	$self->{op} .= "DB\t0F3h,0C3h\t\t;repret";
	127	}
	128	$self->{op};
	129	}
	130	}
	131	}
	132	{ package const; # pick up constants, which start with $
	133	sub re {
	134	my $self = shift; # single instance in enough...
	135	local *line = shift;
	136	undef $ret;
	137
	138	if ($line =~ /^\$([^,]+)/) {
	139	$self->{value} = $1;
	140	$ret = $self;
	141	$line = substr($line,@+[0]); $line =~ s/^\s+//;
	142	}
	143	$ret;
	144	}
	145	sub out {
	146	my $self = shift;
5d0d60e2 AP	147
5d0d60e2 AP	148	if (!$masm) {
5f121183 AP	149	# Solaris /usr/ccs/bin/as can't handle multiplications
	150	# in $self->{value}
	151	$self->{value} =~ s/(?<![0-9a-f])(0[x0-9a-f]+)/oct($1)/egi;
	152	$self->{value} =~ s/([0-9]+\s[\\/\%]\s*[0-9]+)/eval($1)/eg;
5d0d60e2 AP	153	sprintf "\$%s",$self->{value};
	154	} else {
	155	$self->{value} =~ s/0x([0-9a-f]+)/0$1h/ig;
	156	sprintf "%s",$self->{value};
	157	}
1cfd258e AP	158	}
	159	}
	160	{ package ea; # pick up effective addresses: expr(%reg,%reg,scale)
	161	sub re {
	162	my $self = shift; # single instance in enough...
	163	local *line = shift;
	164	undef $ret;
	165
	166	if ($line =~ /^([^\(,]*)\(([%\w,]+)\)/) {
	167	$self->{label} = $1;
	168	($self->{base},$self->{index},$self->{scale})=split(/,/,$2);
	169	$self->{scale} = 1 if (!defined($self->{scale}));
	170	$ret = $self;
	171	$line = substr($line,@+[0]); $line =~ s/^\s+//;
	172
1cfd258e AP	173	$self->{base} =~ s/^%//;
	174	$self->{index} =~ s/^%// if (defined($self->{index}));
	175	}
	176	$ret;
	177	}
	178	sub size {}
	179	sub out {
	180	my $self = shift;
	181	my $sz = shift;
	182
5f121183 AP	183	# Silently convert all EAs to 64-bit. This is required for
	184	# elder GNU assembler and results in more compact code,
	185	# but most importantly AES module depends on this feature!
	186	$self->{index} =~ s/^[er](.?[0-9xpi])[d]?$/r\1/;
	187	$self->{base} =~ s/^[er](.?[0-9xpi])[d]?$/r\1/;
	188
1cfd258e	189	if (!$masm) {
8d56c8b5 AP	190	# Solaris /usr/ccs/bin/as can't handle multiplications
8d56c8b5 AP	191	# in $self->{label}
5f121183	192	$self->{label} =~ s/(?<![0-9a-f])(0[x0-9a-f]+)/oct($1)/egi;
8d56c8b5	193	$self->{label} =~ s/([0-9]+\s[\\/\%]\s*[0-9]+)/eval($1)/eg;
4b450519	194
1cfd258e	195	if (defined($self->{index})) {
70cf3095 AP	196	sprintf "%s(%%%s,%%%s,%d)",
70cf3095 AP	197	$self->{label},$self->{base},
1cfd258e	198	$self->{index},$self->{scale};
5d0d60e2	199	} else {
1cfd258e AP	200	sprintf "%s(%%%s)", $self->{label},$self->{base};
	201	}
	202	} else {
	203	%szmap = ( b=>"BYTE", w=>"WORD", l=>"DWORD", q=>"QWORD" );
	204
70cf3095 AP	205	$self->{label} =~ s/\./\$/g;
	206	$self->{label} =~ s/0x([0-9a-f]+)/0$1h/ig;
	207	$self->{label} = "($self->{label})" if ($self->{label} =~ /[\*\+\-\/]/);
	208
1cfd258e AP	209	if (defined($self->{index})) {
	210	sprintf "%s PTR %s[%s*%d+%s]",$szmap{$sz},
	211	$self->{label},
	212	$self->{index},$self->{scale},
	213	$self->{base};
5f121183 AP	214	} elsif ($self->{base} eq "rip") {
5f121183 AP	215	sprintf "%s PTR %s",$szmap{$sz},$self->{label};
5d0d60e2	216	} else {
1cfd258e AP	217	sprintf "%s PTR %s[%s]",$szmap{$sz},
	218	$self->{label},$self->{base};
	219	}
	220	}
	221	}
	222	}
	223	{ package register; # pick up registers, which start with %.
	224	sub re {
	225	my $class = shift; # muliple instances...
	226	my $self = {};
	227	local *line = shift;
	228	undef $ret;
	229
	230	if ($line =~ /^%(\w+)/) {
	231	bless $self,$class;
	232	$self->{value} = $1;
	233	$ret = $self;
	234	$line = substr($line,@+[0]); $line =~ s/^\s+//;
	235	}
	236	$ret;
	237	}
	238	sub size {
	239	my $self = shift;
	240	undef $ret;
	241
	242	if ($self->{value} =~ /^r[\d]+b$/i) { $ret="b"; }
	243	elsif ($self->{value} =~ /^r[\d]+w$/i) { $ret="w"; }
	244	elsif ($self->{value} =~ /^r[\d]+d$/i) { $ret="l"; }
	245	elsif ($self->{value} =~ /^r[\w]+$/i) { $ret="q"; }
	246	elsif ($self->{value} =~ /^[a-d][hl]$/i){ $ret="b"; }
	247	elsif ($self->{value} =~ /^[\w]{2}l$/i) { $ret="b"; }
	248	elsif ($self->{value} =~ /^[\w]{2}$/i) { $ret="w"; }
	249	elsif ($self->{value} =~ /^e[a-z]{2}$/i){ $ret="l"; }
	250
	251	$ret;
	252	}
	253	sub out {
	254	my $self = shift;
	255	sprintf $masm?"%s":"%%%s",$self->{value};
	256	}
	257	}
	258	{ package label; # pick up labels, which end with :
	259	sub re {
	260	my $self = shift; # single instance is enough...
	261	local *line = shift;
	262	undef $ret;
	263
	264	if ($line =~ /(^[\.\w]+\:)/) {
	265	$self->{value} = $1;
	266	$ret = $self;
	267	$line = substr($line,@+[0]); $line =~ s/^\s+//;
	268
	269	$self->{value} =~ s/\.L/\$L/ if ($masm);
	270	}
	271	$ret;
	272	}
	273	sub out {
	274	my $self = shift;
	275
	276	if (!$masm) {
	277	$self->{value};
	278	} elsif ($self->{value} ne "$current_function->{name}:") {
	279	$self->{value};
	280	} elsif ($current_function->{abi} eq "svr4") {
281	my $func = "$current_function->{name} PROC\n".
282	" mov QWORD PTR 8[rsp],rdi\t;WIN64 prologue\n".
283	" mov QWORD PTR 16[rsp],rsi\n";
284	my $narg = $current_function->{narg};
285	$narg=6 if (!defined($narg));
286	$func .= " mov rdi,rcx\n" if ($narg>0);
287	$func .= " mov rsi,rdx\n" if ($narg>1);
288	$func .= " mov rdx,r8\n" if ($narg>2);
289	$func .= " mov rcx,r9\n" if ($narg>3);
290	$func .= " mov r8,QWORD PTR 40[rsp]\n" if ($narg>4);
291	$func .= " mov r9,QWORD PTR 48[rsp]\n" if ($narg>5);
292	$func .= "\n";
293	} else {
294	"$current_function->{name} PROC";
295	}
296	}
297	}
298	{ package expr; # pick up expressioins
299	sub re {
300	my $self = shift; # single instance is enough...
301	local *line = shift;
302	undef $ret;
303
304	if ($line =~ /(^[^,]+)/) {
305	$self->{value} = $1;
306	$ret = $self;
307	$line = substr($line,@+[0]); $line =~ s/^\s+//;
308
309	$self->{value} =~ s/\.L/\$L/g if ($masm);
310	}
311	$ret;
312	}
313	sub out {
314	my $self = shift;
315	$self->{value};
316	}
317	}
318	{ package directive; # pick up directives, which start with .
319	sub re {
320	my $self = shift; # single instance is enough...
321	local *line = shift;
322	undef $ret;
323	my $dir;
5d0d60e2 AP	324	my %opcode = # lea 2f-1f(%rip),%dst; 1: nop; 2:
	325	( "%rax"=>0x01058d48, "%rcx"=>0x010d8d48,
	326	"%rdx"=>0x01158d48, "%rbx"=>0x011d8d48,
	327	"%rsp"=>0x01258d48, "%rbp"=>0x012d8d48,
	328	"%rsi"=>0x01358d48, "%rdi"=>0x013d8d48,
	329	"%r8" =>0x01058d4c, "%r9" =>0x010d8d4c,
	330	"%r10"=>0x01158d4c, "%r11"=>0x011d8d4c,
	331	"%r12"=>0x01258d4c, "%r13"=>0x012d8d4c,
	332	"%r14"=>0x01358d4c, "%r15"=>0x013d8d4c );
1cfd258e AP	333
	334	if ($line =~ /^\s*(\.\w+)/) {
	335	if (!$masm) {
	336	$self->{value} = $1;
	337	$line =~ s/\@abi\-omnipotent/\@function/;
	338	$line =~ s/\@function.*/\@function/;
5d0d60e2 AP	339	if ($line =~ /\.picmeup\s+(%r[\w]+)/i) {
5d0d60e2 AP	340	$self->{value} = sprintf "\t.long\t0x%x,0x90000000",$opcode{$1};
5f121183 AP	341	} elsif ($line =~ /\.asciz\s+"(.*)"$/) {
	342	$self->{value} = ".byte\t".join(",",unpack("C*",$1),0);
	343	} elsif ($line =~ /\.extern/) {
	344	$self->{value} = ""; # swallow extern
5d0d60e2 AP	345	} else {
	346	$self->{value} = $line;
	347	}
1cfd258e AP	348	$line = "";
	349	return $self;
	350	}
	351
	352	$dir = $1;
	353	$ret = $self;
	354	undef $self->{value};
	355	$line = substr($line,@+[0]); $line =~ s/^\s+//;
	356	SWITCH: for ($dir) {
d7561ac5	357	/\.(text)/
1cfd258e AP	358	&& do { my $v=undef;
1cfd258e AP	359	$v="$current_segment\tENDS\n" if ($current_segment);
d7561ac5	360	$current_segment = "_$1\$";
1cfd258e	361	$current_segment =~ tr/[a-z]/[A-Z]/;
85a752e8 AP	362	$v.="$current_segment\tSEGMENT ";
	363	$v.=$masm>=$masmref ? "ALIGN(64)" : "PAGE";
	364	$v.=" 'CODE'";
1cfd258e AP	365	$self->{value} = $v;
	366	last;
	367	};
76108ba7	368	/\.extern/ && do { $self->{value} = "EXTRN\t".$line.":BYTE"; last; };
1cfd258e AP	369	/\.globl/ && do { $self->{value} = "PUBLIC\t".$line; last; };
1cfd258e AP	370	/\.type/ && do { ($sym,$type,$narg) = split(',',$line);
5d0d60e2 AP	371	if ($type eq "\@function") {
5d0d60e2 AP	372	undef $current_function;
1cfd258e AP	373	$current_function->{name} = $sym;
	374	$current_function->{abi} = "svr4";
	375	$current_function->{narg} = $narg;
5d0d60e2 AP	376	} elsif ($type eq "\@abi-omnipotent") {
5d0d60e2 AP	377	undef $current_function;
1cfd258e AP	378	$current_function->{name} = $sym;
	379	}
	380	last;
	381	};
5d0d60e2 AP	382	/\.size/ && do { if (defined($current_function)) {
5d0d60e2 AP	383	$self->{value}="$current_function->{name}\tENDP";
1cfd258e AP	384	undef $current_function;
	385	}
	386	last;
	387	};
	388	/\.align/ && do { $self->{value} = "ALIGN\t".$line; last; };
	389	/\.(byte\|value\|long\|quad)/
	390	&& do { my @arr = split(',',$line);
	391	my $sz = substr($1,0,1);
	392	my $last = pop(@arr);
1980bc91 AP	393	my $conv = sub { my $var=shift;
	394	if ($var=~s/0x([0-9a-f]+)/0$1h/i) { $var; }
	395	else { sprintf"0%Xh",$var; }
	396	};
1cfd258e AP	397
	398	$sz =~ tr/bvlq/BWDQ/;
	399	$self->{value} = "\tD$sz\t";
1980bc91 AP	400	for (@arr) { $self->{value} .= &$conv($_).","; }
1980bc91 AP	401	$self->{value} .= &$conv($last);
1cfd258e AP	402	last;
1cfd258e AP	403	};
5d0d60e2 AP	404	/\.picmeup/ && do { $self->{value} = sprintf"\tDD\t 0%Xh,090000000h",$opcode{$line};
	405	last;
	406	};
5f121183	407	/\.asciz/ && do { if ($line =~ /^"(.*)"$/) {
76108ba7 AP	408	my @str=unpack("C*",$1);
	409	push @str,0;
	410	while ($#str>15) {
	411	$self->{value}.="DB\t"
	412	.join(",",@str[0..15])."\n";
	413	foreach (0..15) { shift @str; }
	414	}
	415	$self->{value}.="DB\t"
	416	.join(",",@str) if (@str);
5f121183 AP	417	}
	418	last;
	419	};
1cfd258e AP	420	}
	421	$line = "";
	422	}
	423
	424	$ret;
	425	}
	426	sub out {
	427	my $self = shift;
	428	$self->{value};
	429	}
	430	}
	431
	432	while($line=<>) {
	433
	434	chomp($line);
	435
4b450519 AP	436	$line =~ s\|[#!].*$\|\|; # get rid of asm-style comments...
	437	$line =~ s\|/\.\*/\|\|; # ... and C-style comments...
	438	$line =~ s\|^\s+\|\|; # ... and skip white spaces in beginning
1cfd258e AP	439
	440	undef $label;
	441	undef $opcode;
	442	undef $dst;
	443	undef $src;
	444	undef $sz;
	445
	446	if ($label=label->re(\$line)) { print $label->out(); }
	447
	448	if (directive->re(\$line)) {
	449	printf "%s",directive->out();
	450	} elsif ($opcode=opcode->re(\$line)) { ARGUMENT: {
	451
	452	if ($src=register->re(\$line)) { opcode->size($src->size()); }
	453	elsif ($src=const->re(\$line)) { }
	454	elsif ($src=ea->re(\$line)) { }
	455	elsif ($src=expr->re(\$line)) { }
	456
	457	last ARGUMENT if ($line !~ /^,/);
	458
	459	$line = substr($line,1); $line =~ s/^\s+//;
	460
	461	if ($dst=register->re(\$line)) { opcode->size($dst->size()); }
	462	elsif ($dst=const->re(\$line)) { }
	463	elsif ($dst=ea->re(\$line)) { }
	464
	465	} # ARGUMENT:
	466
	467	$sz=opcode->size();
	468
	469	if (defined($dst)) {
	470	if (!$masm) {
	471	printf "\t%s\t%s,%s", $opcode->out($dst->size()),
	472	$src->out($sz),$dst->out($sz);
5d0d60e2	473	} else {
1cfd258e AP	474	printf "\t%s\t%s,%s", $opcode->out(),
	475	$dst->out($sz),$src->out($sz);
	476	}
5d0d60e2	477	} elsif (defined($src)) {
1cfd258e AP	478	printf "\t%s\t%s",$opcode->out(),$src->out($sz);
	479	} else {
	480	printf "\t%s",$opcode->out();
	481	}
	482	}
	483
	484	print $line,"\n";
	485	}
	486
	487	print "\n$current_segment\tENDS\nEND\n" if ($masm);
	488
	489	close STDOUT;
	490
	491	#################################################
	492	# Cross-reference x86_64 ABI "card"
	493	#
	494	# Unix Win64
	495	# %rax * *
	496	# %rbx - -
	497	# %rcx #4 #1
	498	# %rdx #3 #2
	499	# %rsi #2 -
	500	# %rdi #1 -
	501	# %rbp - -
	502	# %rsp - -
	503	# %r8 #5 #3
	504	# %r9 #6 #4
	505	# %r10 * *
	506	# %r11 * *
	507	# %r12 - -
	508	# %r13 - -
	509	# %r14 - -
	510	# %r15 - -
	511	#
	512	# (*) volatile register
	513	# (-) preserved by callee
	514	# (#) Nth argument, volatile
	515	#
	516	# In Unix terms top of stack is argument transfer area for arguments
	517	# which could not be accomodated in registers. Or in other words 7th
	518	# [integer] argument resides at 8(%rsp) upon function entry point.
	519	# 128 bytes above %rsp constitute a "red zone" which is not touched
	520	# by signal handlers and can be used as temporal storage without
	521	# allocating a frame.
	522	#
	523	# In Win64 terms N*8 bytes on top of stack is argument transfer area,
	524	# which belongs to/can be overwritten by callee. N is the number of
	525	# arguments passed to callee, but not less than 4! This means that
	526	# upon function entry point 5th argument resides at 40(%rsp), as well
	527	# as that 32 bytes from 8(%rsp) can always be used as temporal
5f121183 AP	528	# storage [without allocating a frame]. One can actually argue that
	529	# one can assume a "red zone" above stack pointer under Win64 as well.
	530	# Point is that at apparently no occasion Windows kernel would alter
	531	# the area above user stack pointer in true asynchronous manner...
1cfd258e AP	532	#
	533	# All the above means that if assembler programmer adheres to Unix
	534	# register and stack layout, but disregards the "red zone" existense,
	535	# it's possible to use following prologue and epilogue to "gear" from
	536	# Unix to Win64 ABI in leaf functions with not more than 6 arguments.
	537	#
	538	# omnipotent_function:
	539	# ifdef WIN64
	540	# movq %rdi,8(%rsp)
	541	# movq %rsi,16(%rsp)
	542	# movq %rcx,%rdi ; if 1st argument is actually present
	543	# movq %rdx,%rsi ; if 2nd argument is actually ...
	544	# movq %r8,%rdx ; if 3rd argument is ...
	545	# movq %r9,%rcx ; if 4th argument ...
	546	# movq 40(%rsp),%r8 ; if 5th ...
	547	# movq 48(%rsp),%r9 ; if 6th ...
	548	# endif
	549	# ...
	550	# ifdef WIN64
	551	# movq 8(%rsp),%rdi
	552	# movq 16(%rsp),%rsi
	553	# endif
	554	# ret