David T. Lewis uploaded a new version of MemoryAccess to project VM Maker: http://source.squeak.org/VMMaker/MemoryAccess-dtl.5.mcz ==================== Summary ==================== Name: MemoryAccess-dtl.5 Author: dtl Time: 22 March 2013, 7:19:08.002 pm UUID: 95c752da-f58d-43df-a9cc-9ebe7b2efd92 Ancestors: MemoryAccess-dtl.4 Move MemoryAccess under VMClass rather than object because it needs requiredMethodNames. =============== Diff against MemoryAccess-dtl.4 =============== Item was changed: + VMClass subclass: #MemoryAccess - Object subclass: #MemoryAccess instanceVariableNames: '' classVariableNames: 'Enabled' poolDictionaries: '' category: 'MemoryAccess'! + !MemoryAccess commentStamp: 'dtl 3/21/2013 23:50' prior: 0! + MemoryAccess defines the low level mapping of object memory addresses to the underlying machine address space. When implemented as Smalltalk methods, the generated C code is available for debugging and profiling. The Squeak code generator inlines the methods such that the resulting VM will have performance very similar to that obtained with traditional C preprocessor macros or inlined static functions. - !MemoryAccess commentStamp: 'dtl 4/5/2009 14:38' prior: 0! - MemoryAccess defines the low level mapping of object memory addresses to the underlying machine address space. When implemented as Smalltalk methods, the generated C code - is available for debugging and profiling. The Squeak code generator inlines the methods - such that the resulting VM will have performance very similar to that obtained with - traditional C preprocessor macros or inlined static functions. + Methods are categorized and commented in order to clarify the type casting and memory address translation. - Methods are categorized and commented in order to clarify the type casting and memory - address translation. MemoryAccess replaces the traditional external definitions in sqMemoryAccess.h: #ifdef USE_INLINE_MEMORY_ACCESSORS /* Use static inline functions when the compiler produces efficient code for small accessors. These are preferred because static type checking will prevent inadvertent confusion of pointers and oops. */ static inline sqInt byteAtPointer(char *ptr) { return (sqInt)(*((unsigned char *)ptr)); } static inline sqInt byteAtPointerput(char *ptr, int val) { return (sqInt)(*((unsigned char *)ptr)= (unsigned char)val); } static inline sqInt shortAtPointer(char *ptr) { return (sqInt)(*((short *)ptr)); } static inline sqInt shortAtPointerput(char *ptr, int val) { return (sqInt)(*((short *)ptr)= (short)val); } static inline sqInt intAtPointer(char *ptr) { return (sqInt)(*((unsigned int *)ptr)); } static inline sqInt intAtPointerput(char *ptr, int val) { return (sqInt)(*((unsigned int *)ptr)= (int)val); } static inline sqInt longAtPointer(char *ptr) { return (sqInt)(*((sqInt *)ptr)); } static inline sqInt longAtPointerput(char *ptr, sqInt val) { return (sqInt)(*((sqInt *)ptr)= (sqInt)val); } static inline sqInt oopAtPointer(char *ptr) { return (sqInt)(*((sqInt *)ptr)); } static inline sqInt oopAtPointerput(char *ptr, sqInt val) { return (sqInt)(*((sqInt *)ptr)= (sqInt)val); } static inline char *pointerForOop(usqInt oop) { return sqMemoryBase + oop; } static inline sqInt oopForPointer(char *ptr) { return (sqInt)(ptr - sqMemoryBase); } static inline sqInt byteAt(sqInt oop) { return byteAtPointer(pointerForOop(oop)); } static inline sqInt byteAtput(sqInt oop, int val) { return byteAtPointerput(pointerForOop(oop), val); } static inline sqInt shortAt(sqInt oop) { return shortAtPointer(pointerForOop(oop)); } static inline sqInt shortAtput(sqInt oop, int val) { return shortAtPointerput(pointerForOop(oop), val); } static inline sqInt intAt(sqInt oop) { return intAtPointer(pointerForOop(oop)); } static inline sqInt intAtput(sqInt oop, int val) { return intAtPointerput(pointerForOop(oop), val); } static inline sqInt longAt(sqInt oop) { return longAtPointer(pointerForOop(oop)); } static inline sqInt longAtput(sqInt oop, sqInt val) { return longAtPointerput(pointerForOop(oop), val); } static inline sqInt oopAt(sqInt oop) { return oopAtPointer(pointerForOop(oop)); } static inline sqInt oopAtput(sqInt oop, sqInt val) { return oopAtPointerput(pointerForOop(oop), val); } #else /* Use macros when static inline functions aren't efficient. */ # define byteAtPointer(ptr) ((sqInt)(*((unsigned char *)(ptr)))) # define byteAtPointerput(ptr, val) ((sqInt)(*((unsigned char *)(ptr))= (unsigned char)(val))) # define shortAtPointer(ptr) ((sqInt)(*((short *)(ptr)))) # define shortAtPointerput(ptr, val) ((sqInt)(*((short *)(ptr))= (short)(val))) # define intAtPointer(ptr) ((sqInt)(*((unsigned int *)(ptr)))) # define intAtPointerput(ptr, val) ((sqInt)(*((unsigned int *)(ptr))= (int)(val))) # define longAtPointer(ptr) ((sqInt)(*((sqInt *)(ptr)))) # define longAtPointerput(ptr, val) ((sqInt)(*((sqInt *)(ptr))= (sqInt)(val))) # define oopAtPointer(ptr) (sqInt)(*((sqInt *)ptr)) # define oopAtPointerput(ptr, val) (sqInt)(*((sqInt *)ptr)= (sqInt)val) # define pointerForOop(oop) ((char *)(sqMemoryBase + ((usqInt)(oop)))) # define oopForPointer(ptr) ((sqInt)(((char *)(ptr)) - (sqMemoryBase))) # define byteAt(oop) byteAtPointer(pointerForOop(oop)) # define byteAtput(oop, val) byteAtPointerput(pointerForOop(oop), (val)) # define shortAt(oop) shortAtPointer(pointerForOop(oop)) # define shortAtput(oop, val) shortAtPointerput(pointerForOop(oop), (val)) # define longAt(oop) longAtPointer(pointerForOop(oop)) # define longAtput(oop, val) longAtPointerput(pointerForOop(oop), (val)) # define intAt(oop) intAtPointer(pointerForOop(oop)) # define intAtput(oop, val) intAtPointerput(pointerForOop(oop), (val)) # define oopAt(oop) oopAtPointer(pointerForOop(oop)) # define oopAtput(oop, val) oopAtPointerput(pointerForOop(oop), (val)) #endif ! |
Free forum by Nabble | Edit this page |