Advertisement
Reisyukaku

strcpy (^:

Apr 11th, 2016
946
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 14.96 KB | None | 0 0
  1. #include <stdio.h>
  2. #include <stdint.h>
  3. #include "defines.h"
  4. #define __CFSHL__(x, y) (x<<y)
  5. #define __OFSUB__(x, y) (x-y)
  6.  
  7. int _strcpy(char *result, char *str, unsigned int size)
  8. {
  9.   char v3; // t1@7
  10.   int v4; // r0@7
  11.   char *v5; // r1@14
  12.   unsigned int v6; // t1@14
  13.   __int16 v7; // r3@14
  14.   int v8; // r0@14
  15.   char v9; // t1@13
  16.   int v10; // r0@13
  17.   __int16 v11; // t1@17
  18.   int v12; // r0@17
  19.   int v13; // t1@18
  20.   int v14; // r0@18
  21.   char v15; // t1@20
  22.   char *v16; // r1@22
  23.   char v17; // r3@22
  24.   char v18; // t1@22
  25.   char v19; // t1@22
  26.   int v20; // r0@22
  27.   int v21; // r3@23
  28.   unsigned int l; // r2@24
  29.   char *v23; // r1@26
  30.   unsigned int v24; // r4@26
  31.   int v25; // r5@26
  32.   int v26; // r6@26
  33.   int v27; // r7@26
  34.   int v28; // r8@26
  35.   int v29; // r9@26
  36.   int v30; // r10@26
  37.   int v31; // lr@26
  38.   int v32; // r0@26
  39.   int v33; // r4@28
  40.   int v34; // r12@28
  41.   int v35; // lr@28
  42.   int v36; // r4@30
  43.   unsigned int v37; // t1@32
  44.   unsigned __int8 v38; // cf@34
  45.   char v39; // nf@34
  46.   unsigned int v40; // r2@34
  47.   __int16 v41; // t1@35
  48.   int v42; // r12@45
  49.   unsigned __int8 k; // nf@45
  50.   unsigned __int8 v44; // vf@45
  51.   unsigned int v45; // r2@45
  52.   unsigned int v46; // r4@47
  53.   unsigned int v47; // r5@47
  54.   unsigned int v48; // r6@47
  55.   unsigned int v49; // r7@47
  56.   unsigned int v50; // r8@47
  57.   unsigned int v51; // r9@47
  58.   unsigned int v52; // r10@47
  59.   unsigned int v53; // lr@47
  60.   unsigned int v54; // r3@47
  61.   int v55; // r4@47
  62.   unsigned int v56; // r12@47
  63.   int v57; // r5@47
  64.   unsigned int v58; // r3@47
  65.   int v59; // r6@47
  66.   unsigned int v60; // r12@47
  67.   int v61; // r7@47
  68.   unsigned int v62; // r3@47
  69.   int v63; // r8@47
  70.   unsigned int v64; // r12@47
  71.   int v65; // r9@47
  72.   unsigned int v66; // r3@47
  73.   int v67; // r10@47
  74.   int v68; // r2@49
  75.   unsigned __int8 v69; // nf@49
  76.   unsigned __int8 v70; // vf@49
  77.   int v71; // r2@49
  78.   unsigned int v72; // t1@51
  79.   char *v73; // r1@53
  80.   char v74; // r2@53
  81.   int v75; // r12@54
  82.   unsigned __int8 i; // nf@54
  83.   unsigned __int8 v77; // vf@54
  84.   unsigned int v78; // r2@54
  85.   unsigned int v79; // r4@56
  86.   unsigned int v80; // r5@56
  87.   unsigned int v81; // r6@56
  88.   unsigned int v82; // r7@56
  89.   unsigned int v83; // r8@56
  90.   unsigned int v84; // r9@56
  91.   unsigned int v85; // r10@56
  92.   unsigned int v86; // lr@56
  93.   unsigned int v87; // r3@56
  94.   int v88; // r4@56
  95.   unsigned int v89; // r12@56
  96.   int v90; // r5@56
  97.   unsigned int v91; // r3@56
  98.   int v92; // r6@56
  99.   unsigned int v93; // r12@56
  100.   int v94; // r7@56
  101.   unsigned int v95; // r3@56
  102.   int v96; // r8@56
  103.   unsigned int v97; // r12@56
  104.   int v98; // r9@56
  105.   unsigned int v99; // r3@56
  106.   int v100; // r10@56
  107.   int v101; // r2@58
  108.   unsigned __int8 v102; // nf@58
  109.   unsigned __int8 v103; // vf@58
  110.   int v104; // r2@58
  111.   unsigned int v105; // t1@60
  112.   int v106; // r12@63
  113.   unsigned __int8 j; // nf@63
  114.   unsigned __int8 v108; // vf@63
  115.   unsigned int v109; // r2@63
  116.   unsigned int v110; // r4@65
  117.   unsigned int v111; // r5@65
  118.   unsigned int v112; // r6@65
  119.   unsigned int v113; // r7@65
  120.   unsigned int v114; // r8@65
  121.   unsigned int v115; // r9@65
  122.   unsigned int v116; // r10@65
  123.   unsigned int v117; // lr@65
  124.   unsigned int v118; // r3@65
  125.   int v119; // r4@65
  126.   unsigned int v120; // r12@65
  127.   int v121; // r5@65
  128.   unsigned int v122; // r3@65
  129.   int v123; // r6@65
  130.   unsigned int v124; // r12@65
  131.   int v125; // r7@65
  132.   unsigned int v126; // r3@65
  133.   int v127; // r8@65
  134.   unsigned int v128; // r12@65
  135.   int v129; // r9@65
  136.   unsigned int v130; // r3@65
  137.   int v131; // r10@65
  138.   int v132; // r2@67
  139.   unsigned __int8 v133; // nf@67
  140.   unsigned __int8 v134; // vf@67
  141.   int v135; // r2@67
  142.   unsigned int v136; // t1@69
  143.   int v137; // r1@73
  144.   char v138; // r3@73
  145.   char v139; // t1@73
  146.   char v140; // t1@73
  147.   int v141; // r0@73
  148.   char v142; // r3@73
  149.   char v143; // t1@73
  150.   char v144; // t1@73
  151.   int v145; // r1@75
  152.   char v146; // r3@75
  153.   char v147; // t1@75
  154.   char v148; // t1@75
  155.   int v149; // r0@75
  156.  
  157.   if ( size > 8 )
  158.   {
  159.     if ( (unsigned __int8)str & 1 )
  160.     {
  161.       --size;
  162.       v15 = *str++;
  163.       *(_BYTE *)result++ = v15;
  164.     }
  165.     if ( (unsigned __int8)str & 2 )
  166.     {
  167.       size -= 2;
  168.       v18 = *str;
  169.       v16 = str + 1;
  170.       v17 = v18;
  171.       v19 = *v16;
  172.       str = v16 + 1;
  173.       *(_BYTE *)result = v17;
  174.       v20 = result + 1;
  175.       *(_BYTE *)v20 = v19;
  176.       result = v20 + 1;
  177.     }
  178.     v21 = result & 3;
  179.     if ( result & 3 )
  180.     {
  181.       result &= 0xFFFFFFFC;
  182.       if ( v21 == 2 )
  183.       {
  184.         v75 = *(_DWORD *)result & 0xFFFF;
  185.         v77 = __OFSUB__(size, 32);
  186.         v78 = size - 32;
  187.         for ( i = (v78 & 0x80000000) != 0; !(((v78 & 0x80000000) != 0) ^ v77); i = (v78 & 0x80000000) != 0 )
  188.         {
  189.           if ( i ^ v77 )
  190.             break;
  191.           v79 = *(_DWORD *)str;
  192.           v80 = *((_DWORD *)str + 1);
  193.           v81 = *((_DWORD *)str + 2);
  194.           v82 = *((_DWORD *)str + 3);
  195.           v83 = *((_DWORD *)str + 4);
  196.           v84 = *((_DWORD *)str + 5);
  197.           v85 = *((_DWORD *)str + 6);
  198.           v86 = *((_DWORD *)str + 7);
  199.           str += 32;
  200.           v87 = v79 >> 16;
  201.           v88 = v75 | (v79 << 16);
  202.           v89 = v80 >> 16;
  203.           v90 = v87 | (v80 << 16);
  204.           v91 = v81 >> 16;
  205.           v92 = v89 | (v81 << 16);
  206.           v93 = v82 >> 16;
  207.           v94 = v91 | (v82 << 16);
  208.           v95 = v83 >> 16;
  209.           v96 = v93 | (v83 << 16);
  210.           v97 = v84 >> 16;
  211.           v98 = v95 | (v84 << 16);
  212.           v99 = v85 >> 16;
  213.           v100 = v97 | (v85 << 16);
  214.           v75 = v86 >> 16;
  215.           *(_DWORD *)result = v88;
  216.           *(_DWORD *)(result + 4) = v90;
  217.           *(_DWORD *)(result + 8) = v92;
  218.           *(_DWORD *)(result + 12) = v94;
  219.           *(_DWORD *)(result + 16) = v96;
  220.           *(_DWORD *)(result + 20) = v98;
  221.           *(_DWORD *)(result + 24) = v100;
  222.           *(_DWORD *)(result + 28) = v99 | (v86 << 16);
  223.           result += 32;
  224.           v77 = __OFSUB__(v78, 32);
  225.           v78 -= 32;
  226.         }
  227.         v101 = v78 + 32;
  228.         v103 = __OFSUB__(v101, 4);
  229.         v104 = v101 - 4;
  230.         v102 = v104 < 0;
  231.         do
  232.         {
  233.           if ( v102 ^ v103 )
  234.             break;
  235.           v105 = *(_DWORD *)str;
  236.           str += 4;
  237.           *(_DWORD *)result = v75 | (v105 << 16);
  238.           result += 4;
  239.           v75 = v105 >> 16;
  240.           v103 = __OFSUB__(v104, 4);
  241.           v104 -= 4;
  242.           v102 = v104 < 0;
  243.         }
  244.         while ( !((v104 < 0) ^ v103) );
  245.         v73 = str - 2;
  246.         v74 = v104 + 6;
  247.       }
  248.       else if ( (unsigned int)v21 > 2 )
  249.       {
  250.         v106 = *(_DWORD *)result & 0xFFFFFF;
  251.         v108 = __OFSUB__(size, 32);
  252.         v109 = size - 32;
  253.         for ( j = (v109 & 0x80000000) != 0; !(((v109 & 0x80000000) != 0) ^ v108); j = (v109 & 0x80000000) != 0 )
  254.         {
  255.           if ( j ^ v108 )
  256.             break;
  257.           v110 = *(_DWORD *)str;
  258.           v111 = *((_DWORD *)str + 1);
  259.           v112 = *((_DWORD *)str + 2);
  260.           v113 = *((_DWORD *)str + 3);
  261.           v114 = *((_DWORD *)str + 4);
  262.           v115 = *((_DWORD *)str + 5);
  263.           v116 = *((_DWORD *)str + 6);
  264.           v117 = *((_DWORD *)str + 7);
  265.           str += 32;
  266.           v118 = v110 >> 8;
  267.           v119 = v106 | (v110 << 24);
  268.           v120 = v111 >> 8;
  269.           v121 = v118 | (v111 << 24);
  270.           v122 = v112 >> 8;
  271.           v123 = v120 | (v112 << 24);
  272.           v124 = v113 >> 8;
  273.           v125 = v122 | (v113 << 24);
  274.           v126 = v114 >> 8;
  275.           v127 = v124 | (v114 << 24);
  276.           v128 = v115 >> 8;
  277.           v129 = v126 | (v115 << 24);
  278.           v130 = v116 >> 8;
  279.           v131 = v128 | (v116 << 24);
  280.           v106 = v117 >> 8;
  281.           *(_DWORD *)result = v119;
  282.           *(_DWORD *)(result + 4) = v121;
  283.           *(_DWORD *)(result + 8) = v123;
  284.           *(_DWORD *)(result + 12) = v125;
  285.           *(_DWORD *)(result + 16) = v127;
  286.           *(_DWORD *)(result + 20) = v129;
  287.           *(_DWORD *)(result + 24) = v131;
  288.           *(_DWORD *)(result + 28) = v130 | (v117 << 24);
  289.           result += 32;
  290.           v108 = __OFSUB__(v109, 32);
  291.           v109 -= 32;
  292.         }
  293.         v132 = v109 + 32;
  294.         v134 = __OFSUB__(v132, 4);
  295.         v135 = v132 - 4;
  296.         v133 = v135 < 0;
  297.         do
  298.         {
  299.           if ( v133 ^ v134 )
  300.             break;
  301.           v136 = *(_DWORD *)str;
  302.           str += 4;
  303.           *(_DWORD *)result = v106 | (v136 << 24);
  304.           result += 4;
  305.           v106 = v136 >> 8;
  306.           v134 = __OFSUB__(v135, 4);
  307.           v135 -= 4;
  308.           v133 = v135 < 0;
  309.         }
  310.         while ( !((v135 < 0) ^ v134) );
  311.         v73 = str - 3;
  312.         v74 = v135 + 7;
  313.       }
  314.       else
  315.       {
  316.         v42 = *(_DWORD *)result & 0xFF;
  317.         v44 = __OFSUB__(size, 32);
  318.         v45 = size - 32;
  319.         for ( k = (v45 & 0x80000000) != 0; !(((v45 & 0x80000000) != 0) ^ v44); k = (v45 & 0x80000000) != 0 )
  320.         {
  321.           if ( k ^ v44 )
  322.             break;
  323.           v46 = *(_DWORD *)str;
  324.           v47 = *((_DWORD *)str + 1);
  325.           v48 = *((_DWORD *)str + 2);
  326.           v49 = *((_DWORD *)str + 3);
  327.           v50 = *((_DWORD *)str + 4);
  328.           v51 = *((_DWORD *)str + 5);
  329.           v52 = *((_DWORD *)str + 6);
  330.           v53 = *((_DWORD *)str + 7);
  331.           str += 32;
  332.           v54 = v46 >> 24;
  333.           v55 = v42 | (v46 << 8);
  334.           v56 = v47 >> 24;
  335.           v57 = v54 | (v47 << 8);
  336.           v58 = v48 >> 24;
  337.           v59 = v56 | (v48 << 8);
  338.           v60 = v49 >> 24;
  339.           v61 = v58 | (v49 << 8);
  340.           v62 = v50 >> 24;
  341.           v63 = v60 | (v50 << 8);
  342.           v64 = v51 >> 24;
  343.           v65 = v62 | (v51 << 8);
  344.           v66 = v52 >> 24;
  345.           v67 = v64 | (v52 << 8);
  346.           v42 = v53 >> 24;
  347.           *(_DWORD *)result = v55;
  348.           *(_DWORD *)(result + 4) = v57;
  349.           *(_DWORD *)(result + 8) = v59;
  350.           *(_DWORD *)(result + 12) = v61;
  351.           *(_DWORD *)(result + 16) = v63;
  352.           *(_DWORD *)(result + 20) = v65;
  353.           *(_DWORD *)(result + 24) = v67;
  354.           *(_DWORD *)(result + 28) = v66 | (v53 << 8);
  355.           result += 32;
  356.           v44 = __OFSUB__(v45, 0x20);
  357.           v45 -= 0x20;
  358.         }
  359.         v68 = v45 + 32;
  360.         v70 = __OFSUB__(v68, 4);
  361.         v71 = v68 - 4;
  362.         v69 = v71 < 0;
  363.         do
  364.         {
  365.           if ( v69 ^ v70 )
  366.             break;
  367.           v72 = *(_DWORD *)str;
  368.           str += 4;
  369.           *(_DWORD *)result = v42 | (v72 << 8);
  370.           result += 4;
  371.           v42 = v72 >> 24;
  372.           v70 = __OFSUB__(v71, 4);
  373.           v71 -= 4;
  374.           v69 = v71 < 0;
  375.         }
  376.         while ( !((v71 < 0) ^ v70) );
  377.         v73 = str - 1;
  378.         v74 = v71 + 5;
  379.       }
  380.       if ( v74 & 4 )
  381.       {
  382.         v139 = *v73;
  383.         v137 = (int)(v73 + 1);
  384.         v138 = v139;
  385.         v140 = *(_BYTE *)v137++;
  386.         *(_BYTE *)result = v138;
  387.         v141 = result + 1;
  388.         *(_BYTE *)v141++ = v140;
  389.         v143 = *(_BYTE *)v137++;
  390.         v142 = v143;
  391.         v144 = *(_BYTE *)v137;
  392.         v73 = (char *)(v137 + 1);
  393.         *(_BYTE *)v141++ = v142;
  394.         *(_BYTE *)v141 = v144;
  395.         result = v141 + 1;
  396.       }
  397.       if ( v74 & 2 )
  398.       {
  399.         v147 = *v73;
  400.         v145 = (int)(v73 + 1);
  401.         v146 = v147;
  402.         v148 = *(_BYTE *)v145;
  403.         v73 = (char *)(v145 + 1);
  404.         *(_BYTE *)result = v146;
  405.         v149 = result + 1;
  406.         *(_BYTE *)v149 = v148;
  407.         result = v149 + 1;
  408.       }
  409.       if ( v74 & 1 )
  410.         *(_BYTE *)result++ = *v73;
  411.     }
  412.     else
  413.     {
  414.       v38 = size >= 0x20;
  415.       for ( l = size - 32; v38; result = v32 + 16 )
  416.       {
  417.         v24 = *(_DWORD *)str;
  418.         v25 = *((_DWORD *)str + 1);
  419.         v26 = *((_DWORD *)str + 2);
  420.         v27 = *((_DWORD *)str + 3);
  421.         v23 = str + 16;
  422.         v28 = *(_DWORD *)v23;
  423.         v29 = *((_DWORD *)v23 + 1);
  424.         v30 = *((_DWORD *)v23 + 2);
  425.         v31 = *((_DWORD *)v23 + 3);
  426.         str = v23 + 16;
  427.         //__pld(str + 64);
  428.         v38 = l >= 0x20;
  429.         l -= 32;
  430.         *(_DWORD *)result = v24;
  431.         *(_DWORD *)(result + 4) = v25;
  432.         *(_DWORD *)(result + 8) = v26;
  433.         *(_DWORD *)(result + 12) = v27;
  434.         v32 = result + 16;
  435.         *(_DWORD *)v32 = v28;
  436.         *(_DWORD *)(v32 + 4) = v29;
  437.         *(_DWORD *)(v32 + 8) = v30;
  438.         *(_DWORD *)(v32 + 12) = v31;
  439.       }
  440.       if ( __CFSHL__(l, 28) )
  441.       {
  442.         v21 = *(_DWORD *)str;
  443.         v33 = *((_DWORD *)str + 1);
  444.         v34 = *((_DWORD *)str + 2);
  445.         v35 = *((_DWORD *)str + 3);
  446.         str += 16;
  447.         *(_DWORD *)result = v21;
  448.         *(_DWORD *)(result + 4) = v33;
  449.         *(_DWORD *)(result + 8) = v34;
  450.         *(_DWORD *)(result + 12) = v35;
  451.         result += 16;
  452.       }
  453.       if ( ((l << 28) & 0x80000000) != 0 )
  454.       {
  455.         v21 = *(_DWORD *)str;
  456.         v36 = *((_DWORD *)str + 1);
  457.         str += 8;
  458.         *(_DWORD *)result = v21;
  459.         *(_DWORD *)(result + 4) = v36;
  460.         result += 8;
  461.       }
  462.       if ( __CFSHL__(l, 30) )
  463.       {
  464.         v37 = *(_DWORD *)str;
  465.         str += 4;
  466.         LOWORD(v21) = v37;
  467.         *(_DWORD *)result = v37;
  468.         result += 4;
  469.       }
  470.       if ( l << 30 )
  471.       {
  472.         v38 = __CFSHL__(l, 31);
  473.         v40 = l << 31;
  474.         v39 = (v40 & 0x80000000) != 0;
  475.         if ( v38 )
  476.         {
  477.           v41 = *(_WORD *)str;
  478.           str += 2;
  479.           LOWORD(v21) = v41;
  480.         }
  481.         if ( (v40 & 0x80000000) != 0 )
  482.           LOBYTE(v40) = *str;
  483.         if ( v38 )
  484.         {
  485.           *(_WORD *)result = v21;
  486.           result += 2;
  487.         }
  488.         if ( v39 )
  489.           *(_BYTE *)result++ = v40;
  490.       }
  491.     }
  492.   }
  493.   else if ( size == 8 )
  494.   {
  495.     v13 = *((_DWORD *)str + 1);
  496.     *(_DWORD *)result = *(_DWORD *)str;
  497.     v14 = result + 4;
  498.     *(_DWORD *)v14 = v13;
  499.     result = v14 + 4;
  500.   }
  501.   else if ( size > 4 )
  502.   {
  503.     if ( size == 6 )
  504.     {
  505.       v11 = *((_WORD *)str + 2);
  506.       *(_DWORD *)result = *(_DWORD *)str;
  507.       v12 = result + 4;
  508.       *(_WORD *)v12 = v11;
  509.       result = v12 + 2;
  510.     }
  511.     else if ( size >= 6 )
  512.     {
  513.       v6 = *(_DWORD *)str;
  514.       v5 = str + 4;
  515.       v7 = *(_WORD *)v5;
  516.       *(_DWORD *)result = v6;
  517.       v8 = result + 4;
  518.       LOBYTE(v6) = v5[2];
  519.       *(_WORD *)v8 = v7;
  520.       v8 += 2;
  521.       *(_BYTE *)v8 = v6;
  522.       result = v8 + 1;
  523.     }
  524.     else
  525.     {
  526.       v9 = str[4];
  527.       *(_DWORD *)result = *(_DWORD *)str;
  528.       v10 = result + 4;
  529.       *(_BYTE *)v10 = v9;
  530.       result = v10 + 1;
  531.     }
  532.   }
  533.   else if ( size == 4 )
  534.   {
  535.     *(_DWORD *)result = *(_DWORD *)str;
  536.     result += 4;
  537.   }
  538.   else if ( size < 2 )
  539.   {
  540.     if ( size >= 1 )
  541.       *(_BYTE *)result++ = *str;
  542.   }
  543.   else if ( size == 2 )
  544.   {
  545.     *(_WORD *)result = *(_WORD *)str;
  546.     result += 2;
  547.   }
  548.   else
  549.   {
  550.     v3 = str[2];
  551.     *(_WORD *)result = *(_WORD *)str;
  552.     v4 = result + 2;
  553.     *(_BYTE *)v4 = v3;
  554.     result = v4 + 1;
  555.   }
  556.   return result;
  557. }
  558.  
  559. int main(){
  560.     char buf[12] = "Hello World";
  561.     char temp[12];
  562.     _strcpy(temp, buf, 12);
  563.     printf("buf=%s\ntemp=%s\n", buf, temp);
  564.     return 0;
  565. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement