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:
153 #mov %rsi,$inp # put away arguments
157 shl \$6,%edi # process grandRounds
158 lea .LCamellia_SBOX(%rip),$Tbl
159 lea ($key,%rdi),$keyend
161 mov 0(%rsi),@S[0] # load plaintext
170 call _x86_64_Camellia_encrypt
192 .cfi_adjust_cfa_offset -40
196 .size Camellia_EncryptBlock_Rounds,.-Camellia_EncryptBlock_Rounds
198 .type _x86_64_Camellia_encrypt,\@abi-omnipotent
200 _x86_64_Camellia_encrypt:
202 xor 4($key),@S[0] # ^=key[0-3]
207 mov 16($key),$t1 # prefetch key[4-5]
211 for ($i=0;$i<6;$i++) { Camellia_Feistel($i,16); }
215 mov 8($key),$t3 # prefetch key[2-3]
222 xor $t3,@S[2] # s2^=s3|key[3];
223 xor $t0,@S[1] # s1^=LeftRotate(s0&key[0],1);
227 xor $t1,@S[0] # s0^=s1|key[1];
228 xor $t2,@S[3] # s3^=LeftRotate(s2&key[2],1);
233 xor @S[2],$t0 # SwapHalf
243 .byte 0xf3,0xc3 # rep ret
244 .size _x86_64_Camellia_encrypt,.-_x86_64_Camellia_encrypt
247 .globl Camellia_DecryptBlock
248 .type Camellia_DecryptBlock,\@abi-omnipotent
250 Camellia_DecryptBlock:
254 adcl \$0,$arg0d # keyBitLength==128?3:4
256 .size Camellia_DecryptBlock,.-Camellia_DecryptBlock
258 .globl Camellia_DecryptBlock_Rounds
259 .type Camellia_DecryptBlock_Rounds,\@function,4
262 Camellia_DecryptBlock_Rounds:
276 #mov %rsi,$inp # put away arguments
280 shl \$6,%edi # process grandRounds
281 lea .LCamellia_SBOX(%rip),$Tbl
282 lea ($keyend,%rdi),$key
284 mov 0(%rsi),@S[0] # load plaintext
293 call _x86_64_Camellia_decrypt
315 .cfi_adjust_cfa_offset -40
319 .size Camellia_DecryptBlock_Rounds,.-Camellia_DecryptBlock_Rounds
321 .type _x86_64_Camellia_decrypt,\@abi-omnipotent
323 _x86_64_Camellia_decrypt:
325 xor 4($key),@S[0] # ^=key[0-3]
330 mov -8($key),$t1 # prefetch key[4-5]
334 for ($i=0;$i<6;$i++) { Camellia_Feistel($i,-8); }
338 mov 0($key),$t3 # prefetch key[2-3]
345 xor $t3,@S[2] # s2^=s3|key[3];
346 xor $t0,@S[1] # s1^=LeftRotate(s0&key[0],1);
350 xor $t1,@S[0] # s0^=s1|key[1];
351 xor $t2,@S[3] # s3^=LeftRotate(s2&key[2],1);
362 mov $t2,@S[0] # SwapHalf
367 .byte 0xf3,0xc3 # rep ret
368 .size _x86_64_Camellia_decrypt,.-_x86_64_Camellia_decrypt
372 my ($rnd,$key,@T)=@_;
373 my $bias=int(@T[0])?shift(@T):0;
377 mov @T[1],`$bias+$rnd*8+0`($key)
378 mov @T[0],`$bias+$rnd*8+4`($key)
379 mov @T[3],`$bias+$rnd*8+8`($key)
380 mov @T[2],`$bias+$rnd*8+12`($key)
383 $code.=" mov @T[0],`$bias+$rnd*8+0`($key)\n";
384 $code.=" mov @T[1],`$bias+$rnd*8+8`($key)\n" if ($#T>=1);
389 my ($rnd,$key,@T)=@_;
390 my $bias=int(@T[0])?shift(@T):0;
392 $code.=" mov `$bias+$rnd*8+0`($key),@T[0]\n";
393 $code.=" mov `$bias+$rnd*8+8`($key),@T[1]\n" if ($#T>=1);
396 # shld is very slow on Intel EM64T family. Even on AMD it limits
397 # instruction decode rate [because it's VectorPath] and consequently
400 my ($i0,$i1,$rot)=@_;
411 # ... Implementing 128-bit rotate without shld gives 80% better
412 # performance EM64T, +15% on AMD64 and only ~7% degradation on
413 # Core2. This is therefore preferred.
415 my ($i0,$i1,$rot)=@_;
434 .globl Camellia_Ekeygen
435 .type Camellia_Ekeygen,\@function,3
451 mov %edi,${keyend}d # put away arguments, keyBitLength
452 mov %rdx,$out # keyTable
454 mov 0(%rsi),@S[0] # load 0-127 bits
464 &_saveround (0,$out,@S); # KL<<<0
466 cmp \$128,$keyend # check keyBitLength
469 mov 16(%rsi),@S[0] # load 128-191 bits
473 mov 24(%rsi),@S[2] # load 192-255 bits
487 &_saveround (4,$out,@S); # temp storage for KR!
489 xor 0($out),@S[1] # KR^KL
495 lea .LCamellia_SIGMA(%rip),$key
496 lea .LCamellia_SBOX(%rip),$Tbl
501 &Camellia_Feistel($step++);
502 &Camellia_Feistel($step++);
504 xor 0($out),@S[1] # ^KL
509 &Camellia_Feistel($step++);
510 &Camellia_Feistel($step++);
515 lea 128($out),$out # size optimization
516 shl \$32,%r8 # @S[0]||
517 shl \$32,%r10 # @S[2]||
519 or %r11,%r10 # ||@S[3]
521 &_loadround (0,$out,-128,"%rax","%rbx"); # KL
522 &_saveround (2,$out,-128,"%r8","%r10"); # KA<<<0
523 &_rotl128 ("%rax","%rbx",15);
524 &_saveround (4,$out,-128,"%rax","%rbx"); # KL<<<15
525 &_rotl128 ("%r8","%r10",15);
526 &_saveround (6,$out,-128,"%r8","%r10"); # KA<<<15
527 &_rotl128 ("%r8","%r10",15); # 15+15=30
528 &_saveround (8,$out,-128,"%r8","%r10"); # KA<<<30
529 &_rotl128 ("%rax","%rbx",30); # 15+30=45
530 &_saveround (10,$out,-128,"%rax","%rbx"); # KL<<<45
531 &_rotl128 ("%r8","%r10",15); # 30+15=45
532 &_saveround (12,$out,-128,"%r8"); # KA<<<45
533 &_rotl128 ("%rax","%rbx",15); # 45+15=60
534 &_saveround (13,$out,-128,"%rbx"); # KL<<<60
535 &_rotl128 ("%r8","%r10",15); # 45+15=60
536 &_saveround (14,$out,-128,"%r8","%r10"); # KA<<<60
537 &_rotl128 ("%rax","%rbx",17); # 60+17=77
538 &_saveround (16,$out,-128,"%rax","%rbx"); # KL<<<77
539 &_rotl128 ("%rax","%rbx",17); # 77+17=94
540 &_saveround (18,$out,-128,"%rax","%rbx"); # KL<<<94
541 &_rotl128 ("%r8","%r10",34); # 60+34=94
542 &_saveround (20,$out,-128,"%r8","%r10"); # KA<<<94
543 &_rotl128 ("%rax","%rbx",17); # 94+17=111
544 &_saveround (22,$out,-128,"%rax","%rbx"); # KL<<<111
545 &_rotl128 ("%r8","%r10",17); # 94+17=111
546 &_saveround (24,$out,-128,"%r8","%r10"); # KA<<<111
553 &_saveround (6,$out,@S); # temp storage for KA!
555 xor `4*8+0`($out),@S[1] # KA^KR
556 xor `4*8+4`($out),@S[0]
557 xor `5*8+0`($out),@S[3]
558 xor `5*8+4`($out),@S[2]
560 &Camellia_Feistel($step++);
561 &Camellia_Feistel($step++);
563 &_loadround (0,$out,"%rax","%rbx"); # KL
564 &_loadround (4,$out,"%rcx","%rdx"); # KR
565 &_loadround (6,$out,"%r14","%r15"); # KA
567 lea 128($out),$out # size optimization
568 shl \$32,%r8 # @S[0]||
569 shl \$32,%r10 # @S[2]||
571 or %r11,%r10 # ||@S[3]
573 &_saveround (2,$out,-128,"%r8","%r10"); # KB<<<0
574 &_rotl128 ("%rcx","%rdx",15);
575 &_saveround (4,$out,-128,"%rcx","%rdx"); # KR<<<15
576 &_rotl128 ("%r14","%r15",15);
577 &_saveround (6,$out,-128,"%r14","%r15"); # KA<<<15
578 &_rotl128 ("%rcx","%rdx",15); # 15+15=30
579 &_saveround (8,$out,-128,"%rcx","%rdx"); # KR<<<30
580 &_rotl128 ("%r8","%r10",30);
581 &_saveround (10,$out,-128,"%r8","%r10"); # KB<<<30
582 &_rotl128 ("%rax","%rbx",45);
583 &_saveround (12,$out,-128,"%rax","%rbx"); # KL<<<45
584 &_rotl128 ("%r14","%r15",30); # 15+30=45
585 &_saveround (14,$out,-128,"%r14","%r15"); # KA<<<45
586 &_rotl128 ("%rax","%rbx",15); # 45+15=60
587 &_saveround (16,$out,-128,"%rax","%rbx"); # KL<<<60
588 &_rotl128 ("%rcx","%rdx",30); # 30+30=60
589 &_saveround (18,$out,-128,"%rcx","%rdx"); # KR<<<60
590 &_rotl128 ("%r8","%r10",30); # 30+30=60
591 &_saveround (20,$out,-128,"%r8","%r10"); # KB<<<60
592 &_rotl128 ("%rax","%rbx",17); # 60+17=77
593 &_saveround (22,$out,-128,"%rax","%rbx"); # KL<<<77
594 &_rotl128 ("%r14","%r15",32); # 45+32=77
595 &_saveround (24,$out,-128,"%r14","%r15"); # KA<<<77
596 &_rotl128 ("%rcx","%rdx",34); # 60+34=94
597 &_saveround (26,$out,-128,"%rcx","%rdx"); # KR<<<94
598 &_rotl128 ("%r14","%r15",17); # 77+17=94
599 &_saveround (28,$out,-128,"%r14","%r15"); # KA<<<77
600 &_rotl128 ("%rax","%rbx",34); # 77+34=111
601 &_saveround (30,$out,-128,"%rax","%rbx"); # KL<<<111
602 &_rotl128 ("%r8","%r10",51); # 60+51=111
603 &_saveround (32,$out,-128,"%r8","%r10"); # KB<<<111
618 .cfi_adjust_cfa_offset -40
622 .size Camellia_Ekeygen,.-Camellia_Ekeygen
627 112,130, 44,236,179, 39,192,229,228,133, 87, 53,234, 12,174, 65,
628 35,239,107,147, 69, 25,165, 33,237, 14, 79, 78, 29,101,146,189,
629 134,184,175,143,124,235, 31,206, 62, 48,220, 95, 94,197, 11, 26,
630 166,225, 57,202,213, 71, 93, 61,217, 1, 90,214, 81, 86,108, 77,
631 139, 13,154,102,251,204,176, 45,116, 18, 43, 32,240,177,132,153,
632 223, 76,203,194, 52,126,118, 5,109,183,169, 49,209, 23, 4,215,
633 20, 88, 58, 97,222, 27, 17, 28, 50, 15,156, 22, 83, 24,242, 34,
634 254, 68,207,178,195,181,122,145, 36, 8,232,168, 96,252,105, 80,
635 170,208,160,125,161,137, 98,151, 84, 91, 30,149,224,255,100,210,
636 16,196, 0, 72,163,247,117,219,138, 3,230,218, 9, 63,221,148,
637 135, 92,131, 2,205, 74,144, 51,115,103,246,243,157,127,191,226,
638 82,155,216, 38,200, 55,198, 59,129,150,111, 75, 19,190, 99, 46,
639 233,121,167,140,159,110,188,142, 41,245,249,182, 47,253,180, 89,
640 120,152, 6,106,231, 70,113,186,212, 37,171, 66,136,162,141,250,
641 114, 7,185, 85,248,238,172, 10, 54, 73, 42,104, 60, 56,241,164,
642 64, 40,211,123,187,201, 67,193, 21,227,173,244,119,199,128,158);
644 sub S1110 { my $i=shift; $i=@SBOX[$i]; $i=$i<<24|$i<<16|$i<<8; sprintf("0x%08x",$i); }
645 sub S4404 { my $i=shift; $i=($i<<1|$i>>7)&0xff; $i=@SBOX[$i]; $i=$i<<24|$i<<16|$i; sprintf("0x%08x",$i); }
646 sub S0222 { my $i=shift; $i=@SBOX[$i]; $i=($i<<1|$i>>7)&0xff; $i=$i<<16|$i<<8|$i; sprintf("0x%08x",$i); }
647 sub S3033 { my $i=shift; $i=@SBOX[$i]; $i=($i>>1|$i<<7)&0xff; $i=$i<<24|$i<<8|$i; sprintf("0x%08x",$i); }
652 .long 0x3bcc908b, 0xa09e667f, 0x4caa73b2, 0xb67ae858
653 .long 0xe94f82be, 0xc6ef372f, 0xf1d36f1c, 0x54ff53a5
654 .long 0xde682d1d, 0x10e527fa, 0xb3e6c1fd, 0xb05688c2
658 # tables are interleaved, remember?
659 sub data_word { $code.=".long\t".join(',',@_)."\n"; }
660 for ($i=0;$i<256;$i++) { &data_word(&S1110($i),&S4404($i)); }
661 for ($i=0;$i<256;$i++) { &data_word(&S0222($i),&S3033($i)); }
663 # void Camellia_cbc_encrypt (const void char *inp, unsigned char *out,
664 # size_t length, const CAMELLIA_KEY *key,
665 # unsigned char *ivp,const int enc);
668 $_end="8(%rsp)"; # inp+len&~15
669 $_res="16(%rsp)"; # len&15
675 .globl Camellia_cbc_encrypt
676 .type Camellia_cbc_encrypt,\@function,6
678 Camellia_cbc_encrypt:
697 .cfi_def_cfa_register %rbp
701 # place stack frame just "above mod 1024" the key schedule,
702 # this ensures that cache associativity suffices
703 lea -64-63(%rcx),%r10
708 #add \$8,%rsp # 8 is reserved for callee's ra
710 mov %rdi,$inp # inp argument
711 mov %rsi,$out # out argument
712 mov %r8,%rbx # ivp argument
713 mov %rcx,$key # key argument
714 mov 272(%rcx),${keyend}d # grandRounds
718 .cfi_cfa_expression $_rsp,deref,+56
721 lea .LCamellia_SBOX(%rip),$Tbl
731 loop .Lcbc_prefetch_sbox
734 mov %rdx,%rcx # len argument
735 lea ($key,$keyend),$keyend
737 cmp \$0,%r9d # enc argument
741 and \$15,%rcx # length residue
748 mov 0(%rbx),@S[0] # load IV
766 call _x86_64_Camellia_encrypt
768 mov $_key,$key # "rewind" the key
788 mov @S[0],0($out) # write out IV residue
806 .long 0x9066A4F3 # rep movsb
813 jmp .Lcbc_eloop # one more time
819 and \$15,%rcx # length residue
826 mov (%rbx),%rax # load IV
837 mov %rax,0+$ivec # save IV to temporary storage
842 call _x86_64_Camellia_decrypt
844 mov $_key,$key # "rewind" the key
849 mov ($inp),%rax # load IV for next iteration
881 mov %rax,(%rdx) # write out IV residue
896 .long 0x9066A4F3 # rep movsb
900 mov %rax,(%rdx) # write out IV residue
925 .size Camellia_cbc_encrypt,.-Camellia_cbc_encrypt
927 .asciz "Camellia for x86_64 by <appro\@openssl.org>"
931 # EXCEPTION_DISPOSITION handler (EXCEPTION_RECORD *rec,ULONG64 frame,
932 # CONTEXT *context,DISPATCHER_CONTEXT *disp)
940 .extern __imp_RtlVirtualUnwind
941 .type common_se_handler,\@abi-omnipotent
955 mov 120($context),%rax # pull context->Rax
956 mov 248($context),%rbx # pull context->Rip
958 mov 8($disp),%rsi # disp->ImageBase
959 mov 56($disp),%r11 # disp->HandlerData
961 mov 0(%r11),%r10d # HandlerData[0]
962 lea (%rsi,%r10),%r10 # prologue label
963 cmp %r10,%rbx # context->Rip<prologue label
966 mov 152($context),%rax # pull context->Rsp
968 mov 4(%r11),%r10d # HandlerData[1]
969 lea (%rsi,%r10),%r10 # epilogue label
970 cmp %r10,%rbx # context->Rip>=epilogue label
979 mov %rbx,144($context) # restore context->Rbx
980 mov %rbp,160($context) # restore context->Rbp
981 mov %r13,224($context) # restore context->R13
982 mov %r14,232($context) # restore context->R14
983 mov %r15,240($context) # restore context->R15
988 mov %rax,152($context) # restore context->Rsp
989 mov %rsi,168($context) # restore context->Rsi
990 mov %rdi,176($context) # restore context->Rdi
992 jmp .Lcommon_seh_exit
993 .size common_se_handler,.-common_se_handler
995 .type cbc_se_handler,\@abi-omnipotent
1009 mov 120($context),%rax # pull context->Rax
1010 mov 248($context),%rbx # pull context->Rip
1012 lea .Lcbc_prologue(%rip),%r10
1013 cmp %r10,%rbx # context->Rip<.Lcbc_prologue
1014 jb .Lin_cbc_prologue
1016 lea .Lcbc_body(%rip),%r10
1017 cmp %r10,%rbx # context->Rip<.Lcbc_body
1018 jb .Lin_cbc_frame_setup
1020 mov 152($context),%rax # pull context->Rsp
1022 lea .Lcbc_abort(%rip),%r10
1023 cmp %r10,%rbx # context->Rip>=.Lcbc_abort
1024 jae .Lin_cbc_prologue
1026 # handle pushf/popf in Camellia_cbc_encrypt
1027 lea .Lcbc_enc_pushf(%rip),%r10
1028 cmp %r10,%rbx # context->Rip<=.Lcbc_enc_pushf
1029 jbe .Lin_cbc_no_flag
1031 lea .Lcbc_enc_popf(%rip),%r10
1032 cmp %r10,%rbx # context->Rip<.Lcbc_enc_popf
1035 lea .Lcbc_dec_pushf(%rip),%r10
1036 cmp %r10,%rbx # context->Rip<=.Lcbc_dec_pushf
1037 jbe .Lin_cbc_no_flag
1039 lea .Lcbc_dec_popf(%rip),%r10
1040 cmp %r10,%rbx # context->Rip<.Lcbc_dec_popf
1045 mov 48(%rax),%rax # $_rsp
1048 .Lin_cbc_frame_setup:
1055 mov %rbx,144($context) # restore context->Rbx
1056 mov %rbp,160($context) # restore context->Rbp
1057 mov %r12,216($context) # restore context->R12
1058 mov %r13,224($context) # restore context->R13
1059 mov %r14,232($context) # restore context->R14
1060 mov %r15,240($context) # restore context->R15
1065 mov %rax,152($context) # restore context->Rsp
1066 mov %rsi,168($context) # restore context->Rsi
1067 mov %rdi,176($context) # restore context->Rdi
1072 mov 40($disp),%rdi # disp->ContextRecord
1073 mov $context,%rsi # context
1074 mov \$`1232/8`,%ecx # sizeof(CONTEXT)
1075 .long 0xa548f3fc # cld; rep movsq
1078 xor %rcx,%rcx # arg1, UNW_FLAG_NHANDLER
1079 mov 8(%rsi),%rdx # arg2, disp->ImageBase
1080 mov 0(%rsi),%r8 # arg3, disp->ControlPc
1081 mov 16(%rsi),%r9 # arg4, disp->FunctionEntry
1082 mov 40(%rsi),%r10 # disp->ContextRecord
1083 lea 56(%rsi),%r11 # &disp->HandlerData
1084 lea 24(%rsi),%r12 # &disp->EstablisherFrame
1085 mov %r10,32(%rsp) # arg5
1086 mov %r11,40(%rsp) # arg6
1087 mov %r12,48(%rsp) # arg7
1088 mov %rcx,56(%rsp) # arg8, (NULL)
1089 call *__imp_RtlVirtualUnwind(%rip)
1091 mov \$1,%eax # ExceptionContinueSearch
1103 .size cbc_se_handler,.-cbc_se_handler
1107 .rva .LSEH_begin_Camellia_EncryptBlock_Rounds
1108 .rva .LSEH_end_Camellia_EncryptBlock_Rounds
1109 .rva .LSEH_info_Camellia_EncryptBlock_Rounds
1111 .rva .LSEH_begin_Camellia_DecryptBlock_Rounds
1112 .rva .LSEH_end_Camellia_DecryptBlock_Rounds
1113 .rva .LSEH_info_Camellia_DecryptBlock_Rounds
1115 .rva .LSEH_begin_Camellia_Ekeygen
1116 .rva .LSEH_end_Camellia_Ekeygen
1117 .rva .LSEH_info_Camellia_Ekeygen
1119 .rva .LSEH_begin_Camellia_cbc_encrypt
1120 .rva .LSEH_end_Camellia_cbc_encrypt
1121 .rva .LSEH_info_Camellia_cbc_encrypt
1125 .LSEH_info_Camellia_EncryptBlock_Rounds:
1127 .rva common_se_handler
1128 .rva .Lenc_prologue,.Lenc_epilogue # HandlerData[]
1129 .LSEH_info_Camellia_DecryptBlock_Rounds:
1131 .rva common_se_handler
1132 .rva .Ldec_prologue,.Ldec_epilogue # HandlerData[]
1133 .LSEH_info_Camellia_Ekeygen:
1135 .rva common_se_handler
1136 .rva .Lkey_prologue,.Lkey_epilogue # HandlerData[]
1137 .LSEH_info_Camellia_cbc_encrypt:
1143 $code =~ s/\`([^\`]*)\`/eval $1/gem;