2 # Copyright 2008-2016 The OpenSSL Project Authors. All Rights Reserved.
4 # Licensed under the OpenSSL license (the "License"). You may not use
5 # this file except in compliance with the License. You can obtain a copy
6 # in the file LICENSE in the source distribution or at
7 # https://www.openssl.org/source/license.html
10 # ====================================================================
11 # Copyright (c) 2008 Andy Polyakov <appro@openssl.org>
13 # This module may be used under the terms of either the GNU General
14 # Public License version 2 or later, the GNU Lesser General Public
15 # License version 2.1 or later, the Mozilla Public License version
16 # 1.1 or the BSD License. The exact terms of either license are
17 # distributed along with this module. For further details see
18 # http://www.openssl.org/~appro/camellia/.
19 # ====================================================================
21 # Performance in cycles per processed byte (less is better) in
22 # 'openssl speed ...' benchmark:
25 # -evp camellia-128-ecb 16.7 21.0 22.7
26 # + over gcc 3.4.6 +25% +5% 0%
28 # camellia-128-cbc 15.7 20.4 21.1
30 # 128-bit key setup 128 216 205 cycles/key
31 # + over gcc 3.4.6 +54% +39% +15%
33 # Numbers in "+" rows represent performance improvement over compiler
34 # generated code. Key setup timings are impressive on AMD and Core2
35 # thanks to 64-bit operations being covertly deployed. Improvement on
36 # EM64T, pre-Core2 Intel x86_64 CPU, is not as impressive, because it
37 # apparently emulates some of 64-bit operations in [32-bit] microcode.
41 if ($flavour =~ /\./) { $output = $flavour; undef $flavour; }
43 $win64=0; $win64=1 if ($flavour =~ /[nm]asm|mingw64/ || $output =~ /\.asm$/);
45 $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
46 ( $xlate="${dir}x86_64-xlate.pl" and -f $xlate ) or
47 ( $xlate="${dir}../../perlasm/x86_64-xlate.pl" and -f $xlate) or
48 die "can't locate x86_64-xlate.pl";
50 open OUT,"| \"$^X\" \"$xlate\" $flavour \"$output\"";
53 sub hi() { my $r=shift; $r =~ s/%[er]([a-d])x/%\1h/; $r; }
54 sub lo() { my $r=shift; $r =~ s/%[er]([a-d])x/%\1l/;
55 $r =~ s/%[er]([sd]i)/%\1l/;
56 $r =~ s/%(r[0-9]+)[d]?/%\1b/; $r; }
58 $t0="%eax";$t1="%ebx";$t2="%ecx";$t3="%edx";
59 @S=("%r8d","%r9d","%r10d","%r11d");
62 $Tbl="%rbp"; # size optimization
67 $arg0d=$win64?"%ecx":"%edi";
69 # const unsigned int Camellia_SBOX[4][256];
70 # Well, sort of... Camellia_SBOX[0][] is interleaved with [1][],
71 # and [2][] - with [3][]. This is done to minimize code size.
72 $SBOX1_1110=0; # Camellia_SBOX[0]
73 $SBOX4_4404=4; # Camellia_SBOX[1]
74 $SBOX2_0222=2048; # Camellia_SBOX[2]
75 $SBOX3_3033=2052; # Camellia_SBOX[3]
77 sub Camellia_Feistel {
79 my $seed=defined(@_[1])?@_[1]:0;
80 my $scale=$seed<0?-8:8;
82 my ($s0,$s1,$s2,$s3)=(@S[($j)%4],@S[($j+1)%4],@S[($j+2)%4],@S[($j+3)%4]);
85 xor $s0,$t0 # t0^=key[0]
86 xor $s1,$t1 # t1^=key[1]
87 movz `&hi("$t0")`,$i0 # (t0>>8)&0xff
88 movz `&lo("$t1")`,$i1 # (t1>>0)&0xff
89 mov $SBOX3_3033($Tbl,$i0,8),$t3 # t3=SBOX3_3033[0]
90 mov $SBOX1_1110($Tbl,$i1,8),$t2 # t2=SBOX1_1110[1]
91 movz `&lo("$t0")`,$i0 # (t0>>0)&0xff
93 movz `&hi("$t1")`,$i1 # (t1>>8)&0xff
94 xor $SBOX4_4404($Tbl,$i0,8),$t3 # t3^=SBOX4_4404[0]
96 xor $SBOX4_4404($Tbl,$i1,8),$t2 # t2^=SBOX4_4404[1]
97 movz `&hi("$t0")`,$i0 # (t0>>24)&0xff
98 movz `&lo("$t1")`,$i1 # (t1>>16)&0xff
99 xor $SBOX1_1110($Tbl,$i0,8),$t3 # t3^=SBOX1_1110[0]
100 xor $SBOX3_3033($Tbl,$i1,8),$t2 # t2^=SBOX3_3033[1]
101 movz `&lo("$t0")`,$i0 # (t0>>16)&0xff
102 movz `&hi("$t1")`,$i1 # (t1>>24)&0xff
103 xor $SBOX2_0222($Tbl,$i0,8),$t3 # t3^=SBOX2_0222[0]
104 xor $SBOX2_0222($Tbl,$i1,8),$t2 # t2^=SBOX2_0222[1]
105 mov `$seed+($i+1)*$scale`($key),$t1 # prefetch key[i+1]
106 mov `$seed+($i+1)*$scale+4`($key),$t0
108 ror \$8,$t3 # t3=RightRotate(t3,8)
115 # void Camellia_EncryptBlock_Rounds(
117 # const Byte plaintext[],
118 # const KEY_TABLE_TYPE keyTable,
124 .globl Camellia_EncryptBlock
125 .type Camellia_EncryptBlock,\@abi-omnipotent
127 Camellia_EncryptBlock:
131 adcl \$0,$arg0d # keyBitLength==128?3:4
133 .size Camellia_EncryptBlock,.-Camellia_EncryptBlock
135 .globl Camellia_EncryptBlock_Rounds
136 .type Camellia_EncryptBlock_Rounds,\@function,4
139 Camellia_EncryptBlock_Rounds:
147 #mov %rsi,$inp # put away arguments
151 shl \$6,%edi # process grandRounds
152 lea .LCamellia_SBOX(%rip),$Tbl
153 lea ($key,%rdi),$keyend
155 mov 0(%rsi),@S[0] # load plaintext
164 call _x86_64_Camellia_encrypt
183 .size Camellia_EncryptBlock_Rounds,.-Camellia_EncryptBlock_Rounds
185 .type _x86_64_Camellia_encrypt,\@abi-omnipotent
187 _x86_64_Camellia_encrypt:
189 xor 4($key),@S[0] # ^=key[0-3]
194 mov 16($key),$t1 # prefetch key[4-5]
198 for ($i=0;$i<6;$i++) { Camellia_Feistel($i,16); }
202 mov 8($key),$t3 # prefetch key[2-3]
209 xor $t3,@S[2] # s2^=s3|key[3];
210 xor $t0,@S[1] # s1^=LeftRotate(s0&key[0],1);
214 xor $t1,@S[0] # s0^=s1|key[1];
215 xor $t2,@S[3] # s3^=LeftRotate(s2&key[2],1);
220 xor @S[2],$t0 # SwapHalf
230 .byte 0xf3,0xc3 # rep ret
231 .size _x86_64_Camellia_encrypt,.-_x86_64_Camellia_encrypt
234 .globl Camellia_DecryptBlock
235 .type Camellia_DecryptBlock,\@abi-omnipotent
237 Camellia_DecryptBlock:
241 adcl \$0,$arg0d # keyBitLength==128?3:4
243 .size Camellia_DecryptBlock,.-Camellia_DecryptBlock
245 .globl Camellia_DecryptBlock_Rounds
246 .type Camellia_DecryptBlock_Rounds,\@function,4
249 Camellia_DecryptBlock_Rounds:
257 #mov %rsi,$inp # put away arguments
261 shl \$6,%edi # process grandRounds
262 lea .LCamellia_SBOX(%rip),$Tbl
263 lea ($keyend,%rdi),$key
265 mov 0(%rsi),@S[0] # load plaintext
274 call _x86_64_Camellia_decrypt
293 .size Camellia_DecryptBlock_Rounds,.-Camellia_DecryptBlock_Rounds
295 .type _x86_64_Camellia_decrypt,\@abi-omnipotent
297 _x86_64_Camellia_decrypt:
299 xor 4($key),@S[0] # ^=key[0-3]
304 mov -8($key),$t1 # prefetch key[4-5]
308 for ($i=0;$i<6;$i++) { Camellia_Feistel($i,-8); }
312 mov 0($key),$t3 # prefetch key[2-3]
319 xor $t3,@S[2] # s2^=s3|key[3];
320 xor $t0,@S[1] # s1^=LeftRotate(s0&key[0],1);
324 xor $t1,@S[0] # s0^=s1|key[1];
325 xor $t2,@S[3] # s3^=LeftRotate(s2&key[2],1);
336 mov $t2,@S[0] # SwapHalf
341 .byte 0xf3,0xc3 # rep ret
342 .size _x86_64_Camellia_decrypt,.-_x86_64_Camellia_decrypt
346 my ($rnd,$key,@T)=@_;
347 my $bias=int(@T[0])?shift(@T):0;
351 mov @T[1],`$bias+$rnd*8+0`($key)
352 mov @T[0],`$bias+$rnd*8+4`($key)
353 mov @T[3],`$bias+$rnd*8+8`($key)
354 mov @T[2],`$bias+$rnd*8+12`($key)
357 $code.=" mov @T[0],`$bias+$rnd*8+0`($key)\n";
358 $code.=" mov @T[1],`$bias+$rnd*8+8`($key)\n" if ($#T>=1);
363 my ($rnd,$key,@T)=@_;
364 my $bias=int(@T[0])?shift(@T):0;
366 $code.=" mov `$bias+$rnd*8+0`($key),@T[0]\n";
367 $code.=" mov `$bias+$rnd*8+8`($key),@T[1]\n" if ($#T>=1);
370 # shld is very slow on Intel EM64T family. Even on AMD it limits
371 # instruction decode rate [because it's VectorPath] and consequently
374 my ($i0,$i1,$rot)=@_;
385 # ... Implementing 128-bit rotate without shld gives 80% better
386 # performance EM64T, +15% on AMD64 and only ~7% degradation on
387 # Core2. This is therefore preferred.
389 my ($i0,$i1,$rot)=@_;
408 .globl Camellia_Ekeygen
409 .type Camellia_Ekeygen,\@function,3
419 mov %edi,${keyend}d # put away arguments, keyBitLength
420 mov %rdx,$out # keyTable
422 mov 0(%rsi),@S[0] # load 0-127 bits
432 &_saveround (0,$out,@S); # KL<<<0
434 cmp \$128,$keyend # check keyBitLength
437 mov 16(%rsi),@S[0] # load 128-191 bits
441 mov 24(%rsi),@S[2] # load 192-255 bits
455 &_saveround (4,$out,@S); # temp storage for KR!
457 xor 0($out),@S[1] # KR^KL
463 lea .LCamellia_SIGMA(%rip),$key
464 lea .LCamellia_SBOX(%rip),$Tbl
469 &Camellia_Feistel($step++);
470 &Camellia_Feistel($step++);
472 xor 0($out),@S[1] # ^KL
477 &Camellia_Feistel($step++);
478 &Camellia_Feistel($step++);
483 lea 128($out),$out # size optimization
484 shl \$32,%r8 # @S[0]||
485 shl \$32,%r10 # @S[2]||
487 or %r11,%r10 # ||@S[3]
489 &_loadround (0,$out,-128,"%rax","%rbx"); # KL
490 &_saveround (2,$out,-128,"%r8","%r10"); # KA<<<0
491 &_rotl128 ("%rax","%rbx",15);
492 &_saveround (4,$out,-128,"%rax","%rbx"); # KL<<<15
493 &_rotl128 ("%r8","%r10",15);
494 &_saveround (6,$out,-128,"%r8","%r10"); # KA<<<15
495 &_rotl128 ("%r8","%r10",15); # 15+15=30
496 &_saveround (8,$out,-128,"%r8","%r10"); # KA<<<30
497 &_rotl128 ("%rax","%rbx",30); # 15+30=45
498 &_saveround (10,$out,-128,"%rax","%rbx"); # KL<<<45
499 &_rotl128 ("%r8","%r10",15); # 30+15=45
500 &_saveround (12,$out,-128,"%r8"); # KA<<<45
501 &_rotl128 ("%rax","%rbx",15); # 45+15=60
502 &_saveround (13,$out,-128,"%rbx"); # KL<<<60
503 &_rotl128 ("%r8","%r10",15); # 45+15=60
504 &_saveround (14,$out,-128,"%r8","%r10"); # KA<<<60
505 &_rotl128 ("%rax","%rbx",17); # 60+17=77
506 &_saveround (16,$out,-128,"%rax","%rbx"); # KL<<<77
507 &_rotl128 ("%rax","%rbx",17); # 77+17=94
508 &_saveround (18,$out,-128,"%rax","%rbx"); # KL<<<94
509 &_rotl128 ("%r8","%r10",34); # 60+34=94
510 &_saveround (20,$out,-128,"%r8","%r10"); # KA<<<94
511 &_rotl128 ("%rax","%rbx",17); # 94+17=111
512 &_saveround (22,$out,-128,"%rax","%rbx"); # KL<<<111
513 &_rotl128 ("%r8","%r10",17); # 94+17=111
514 &_saveround (24,$out,-128,"%r8","%r10"); # KA<<<111
521 &_saveround (6,$out,@S); # temp storage for KA!
523 xor `4*8+0`($out),@S[1] # KA^KR
524 xor `4*8+4`($out),@S[0]
525 xor `5*8+0`($out),@S[3]
526 xor `5*8+4`($out),@S[2]
528 &Camellia_Feistel($step++);
529 &Camellia_Feistel($step++);
531 &_loadround (0,$out,"%rax","%rbx"); # KL
532 &_loadround (4,$out,"%rcx","%rdx"); # KR
533 &_loadround (6,$out,"%r14","%r15"); # KA
535 lea 128($out),$out # size optimization
536 shl \$32,%r8 # @S[0]||
537 shl \$32,%r10 # @S[2]||
539 or %r11,%r10 # ||@S[3]
541 &_saveround (2,$out,-128,"%r8","%r10"); # KB<<<0
542 &_rotl128 ("%rcx","%rdx",15);
543 &_saveround (4,$out,-128,"%rcx","%rdx"); # KR<<<15
544 &_rotl128 ("%r14","%r15",15);
545 &_saveround (6,$out,-128,"%r14","%r15"); # KA<<<15
546 &_rotl128 ("%rcx","%rdx",15); # 15+15=30
547 &_saveround (8,$out,-128,"%rcx","%rdx"); # KR<<<30
548 &_rotl128 ("%r8","%r10",30);
549 &_saveround (10,$out,-128,"%r8","%r10"); # KB<<<30
550 &_rotl128 ("%rax","%rbx",45);
551 &_saveround (12,$out,-128,"%rax","%rbx"); # KL<<<45
552 &_rotl128 ("%r14","%r15",30); # 15+30=45
553 &_saveround (14,$out,-128,"%r14","%r15"); # KA<<<45
554 &_rotl128 ("%rax","%rbx",15); # 45+15=60
555 &_saveround (16,$out,-128,"%rax","%rbx"); # KL<<<60
556 &_rotl128 ("%rcx","%rdx",30); # 30+30=60
557 &_saveround (18,$out,-128,"%rcx","%rdx"); # KR<<<60
558 &_rotl128 ("%r8","%r10",30); # 30+30=60
559 &_saveround (20,$out,-128,"%r8","%r10"); # KB<<<60
560 &_rotl128 ("%rax","%rbx",17); # 60+17=77
561 &_saveround (22,$out,-128,"%rax","%rbx"); # KL<<<77
562 &_rotl128 ("%r14","%r15",32); # 45+32=77
563 &_saveround (24,$out,-128,"%r14","%r15"); # KA<<<77
564 &_rotl128 ("%rcx","%rdx",34); # 60+34=94
565 &_saveround (26,$out,-128,"%rcx","%rdx"); # KR<<<94
566 &_rotl128 ("%r14","%r15",17); # 77+17=94
567 &_saveround (28,$out,-128,"%r14","%r15"); # KA<<<77
568 &_rotl128 ("%rax","%rbx",34); # 77+34=111
569 &_saveround (30,$out,-128,"%rax","%rbx"); # KL<<<111
570 &_rotl128 ("%r8","%r10",51); # 60+51=111
571 &_saveround (32,$out,-128,"%r8","%r10"); # KB<<<111
583 .size Camellia_Ekeygen,.-Camellia_Ekeygen
588 112,130, 44,236,179, 39,192,229,228,133, 87, 53,234, 12,174, 65,
589 35,239,107,147, 69, 25,165, 33,237, 14, 79, 78, 29,101,146,189,
590 134,184,175,143,124,235, 31,206, 62, 48,220, 95, 94,197, 11, 26,
591 166,225, 57,202,213, 71, 93, 61,217, 1, 90,214, 81, 86,108, 77,
592 139, 13,154,102,251,204,176, 45,116, 18, 43, 32,240,177,132,153,
593 223, 76,203,194, 52,126,118, 5,109,183,169, 49,209, 23, 4,215,
594 20, 88, 58, 97,222, 27, 17, 28, 50, 15,156, 22, 83, 24,242, 34,
595 254, 68,207,178,195,181,122,145, 36, 8,232,168, 96,252,105, 80,
596 170,208,160,125,161,137, 98,151, 84, 91, 30,149,224,255,100,210,
597 16,196, 0, 72,163,247,117,219,138, 3,230,218, 9, 63,221,148,
598 135, 92,131, 2,205, 74,144, 51,115,103,246,243,157,127,191,226,
599 82,155,216, 38,200, 55,198, 59,129,150,111, 75, 19,190, 99, 46,
600 233,121,167,140,159,110,188,142, 41,245,249,182, 47,253,180, 89,
601 120,152, 6,106,231, 70,113,186,212, 37,171, 66,136,162,141,250,
602 114, 7,185, 85,248,238,172, 10, 54, 73, 42,104, 60, 56,241,164,
603 64, 40,211,123,187,201, 67,193, 21,227,173,244,119,199,128,158);
605 sub S1110 { my $i=shift; $i=@SBOX[$i]; $i=$i<<24|$i<<16|$i<<8; sprintf("0x%08x",$i); }
606 sub S4404 { my $i=shift; $i=($i<<1|$i>>7)&0xff; $i=@SBOX[$i]; $i=$i<<24|$i<<16|$i; sprintf("0x%08x",$i); }
607 sub S0222 { my $i=shift; $i=@SBOX[$i]; $i=($i<<1|$i>>7)&0xff; $i=$i<<16|$i<<8|$i; sprintf("0x%08x",$i); }
608 sub S3033 { my $i=shift; $i=@SBOX[$i]; $i=($i>>1|$i<<7)&0xff; $i=$i<<24|$i<<8|$i; sprintf("0x%08x",$i); }
613 .long 0x3bcc908b, 0xa09e667f, 0x4caa73b2, 0xb67ae858
614 .long 0xe94f82be, 0xc6ef372f, 0xf1d36f1c, 0x54ff53a5
615 .long 0xde682d1d, 0x10e527fa, 0xb3e6c1fd, 0xb05688c2
619 # tables are interleaved, remember?
620 sub data_word { $code.=".long\t".join(',',@_)."\n"; }
621 for ($i=0;$i<256;$i++) { &data_word(&S1110($i),&S4404($i)); }
622 for ($i=0;$i<256;$i++) { &data_word(&S0222($i),&S3033($i)); }
624 # void Camellia_cbc_encrypt (const void char *inp, unsigned char *out,
625 # size_t length, const CAMELLIA_KEY *key,
626 # unsigned char *ivp,const int enc);
629 $_end="8(%rsp)"; # inp+len&~15
630 $_res="16(%rsp)"; # len&15
636 .globl Camellia_cbc_encrypt
637 .type Camellia_cbc_encrypt,\@function,6
639 Camellia_cbc_encrypt:
654 # place stack frame just "above mod 1024" the key schedule,
655 # this ensures that cache associativity suffices
656 lea -64-63(%rcx),%r10
661 #add \$8,%rsp # 8 is reserved for callee's ra
663 mov %rdi,$inp # inp argument
664 mov %rsi,$out # out argument
665 mov %r8,%rbx # ivp argument
666 mov %rcx,$key # key argument
667 mov 272(%rcx),${keyend}d # grandRounds
673 lea .LCamellia_SBOX(%rip),$Tbl
683 loop .Lcbc_prefetch_sbox
686 mov %rdx,%rcx # len argument
687 lea ($key,$keyend),$keyend
689 cmp \$0,%r9d # enc argument
693 and \$15,%rcx # length residue
700 mov 0(%rbx),@S[0] # load IV
718 call _x86_64_Camellia_encrypt
720 mov $_key,$key # "rewind" the key
740 mov @S[0],0($out) # write out IV residue
758 .long 0x9066A4F3 # rep movsb
765 jmp .Lcbc_eloop # one more time
771 and \$15,%rcx # length residue
778 mov (%rbx),%rax # load IV
789 mov %rax,0+$ivec # save IV to temporary storage
794 call _x86_64_Camellia_decrypt
796 mov $_key,$key # "rewind" the key
801 mov ($inp),%rax # load IV for next iteration
833 mov %rax,(%rdx) # write out IV residue
848 .long 0x9066A4F3 # rep movsb
852 mov %rax,(%rdx) # write out IV residue
868 .size Camellia_cbc_encrypt,.-Camellia_cbc_encrypt
870 .asciz "Camellia for x86_64 by <appro\@openssl.org>"
874 # EXCEPTION_DISPOSITION handler (EXCEPTION_RECORD *rec,ULONG64 frame,
875 # CONTEXT *context,DISPATCHER_CONTEXT *disp)
883 .extern __imp_RtlVirtualUnwind
884 .type common_se_handler,\@abi-omnipotent
898 mov 120($context),%rax # pull context->Rax
899 mov 248($context),%rbx # pull context->Rip
901 mov 8($disp),%rsi # disp->ImageBase
902 mov 56($disp),%r11 # disp->HandlerData
904 mov 0(%r11),%r10d # HandlerData[0]
905 lea (%rsi,%r10),%r10 # prologue label
906 cmp %r10,%rbx # context->Rip<prologue label
909 mov 152($context),%rax # pull context->Rsp
911 mov 4(%r11),%r10d # HandlerData[1]
912 lea (%rsi,%r10),%r10 # epilogue label
913 cmp %r10,%rbx # context->Rip>=epilogue label
922 mov %rbx,144($context) # restore context->Rbx
923 mov %rbp,160($context) # restore context->Rbp
924 mov %r13,224($context) # restore context->R13
925 mov %r14,232($context) # restore context->R14
926 mov %r15,240($context) # restore context->R15
931 mov %rax,152($context) # restore context->Rsp
932 mov %rsi,168($context) # restore context->Rsi
933 mov %rdi,176($context) # restore context->Rdi
935 jmp .Lcommon_seh_exit
936 .size common_se_handler,.-common_se_handler
938 .type cbc_se_handler,\@abi-omnipotent
952 mov 120($context),%rax # pull context->Rax
953 mov 248($context),%rbx # pull context->Rip
955 lea .Lcbc_prologue(%rip),%r10
956 cmp %r10,%rbx # context->Rip<.Lcbc_prologue
959 lea .Lcbc_body(%rip),%r10
960 cmp %r10,%rbx # context->Rip<.Lcbc_body
961 jb .Lin_cbc_frame_setup
963 mov 152($context),%rax # pull context->Rsp
965 lea .Lcbc_abort(%rip),%r10
966 cmp %r10,%rbx # context->Rip>=.Lcbc_abort
967 jae .Lin_cbc_prologue
969 # handle pushf/popf in Camellia_cbc_encrypt
970 lea .Lcbc_enc_pushf(%rip),%r10
971 cmp %r10,%rbx # context->Rip<=.Lcbc_enc_pushf
974 lea .Lcbc_enc_popf(%rip),%r10
975 cmp %r10,%rbx # context->Rip<.Lcbc_enc_popf
978 lea .Lcbc_dec_pushf(%rip),%r10
979 cmp %r10,%rbx # context->Rip<=.Lcbc_dec_pushf
982 lea .Lcbc_dec_popf(%rip),%r10
983 cmp %r10,%rbx # context->Rip<.Lcbc_dec_popf
988 mov 48(%rax),%rax # $_rsp
991 .Lin_cbc_frame_setup:
998 mov %rbx,144($context) # restore context->Rbx
999 mov %rbp,160($context) # restore context->Rbp
1000 mov %r12,216($context) # restore context->R12
1001 mov %r13,224($context) # restore context->R13
1002 mov %r14,232($context) # restore context->R14
1003 mov %r15,240($context) # restore context->R15
1008 mov %rax,152($context) # restore context->Rsp
1009 mov %rsi,168($context) # restore context->Rsi
1010 mov %rdi,176($context) # restore context->Rdi
1015 mov 40($disp),%rdi # disp->ContextRecord
1016 mov $context,%rsi # context
1017 mov \$`1232/8`,%ecx # sizeof(CONTEXT)
1018 .long 0xa548f3fc # cld; rep movsq
1021 xor %rcx,%rcx # arg1, UNW_FLAG_NHANDLER
1022 mov 8(%rsi),%rdx # arg2, disp->ImageBase
1023 mov 0(%rsi),%r8 # arg3, disp->ControlPc
1024 mov 16(%rsi),%r9 # arg4, disp->FunctionEntry
1025 mov 40(%rsi),%r10 # disp->ContextRecord
1026 lea 56(%rsi),%r11 # &disp->HandlerData
1027 lea 24(%rsi),%r12 # &disp->EstablisherFrame
1028 mov %r10,32(%rsp) # arg5
1029 mov %r11,40(%rsp) # arg6
1030 mov %r12,48(%rsp) # arg7
1031 mov %rcx,56(%rsp) # arg8, (NULL)
1032 call *__imp_RtlVirtualUnwind(%rip)
1034 mov \$1,%eax # ExceptionContinueSearch
1046 .size cbc_se_handler,.-cbc_se_handler
1050 .rva .LSEH_begin_Camellia_EncryptBlock_Rounds
1051 .rva .LSEH_end_Camellia_EncryptBlock_Rounds
1052 .rva .LSEH_info_Camellia_EncryptBlock_Rounds
1054 .rva .LSEH_begin_Camellia_DecryptBlock_Rounds
1055 .rva .LSEH_end_Camellia_DecryptBlock_Rounds
1056 .rva .LSEH_info_Camellia_DecryptBlock_Rounds
1058 .rva .LSEH_begin_Camellia_Ekeygen
1059 .rva .LSEH_end_Camellia_Ekeygen
1060 .rva .LSEH_info_Camellia_Ekeygen
1062 .rva .LSEH_begin_Camellia_cbc_encrypt
1063 .rva .LSEH_end_Camellia_cbc_encrypt
1064 .rva .LSEH_info_Camellia_cbc_encrypt
1068 .LSEH_info_Camellia_EncryptBlock_Rounds:
1070 .rva common_se_handler
1071 .rva .Lenc_prologue,.Lenc_epilogue # HandlerData[]
1072 .LSEH_info_Camellia_DecryptBlock_Rounds:
1074 .rva common_se_handler
1075 .rva .Ldec_prologue,.Ldec_epilogue # HandlerData[]
1076 .LSEH_info_Camellia_Ekeygen:
1078 .rva common_se_handler
1079 .rva .Lkey_prologue,.Lkey_epilogue # HandlerData[]
1080 .LSEH_info_Camellia_cbc_encrypt:
1086 $code =~ s/\`([^\`]*)\`/eval $1/gem;