source: trunk/lib/symtab/ls_symbol_table_compare.h @ 1428

Last change on this file since 1428 was 1428, checked in by vla24, 8 years ago

SymbolTable?: commit some missing files

File size: 19.3 KB
RevLine 
[1229]1/*
2 *      ls_symbol_table_compare.h
3 *
4 *      Created on: 27-May-2010
5 *      Author: ksherdy
6 *
7 *      Length specific comparison functions using a C++ function object or a C++ function template approach.
8 */
9
10#ifndef LS_SYMBOL_TABLE_COMPARE_H_
11#define LS_SYMBOL_TABLE_COMPARE_H_
12
[1428]13#include "library_conversion.h"
[1427]14
[1229]15#include <string.h>
16
17#if (BYTE_ORDER == BIG_ENDIAN)& !defined(BYTE_SHIFT)
18#define BYTE_SHIFT
19#define LOW_BYTE_SHIFT 8
20#define HIGH_BYTE_SHIFT 0
21#endif
22
23#if (BYTE_ORDER == LITTLE_ENDIAN)& !defined(BYTE_SHIFT)
24#define BYTE_SHIFT
25#define LOW_BYTE_SHIFT 0
26#define HIGH_BYTE_SHIFT 8
27#endif
28
29//#define LOW_BYTE_SHIFT 0
30//#define HIGH_BYTE_SHIFT 8
31
32#define simd_mask_eq_8(v1, v2, hex_mask) simd_mask_true<8>(_mm_cmpeq_epi8(v1, v2), hex_mask)
33//#define simd_mask_eq_8(v1, v2, hex_mask) (_mm_movemask_epi8(_mm_cmpeq_epi8(v1, v2)) & hex_mask) == hex_mask
34//#define simd_all_eq_8(v1, v2) simd_all_true<8>(_mm_cmpeq_epi8(v1, v2))
35
36// ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- -----
37// Symbol-at-a-time comparison methods implemented using C++ function objects.
38
39inline bool mem_compare(const unsigned char * x, const unsigned char * y, size_t lgth);
40inline bool simd_compare(const unsigned char * x, const unsigned char * y, size_t lgth);
41
42#ifdef USE_FUNCTION_OBJECTS
43
44        class CmpS1 {
45       
46        public:
47                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
48                        return ((* ((uint8_t *) x)) == 
49                                        (* ((uint8_t *) y)));
50                }
51        };
52       
53        class CmpS2 {
54               
55        public:         
56                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
57                  return ((* ((uint16_t *) x)) == 
58                                  (* ((uint16_t *) y)));
59                }
60        };
61       
62        class CmpS3 {
63       
64        public:
65                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
66                        return (((* ((uint32_t *) x)) & (0xFFFFFF << LOW_BYTE_SHIFT)) == 
67                                        ((* ((uint32_t *) y)) & (0xFFFFFF << LOW_BYTE_SHIFT))); // s4int32()
68                }
69        };
70       
71        class CmpS4 {
72       
73        public:
74                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
75                        return ((* ((uint32_t *) x)) == 
76                                        (* ((uint32_t *) y)));
77                }
78        };
79       
80        class CmpS5 {
81       
82        public: 
83                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
84                        return (((* ((uint64_t *) x)) & (0xFFFFFFFFFFULL << (3 * LOW_BYTE_SHIFT)))      == 
85                                        ((* ((uint64_t *) y)) & (0xFFFFFFFFFFULL << (3 * LOW_BYTE_SHIFT)))); // s8int64()
86                }
87        };
88       
89        class CmpS6 {
90       
91        public:
92                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
93                        return (((* ((uint64_t *) x)) & (0xFFFFFFFFFFFFULL << (2 * LOW_BYTE_SHIFT))) ==
94                                        ((* ((uint64_t *) y)) & (0xFFFFFFFFFFFFULL << (2 * LOW_BYTE_SHIFT)))); // s8int64()
95                }
96        };
97       
98        class CmpS7 {
99       
100        public:
101                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
102                        return (((* ((uint64_t *) x)) & (0xFFFFFFFFFFFFFFULL << LOW_BYTE_SHIFT)) == 
103                                        ((* ((uint64_t *) y)) & (0xFFFFFFFFFFFFFFULL << LOW_BYTE_SHIFT))); // s8int64()
104                }
105        };
106       
107        class CmpS8 {
108       
109        public: 
110                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
111                        return ((* (uint64_t *) x) == 
112                                        (* ((uint64_t *) y)));
113                }                                                                 
114        };     
115       
116        class CmpS9 {
117        public: 
118               
119                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
120                        return simd_mask_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y), 0x1FF); 
121                }
122        };
123                       
124        class CmpS10 {
125       
126        public:         
127                inline bool operator()(const unsigned char * x, const unsigned char * y) const {       
128                        return simd_mask_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y), 0x3FF);
129                }
130        };
131       
132        class CmpS11 {
133       
134        public:         
135                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
136                        return simd_mask_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y), 0x7FF);
137                }
138        };
139       
140        class CmpS12 {
141       
142        public:         
143                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
144                        return simd_mask_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y), 0xFFF);
145                }
146        };
147       
148        class CmpS13 {
149       
150        public:         
151                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
152                        return simd_mask_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y), 0x1FFF);
153                }
154        };
155       
156        class CmpS14 {
157       
158        public:         
159                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
160                        return simd_mask_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y), 0x3FFF);
161                }
162        };
163       
164        class CmpS15 {
165       
166        public:         
167                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
168                        return simd_mask_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y), 0x7FFF);
169                }
170        };
171       
172        class CmpS16 {
173       
174        public:         
175                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
176                        return simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y));
177                }
178        };     
179       
180        class CmpS17 {
181       
182        public:         
183                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
184                        return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
185                                        simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+1)), sisd_load_unaligned((SIMD_type *)(y+1)));
186                }
187        };             
188       
189        class CmpS18 {
190       
191        public:         
192                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
193                        return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
194                                        simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+2)), sisd_load_unaligned((SIMD_type *)(y+2)));
195                }
196        };
197       
198        class CmpS19 {
199       
200        public:         
201                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
202                        return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
203                                        simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+3)), sisd_load_unaligned((SIMD_type *)(y+3)));
204                }
205        };
206       
207        class CmpS20 {
208       
209        public:         
210                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
211                        return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
212                                        simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+4)), sisd_load_unaligned((SIMD_type *)(y+4)));
213                }
214        };
215       
216        class CmpS21 {
217       
218        public:         
219                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
220                        return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
221                                        simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+5)), sisd_load_unaligned((SIMD_type *)(y+5)));
222                }
223        };
224       
225        class CmpS22 {
226       
227        public:         
228                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
229                        return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
230                                        simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+6)), sisd_load_unaligned((SIMD_type *)(y+6)));
231                }
232        };
233       
234        class CmpS23 {
235       
236        public:         
237                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
238                        return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
239                                        simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+7)), sisd_load_unaligned((SIMD_type *)(y+7)));
240                }
241        };
242       
243        class CmpS24 {
244       
245        public:         
246                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
247                        return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
248                                        simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+8)), sisd_load_unaligned((SIMD_type *)(y+8)));
249                }
250        };
251       
252        class CmpS25 {
253       
254        public:         
255                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
256                        return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
257                                        simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+9)), sisd_load_unaligned((SIMD_type *)(y+9)));
258                }
259        };
260       
261        class CmpS26 {
262       
263        public:         
264                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
265                        return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
266                                        simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+10)), sisd_load_unaligned((SIMD_type *)(y+10)));
267                }
268        };
269       
270        class CmpS27 {
271       
272        public:         
273                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
274                        return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
275                                        simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+11)), sisd_load_unaligned((SIMD_type *)(y+11)));
276                }
277        };
278       
279        class CmpS28 {
280       
281        public:         
282                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
283                        return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
284                                        simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+12)), sisd_load_unaligned((SIMD_type *)(y+12)));
285                }
286        };
287       
288        class CmpS29 {
289       
290        public:         
291                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
292                        return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
293                                        simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+13)), sisd_load_unaligned((SIMD_type *)(y+13)));
294                }
295        };     
296       
297        class CmpS30 {
298       
299        public:         
300                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
301                        return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
302                                        simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+14)), sisd_load_unaligned((SIMD_type *)(y+14)));
303                }
304        };     
305       
306        class CmpS31 {
307       
308        public:         
309                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
310                        return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
311                                        simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+15)), sisd_load_unaligned((SIMD_type *)(y+15)));
312                }
313        };     
314       
315        class CmpS32 {
316       
317        public:         
318                inline bool operator()(const unsigned char * x, const unsigned char * y) const {
319                        return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
320                                        simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+16)), sisd_load_unaligned((SIMD_type *)(y+16)));
321                }
322        };
323#endif /* USE_FUNCTION_OBJECTS */
324
325// ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- -----
326// Equivalent symbol-at-a-time comparison methods implemented using C++ function templates.     
327       
328#ifdef USE_FUNCTION_TEMPLATES
329
330        template <size_t L>
331        inline bool compare(const unsigned char * x, const unsigned char * y) {
332                return simd_compare(x, y, L);
333        }
334       
335        template<>
336        inline bool compare<1>(const unsigned char * x, const unsigned char * y) __attribute__((flatten));
337       
338        template<>
339        inline bool compare<1>(const unsigned char * x, const unsigned char * y) {
340                return ((* ((uint8_t *) x)) == 
341                                (* ((uint8_t *) y)));
342        }
343       
344        template<>
345        inline bool compare<2>(const unsigned char * x, const unsigned char * y) {
346          return ((* ((uint16_t *) x)) == 
347                          (* ((uint16_t *) y)));
348        }
349       
350        template<>
351        inline bool compare<3>(const unsigned char * x, const unsigned char * y) {
352                        return (((* ((uint32_t *) x)) & (0xFFFFFF << LOW_BYTE_SHIFT)) == 
353                                        ((* ((uint32_t *) y)) & (0xFFFFFF << LOW_BYTE_SHIFT))); // s4int32()
354        }
355       
356        template<>     
357        inline bool compare<4>(const unsigned char * x, const unsigned char * y) {
358                        return ((* ((uint32_t *) x)) == 
359                                        (* ((uint32_t *) y)));
360        }
361       
362        template<>
363        inline bool compare<5>(const unsigned char * x, const unsigned char * y) {
364                return (((* ((uint64_t *) x)) & (0xFFFFFFFFFFULL << (3 * LOW_BYTE_SHIFT)))      == 
365                                ((* ((uint64_t *) y)) & (0xFFFFFFFFFFULL << (3 * LOW_BYTE_SHIFT)))); // s8int64()
366        }
367       
368        template<>
369        inline bool compare<6>(const unsigned char * x, const unsigned char * y) {
370                return (((* ((uint64_t *) x)) & (0xFFFFFFFFFFFFULL << (2 * LOW_BYTE_SHIFT))) ==
371                                ((* ((uint64_t *) y)) & (0xFFFFFFFFFFFFULL << (2 * LOW_BYTE_SHIFT)))); // s8int64()
372        }
373       
374        template<>
375        inline bool compare<7>(const unsigned char * x, const unsigned char * y) {
376                return (((* ((uint64_t *) x)) & (0xFFFFFFFFFFFFFFULL << LOW_BYTE_SHIFT)) == 
377                                ((* ((uint64_t *) y)) & (0xFFFFFFFFFFFFFFULL << LOW_BYTE_SHIFT))); // s8int64()
378        }
379       
380        template<>     
381        inline bool compare<8>(const unsigned char * x, const unsigned char * y) {
382                return ((* (uint64_t *) x) == 
383                                (* ((uint64_t *) y)));
384        }                                                                 
385       
386        template<>
387        inline bool compare<9>(const unsigned char * x, const unsigned char * y) {
388                return simd_mask_eq_8( sisd_load_unaligned((SIMD_type *)x)
389                                     , sisd_load_unaligned((SIMD_type *)y)
390                                     , 0x1FF);
391        }
392                       
393        template<>             
394        inline bool compare<10>(const unsigned char * x, const unsigned char * y) {     
395                return simd_mask_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y), 0x3FF);
396        }
397       
398        template<>             
399        inline bool compare<11>(const unsigned char * x, const unsigned char * y) {
400                return simd_mask_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y), 0x7FF);
401        }
402       
403        template<>
404        inline bool compare<12>(const unsigned char * x, const unsigned char * y) {
405                return simd_mask_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y), 0xFFF);
406        }
407       
408        template<>
409        inline bool compare<13>(const unsigned char * x, const unsigned char * y) {
410                return simd_mask_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y), 0x1FFF);
411        }
412       
413        template<>
414        inline bool compare<14>(const unsigned char * x, const unsigned char * y) {
415                return simd_mask_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y), 0x3FFF);
416        }
417       
418        template<>
419        inline bool compare<15>(const unsigned char * x, const unsigned char * y) {
420                return simd_mask_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y), 0x7FFF);
421        }
422       
423        template<>             
424        inline bool compare<16>(const unsigned char * x, const unsigned char * y) {
425                return simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y));
426        }
427       
428        template<>
429        inline bool compare<17>(const unsigned char * x, const unsigned char * y) {
430                return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
431                                simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+1)), sisd_load_unaligned((SIMD_type *)(y+1)));
432        }
433       
434        template<>
435        inline bool compare<18>(const unsigned char * x, const unsigned char * y) {
436                return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
437                                simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+2)), sisd_load_unaligned((SIMD_type *)(y+2)));
438        }
439       
440        template<>
441        inline bool compare<19>(const unsigned char * x, const unsigned char * y) {
442                return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
443                                simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+3)), sisd_load_unaligned((SIMD_type *)(y+3)));
444        }
445       
446        template<>
447        inline bool compare<20>(const unsigned char * x, const unsigned char * y) {
448                return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
449                                simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+4)), sisd_load_unaligned((SIMD_type *)(y+4)));
450        }
451       
452        template<>
453        inline bool compare<21>(const unsigned char * x, const unsigned char * y) {
454                return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
455                                simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+5)), sisd_load_unaligned((SIMD_type *)(y+5)));
456        }
457       
458        template<>
459        inline bool compare<22>(const unsigned char * x, const unsigned char * y) {
460                return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
461                                simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+6)), sisd_load_unaligned((SIMD_type *)(y+6)));
462        }
463       
464        template<>
465        inline bool compare<23>(const unsigned char * x, const unsigned char * y) {
466                return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
467                                simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+7)), sisd_load_unaligned((SIMD_type *)(y+7)));
468        }
469       
470        template<>
471        inline bool compare<24>(const unsigned char * x, const unsigned char * y) {
472                return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
473                                simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+8)), sisd_load_unaligned((SIMD_type *)(y+8)));
474        }
475       
476        template<>
477        inline bool compare<25>(const unsigned char * x, const unsigned char * y) {
478                return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
479                                simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+9)), sisd_load_unaligned((SIMD_type *)(y+9)));
480        }
481       
482        template<>
483        inline bool compare<26>(const unsigned char * x, const unsigned char * y) {
484                return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
485                                simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+10)), sisd_load_unaligned((SIMD_type *)(y+10)));
486        }
487       
488        template<>
489        inline bool compare<27>(const unsigned char * x, const unsigned char * y) {
490                return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
491                                simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+11)), sisd_load_unaligned((SIMD_type *)(y+11)));
492        }
493       
494        template<>
495        inline bool compare<28>(const unsigned char * x, const unsigned char * y) {
496                return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
497                                simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+12)), sisd_load_unaligned((SIMD_type *)(y+12)));
498        }
499       
500        template<>
501        inline bool compare<29>(const unsigned char * x, const unsigned char * y) {
502                return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
503                                simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+13)), sisd_load_unaligned((SIMD_type *)(y+13)));
504        }
505       
506        template<>
507        inline bool compare<30>(const unsigned char * x, const unsigned char * y) {
508                return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
509                                simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+14)), sisd_load_unaligned((SIMD_type *)(y+14)));
510        }
511       
512        template<>
513        inline bool compare<31>(const unsigned char * x, const unsigned char * y) {
514                return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
515                                simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+15)), sisd_load_unaligned((SIMD_type *)(y+15)));
516        }
517       
518        template<>
519        inline bool compare<32>(const unsigned char * x, const unsigned char * y) {
520                return  simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)) && 
521                                simd_all_eq_8(sisd_load_unaligned((SIMD_type *)(x+16)), sisd_load_unaligned((SIMD_type *)(y+16)));
522        }
523#endif /* USE_FUNCTION_TEMPLATES */
524
525inline bool mem_compare(const unsigned char * x, const unsigned char * y, size_t lgth) {
526        return (0 == memcmp(x, y, lgth));
527}
528
529inline bool simd_compare(const unsigned char * x, const unsigned char * y, size_t lgth) {
530
531        bool result = true;
532        while(lgth >= sizeof(SIMD_type)) {
533                result = result && simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y));
534               
535                if(!result) {                           // detect comparison failure early and return
536                        return result;
537                }
538               
539                lgth -= sizeof(SIMD_type);
540               
541                x += sizeof(SIMD_type);         // advance sizeof(SIMD_type) bytes via pointer arithmetic
542                y += sizeof(SIMD_type);
543        }
544       
545        if (0 == lgth) {
546                return result;
547        }
548       
549        x -= sizeof(SIMD_type) - lgth;  // back up pointers 'size(SIMD_type) - remainder' bytes
550        y -= sizeof(SIMD_type) - lgth;
551       
552        return (result && simd_all_eq_8(sisd_load_unaligned((SIMD_type *)x), sisd_load_unaligned((SIMD_type *)y)));
553       
554}
555
556
557#endif /* LS_SYMBOL_TABLE_COMPARE_H_ */
Note: See TracBrowser for help on using the repository browser.