source: trunk/symtab/ls_symbol_table_compare.h @ 3587

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

SymbolTable?: Integrated symbol table with the new IDISA architecture

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