API tools faq
paste
Advertisement
Reisyukaku

strcpy (^:

Reisyukaku
Apr 11th, 2016
993
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 14.96 KB | None | 0 0
raw download clone embed print report
  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
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!