Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
torvalds
GitHub Repository: torvalds/linux
 Path: blob/master/arch/csky/abiv2/memcmp.S
26451 views
1
/* SPDX-License-Identifier: GPL-2.0 */

2
// Copyright (C) 2018 Hangzhou C-SKY Microsystems co.,ltd.

3


4
#include <linux/linkage.h>

5
#include "sysdep.h"

6


7
ENTRY(memcmp)

8
	/* Test if len less than 4 bytes.  */

9
	mov	r3, r0

10
	movi	r0, 0

11
	mov	r12, r4

12
	cmplti	r2, 4

13
	bt	.L_compare_by_byte

14


15
	andi	r13, r0, 3

16
	movi	r19, 4

17


18
	/* Test if s1 is not 4 bytes aligned.  */

19
	bnez	r13, .L_s1_not_aligned

20


21
	LABLE_ALIGN

22
.L_s1_aligned:

23
	/* If dest is aligned, then copy.  */

24
	zext	r18, r2, 31, 4

25
	/* Test if len less than 16 bytes.  */

26
	bez	r18, .L_compare_by_word

27


28
.L_compare_by_4word:

29
	/* If aligned, load word each time.  */

30
	ldw	r20, (r3, 0)

31
	ldw	r21, (r1, 0)

32
	/* If s1[i] != s2[i], goto .L_byte_check.  */

33
	cmpne	r20, r21

34
	bt	.L_byte_check

35


36
	ldw	r20, (r3, 4)

37
	ldw	r21, (r1, 4)

38
	cmpne	r20, r21

39
	bt	.L_byte_check

40


41
	ldw	r20, (r3, 8)

42
	ldw	r21, (r1, 8)

43
	cmpne	r20, r21

44
	bt	.L_byte_check

45


46
	ldw	r20, (r3, 12)

47
	ldw	r21, (r1, 12)

48
	cmpne	r20, r21

49
	bt	.L_byte_check

50


51
	PRE_BNEZAD (r18)

52
	addi	a3, 16

53
	addi	a1, 16

54


55
	BNEZAD (r18, .L_compare_by_4word)

56


57
.L_compare_by_word:

58
	zext	r18, r2, 3, 2

59
	bez	r18, .L_compare_by_byte

60
.L_compare_by_word_loop:

61
	ldw	r20, (r3, 0)

62
	ldw	r21, (r1, 0)

63
	addi	r3, 4

64
	PRE_BNEZAD (r18)

65
	cmpne	r20, r21

66
	addi    r1, 4

67
	bt	.L_byte_check

68
	BNEZAD (r18, .L_compare_by_word_loop)

69


70
.L_compare_by_byte:

71
        zext    r18, r2, 1, 0

72
        bez     r18, .L_return

73
.L_compare_by_byte_loop:

74
        ldb     r0, (r3, 0)

75
        ldb     r4, (r1, 0)

76
        addi    r3, 1

77
        subu    r0, r4

78
        PRE_BNEZAD (r18)

79
        addi    r1, 1

80
        bnez    r0, .L_return

81
        BNEZAD (r18, .L_compare_by_byte_loop)

82


83
.L_return:

84
        mov     r4, r12

85
        rts

86


87
# ifdef __CSKYBE__

88
/* d[i] != s[i] in word, so we check byte 0.  */

89
.L_byte_check:

90
        xtrb0   r0, r20

91
        xtrb0   r2, r21

92
        subu    r0, r2

93
        bnez    r0, .L_return

94


95
        /* check byte 1 */

96
        xtrb1   r0, r20

97
        xtrb1   r2, r21

98
        subu    r0, r2

99
        bnez    r0, .L_return

100


101
        /* check byte 2 */

102
        xtrb2   r0, r20

103
        xtrb2   r2, r21

104
        subu    r0, r2

105
        bnez    r0, .L_return

106


107
        /* check byte 3 */

108
        xtrb3   r0, r20

109
        xtrb3   r2, r21

110
        subu    r0, r2

111
# else

112
/* s1[i] != s2[i] in word, so we check byte 3.  */

113
.L_byte_check:

114
	xtrb3	r0, r20

115
	xtrb3	r2, r21

116
        subu    r0, r2

117
        bnez    r0, .L_return

118


119
	/* check byte 2 */

120
	xtrb2	r0, r20

121
	xtrb2	r2, r21

122
        subu    r0, r2

123
        bnez    r0, .L_return

124


125
	/* check byte 1 */

126
	xtrb1	r0, r20

127
	xtrb1	r2, r21

128
	subu	r0, r2

129
	bnez    r0, .L_return

130


131
	/* check byte 0 */

132
	xtrb0	r0, r20

133
	xtrb0	r2, r21

134
	subu	r0, r2

135
	br	.L_return

136
# endif /* !__CSKYBE__ */

137


138
/* Compare when s1 is not aligned.  */

139
.L_s1_not_aligned:

140
	sub	r13, r19, r13

141
	sub	r2, r13

142
.L_s1_not_aligned_loop:

143
	ldb	r0, (r3, 0)

144
	ldb	r4, (r1, 0)

145
	addi	r3, 1

146
	subu	r0, r4

147
	PRE_BNEZAD (r13)

148
	addi	r1, 1

149
	bnez	r0, .L_return

150
	BNEZAD (r13, .L_s1_not_aligned_loop)

151
	br	.L_s1_aligned

152
ENDPROC(memcmp)

153


154