/arch/x86_64/lib/copy_page.S

https://bitbucket.org/evzijst/gittest · Assembly · 101 lines · 76 code · 19 blank · 6 comment · 0 complexity · 37d6474207b19db73bda041962164650 MD5 · raw file 

    

  1. /* Written 2003 by Andi Kleen, based on a kernel by Evandro Menezes */
    2. 

  2. 	
    3. 

  3. /* Don't use streaming store because it's better when the target
    4. 

  4.    ends up in cache. */
    5. 

  5. 	    
    6. 

  6. /* Could vary the prefetch distance based on SMP/UP */
    7. 

  7. 

  8. 	.globl copy_page
    9. 

  9. 	.p2align 4
    10. 

  10. copy_page:
    11. 

  11. 	subq	$3*8,%rsp
    12. 

  12. 	movq	%rbx,(%rsp)
    13. 

  13. 	movq	%r12,1*8(%rsp)
    14. 

  14. 	movq	%r13,2*8(%rsp)
    15. 

  15. 			
    16. 

  16. 	movl	$(4096/64)-5,%ecx
    17. 

  17. 	.p2align 4
    18. 

  18. .Loop64:	
    19. 

  19.   	dec     %rcx
    20. 

  20. 

  21. 	movq        (%rsi), %rax
    22. 

  22. 	movq      8 (%rsi), %rbx
    23. 

  23. 	movq     16 (%rsi), %rdx
    24. 

  24. 	movq     24 (%rsi), %r8
    25. 

  25. 	movq     32 (%rsi), %r9
    26. 

  26. 	movq     40 (%rsi), %r10
    27. 

  27. 	movq     48 (%rsi), %r11
    28. 

  28. 	movq     56 (%rsi), %r12
    29. 

  29. 

  30. 	prefetcht0 5*64(%rsi)
    31. 

  31. 

  32. 	movq     %rax,    (%rdi)
    33. 

  33. 	movq     %rbx,  8 (%rdi)
    34. 

  34. 	movq     %rdx, 16 (%rdi)
    35. 

  35. 	movq     %r8,  24 (%rdi)
    36. 

  36. 	movq     %r9,  32 (%rdi)
    37. 

  37. 	movq     %r10, 40 (%rdi)
    38. 

  38. 	movq     %r11, 48 (%rdi)
    39. 

  39. 	movq     %r12, 56 (%rdi)
    40. 

  40. 

  41. 	leaq    64 (%rsi), %rsi
    42. 

  42. 	leaq    64 (%rdi), %rdi
    43. 

  43. 

  44. 	jnz     .Loop64
    45. 

  45. 

  46. 	movl	$5,%ecx
    47. 

  47. 	.p2align 4
    48. 

  48. .Loop2:	
    49. 

  49. 	decl   %ecx
    50. 

  50. 

  51. 	movq        (%rsi), %rax
    52. 

  52. 	movq      8 (%rsi), %rbx
    53. 

  53. 	movq     16 (%rsi), %rdx
    54. 

  54. 	movq     24 (%rsi), %r8
    55. 

  55. 	movq     32 (%rsi), %r9
    56. 

  56. 	movq     40 (%rsi), %r10
    57. 

  57. 	movq     48 (%rsi), %r11
    58. 

  58. 	movq     56 (%rsi), %r12
    59. 

  59. 

  60. 	movq     %rax,    (%rdi)
    61. 

  61. 	movq     %rbx,  8 (%rdi)
    62. 

  62. 	movq     %rdx, 16 (%rdi)
    63. 

  63. 	movq     %r8,  24 (%rdi)
    64. 

  64. 	movq     %r9,  32 (%rdi)
    65. 

  65. 	movq     %r10, 40 (%rdi)
    66. 

  66. 	movq     %r11, 48 (%rdi)
    67. 

  67. 	movq     %r12, 56 (%rdi)
    68. 

  68. 	
    69. 

  69. 	leaq	64(%rdi),%rdi			
    70. 

  70. 	leaq	64(%rsi),%rsi			
    71. 

  71. 	
    72. 

  72. 	jnz	.Loop2		
    73. 

  73. 	
    74. 

  74. 	movq	(%rsp),%rbx
    75. 

  75. 	movq	1*8(%rsp),%r12
    76. 

  76. 	movq	2*8(%rsp),%r13
    77. 

  77. 	addq	$3*8,%rsp
    78. 

  78. 	ret
    79. 

  79. 	
    80. 

  80. 	/* C stepping K8 run faster using the string copy instructions.
    81. 

  81. 	   It is also a lot simpler. Use this when possible */
    82. 

  82. 

  83. #include <asm/cpufeature.h>		
    84. 

  84. 		
    85. 

  85. 	.section .altinstructions,"a"
    86. 

  86. 	.align 8
    87. 

  87. 	.quad  copy_page
    88. 

  88. 	.quad  copy_page_c
    89. 

  89. 	.byte  X86_FEATURE_K8_C
    90. 

  90. 	.byte  copy_page_c_end-copy_page_c
    91. 

  91. 	.byte  copy_page_c_end-copy_page_c
    92. 

  92. 	.previous
    93. 

  93. 

  94. 	.section .altinstr_replacement,"ax"
    95. 

  95. copy_page_c:
    96. 

  96. 	movl $4096/8,%ecx
    97. 

  97. 	rep 
    98. 

  98. 	movsq 
    99. 

  99. 	ret
    100. 

  100. copy_page_c_end:
    101. 

  101. 	.previous
    102.