![fs 16 fs 16](http://allaboutwindowsphone.com/images/flow/misc/farm5.jpg)
![fs 16 fs 16](https://static.truetrophies.com/customimages/022156.jpg)
If these items reside in different segments, ES will be reloaded several times per operation, adding quite some overhead. While some operations are simply done on a single data item at a time (think A=A*2), most require two ( A=A*B) or three data items ( A=B*C). What really hurts is when user data exceeds 64 KiB and operations have to be commenced. Similarly, it's only a minor annoyance that DS and ES might have to be loaded (and reloaded) when doing string operations - this at least is offset by one of the best character handling instruction sets of its time. Unlike often assumed, this data doesn't get as much accessed, so needing a prefix hurts less than using longer address fields. Like the text of a word processor, the cells of a spreadsheet, or the picture data of a graphics program and so on.
Fs 16 code#
All essential data, which is what is most often accessed, (plus code and stack) is within 16 bit shorthand distance.ĮS is used to access everything else (*2), everything beyond the 64 KiB of DS. It's in some way part of the reason why x86 code is rather compact. This is where all default variables are located - essentially data and bss. Where all operation take place by default (*1). Well, almost, but DS is not 'some' Data Segment, but the default one. So I know what the following registers and their uses are supposed to be: Simply to access data beyond the default data segment (DS). What is the “FS”/“GS” register intended for? Those that don't know history aren't doomed to repeat it they're doomed to doing something dumber. So, the segment registers are now kind of like your appendix.
![fs 16 fs 16](https://dibujando.net/files/fs/p/c/900x1000/2015/23/flash22_211787.jpg)
It would have been architecturally prettier IMHO to make each thread's memory map have an absolute virtual address (e.g, 0-FFF say) that was its thread local storage (no register pointer needed!) I did this in an 8 bit OS back in the 1970s and it was extremely handy, like having another big stack of registers to work in. Intel in their panic to not lose market share to AMD on 64 bits, and Andy being retired, decided to just copy AMD's scheme.
Fs 16 64 Bit#
Since Windows and Linux both used FS and GS (thanks Nick for the clarification) for this purpose in the 32 bit version, AMD decided to let the 64 bit segment registers (GS and FS) be used essentially only for this purpose (I think you can make them point anywhere in your process space I don't know if the application code can load them or not). somewhere in the immediately accessible thread state (e.g, in the registers). There was still a need for threads to access thread local store, and each thread needed a a pointer.
Fs 16 64 bits#
Go, Andy!)ĪMD in going to 64 bits decided they didn't care if they eliminated Multics as a choice (that's the charitable interpretation the uncharitable one is they were clueless about Multics) and so disabled the general capability of segment registers in 64 bit mode.
![fs 16 fs 16](https://i.ytimg.com/vi/PK1PnNI9bvc/hqdefault.jpg)
The segment registers on the x86-32 machine can still be used for real segment registers, but nobody has bothered (Andy Grove, former Intel president, had a rather famous public fit last century when he figured out after all those Intel engineers spent energy and his money to implement this feature, that nobody was going to use it. You can only address your process space's single segment, giving a so-called "flat (IMHO dull) address space". Our current 2010 operating systems are a giant step backwards, which is why they are called "Eunuchs". No BS "Open file, write record, close file", just "Store this value into that virtual data segment" with dirty page flushing. The idea was taken from the 1966 Multics operating system, that treated files as simply addressable memory segments. The original intention behind the segment registers was to allow a program to access many different (large) segments of memory that were intended to be independent and part of a persistent virtual store. There is what they were intended for, and what they are used for by Windows and Linux.