Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
btwise
openssl
提交
1cfd258e
O
openssl
项目概览
btwise
/
openssl
通知
1
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
O
openssl
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
1cfd258e
编写于
4月 17, 2005
作者:
A
Andy Polyakov
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
Throw in x86_64 AT&T to MASM assembler converter to facilitate development
of dual-ABI Unix/Win64 modules.
上级
04d7d51e
变更
2
隐藏空白更改
内联
并排
Showing
2 changed file
with
506 addition
and
114 deletion
+506
-114
crypto/perlasm/x86_64-xlate.pl
crypto/perlasm/x86_64-xlate.pl
+459
-0
crypto/rc4/asm/rc4-amd64.pl
crypto/rc4/asm/rc4-amd64.pl
+47
-114
未找到文件。
crypto/perlasm/x86_64-xlate.pl
0 → 100755
浏览文件 @
1cfd258e
#!/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 Windows prologue and epilogue automatically. If you want
# to take care of ABI differences yourself, tag functions as
# ".type name,@abi-omnipotent."
# 4. As minor optimization 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
# it can't be resolved with unified prologue.
# 5. Name local labels as .L*.
# 6. Don't use repret, it's generated automatically.
my
$output
=
shift
;
open
STDOUT
,"
>
$output
"
||
die
"
can't open
$output
: $!
";
my
$masm
=
1
if
(
$output
=~
/\.asm/
);
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]+)/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
}
=~
/([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 in pain...
sprintf
"
%s%s%s
",
$self
->
{
op
},
$self
->
{
sz
},
shift
;
}
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
\t
0F3h,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
;
sprintf
$masm
?"
%s
":"
\$
%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
->
{
label
}
=~
s/\.L/\$L/g
;
$self
->
{
base
}
=~
s/^%//
;
$self
->
{
index
}
=~
s/^%//
if
(
defined
(
$self
->
{
index
}));
}
$ret
;
}
sub
size
{}
sub
out
{
my
$self
=
shift
;
my
$sz
=
shift
;
if
(
!
$masm
)
{
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
"
);
if
(
defined
(
$self
->
{
index
}))
{
sprintf
"
%s PTR %s[%s*%d+%s]
",
$szmap
{
$sz
},
$self
->
{
label
},
$self
->
{
index
},
$self
->
{
scale
},
$self
->
{
base
};
}
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
;
if
(
$line
=~
/^\s*(\.\w+)/
)
{
if
(
!
$masm
)
{
$self
->
{
value
}
=
$
1
;
$line
=~
s/\@abi\-omnipotent/\@function/
;
$line
=~
s/\@function.*/\@function/
;
$self
->
{
value
}
=
$line
;
$line
=
"";
return
$self
;
}
$dir
=
$
1
;
$ret
=
$self
;
undef
$self
->
{
value
};
$line
=
substr
(
$line
,
@
+
[
0
]);
$line
=~
s/^\s+//
;
SWITCH:
for
(
$dir
)
{
/\.(text|data)/
&&
do
{
my
$v
=
undef
;
$v
=
"
$current_segment
\t
ENDS
\n
"
if
(
$current_segment
);
$current_segment
=
"
_$1
";
$current_segment
=~
tr/[a-z]/[A-Z]/
;
$v
.=
"
$current_segment
\t
SEGMENT PARA
";
$self
->
{
value
}
=
$v
;
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}
\t
ENDP
";
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
);
$sz
=~
tr/bvlq/BWDQ/
;
$self
->
{
value
}
=
"
\t
D
$sz
\t
";
for
(
@arr
)
{
$self
->
{
value
}
.=
sprintf
"
0%Xh,
",
oct
;
}
$self
->
{
value
}
.=
sprintf
"
0%Xh
",
oct
(
$last
);
last
;
};
}
$line
=
"";
}
$ret
;
}
sub
out
{
my
$self
=
shift
;
$self
->
{
value
};
}
}
while
(
$line
=<>
)
{
chomp
(
$line
);
$line
=~
s/\[#!].*$//
;
# get rid of comments...
$line
=~
s/^\s+//
;
# ... and skip white spaces
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
\t
ENDS
\n
END
\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].
#
# 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
crypto/rc4/asm/rc4-amd64.pl
浏览文件 @
1cfd258e
...
...
@@ -35,145 +35,99 @@
# of code remain redundant.
$output
=
shift
;
open
STDOUT
,"
| $^X ../perlasm/x86_64-xlate.pl
$output
";
$win64a
=
1
if
(
$output
=~
/win64a.[s|asm]/
);
open
STDOUT
,"
>
$output
"
||
die
"
can't open
$output
: $!
";
if
(
defined
(
$win64a
))
{
$dat
=
"
%rcx
";
# arg1
$len
=
"
%rdx
";
# arg2
$inp
=
"
%rsi
";
# r8, arg3 moves here
$out
=
"
%rdi
";
# r9, arg4 moves here
}
else
{
$dat
=
"
%rdi
";
# arg1
$len
=
"
%rsi
";
# arg2
$inp
=
"
%rdx
";
# arg3
$out
=
"
%rcx
";
# arg4
}
$dat
=
"
%rdi
";
# arg1
$len
=
"
%rsi
";
# arg2
$inp
=
"
%rdx
";
# arg3
$out
=
"
%rcx
";
# arg4
$XX
=
"
%r10
";
$TX
=
"
%r8
";
$YY
=
"
%r11
";
$TY
=
"
%r9
";
sub
PTR
()
{
my
$ret
=
shift
;
if
(
defined
(
$win64a
))
{
$ret
=~
s/\[([\S]+)\+([\S]+)\]/[$2+$1]/g
;
# [%rN+%rM*4]->[%rM*4+%rN]
$ret
=~
s/:([^\[]+)\[([^\]]+)\]/:[$2+$1]/g
;
# :off[ea]->:[ea+off]
}
else
{
$ret
=~
s/[\+\*]/,/g
;
# [%rN+%rM*4]->[%rN,%rM,4]
$ret
=~
s/\[([^\]]+)\]/($1)/g
;
# [%rN]->(%rN)
}
$ret
;
}
$code
=<<
___
if
(
!
defined
(
$win64a
));
$code
=
<<___;
.text
.globl RC4
.
type
RC4
,
\
@function
.type RC4,\@function
,4
.align 16
RC4: or $len,$len
jne .Lentry
re
pre
t
ret
.Lentry:
___
$code
=<<
___
if
(
defined
(
$win64a
));
_TEXT
SEGMENT
PUBLIC
RC4
ALIGN
16
RC4
PROC
or
$len
,
$len
jne
.
Lentry
repret
.
Lentry:
push
%rdi
push
%rsi
sub
\$40,%
rsp
mov
%
r8
,$
inp
mov
%
r9
,$
out
___
$
code
.=<<
___
;
add \$8,$dat
movl
`
&PTR("DWORD:-8[
$dat
]")
`
,
$XX
#d
movl
`
&PTR("DWORD:-4[
$dat
]")
`
,
$YY
#d
cmpl
\
$
-
1
,
`
&PTR("DWORD:256[
$dat
]")
`
movl
-8($dat)
,$XX#d
movl
-4($dat)
,$YY#d
cmpl \$-1,
256($dat)
je .LRC4_CHAR
test \$-8,$len
jz .Lloop1
.align 16
.Lloop8:
inc $XX#b
movl
`
&PTR("DWORD:[
$dat
+
$XX
*4]")
`
,
$TX
#d
movl
($dat,$XX,4)
,$TX#d
add $TX#b,$YY#b
movl
`
&PTR("DWORD:[
$dat
+
$YY
*4]")
`
,
$TY
#d
movl
$TX
#d,
`&PTR("DWORD:[$dat+$YY*4]")`
movl
$TY
#d,
`&PTR("DWORD:[$dat+$XX*4]")`
movl
($dat,$YY,4)
,$TY#d
movl $TX#d,
($dat,$YY,4)
movl $TY#d,
($dat,$XX,4)
add $TX#b,$TY#b
inc $XX#b
movl
`
&PTR("DWORD:[
$dat
+
$XX
*4]")
`
,
$TX
#d
movb
`
&PTR("BYTE:[
$dat
+
$TY
*4]")
`
,
%al
movl
($dat,$XX,4)
,$TX#d
movb
($dat,$TY,4)
,%al
___
for
(
$i
=
1
;
$i
<=
6
;
$i
++
)
{
$code
.=
<<___;
add $TX#b,$YY#b
ror \$8,%rax
movl
`&PTR("DWORD:[$dat+$YY*4]")`
,$TY#d
movl $TX#d,
`&PTR("DWORD:[$dat+$YY*4]")`
movl $TY#d,
`&PTR("DWORD:[$dat+$XX*4]")`
movl
($dat,$YY,4)
,$TY#d
movl $TX#d,
($dat,$YY,4)
movl $TY#d,
($dat,$XX,4)
add $TX#b,$TY#b
inc $XX#b
movl
`&PTR("DWORD:[$dat+$XX*4]")`
,$TX#d
movb
`&PTR("BYTE:[$dat+$TY*4]")`
,%al
movl
($dat,$XX,4)
,$TX#d
movb
($dat,$TY,4)
,%al
___
}
$code
.=
<<___;
add $TX#b,$YY#b
ror \$8,%rax
movl
`&PTR("DWORD:[$dat+$YY*4]")`
,$TY#d
movl $TX#d,
`&PTR("DWORD:[$dat+$YY*4]")`
movl $TY#d,
`&PTR("DWORD:[$dat+$XX*4]")`
movl
($dat,$YY,4)
,$TY#d
movl $TX#d,
($dat,$YY,4)
movl $TY#d,
($dat,$XX,4)
sub \$8,$len
add $TY#b,$TX#b
movb
`&PTR("BYTE:[$dat+$TX*4]")`
,%al
movb
($dat,$TX,4)
,%al
ror \$8,%rax
add \$8,$inp
add \$8,$out
xor
`&PTR("QWORD:-8[$inp]")`
,%rax
mov %rax,
`&PTR("QWORD:-8[$out]")`
xor
-8($inp)
,%rax
mov %rax,
-8($out)
test \$-8,$len
jnz .Lloop8
cmp \$0,$len
jne .Lloop1
.Lexit:
movl $XX#d,`&PTR("DWORD:-8[$dat]")`
movl $YY#d,`&PTR("DWORD:-4[$dat]")`
___
$code
.=<<
___
if
(
defined
(
$win64a
));
add
\
$
40
,
%rsp
pop
%rsi
pop
%rdi
___
$code
.=
<<___;
repret
movl $XX#d,-8($dat)
movl $YY#d,-4($dat)
ret
.align 16
.Lloop1:
movzb
`&PTR("BYTE:[$inp]")`
,%eax
movzb
($inp)
,%eax
inc $XX#b
movl
`&PTR("DWORD:[$dat+$XX*4]")`
,$TX#d
movl
($dat,$XX,4)
,$TX#d
add $TX#b,$YY#b
movl
`&PTR("DWORD:[$dat+$YY*4]")`
,$TY#d
movl $TX#d,
`&PTR("DWORD:[$dat+$YY*4]")`
movl $TY#d,
`&PTR("DWORD:[$dat+$XX*4]")`
movl
($dat,$YY,4)
,$TY#d
movl $TX#d,
($dat,$YY,4)
movl $TY#d,
($dat,$XX,4)
add $TY#b,$TX#b
movl
`&PTR("DWORD:[$dat+$TX*4]")`
,$TY#d
movl
($dat,$TX,4)
,$TY#d
xor $TY,%rax
inc $inp
movb %al,
`&PTR("BYTE:[$out]")`
movb %al,
($out)
inc $out
dec $len
jnz .Lloop1
...
...
@@ -182,46 +136,25 @@ $code.=<<___;
.align 16
.LRC4_CHAR:
add \$1,$XX#b
movzb
`&PTR("BYTE:[$dat+$XX]")`
,$TX#d
movzb
($dat,$XX)
,$TX#d
add $TX#b,$YY#b
movzb
`&PTR("BYTE:[$dat+$YY]")`
,$TY#d
movb $TX#b,
`&PTR("BYTE:[$dat+$YY]")`
movb $TY#b,
`&PTR("BYTE:[$dat+$XX]")`
movzb
($dat,$YY)
,$TY#d
movb $TX#b,
($dat,$YY)
movb $TY#b,
($dat,$XX)
add $TX#b,$TY#b
movzb
`&PTR("BYTE:[$dat+$TY]")`
,$TY#d
xorb
`&PTR("BYTE:[$inp]")`
,$TY#b
movb $TY#b,
`&PTR("BYTE:[$out]")`
movzb
($dat,$TY)
,$TY#d
xorb
($inp)
,$TY#b
movb $TY#b,
($out)
lea 1($inp),$inp
lea 1($out),$out
sub \$1,$len
jnz .LRC4_CHAR
jmp .Lexit
___
$code
.=<<
___
if
(
defined
(
$win64a
));
RC4
ENDP
_TEXT
ENDS
END
___
$code
.=<<
___
if
(
!
defined
(
$win64a
));
.size RC4,.-RC4
___
$code
=~
s/#([bwd])/$1/gm
;
$code
=~
s/\`([^\`]*)\`/eval $1/g
em
;
if
(
defined
(
$win64a
))
{
$code
=~
s/\.align/ALIGN/gm
;
$code
=~
s/[\$%]//gm
;
$code
=~
s/\.L/\$L/gm
;
$code
=~
s/([\w]+)([\s]+)([\S]+),([\S]+)/$1$2$4,$3/gm
;
$code
=~
s/([QD]*WORD|BYTE):/$1 PTR/gm
;
$code
=~
s/mov[bwlq]/mov/gm
;
$code
=~
s/movzb/movzx/gm
;
$code
=~
s/repret/DB\t0F3h,0C3h/gm
;
$code
=~
s/cmpl/cmp/gm
;
$code
=~
s/xorb/xor/gm
;
}
else
{
$code
=~
s/([QD]*WORD|BYTE)://gm
;
$code
=~
s/repret/.byte\t0xF3,0xC3/gm
;
}
print
$code
;
close
STDOUT
;
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录