Add implementations of __readfs{byte,word,dword,qword} to Intrin.h

[hans]

Summary

Please take a look. I always worry about getting the mov operands backwards :)

[rnk]

LGTM

lib/Headers/Intrin.h

777

I would use offset instead of addr.

779

Can you add explicit size suffixes so we get better error checking here?

I think you can use movb, movw, movl, and movq.

779

I spent a while fooling around with multi-alternative constraints trying to get clang to produce 'movb %fs:0, %reg' for __readfsbyte(0), but I gave up. Our inline asm stuff isn't sophisticated enough to handle that.

[hans]

lib/Headers/Intrin.h

777

Done.

779

That's a good idea. Added the suffixes.

[hans]

Addressed rnk's comments.

Chandler: can you provide a pointer to the address space technique you mentioned?

[rnk]

This is the address space extension for accessing TLS:
http://clang.llvm.org/docs/LanguageExtensions.html#x86-x86-64-language-extensions

That's a lot cleaner. Let's do that.

[hans]

Uploading patch that uses the address_space attribute instead of inline asm.

Please take another look.

[rnk]

lib/Headers/Intrin.h

779

We may want to move to macro-stamping these out if we add incfs*, addfs*, and __*gs*.

779

__offset isn't pointer sized in x64 mode, so we'll get -Wsystem-header warnings here. The API is specified to use unsigned long, since I believe you can't address more than 2 GB off of these segments. I'm not sure what integer type we can use to cast, though...

[hans]

Thanks for the comments! Here's a new version with all the bells and whistles:

• volatile ptr, as per David's request
• using a macro
• casting __offset to size_t to make sure it's pointer-sized
• prefix address_space with double underscores to avoid name conflicts.

[cdavis5x]

lib/Headers/Intrin.h

781–796

In MSVC, these intrinsics actually aren't available on x64. (They're not needed anyway on Windows/x64, because it uses GS for the TEB instead of FS as Windows/i386 does.) For this reason (unless you have some pressing need for FS-relative access on a non-Windows x86-64 platform), you might consider putting them inside an #ifndef __x86_64__ block.

[hans]

Addressing Charles's comment.

[rnk]

lgtm, ship it. :)

[hans]

Closed by commit rL199958 (authored by @hans).

lib/Headers/Intrin.h

 unsigned __int64 __rdtscp(unsigned int *);
 unsigned long __readcr0(void);
 unsigned long __readcr2(void);
 unsigned long __readcr3(void);
 unsigned long __readcr5(void);
 unsigned long __readcr8(void);
 unsigned int __readdr(unsigned int);
 unsigned int __readeflags(void);
+static __inline__
 unsigned char __readfsbyte(unsigned long);
+static __inline__
 unsigned long __readfsdword(unsigned long);
+static __inline__
 unsigned __int64 __readfsqword(unsigned long);
+static __inline__
 unsigned short __readfsword(unsigned long);
 unsigned __int64 __readmsr(unsigned long);
 unsigned __int64 __readpmc(unsigned long);
 unsigned long __segmentlimit(unsigned long);
 void __sidt(void *);
 void *__slwpcb(void);
 void __stosb(unsigned char *, unsigned char, size_t);
 void __stosd(unsigned long *, unsigned long, size_t);
_ReadBarrier(void) {
   __asm__ volatile ("" : : : "memory");
 }
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
 __attribute__((deprecated("use other intrinsics or C++11 atomics instead")))
 _WriteBarrier(void) {
   __asm__ volatile ("" : : : "memory");
 }
 /*----------------------------------------------------------------------------*\
+|* readfs
+\*----------------------------------------------------------------------------*/
+static __inline__ unsigned char __attribute__((__always_inline__, __nodebug__))
+__readfsbyte(unsigned long __addr) {
+  unsigned char __result;
+  __asm__ ("mov %%fs:(%1), %0" : "=r" (__result) : "r" (__addr));
+  return __result;
+}
+static __inline__ unsigned long __attribute__((__always_inline__, __nodebug__))
+__readfsdword(unsigned long __addr) {
+  unsigned long __result;
+  __asm__ ("mov %%fs:(%1), %0" : "=r" (__result) : "r" (__addr));
+  return __result;
+}
+static __inline__ unsigned __int64 __attribute__((__always_inline__, __nodebug__))
+__readfsqword(unsigned long __addr) {
+  unsigned __int64 __result;
+  __asm__ ("mov %%fs:(%1), %0" : "=r" (__result) : "r" (__addr));
+  return __result;
+}
+static __inline__ unsigned short __attribute__((__always_inline__, __nodebug__))
+__readfsword(unsigned long __addr) {
+  unsigned short __result;
+  __asm__ ("mov %%fs:(%1), %0" : "=r" (__result) : "r" (__addr));
+  return __result;
+}
+/*----------------------------------------------------------------------------*\
 |* Misc
 \*----------------------------------------------------------------------------*/
 static __inline__ void * __attribute__((__always_inline__, __nodebug__))
 _AddressOfReturnAddress(void) {
   return (void*)((char*)__builtin_frame_address(0) + sizeof(void*));
 }
 static __inline__ void * __attribute__((__always_inline__, __nodebug__))
 _ReturnAddress(void) {