Uses of Class
org.vmmagic.unboxed.Address

Packages that use Address
gnu.classpath   
org.jikesrvm   
org.jikesrvm.adaptive   
org.jikesrvm.adaptive.measurements   
org.jikesrvm.adaptive.measurements.listeners   
org.jikesrvm.classloader   
org.jikesrvm.compilers.baseline.ia32   
org.jikesrvm.compilers.common   
org.jikesrvm.compilers.common.assembler.ia32   
org.jikesrvm.compilers.opt   
org.jikesrvm.compilers.opt.ir   
org.jikesrvm.compilers.opt.ir.operand   
org.jikesrvm.compilers.opt.lir2mir   
org.jikesrvm.compilers.opt.runtimesupport   
org.jikesrvm.compilers.opt.runtimesupport.ia32   
org.jikesrvm.compilers.opt.util   
org.jikesrvm.ia32   
org.jikesrvm.jni   
org.jikesrvm.jni.ia32   
org.jikesrvm.mm.mminterface   
org.jikesrvm.mm.mmtk   
org.jikesrvm.mm.mmtk.gcspy   
org.jikesrvm.objectmodel   
org.jikesrvm.osr.ia32   
org.jikesrvm.runtime   
org.jikesrvm.scheduler   
org.jikesrvm.tools.header_gen   
org.jikesrvm.util   
org.mmtk.plan   
org.mmtk.plan.concurrent   
org.mmtk.plan.concurrent.marksweep   
org.mmtk.plan.copyms   
org.mmtk.plan.generational   
org.mmtk.plan.generational.copying   
org.mmtk.plan.generational.immix   
org.mmtk.plan.generational.marksweep   
org.mmtk.plan.immix   
org.mmtk.plan.markcompact   
org.mmtk.plan.marksweep   
org.mmtk.plan.nogc   
org.mmtk.plan.poisoned   
org.mmtk.plan.refcount   
org.mmtk.plan.refcount.fullheap   
org.mmtk.plan.refcount.generational   
org.mmtk.plan.semispace   
org.mmtk.plan.semispace.gcspy   
org.mmtk.plan.semispace.gctrace   
org.mmtk.plan.semispace.usePrimitiveWriteBarriers   
org.mmtk.plan.stickyimmix   
org.mmtk.plan.stickyms   
org.mmtk.policy   
org.mmtk.policy.immix   
org.mmtk.utility   
org.mmtk.utility.alloc   
org.mmtk.utility.deque   
org.mmtk.utility.gcspy   
org.mmtk.utility.gcspy.drivers   
org.mmtk.utility.heap   
org.mmtk.utility.sanitychecker   
org.mmtk.vm   
org.mmtk.vm.gcspy   
org.vmmagic.unboxed   
org.vmutil.options   
 

Uses of Address in gnu.classpath
 

Methods in gnu.classpath that return Address
static Address JikesRVMSupport.getAddressFromPointer(gnu.classpath.Pointer pointer)
           
 

Methods in gnu.classpath with parameters of type Address
static gnu.classpath.Pointer JikesRVMSupport.getPointerFromAddress(Address address)
           
 

Uses of Address in org.jikesrvm
 

Fields in org.jikesrvm declared as Address
static Address HeapLayoutConstants.BOOT_IMAGE_CODE_END
          The address of the end of the code section of the boot image.
static Address HeapLayoutConstants.BOOT_IMAGE_CODE_START
          The address of the start of the code section of the boot image.
static Address HeapLayoutConstants.BOOT_IMAGE_DATA_END
          The address of the end of the data section of the boot image.
static Address HeapLayoutConstants.BOOT_IMAGE_DATA_START
          The address of the start of the data section of the boot image.
static Address HeapLayoutConstants.BOOT_IMAGE_END
          The address of the end of the boot image.
static Address HeapLayoutConstants.BOOT_IMAGE_RMAP_END
          The address of the end of the ref map section of the boot image.
static Address HeapLayoutConstants.BOOT_IMAGE_RMAP_START
          The address of the start of the ref map section of the boot image.
static Address HeapLayoutConstants.MAXIMUM_MAPPABLE
          The address in virtual memory that is the highest that can be mapped.
 

Methods in org.jikesrvm with parameters of type Address
static String VM.addressAsHexString(Address addr)
          Format a 32/64 bit number as "0x" followed by 8/16 hex digits.
abstract  void MachineSpecific.initializeStack(ArchitectureSpecific.Registers contextRegisters, Address ip, Address sp)
          The following method initializes a thread stack as if "startoff" method had been called by an empty baseline-compiled "sentinel" frame with one local variable.
static void VM.sysWrite(Address a)
           
static void VM.sysWrite(String s, Address a)
           
static void VM.sysWrite(String s1, Address a, String s2)
           
static void VM.sysWrite(String s1, Address a1, String s2, Address a2)
           
static void VM.sysWrite(String s1, Address a, String s2, int i)
           
static void VM.sysWrite(String s1, String s2, Address a)
           
static void VM.sysWriteHex(Address v)
           
static void VM.sysWriteln(Address a)
           
static void VM.sysWriteln(int i, Address a, Address b)
           
static void VM.sysWriteln(int i, Address a, RVMMethod m)
           
static void VM.sysWriteln(int i, String s, Address a)
           
static void VM.sysWriteln(String s, Address a)
           
static void VM.sysWriteln(String s1, Address a1, Address a2)
           
static void VM.sysWriteln(String s1, Address a, String s2)
           
static void VM.sysWriteln(String s1, Address a1, String s2, Address a2)
           
static void VM.sysWriteln(String s1, Address a, String s2, int i)
           
static void VM.sysWriteln(String s0, Address a1, String s1, Word w1, String s2, int i1, String s3, int i2, String s4, Word w2, String s5, int i3)
           
static void VM.sysWriteln(String s1, int i, String s2, Address a)
           
static void VM.sysWriteln(String s1, int i, String s3, Address a, String s5)
           
static void VM.sysWriteln(String s1, String s2, Address a)
           
static void VM.sysWriteln(String s1, String s2, String s3, Address a)
           
static void VM.tsysWriteln(Address a)
           
static void VM.tsysWriteln(String s, Address a)
           
static void VM.tsysWriteln(String s1, Address a1, String s2, Address a2)
           
static void VM.tsysWriteln(String s1, Address a1, String s2, Address a2, String s3, Address a3)
           
static void VM.tsysWriteln(String s1, Address a1, String s2, Address a2, String s3, Address a3, String s4, Address a4)
           
static void VM.tsysWriteln(String s1, Address a1, String s2, Address a2, String s3, Address a3, String s4, Address a4, String s5, Address a5)
           
static void VM.write(Address addr)
           
static void VM.writeHex(Address value)
           
 

Uses of Address in org.jikesrvm.adaptive
 

Methods in org.jikesrvm.adaptive with parameters of type Address
static boolean OSRListener.checkForOSRPromotion(int whereFrom, Address yieldpointServiceMethodFP)
           
static void OSRListener.handleOSRFromOpt(Address yieldpointServiceMethodFP)
           
 

Uses of Address in org.jikesrvm.adaptive.measurements
 

Methods in org.jikesrvm.adaptive.measurements with parameters of type Address
static void RuntimeMeasurements.takeCBSCallSample(int whereFrom, Address yieldpointServiceMethodFP)
          Called from Thread.yieldpoint when it is time to take a CBS call sample.
static void RuntimeMeasurements.takeCBSMethodSample(int whereFrom, Address yieldpointServiceMethodFP)
          Called from Thread.yieldpoint when it is time to take a CBS method sample.
static void RuntimeMeasurements.takeTimerSample(int whereFrom, Address yieldpointServiceMethodFP)
          Called from Thread.yieldpoint every time it is invoked due to a timer interrupt.
 

Uses of Address in org.jikesrvm.adaptive.measurements.listeners
 

Methods in org.jikesrvm.adaptive.measurements.listeners with parameters of type Address
 void EdgeListener.update(Address sfp, int whereFrom)
          This method is called when a call stack edge needs to be sampled.
abstract  void ContextListener.update(Address sfp, int whereFrom)
          This method is called when its time to record that a yield point has occurred.
 

Uses of Address in org.jikesrvm.classloader
 

Fields in org.jikesrvm.classloader declared as Address
private  Address NativeMethod.nativeIP
          the IP of the native procedure
private  Address NativeMethod.nativeTOC
          the TOC of the native procedure.
 

Methods in org.jikesrvm.classloader that return Address
 Address RVMField.getAddressValueUnchecked(Object obj)
           
 Address NativeMethod.getNativeIP()
          Get the native IP for this method
 Address NativeMethod.getNativeTOC()
          get the native TOC for this method
 

Methods in org.jikesrvm.classloader with parameters of type Address
 void NativeMethod.registerNativeSymbol(Address symbolAddress)
          Registers a native method
 void RVMField.setAddressValueUnchecked(Object obj, Address ref)
           
 

Uses of Address in org.jikesrvm.compilers.baseline.ia32
 

Fields in org.jikesrvm.compilers.baseline.ia32 declared as Address
private  Address BaselineGCMapIterator.bridgeRegisterLocation
          memory address at which that register was saved
private  Address BaselineGCMapIterator.bridgeSpilledParamLocation
          current spilled param location
 

Methods in org.jikesrvm.compilers.baseline.ia32 that return Address
 Address BaselineGCMapIterator.getNextReferenceAddress()
           
 Address BaselineGCMapIterator.getNextReturnAddressAddress()
           
 

Methods in org.jikesrvm.compilers.baseline.ia32 with parameters of type Address
 void BaselineExceptionDeliverer.deliverException(CompiledMethod compiledMethod, Address catchBlockInstructionAddress, Throwable exceptionObject, ArchitectureSpecific.Registers registers)
          Pass control to a catch block.
 void BaselineGCMapIterator.setupIterator(CompiledMethod compiledMethod, Offset instructionOffset, Address fp)
          Set the iterator to scan the map at the machine instruction offset provided.
 

Uses of Address in org.jikesrvm.compilers.common
 

Methods in org.jikesrvm.compilers.common that return Address
 Address CompiledMethod.getInstructionAddress(Offset offset)
          Return the address of the instruction at offset offset in the method's instruction stream.
 Address HardwareTrapGCMapIterator.getNextReferenceAddress()
           
 Address HardwareTrapGCMapIterator.getNextReturnAddressAddress()
           
 

Methods in org.jikesrvm.compilers.common with parameters of type Address
 boolean CompiledMethod.containsReturnAddress(Address ip)
          Does the code for the compiled method contain the given return address?
static CompiledMethod CompiledMethods.findMethodForInstruction(Address ip)
          Find the method whose machine code contains the specified instruction.
 Offset CompiledMethod.getInstructionOffset(Address ip)
          Return the offset in bytes of the given Address from the start of the machine code array.
 Offset CompiledMethod.getInstructionOffset(Address ip, boolean dieOnFailure)
          Return the offset in bytes of the given Address from the start of the machine code array.
 void HardwareTrapGCMapIterator.setupIterator(CompiledMethod compiledMethod, Offset instructionOffset, Address framePtr)
           
 

Uses of Address in org.jikesrvm.compilers.common.assembler.ia32
 

Methods in org.jikesrvm.compilers.common.assembler.ia32 with parameters of type Address
private  void Assembler.emitAbsRegOperands(Address disp, RegisterConstants.MachineRegister reg2)
          Generate the appropriate bytes into the generated code to denote an absolute-address--register instruction.
 void Assembler.emitADC_Abs_Imm_Byte(Address dstDisp, int imm)
          Generate a absolute--immediate ADC.
 void Assembler.emitADC_Abs_Imm_Quad(Address dstDisp, int imm)
          Generate a absolute--immediate ADC.
 void Assembler.emitADC_Abs_Imm_Word(Address dstDisp, int imm)
          Generate a absolute--immediate ADC.
 void Assembler.emitADC_Abs_Imm(Address dstDisp, int imm)
          Generate a absolute--immediate ADC.
 void Assembler.emitADC_Abs_Reg_Byte(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register ADC.
 void Assembler.emitADC_Abs_Reg_Quad(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register ADC.
 void Assembler.emitADC_Abs_Reg_Word(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register ADC.
 void Assembler.emitADC_Abs_Reg(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register ADC.
 void Assembler.emitADC_Reg_Abs_Byte(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset ADC.
 void Assembler.emitADC_Reg_Abs_Quad(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset ADC.
 void Assembler.emitADC_Reg_Abs_Word(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset ADC.
 void Assembler.emitADC_Reg_Abs(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset ADC.
 void Assembler.emitADD_Abs_Imm_Byte(Address dstDisp, int imm)
          Generate a absolute--immediate ADD.
 void Assembler.emitADD_Abs_Imm_Quad(Address dstDisp, int imm)
          Generate a absolute--immediate ADD.
 void Assembler.emitADD_Abs_Imm_Word(Address dstDisp, int imm)
          Generate a absolute--immediate ADD.
 void Assembler.emitADD_Abs_Imm(Address dstDisp, int imm)
          Generate a absolute--immediate ADD.
 void Assembler.emitADD_Abs_Reg_Byte(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register ADD.
 void Assembler.emitADD_Abs_Reg_Quad(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register ADD.
 void Assembler.emitADD_Abs_Reg_Word(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register ADD.
 void Assembler.emitADD_Abs_Reg(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register ADD.
 void Assembler.emitADD_Reg_Abs_Byte(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset ADD.
 void Assembler.emitADD_Reg_Abs_Quad(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset ADD.
 void Assembler.emitADD_Reg_Abs_Word(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset ADD.
 void Assembler.emitADD_Reg_Abs(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset ADD.
 void Assembler.emitADDSD_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute ADDSD.
 void Assembler.emitADDSS_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute ADDSS.
 void Assembler.emitAND_Abs_Imm_Byte(Address dstDisp, int imm)
          Generate a absolute--immediate AND.
 void Assembler.emitAND_Abs_Imm_Quad(Address dstDisp, int imm)
          Generate a absolute--immediate AND.
 void Assembler.emitAND_Abs_Imm_Word(Address dstDisp, int imm)
          Generate a absolute--immediate AND.
 void Assembler.emitAND_Abs_Imm(Address dstDisp, int imm)
          Generate a absolute--immediate AND.
 void Assembler.emitAND_Abs_Reg_Byte(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register AND.
 void Assembler.emitAND_Abs_Reg_Quad(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register AND.
 void Assembler.emitAND_Abs_Reg_Word(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register AND.
 void Assembler.emitAND_Abs_Reg(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register AND.
 void Assembler.emitAND_Reg_Abs_Byte(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset AND.
 void Assembler.emitAND_Reg_Abs_Quad(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset AND.
 void Assembler.emitAND_Reg_Abs_Word(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset AND.
 void Assembler.emitAND_Reg_Abs(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset AND.
 void Assembler.emitANDNPD_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute ANDNPD.
 void Assembler.emitANDNPS_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute ANDNPS.
 void Assembler.emitANDPD_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute ANDPD.
 void Assembler.emitANDPS_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute ANDPS.
 void Assembler.emitBT_Abs_Imm(Address dstDisp, int imm)
          Generate a absolute--immediate BT.
 void Assembler.emitBT_Abs_Reg(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register BT.
 void Assembler.emitBTC_Abs_Imm(Address dstDisp, int imm)
          Generate a absolute--immediate BTC.
 void Assembler.emitBTC_Abs_Reg(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register BTC.
 void Assembler.emitBTR_Abs_Imm(Address dstDisp, int imm)
          Generate a absolute--immediate BTR.
 void Assembler.emitBTR_Abs_Reg(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register BTR.
 void Assembler.emitBTS_Abs_Imm(Address dstDisp, int imm)
          Generate a absolute--immediate BTS.
 void Assembler.emitBTS_Abs_Reg(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register BTS.
 void Assembler.emitCALL_Abs(Address dstDisp)
          Generate a CALL to absolute address.
 void Assembler.emitCMOV_Cond_Reg_Abs(byte cond, RegisterConstants.GPR dst, Address disp2)
          Conditionally move the source to the destination, i.e.
 void Assembler.emitCMP_Abs_Imm_Byte(Address dstDisp, int imm)
          Generate a absolute--immediate CMP.
 void Assembler.emitCMP_Abs_Imm_Quad(Address dstDisp, int imm)
          Generate a absolute--immediate CMP.
 void Assembler.emitCMP_Abs_Imm_Word(Address dstDisp, int imm)
          Generate a absolute--immediate CMP.
 void Assembler.emitCMP_Abs_Imm(Address dstDisp, int imm)
          Generate a absolute--immediate CMP.
 void Assembler.emitCMP_Abs_Reg_Byte(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register CMP.
 void Assembler.emitCMP_Abs_Reg_Quad(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register CMP.
 void Assembler.emitCMP_Abs_Reg_Word(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register CMP.
 void Assembler.emitCMP_Abs_Reg(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register CMP.
 void Assembler.emitCMP_Reg_Abs_Byte(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset CMP.
 void Assembler.emitCMP_Reg_Abs_Quad(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset CMP.
 void Assembler.emitCMP_Reg_Abs_Word(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset CMP.
 void Assembler.emitCMP_Reg_Abs(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset CMP.
 void Assembler.emitCMPEQSD_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute CMPEQSD.
 void Assembler.emitCMPEQSS_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute CMPEQSS.
 void Assembler.emitCMPLESD_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute CMPLESD.
 void Assembler.emitCMPLESS_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute CMPLESS.
 void Assembler.emitCMPLTSD_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute CMPLTSD.
 void Assembler.emitCMPLTSS_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute CMPLTSS.
 void Assembler.emitCMPNESD_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute CMPNESD.
 void Assembler.emitCMPNESS_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute CMPNESS.
 void Assembler.emitCMPNLESD_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute CMPNLESD.
 void Assembler.emitCMPNLESS_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute CMPNLESS.
 void Assembler.emitCMPNLTSD_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute CMPNLTSD.
 void Assembler.emitCMPNLTSS_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute CMPNLTSS.
 void Assembler.emitCMPORDSD_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute CMPORDSD.
 void Assembler.emitCMPORDSS_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute CMPORDSS.
 void Assembler.emitCMPUNORDSD_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute CMPUNORDSD.
 void Assembler.emitCMPUNORDSS_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute CMPUNORDSS.
 void Assembler.emitCMPXCHG_Abs_Reg_Quad(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register CMPXCHG.
 void Assembler.emitCMPXCHG_Abs_Reg(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register CMPXCHG.
 void Assembler.emitCVTSD2SI_Reg_Abs(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--absolute CVTSD2SI.
 void Assembler.emitCVTSD2SIQ_Reg_Abs_Quad(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--absolute CVTSD2SIQ.
 void Assembler.emitCVTSD2SS_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute CVTSD2SS.
 void Assembler.emitCVTSI2SD_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute CVTSI2SD.
 void Assembler.emitCVTSI2SDQ_Reg_Abs_Quad(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute CVTSI2SDQ.
 void Assembler.emitCVTSI2SS_Reg_Abs_Quad(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute CVTSI2SS.
 void Assembler.emitCVTSI2SS_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute CVTSI2SS.
 void Assembler.emitCVTSS2SD_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute CVTSS2SD.
 void Assembler.emitCVTSS2SI_Reg_Abs_Quad(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--absolute CVTSS2SI.
 void Assembler.emitCVTSS2SI_Reg_Abs(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--absolute CVTSS2SI.
 void Assembler.emitCVTTSD2SI_Reg_Abs(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--absolute CVTTSD2SI.
 void Assembler.emitCVTTSD2SIQ_Reg_Abs_Quad(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--absolute CVTTSD2SIQ.
 void Assembler.emitCVTTSS2SI_Reg_Abs_Quad(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--absolute CVTTSS2SI.
 void Assembler.emitCVTTSS2SI_Reg_Abs(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--absolute CVTTSS2SI.
 void Assembler.emitDEC_Abs_Byte(Address disp)
          Generate a DEC to absolute address.
 void Assembler.emitDEC_Abs_Quad(Address disp)
          Generate a DEC to absolute address.
 void Assembler.emitDEC_Abs_Word(Address disp)
          Generate a DEC to absolute address.
 void Assembler.emitDEC_Abs(Address disp)
          Generate a DEC to absolute address.
 void Assembler.emitDIV_Reg_Abs_Quad(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a DIV by absolute address.
 void Assembler.emitDIV_Reg_Abs(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a DIV by absolute address.
 void Assembler.emitDIVSD_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute DIVSD.
 void Assembler.emitDIVSS_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute DIVSS.
 void Assembler.emitFADD_Reg_Abs_Quad(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform + on FP0.
 void Assembler.emitFADD_Reg_Abs(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform + on FP0.
 void Assembler.emitFDIV_Reg_Abs_Quad(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform / on FP0.
 void Assembler.emitFDIV_Reg_Abs(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform / on FP0.
 void Assembler.emitFDIVR_Reg_Abs_Quad(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform / on FP0.
 void Assembler.emitFDIVR_Reg_Abs(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform / on FP0.
 void Assembler.emitFIADD_Reg_Abs_Word(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform + on FP0.
 void Assembler.emitFIADD_Reg_Abs(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform + on FP0.
 void Assembler.emitFIDIV_Reg_Abs_Word(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform / on FP0.
 void Assembler.emitFIDIV_Reg_Abs(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform / on FP0.
 void Assembler.emitFIDIVR_Reg_Abs_Word(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform / on FP0.
 void Assembler.emitFIDIVR_Reg_Abs(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform / on FP0.
 void Assembler.emitFILD_Reg_Abs_Quad(RegisterConstants.FPR dummy, Address disp)
          top of stack loaded from (quad) [disp]
 void Assembler.emitFILD_Reg_Abs_Word(RegisterConstants.FPR dummy, Address disp)
          top of stack loaded from (word) [disp]
 void Assembler.emitFILD_Reg_Abs(RegisterConstants.FPR dummy, Address disp)
          top of stack loaded from (double word) [disp]
 void Assembler.emitFIMUL_Reg_Abs_Word(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform x on FP0.
 void Assembler.emitFIMUL_Reg_Abs(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform x on FP0.
 void Assembler.emitFIST_Abs_Reg_Word(Address disp, RegisterConstants.FPR dummy)
          top of stack stored to (word) [disp]
 void Assembler.emitFIST_Abs_Reg(Address disp, RegisterConstants.FPR dummy)
          top of stack stored to (double word) [disp]
 void Assembler.emitFISTP_Abs_Reg_Quad(Address disp, RegisterConstants.FPR dummy)
          top of stack stored to (quad) [disp]
 void Assembler.emitFISTP_Abs_Reg_Word(Address disp, RegisterConstants.FPR dummy)
          top of stack stored to (word) [disp]
 void Assembler.emitFISTP_Abs_Reg(Address disp, RegisterConstants.FPR dummy)
          top of stack stored to (double word) [disp]
 void Assembler.emitFISUB_Reg_Abs_Word(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform - on FP0.
 void Assembler.emitFISUB_Reg_Abs(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform - on FP0.
 void Assembler.emitFISUBR_Reg_Abs_Word(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform - on FP0.
 void Assembler.emitFISUBR_Reg_Abs(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform - on FP0.
 void Assembler.emitFLD_Reg_Abs_Quad(RegisterConstants.FPR dummy, Address disp)
          top of stack loaded from (quad) [disp]
 void Assembler.emitFLD_Reg_Abs(RegisterConstants.FPR dummy, Address disp)
          top of stack loaded from (double word) [disp]
 void Assembler.emitFLDCW_Abs(Address disp)
          load FPU control word - absolute address
 void Assembler.emitFMUL_Reg_Abs_Quad(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform x on FP0.
 void Assembler.emitFMUL_Reg_Abs(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform x on FP0.
 void Assembler.emitFNSAVE_Abs(Address disp)
          save FPU state ignoring pending exceptions - absolute address
 void Assembler.emitFNSTCW_Abs(Address disp)
          store FPU control word, ignoring exceptions - absolute address
 void Assembler.emitFRSTOR_Abs(Address disp)
          restore FPU state - absolute address
 void Assembler.emitFSAVE_Abs(Address disp)
          save FPU state respecting pending exceptions - absolute address
 void Assembler.emitFST_Abs_Reg_Quad(Address disp, RegisterConstants.FPR dummy)
          top of stack stored to (quad) [disp]
 void Assembler.emitFST_Abs_Reg(Address disp, RegisterConstants.FPR dummy)
          top of stack stored to (double word) [disp]
 void Assembler.emitFSTCW_Abs(Address disp)
          store FPU control word, checking for exceptions - absolute address
 void Assembler.emitFSTP_Abs_Reg_Quad(Address disp, RegisterConstants.FPR dummy)
          top of stack stored to (quad) [disp]
 void Assembler.emitFSTP_Abs_Reg(Address disp, RegisterConstants.FPR dummy)
          top of stack stored to (double word) [disp]
 void Assembler.emitFSUB_Reg_Abs_Quad(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform - on FP0.
 void Assembler.emitFSUB_Reg_Abs(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform - on FP0.
 void Assembler.emitFSUBR_Reg_Abs_Quad(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform - on FP0.
 void Assembler.emitFSUBR_Reg_Abs(RegisterConstants.FPR dstReg, Address srcDisp)
          Perform - on FP0.
 void Assembler.emitIDIV_Reg_Abs_Quad(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a IDIV by absolute address.
 void Assembler.emitIDIV_Reg_Abs(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a IDIV by absolute address.
private  void Assembler.emitImm32(Address disp)
          Generate the smallest-byte-first IA32 encoding of 32 bit immediates into the generated code.
 void Assembler.emitIMUL1_Reg_Abs_Quad(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a IMUL1 by absolute address.
 void Assembler.emitIMUL1_Reg_Abs(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a IMUL1 by absolute address.
 void Assembler.emitIMUL2_Reg_Abs_Quad(RegisterConstants.GPR dstReg, Address srcDisp)
           
 void Assembler.emitIMUL2_Reg_Abs(RegisterConstants.GPR dstReg, Address srcDisp)
           
 void Assembler.emitINC_Abs_Byte(Address disp)
          Generate a INC to absolute address.
 void Assembler.emitINC_Abs_Quad(Address disp)
          Generate a INC to absolute address.
 void Assembler.emitINC_Abs_Word(Address disp)
          Generate a INC to absolute address.
 void Assembler.emitINC_Abs(Address disp)
          Generate a INC to absolute address.
 void Assembler.emitJMP_Abs(Address dstDisp)
          Generate a JMP to absolute address.
 void Assembler.emitLEA_Reg_Abs_Quad(RegisterConstants.GPR dstReg, Address srcDisp)
           
 void Assembler.emitLEA_Reg_Abs(RegisterConstants.GPR dstReg, Address srcDisp)
           
 void Assembler.emitMOV_Abs_Imm_Byte(Address dstDisp, int imm)
          Generate an absolute MOV.
 void Assembler.emitMOV_Abs_Imm_Quad(Address dstDisp, int imm)
          Generate an absolute MOV.
 void Assembler.emitMOV_Abs_Imm_Word(Address dstDisp, int imm)
          Generate an absolute MOV.
 void Assembler.emitMOV_Abs_Imm(Address dstDisp, int imm)
          Generate an absolute MOV.
 void Assembler.emitMOV_Abs_Reg_Byte(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register MOV.
 void Assembler.emitMOV_Abs_Reg_Quad(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register MOV.
 void Assembler.emitMOV_Abs_Reg_Word(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register MOV.
 void Assembler.emitMOV_Abs_Reg(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register MOV.
 void Assembler.emitMOV_Reg_Abs_Byte(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset MOV.
 void Assembler.emitMOV_Reg_Abs_Quad(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset MOV.
 void Assembler.emitMOV_Reg_Abs_Word(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset MOV.
 void Assembler.emitMOV_Reg_Abs(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset MOV.
 void Assembler.emitMOVD_Abs_Reg(Address dstDisp, RegisterConstants.MM srcReg)
          Generate a absolute--register MOVD.
 void Assembler.emitMOVD_Abs_Reg(Address dstDisp, RegisterConstants.XMM srcReg)
          Generate a absolute--register MOVD.
 void Assembler.emitMOVD_Reg_Abs(RegisterConstants.MM dstReg, Address srcDisp)
          Generate a register--absolute MOVD.
 void Assembler.emitMOVD_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute MOVD.
 void Assembler.emitMOVLPD_Abs_Reg(Address dstDisp, RegisterConstants.XMM srcReg)
          Generate a absolute--register MOVLPD.
 void Assembler.emitMOVLPD_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute MOVLPD.
 void Assembler.emitMOVLPS_Abs_Reg(Address dstDisp, RegisterConstants.XMM srcReg)
          Generate a absolute--register MOVLPS.
 void Assembler.emitMOVLPS_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute MOVLPS.
 void Assembler.emitMOVQ_Abs_Reg(Address dstDisp, RegisterConstants.MM srcReg)
          Generate a absolute--register MOVQ.
 void Assembler.emitMOVQ_Abs_Reg(Address dstDisp, RegisterConstants.XMM srcReg)
          Generate a absolute--register MOVQ.
 void Assembler.emitMOVQ_Reg_Abs(RegisterConstants.MM dstReg, Address srcDisp)
          Generate a register--absolute MOVQ.
 void Assembler.emitMOVQ_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute MOVQ.
 void Assembler.emitMOVSD_Abs_Reg(Address dstDisp, RegisterConstants.XMM srcReg)
          Generate a absolute--register MOVSD.
 void Assembler.emitMOVSD_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute MOVSD.
 void Assembler.emitMOVSS_Abs_Reg(Address dstDisp, RegisterConstants.XMM srcReg)
          Generate a absolute--register MOVSS.
 void Assembler.emitMOVSS_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute MOVSS.
 void Assembler.emitMOVSX_Reg_Abs_Byte(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a move sign extended from an absolute address.
 void Assembler.emitMOVSX_Reg_Abs_Word(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a move sign extended from an absolute address.
 void Assembler.emitMOVSXQ_Reg_Abs_Byte(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a move sign extended from an absolute address.
 void Assembler.emitMOVSXQ_Reg_Abs_Word(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a move sign extended from an absolute address.
 void Assembler.emitMOVZX_Reg_Abs_Byte(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a move zero extended from an absolute address.
 void Assembler.emitMOVZX_Reg_Abs_Word(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a move zero extended from an absolute address.
 void Assembler.emitMOVZXQ_Reg_Abs_Byte(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a move zero extended from an absolute address.
 void Assembler.emitMOVZXQ_Reg_Abs_Word(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a move zero extended from an absolute address.
 void Assembler.emitMUL_Reg_Abs_Quad(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a MUL by absolute address.
 void Assembler.emitMUL_Reg_Abs(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a MUL by absolute address.
 void Assembler.emitMULSD_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute MULSD.
 void Assembler.emitMULSS_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute MULSS.
 void Assembler.emitNEG_Abs_Byte(Address disp)
          Generate a NEG to absolute address.
 void Assembler.emitNEG_Abs_Quad(Address disp)
          Generate a NEG to absolute address.
 void Assembler.emitNEG_Abs_Word(Address disp)
          Generate a NEG to absolute address.
 void Assembler.emitNEG_Abs(Address disp)
          Generate a NEG to absolute address.
 void Assembler.emitNOT_Abs_Byte(Address disp)
          Generate a NOT to absolute address.
 void Assembler.emitNOT_Abs_Quad(Address disp)
          Generate a NOT to absolute address.
 void Assembler.emitNOT_Abs_Word(Address disp)
          Generate a NOT to absolute address.
 void Assembler.emitNOT_Abs(Address disp)
          Generate a NOT to absolute address.
 void Assembler.emitOR_Abs_Imm_Byte(Address dstDisp, int imm)
          Generate a absolute--immediate OR.
 void Assembler.emitOR_Abs_Imm_Quad(Address dstDisp, int imm)
          Generate a absolute--immediate OR.
 void Assembler.emitOR_Abs_Imm_Word(Address dstDisp, int imm)
          Generate a absolute--immediate OR.
 void Assembler.emitOR_Abs_Imm(Address dstDisp, int imm)
          Generate a absolute--immediate OR.
 void Assembler.emitOR_Abs_Reg_Byte(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register OR.
 void Assembler.emitOR_Abs_Reg_Quad(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register OR.
 void Assembler.emitOR_Abs_Reg_Word(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register OR.
 void Assembler.emitOR_Abs_Reg(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register OR.
 void Assembler.emitOR_Reg_Abs_Byte(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset OR.
 void Assembler.emitOR_Reg_Abs_Quad(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset OR.
 void Assembler.emitOR_Reg_Abs_Word(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset OR.
 void Assembler.emitOR_Reg_Abs(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset OR.
 void Assembler.emitORPD_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute ORPD.
 void Assembler.emitORPS_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute ORPS.
 void Assembler.emitPOP_Abs(Address disp)
          Generate an absolute POP.
 void Assembler.emitPSLLQ_Reg_Abs(RegisterConstants.MM dstReg, Address srcDisp)
          Generate a register--absolute PSLLQ.
 void Assembler.emitPSLLQ_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute PSLLQ.
 void Assembler.emitPSRLQ_Reg_Abs(RegisterConstants.MM dstReg, Address srcDisp)
          Generate a register--absolute PSRLQ.
 void Assembler.emitPSRLQ_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute PSRLQ.
 void Assembler.emitPUSH_Abs(Address disp)
          Generate an absolute PUSH.
 void Assembler.emitRCL_Abs_Imm_Byte(Address dstDisp, int imm)
          Generate a absolute--immediate RCL.
 void Assembler.emitRCL_Abs_Imm_Quad(Address dstDisp, int imm)
          Generate a absolute--immediate RCL.
 void Assembler.emitRCL_Abs_Imm_Word(Address dstDisp, int imm)
          Generate a absolute--immediate RCL.
 void Assembler.emitRCL_Abs_Imm(Address dstDisp, int imm)
          Generate a absolute--immediate RCL.
 void Assembler.emitRCL_Abs_Reg_Byte(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register RCL.
 void Assembler.emitRCL_Abs_Reg_Quad(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register RCL.
 void Assembler.emitRCL_Abs_Reg_Word(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register RCL.
 void Assembler.emitRCL_Abs_Reg(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register RCL.
 void Assembler.emitRCR_Abs_Imm_Byte(Address dstDisp, int imm)
          Generate a absolute--immediate RCR.
 void Assembler.emitRCR_Abs_Imm_Quad(Address dstDisp, int imm)
          Generate a absolute--immediate RCR.
 void Assembler.emitRCR_Abs_Imm_Word(Address dstDisp, int imm)
          Generate a absolute--immediate RCR.
 void Assembler.emitRCR_Abs_Imm(Address dstDisp, int imm)
          Generate a absolute--immediate RCR.
 void Assembler.emitRCR_Abs_Reg_Byte(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register RCR.
 void Assembler.emitRCR_Abs_Reg_Quad(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register RCR.
 void Assembler.emitRCR_Abs_Reg_Word(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register RCR.
 void Assembler.emitRCR_Abs_Reg(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register RCR.
 void Assembler.emitROL_Abs_Imm_Byte(Address dstDisp, int imm)
          Generate a absolute--immediate ROL.
 void Assembler.emitROL_Abs_Imm_Quad(Address dstDisp, int imm)
          Generate a absolute--immediate ROL.
 void Assembler.emitROL_Abs_Imm_Word(Address dstDisp, int imm)
          Generate a absolute--immediate ROL.
 void Assembler.emitROL_Abs_Imm(Address dstDisp, int imm)
          Generate a absolute--immediate ROL.
 void Assembler.emitROL_Abs_Reg_Byte(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register ROL.
 void Assembler.emitROL_Abs_Reg_Quad(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register ROL.
 void Assembler.emitROL_Abs_Reg_Word(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register ROL.
 void Assembler.emitROL_Abs_Reg(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register ROL.
 void Assembler.emitROR_Abs_Imm_Byte(Address dstDisp, int imm)
          Generate a absolute--immediate ROR.
 void Assembler.emitROR_Abs_Imm_Quad(Address dstDisp, int imm)
          Generate a absolute--immediate ROR.
 void Assembler.emitROR_Abs_Imm_Word(Address dstDisp, int imm)
          Generate a absolute--immediate ROR.
 void Assembler.emitROR_Abs_Imm(Address dstDisp, int imm)
          Generate a absolute--immediate ROR.
 void Assembler.emitROR_Abs_Reg_Byte(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register ROR.
 void Assembler.emitROR_Abs_Reg_Quad(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register ROR.
 void Assembler.emitROR_Abs_Reg_Word(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register ROR.
 void Assembler.emitROR_Abs_Reg(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register ROR.
 void Assembler.emitSAL_Abs_Imm_Byte(Address dstDisp, int imm)
          Generate a absolute--immediate SAL.
 void Assembler.emitSAL_Abs_Imm_Quad(Address dstDisp, int imm)
          Generate a absolute--immediate SAL.
 void Assembler.emitSAL_Abs_Imm_Word(Address dstDisp, int imm)
          Generate a absolute--immediate SAL.
 void Assembler.emitSAL_Abs_Imm(Address dstDisp, int imm)
          Generate a absolute--immediate SAL.
 void Assembler.emitSAL_Abs_Reg_Byte(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register SAL.
 void Assembler.emitSAL_Abs_Reg_Quad(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register SAL.
 void Assembler.emitSAL_Abs_Reg_Word(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register SAL.
 void Assembler.emitSAL_Abs_Reg(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register SAL.
 void Assembler.emitSAR_Abs_Imm_Byte(Address dstDisp, int imm)
          Generate a absolute--immediate SAR.
 void Assembler.emitSAR_Abs_Imm_Quad(Address dstDisp, int imm)
          Generate a absolute--immediate SAR.
 void Assembler.emitSAR_Abs_Imm_Word(Address dstDisp, int imm)
          Generate a absolute--immediate SAR.
 void Assembler.emitSAR_Abs_Imm(Address dstDisp, int imm)
          Generate a absolute--immediate SAR.
 void Assembler.emitSAR_Abs_Reg_Byte(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register SAR.
 void Assembler.emitSAR_Abs_Reg_Quad(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register SAR.
 void Assembler.emitSAR_Abs_Reg_Word(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register SAR.
 void Assembler.emitSAR_Abs_Reg(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register SAR.
 void Assembler.emitSBB_Abs_Imm_Byte(Address dstDisp, int imm)
          Generate a absolute--immediate SBB.
 void Assembler.emitSBB_Abs_Imm_Quad(Address dstDisp, int imm)
          Generate a absolute--immediate SBB.
 void Assembler.emitSBB_Abs_Imm_Word(Address dstDisp, int imm)
          Generate a absolute--immediate SBB.
 void Assembler.emitSBB_Abs_Imm(Address dstDisp, int imm)
          Generate a absolute--immediate SBB.
 void Assembler.emitSBB_Abs_Reg_Byte(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register SBB.
 void Assembler.emitSBB_Abs_Reg_Quad(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register SBB.
 void Assembler.emitSBB_Abs_Reg_Word(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register SBB.
 void Assembler.emitSBB_Abs_Reg(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register SBB.
 void Assembler.emitSBB_Reg_Abs_Byte(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset SBB.
 void Assembler.emitSBB_Reg_Abs_Quad(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset SBB.
 void Assembler.emitSBB_Reg_Abs_Word(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset SBB.
 void Assembler.emitSBB_Reg_Abs(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset SBB.
 void Assembler.emitSET_Cond_Abs_Byte(byte cond, Address disp)
           
 void Assembler.emitSHL_Abs_Imm_Byte(Address dstDisp, int imm)
          Generate a absolute--immediate SHL.
 void Assembler.emitSHL_Abs_Imm_Quad(Address dstDisp, int imm)
          Generate a absolute--immediate SHL.
 void Assembler.emitSHL_Abs_Imm_Word(Address dstDisp, int imm)
          Generate a absolute--immediate SHL.
 void Assembler.emitSHL_Abs_Imm(Address dstDisp, int imm)
          Generate a absolute--immediate SHL.
 void Assembler.emitSHL_Abs_Reg_Byte(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register SHL.
 void Assembler.emitSHL_Abs_Reg_Quad(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register SHL.
 void Assembler.emitSHL_Abs_Reg_Word(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register SHL.
 void Assembler.emitSHL_Abs_Reg(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register SHL.
 void Assembler.emitSHLD_Abs_Reg_Imm_Quad(Address disp, RegisterConstants.GPR right, int shiftBy)
          Generate an absolute--register--immediate SHLD.
 void Assembler.emitSHLD_Abs_Reg_Imm(Address disp, RegisterConstants.GPR right, int shiftBy)
          Generate an absolute--register--immediate SHLD.
 void Assembler.emitSHLD_Abs_Reg_Reg_Quad(Address disp, RegisterConstants.GPR right, RegisterConstants.GPR shiftBy)
          Generate a register-index--register--register SHLD.
 void Assembler.emitSHLD_Abs_Reg_Reg(Address disp, RegisterConstants.GPR right, RegisterConstants.GPR shiftBy)
          Generate a register-index--register--register SHLD.
 void Assembler.emitSHR_Abs_Imm_Byte(Address dstDisp, int imm)
          Generate a absolute--immediate SHR.
 void Assembler.emitSHR_Abs_Imm_Quad(Address dstDisp, int imm)
          Generate a absolute--immediate SHR.
 void Assembler.emitSHR_Abs_Imm_Word(Address dstDisp, int imm)
          Generate a absolute--immediate SHR.
 void Assembler.emitSHR_Abs_Imm(Address dstDisp, int imm)
          Generate a absolute--immediate SHR.
 void Assembler.emitSHR_Abs_Reg_Byte(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register SHR.
 void Assembler.emitSHR_Abs_Reg_Quad(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register SHR.
 void Assembler.emitSHR_Abs_Reg_Word(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register SHR.
 void Assembler.emitSHR_Abs_Reg(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate an absolute--register SHR.
 void Assembler.emitSHRD_Abs_Reg_Imm_Quad(Address disp, RegisterConstants.GPR right, int shiftBy)
          Generate an absolute--register--immediate SHRD.
 void Assembler.emitSHRD_Abs_Reg_Imm(Address disp, RegisterConstants.GPR right, int shiftBy)
          Generate an absolute--register--immediate SHRD.
 void Assembler.emitSHRD_Abs_Reg_Reg_Quad(Address disp, RegisterConstants.GPR right, RegisterConstants.GPR shiftBy)
          Generate a register-index--register--register SHRD.
 void Assembler.emitSHRD_Abs_Reg_Reg(Address disp, RegisterConstants.GPR right, RegisterConstants.GPR shiftBy)
          Generate a register-index--register--register SHRD.
 void Assembler.emitSQRTSD_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute SQRTSD.
 void Assembler.emitSQRTSS_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute SQRTSS.
 void Assembler.emitSUB_Abs_Imm_Byte(Address dstDisp, int imm)
          Generate a absolute--immediate SUB.
 void Assembler.emitSUB_Abs_Imm_Quad(Address dstDisp, int imm)
          Generate a absolute--immediate SUB.
 void Assembler.emitSUB_Abs_Imm_Word(Address dstDisp, int imm)
          Generate a absolute--immediate SUB.
 void Assembler.emitSUB_Abs_Imm(Address dstDisp, int imm)
          Generate a absolute--immediate SUB.
 void Assembler.emitSUB_Abs_Reg_Byte(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register SUB.
 void Assembler.emitSUB_Abs_Reg_Quad(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register SUB.
 void Assembler.emitSUB_Abs_Reg_Word(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register SUB.
 void Assembler.emitSUB_Abs_Reg(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register SUB.
 void Assembler.emitSUB_Reg_Abs_Byte(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset SUB.
 void Assembler.emitSUB_Reg_Abs_Quad(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset SUB.
 void Assembler.emitSUB_Reg_Abs_Word(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset SUB.
 void Assembler.emitSUB_Reg_Abs(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset SUB.
 void Assembler.emitSUBSD_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute SUBSD.
 void Assembler.emitSUBSS_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute SUBSS.
 void Assembler.emitTEST_Abs_Imm_Byte(Address dstDisp, int imm)
          Generate a absolute--immediate TEST.
 void Assembler.emitTEST_Abs_Imm_Quad(Address dstDisp, int imm)
          Generate a absolute--immediate TEST.
 void Assembler.emitTEST_Abs_Imm_Word(Address dstDisp, int imm)
          Generate a absolute--immediate TEST.
 void Assembler.emitTEST_Abs_Imm(Address dstDisp, int imm)
          Generate a absolute--immediate TEST.
 void Assembler.emitTEST_Abs_Reg_Byte(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register TEST.
 void Assembler.emitTEST_Abs_Reg_Quad(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register TEST.
 void Assembler.emitTEST_Abs_Reg_Word(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register TEST.
 void Assembler.emitTEST_Abs_Reg(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register TEST.
 void Assembler.emitUCOMISD_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute UCOMISD.
 void Assembler.emitUCOMISS_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute UCOMISS.
 void Assembler.emitXOR_Abs_Imm_Byte(Address dstDisp, int imm)
          Generate a absolute--immediate XOR.
 void Assembler.emitXOR_Abs_Imm_Quad(Address dstDisp, int imm)
          Generate a absolute--immediate XOR.
 void Assembler.emitXOR_Abs_Imm_Word(Address dstDisp, int imm)
          Generate a absolute--immediate XOR.
 void Assembler.emitXOR_Abs_Imm(Address dstDisp, int imm)
          Generate a absolute--immediate XOR.
 void Assembler.emitXOR_Abs_Reg_Byte(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register XOR.
 void Assembler.emitXOR_Abs_Reg_Quad(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register XOR.
 void Assembler.emitXOR_Abs_Reg_Word(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register XOR.
 void Assembler.emitXOR_Abs_Reg(Address dstDisp, RegisterConstants.GPR srcReg)
          Generate a absolute--register XOR.
 void Assembler.emitXOR_Reg_Abs_Byte(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset XOR.
 void Assembler.emitXOR_Reg_Abs_Quad(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset XOR.
 void Assembler.emitXOR_Reg_Abs_Word(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset XOR.
 void Assembler.emitXOR_Reg_Abs(RegisterConstants.GPR dstReg, Address srcDisp)
          Generate a register--register-offset XOR.
 void Assembler.emitXORPD_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute XORPD.
 void Assembler.emitXORPS_Reg_Abs(RegisterConstants.XMM dstReg, Address srcDisp)
          Generate a register--absolute XORPS.
protected static boolean Assembler.fits(Address val, int bits)
          Find out whether a given signed value can be represented in a given number of bits.
(package private) static String Lister.hex(Address i)
           
 void Lister.RA(int i, String op, Address d)
           
 void Lister.RAI(int i, String op, Address d, long n)
           
 void Lister.RAR(int i, String op, Address d, RegisterConstants.MachineRegister R0)
           
 void Lister.RARI(int i, String op, Address d, RegisterConstants.MachineRegister R0, int imm)
           
 void Lister.RARR(int i, String op, Address d, RegisterConstants.MachineRegister R0, RegisterConstants.MachineRegister R2)
           
 void Lister.RRA(int i, String op, RegisterConstants.MachineRegister R0, Address d)
           
 

Uses of Address in org.jikesrvm.compilers.opt
 

Methods in org.jikesrvm.compilers.opt that return Address
static Address StaticFieldReader.getAddressStaticFieldValue(RVMField field)
          Returns the current contents of a Address static field.
private static Address ExpressionFolding.getAddressValue(Operand op)
           
private static Address Simplifier.getAddressValue(Operand op)
          Turn the given operand encoding an address constant into an Address
 

Uses of Address in org.jikesrvm.compilers.opt.ir
 

Methods in org.jikesrvm.compilers.opt.ir with parameters of type Address
static AddressConstantOperand IRTools.AC(Address value)
          Create an address constant operand with a given value.
 

Uses of Address in org.jikesrvm.compilers.opt.ir.operand
 

Fields in org.jikesrvm.compilers.opt.ir.operand declared as Address
 Address AddressConstantOperand.value
          Value of this operand.
 

Methods in org.jikesrvm.compilers.opt.ir.operand with parameters of type Address
static MemoryOperand MemoryOperand.D(Address disp, byte size, LocationOperand loc, Operand guard)
           
 int ConditionOperand.evaluate(Address v1, Address v2)
          Given two Addresses, evaluate the condition on them.
 

Constructors in org.jikesrvm.compilers.opt.ir.operand with parameters of type Address
AddressConstantOperand(Address v)
          Constructs a new address constant operand with the specified value.
 

Uses of Address in org.jikesrvm.compilers.opt.lir2mir
 

Methods in org.jikesrvm.compilers.opt.lir2mir that return Address
protected static Address BURS_Common_Helpers.AV(Operand op)
           
 

Uses of Address in org.jikesrvm.compilers.opt.runtimesupport
 

Fields in org.jikesrvm.compilers.opt.runtimesupport declared as Address
private  Address OptGenericGCMapIterator.spillLoc
          This caches the spill location, so that we can check for missed refs hiding in spills
 

Methods in org.jikesrvm.compilers.opt.runtimesupport that return Address
abstract  Address OptGenericGCMapIterator.getFirstSpillLoc()
          Get address of the first spill location (The location of spills varies among architectures.)
abstract  Address OptGenericGCMapIterator.getLastSpillLoc()
          Get address of the last spill location (The location of spills varies among architectures.)
 Address OptGenericGCMapIterator.getNextReferenceAddress()
          Returns the next address that contains a reference
 Address OptGenericGCMapIterator.getNextReturnAddressAddress()
          This method is called repeatedly to process derived pointers related to JSRs.
abstract  Address OptGenericGCMapIterator.getStackLocation(Address framePtr, int offset)
          Determine the stack location given the frame ptr and spill offset.
 

Methods in org.jikesrvm.compilers.opt.runtimesupport with parameters of type Address
(package private)  void OptGenericGCMapIterator.checkForMissedSpills(Address ref1, Address ref2)
          This method inspects spill locations between the parameters passed to determine if they look like heap points If the first parameter is 0, it looks from the beginning of the frame until new.
abstract  Address OptGenericGCMapIterator.getStackLocation(Address framePtr, int offset)
          Determine the stack location given the frame ptr and spill offset.
 void OptGenericGCMapIterator.setupIterator(CompiledMethod cm, Offset instructionOffset, Address framePtr)
          Initialize the iterator for another stack frame scan
 

Uses of Address in org.jikesrvm.compilers.opt.runtimesupport.ia32
 

Methods in org.jikesrvm.compilers.opt.runtimesupport.ia32 that return Address
 Address OptGCMapIterator.getFirstSpillLoc()
          Get address of the first spill location for the given frame ptr
 Address OptGCMapIterator.getLastSpillLoc()
          Get address of the last spill location for the given frame ptr
 Address OptGCMapIterator.getStackLocation(Address framePtr, int offset)
           
 

Methods in org.jikesrvm.compilers.opt.runtimesupport.ia32 with parameters of type Address
 void OptExceptionDeliverer.deliverException(CompiledMethod compiledMethod, Address catchBlockInstructionAddress, Throwable exceptionObject, ArchitectureSpecific.Registers registers)
          Pass control to a catch block.
 Address OptGCMapIterator.getStackLocation(Address framePtr, int offset)
           
 

Uses of Address in org.jikesrvm.compilers.opt.util
 

Methods in org.jikesrvm.compilers.opt.util with parameters of type Address
static boolean Bits.fits(Address val, int bits)
          Does an address literal val fit in bits bits?
 

Uses of Address in org.jikesrvm.ia32
 

Fields in org.jikesrvm.ia32 declared as Address
 Address Registers.fp
          Frame pointer
 Address Registers.ip
          Instruction address register
static Address StackframeLayoutConstants.STACKFRAME_SENTINEL_FP
          fp value indicating end of stack walkback
 

Methods in org.jikesrvm.ia32 that return Address
 Address Registers.getInnermostFramePointer()
          Return framepointer for the deepest stackframe
 Address Registers.getInnermostInstructionAddress()
          Return next instruction address for the deepest stackframe
 Address Registers.getIPLocation()
           
 

Methods in org.jikesrvm.ia32 with parameters of type Address
 void MachineSpecificIA.initializeStack(ArchitectureSpecific.Registers contextRegisters, Address ip, Address sp)
           
 void Registers.setInnermost(Address newip, Address newfp)
          set ip & fp. used to control the stack frame at which a scan of the stack during GC will start, for ex., the top java frame for a thread that is blocked in native code during GC.
 

Uses of Address in org.jikesrvm.jni
 

Fields in org.jikesrvm.jni declared as Address
private  Address JNIEnvironment.basePointerOnEntryToNative
          When native code doesn't maintain a base pointer we can't chain through the base pointers when walking the stack.
private  Address JNIEnvironment.externalJNIFunctions
          This is the pointer to the shared JNIFunction table.
private  Address JNIEnvironment.JNITopJavaFP
          When transitioning between Java and C and back, we may want to stop a thread returning into Java and executing mutator code when a GC is in progress.
private  Address JNIEnvironment.savedJTOC
          For saving JTOC register on entry to native, to be restored on JNI call from native (only used on PowerPC)
 

Methods in org.jikesrvm.jni that return Address
private static Address JNIFunctions.GetBooleanArrayElements(JNIEnvironment env, int arrayJREF, Address isCopyAddress)
          GetBooleanArrayElements: get all the elements of a boolean array
private static Address JNIFunctions.GetByteArrayElements(JNIEnvironment env, int arrayJREF, Address isCopyAddress)
          GetByteArrayElements: get all the elements of a byte array
private static Address JNIFunctions.GetCharArrayElements(JNIEnvironment env, int arrayJREF, Address isCopyAddress)
          GetCharArrayElements: get all the elements of a char array
private static Address JNIFunctions.GetDirectBufferAddress(JNIEnvironment env, int bufJREF)
           
private static Address JNIFunctions.GetDoubleArrayElements(JNIEnvironment env, int arrayJREF, Address isCopyAddress)
          GetDoubleArrayElements: get all the elements of a double array
private static Address JNIFunctions.GetFloatArrayElements(JNIEnvironment env, int arrayJREF, Address isCopyAddress)
          GetFloatArrayElements: get all the elements of a float array
private static Address JNIFunctions.GetIntArrayElements(JNIEnvironment env, int arrayJREF, Address isCopyAddress)
          GetIntArrayElements: get all the elements of an integer array
private static Address JNIFunctions.GetLongArrayElements(JNIEnvironment env, int arrayJREF, Address isCopyAddress)
          GetLongArrayElements: get all the elements of a long array
private static Address JNIFunctions.GetPrimitiveArrayCritical(JNIEnvironment env, int arrayJREF, Address isCopyAddress)
          GetPrimitiveArrayCritical: return a direct pointer to the primitive array and disable GC so that the array will not be moved.
private static Address JNIFunctions.GetShortArrayElements(JNIEnvironment env, int arrayJREF, Address isCopyAddress)
          GetShortArrayElements: get all the elements of a short array
private static Address JNIFunctions.GetStringChars(JNIEnvironment env, int strJREF, Address isCopyAddress)
          GetStringChars: return address of buffer containing contents of a String
private static Address JNIFunctions.GetStringCritical(JNIEnvironment env, int strJREF, Address isCopyAddress)
          GetStringCritical: Like GetStringChars and ReleaseStringChars, but in some VM environments the VM may be able to avoid making a copy.
private static Address JNIFunctions.GetStringUTFChars(JNIEnvironment env, int strJREF, Address isCopyAddress)
          GetStringUTFChars: return address of buffer containing contents of a String
 Address JNIEnvironment.topJavaFP()
           
 

Methods in org.jikesrvm.jni with parameters of type Address
private static boolean JNIFunctions.CallBooleanMethodA(JNIEnvironment env, int objJREF, int methodID, Address argAddress)
          CallBooleanMethodA: invoke a virtual method that returns a boolean value
private static boolean JNIFunctions.CallBooleanMethodV(JNIEnvironment env, int objJREF, int methodID, Address argAddress)
          CallBooleanMethodV: invoke a virtual method that returns a boolean value
private static byte JNIFunctions.CallByteMethodA(JNIEnvironment env, int objJREF, int methodID, Address argAddress)
          CallByteMethodA: invoke a virtual method that returns a byte value
private static byte JNIFunctions.CallByteMethodV(JNIEnvironment env, int objJREF, int methodID, Address argAddress)
          CallByteMethodV: invoke a virtual method that returns a byte value
private static char JNIFunctions.CallCharMethodA(JNIEnvironment env, int objJREF, int methodID, Address argAddress)
          CallCharMethodA: invoke a virtual method that returns a char value
private static char JNIFunctions.CallCharMethodV(JNIEnvironment env, int objJREF, int methodID, Address argAddress)
          CallCharMethodV: invoke a virtual method that returns a char value
private static double JNIFunctions.CallDoubleMethodA(JNIEnvironment env, int objJREF, int methodID, Address argAddress)
          CallDoubleMethodA: invoke a virtual method that returns a double value
private static double JNIFunctions.CallDoubleMethodV(JNIEnvironment env, int objJREF, int methodID, Address argAddress)
          CallDoubleMethodV: invoke a virtual method that returns a double value
private static float JNIFunctions.CallFloatMethodA(JNIEnvironment env, int objJREF, int methodID, Address argAddress)
          CallFloatMethodA: invoke a virtual method that returns a float value
private static float JNIFunctions.CallFloatMethodV(JNIEnvironment env, int objJREF, int methodID, Address argAddress)
          CallFloatMethodV: invoke a virtual method that returns a float value
private static int JNIFunctions.CallIntMethodA(JNIEnvironment env, int objJREF, int methodID, Address argAddress)
          CallIntMethodA: invoke a virtual method that returns an integer value
private static int JNIFunctions.CallIntMethodV(JNIEnvironment env, int objJREF, int methodID, Address argAddress)
          CallIntMethodV: invoke a virtual method that returns an int value
private static long JNIFunctions.CallLongMethodA(JNIEnvironment env, int objJREF, int methodID, Address argAddress)
          CallLongMethodA: invoke a virtual method that returns a long value
private static long JNIFunctions.CallLongMethodV(JNIEnvironment env, int objJREF, int methodID, Address argAddress)
          CallLongMethodV: invoke a virtual method that returns a long value
private static boolean JNIFunctions.CallNonvirtualBooleanMethodA(JNIEnvironment env, int objJREF, int classJREF, int methodID, Address argAddress)
          CallNonvirtualBooleanMethodA: invoke a virtual method that returns a boolean value
private static boolean JNIFunctions.CallNonvirtualBooleanMethodV(JNIEnvironment env, int objJREF, int classJREF, int methodID, Address argAddress)
          CallNonvirtualBooleanMethodV: invoke a virtual method that returns a boolean value
private static byte JNIFunctions.CallNonvirtualByteMethodA(JNIEnvironment env, int objJREF, int classJREF, int methodID, Address argAddress)
          CallNonvirtualByteMethodA: invoke a virtual method that returns a byte value
private static byte JNIFunctions.CallNonvirtualByteMethodV(JNIEnvironment env, int objJREF, int classJREF, int methodID, Address argAddress)
          CallNonvirtualByteMethodV: invoke a virtual method that returns a byte value
private static char JNIFunctions.CallNonvirtualCharMethodA(JNIEnvironment env, int objJREF, int classJREF, int methodID, Address argAddress)
          CallNonvirtualCharMethodA: invoke a virtual method that returns a char value
private static char JNIFunctions.CallNonvirtualCharMethodV(JNIEnvironment env, int objJREF, int classJREF, int methodID, Address argAddress)
          CallNonvirtualCharMethodV: invoke a virtual method that returns a char value
private static double JNIFunctions.CallNonvirtualDoubleMethodA(JNIEnvironment env, int objJREF, int classJREF, int methodID, Address argAddress)
          CallNonvirtualDoubleMethodA: invoke a virtual method that returns a double value
private static double JNIFunctions.CallNonvirtualDoubleMethodV(JNIEnvironment env, int objJREF, int classJREF, int methodID, Address argAddress)
          CallNonvirtualDoubleMethodV: invoke a virtual method that returns a double value
private static float JNIFunctions.CallNonvirtualFloatMethodA(JNIEnvironment env, int objJREF, int classJREF, int methodID, Address argAddress)
          CallNonvirtualFloatMethodA: invoke a virtual method that returns a float value
private static float JNIFunctions.CallNonvirtualFloatMethodV(JNIEnvironment env, int objJREF, int classJREF, int methodID, Address argAddress)
          CallNonvirtualFloatMethodV: invoke a virtual method that returns a float value
private static int JNIFunctions.CallNonvirtualIntMethodA(JNIEnvironment env, int objJREF, int classJREF, int methodID, Address argAddress)
          CallNonvirtualIntMethodA: invoke a virtual method that returns an integer value
private static int JNIFunctions.CallNonvirtualIntMethodV(JNIEnvironment env, int objJREF, int classJREF, int methodID, Address argAddress)
          CallNonvirtualIntMethodV: invoke a virtual method that returns an int value
private static long JNIFunctions.CallNonvirtualLongMethodA(JNIEnvironment env, int objJREF, int classJREF, int methodID, Address argAddress)
          CallNonvirtualLongMethodA: invoke a virtual method that returns a long value
private static long JNIFunctions.CallNonvirtualLongMethodV(JNIEnvironment env, int objJREF, int classJREF, int methodID, Address argAddress)
          CallNonvirtualLongMethodV: invoke a virtual method that returns a long value
private static int JNIFunctions.CallNonvirtualObjectMethodA(JNIEnvironment env, int objJREF, int classJREF, int methodID, Address argAddress)
          CallNonvirtualNonvirtualObjectMethodA: invoke a virtual method that returns an object value
private static int JNIFunctions.CallNonvirtualObjectMethodV(JNIEnvironment env, int objJREF, int classJREF, int methodID, Address argAddress)
          CallNonvirtualObjectMethodV: invoke a virtual method that returns an object
private static short JNIFunctions.CallNonvirtualShortMethodA(JNIEnvironment env, int objJREF, int classJREF, int methodID, Address argAddress)
          CallNonvirtualShortMethodA: invoke a virtual method that returns a short value
private static short JNIFunctions.CallNonvirtualShortMethodV(JNIEnvironment env, int objJREF, int classJREF, int methodID, Address argAddress)
          CallNonvirtualShortMethodV: invoke a virtual method that returns a short value
private static void JNIFunctions.CallNonvirtualVoidMethodA(JNIEnvironment env, int objJREF, int classJREF, int methodID, Address argAddress)
          CallNonvirtualVoidMethodA: invoke a virtual method that returns void
private static void JNIFunctions.CallNonvirtualVoidMethodV(JNIEnvironment env, int objJREF, int classJREF, int methodID, Address argAddress)
          CallNonvirtualVoidMethodV: invoke a virtual method that returns void
private static int JNIFunctions.CallObjectMethodA(JNIEnvironment env, int objJREF, int methodID, Address argAddress)
          CallObjectMethodA: invoke a virtual method that returns an object value
private static int JNIFunctions.CallObjectMethodV(JNIEnvironment env, int objJREF, int methodID, Address argAddress)
          CallObjectMethodV: invoke a virtual method that returns an object
private static short JNIFunctions.CallShortMethodA(JNIEnvironment env, int objJREF, int methodID, Address argAddress)
          CallShortMethodA: invoke a virtual method that returns a short value
private static short JNIFunctions.CallShortMethodV(JNIEnvironment env, int objJREF, int methodID, Address argAddress)
          CallShortMethodV: invoke a virtual method that returns a short value
private static boolean JNIFunctions.CallStaticBooleanMethodA(JNIEnvironment env, int classJREF, int methodID, Address argAddress)
          CallStaticBooleanMethodA: invoke a static method that returns a boolean value
private static boolean JNIFunctions.CallStaticBooleanMethodV(JNIEnvironment env, int classJREF, int methodID, Address argAddress)
          CallStaticBooleanMethodV: invoke a static method that returns a boolean value
private static byte JNIFunctions.CallStaticByteMethodA(JNIEnvironment env, int classJREF, int methodID, Address argAddress)
          CallStaticByteMethodA: invoke a static method that returns a byte value
private static byte JNIFunctions.CallStaticByteMethodV(JNIEnvironment env, int classJREF, int methodID, Address argAddress)
          CallStaticByteMethodV: invoke a static method that returns a byte value
private static char JNIFunctions.CallStaticCharMethodA(JNIEnvironment env, int classJREF, int methodID, Address argAddress)
          CallStaticCharMethodA: invoke a static method that returns a char value
private static char JNIFunctions.CallStaticCharMethodV(JNIEnvironment env, int classJREF, int methodID, Address argAddress)
          CallStaticCharMethodV: invoke a static method that returns a char value
private static double JNIFunctions.CallStaticDoubleMethodA(JNIEnvironment env, int classJREF, int methodID, Address argAddress)
          CallStaticDoubleMethodA: invoke a static method that returns a double value
private static double JNIFunctions.CallStaticDoubleMethodV(JNIEnvironment env, int classJREF, int methodID, Address argAddress)
          CallStaticDoubleMethodV: invoke a static method that returns a double value
private static float JNIFunctions.CallStaticFloatMethodA(JNIEnvironment env, int classJREF, int methodID, Address argAddress)
          CallStaticFloatMethodA: invoke a static method that returns a float value
private static float JNIFunctions.CallStaticFloatMethodV(JNIEnvironment env, int classJREF, int methodID, Address argAddress)
          CallStaticFloatMethodV: invoke a static method that returns a float value
private static int JNIFunctions.CallStaticIntMethodA(JNIEnvironment env, int classJREF, int methodID, Address argAddress)
          CallStaticIntMethodA: invoke a static method that returns an integer value
private static int JNIFunctions.CallStaticIntMethodV(JNIEnvironment env, int classJREF, int methodID, Address argAddress)
          CallStaticIntMethodV: invoke a static method that returns an integer value
private static long JNIFunctions.CallStaticLongMethodA(JNIEnvironment env, int classJREF, int methodID, Address argAddress)
          CallStaticLongMethodA: invoke a static method that returns a long value
private static long JNIFunctions.CallStaticLongMethodV(JNIEnvironment env, int classJREF, int methodID, Address argAddress)
          CallStaticLongMethodV: invoke a static method that returns a long value
private static int JNIFunctions.CallStaticObjectMethodA(JNIEnvironment env, int classJREF, int methodID, Address argAddress)
          CallStaticObjectMethodA: invoke a static method that returns an object
private static int JNIFunctions.CallStaticObjectMethodV(JNIEnvironment env, int classJREF, int methodID, Address argAddress)
          CallStaticObjectMethodV: invoke a static method that returns an object
private static short JNIFunctions.CallStaticShortMethodA(JNIEnvironment env, int classJREF, int methodID, Address argAddress)
          CallStaticShortMethodA: invoke a static method that returns a short value
private static short JNIFunctions.CallStaticShortMethodV(JNIEnvironment env, int classJREF, int methodID, Address argAddress)
          CallStaticShortMethodV: invoke a static method that returns a short value
private static void JNIFunctions.CallStaticVoidMethodA(JNIEnvironment env, int classJREF, int methodID, Address argAddress)
          CallStaticVoidMethodA: invoke a static method that returns void
private static void JNIFunctions.CallStaticVoidMethodV(JNIEnvironment env, int classJREF, int methodID, Address argAddress)
          CallStaticVoidMethodA: invoke a static method that returns void
private static void JNIFunctions.CallVoidMethodA(JNIEnvironment env, int objJREF, int methodID, Address argAddress)
          CallVoidMethodA: invoke a virtual method that returns void
private static void JNIFunctions.CallVoidMethodV(JNIEnvironment env, int objJREF, int methodID, Address argAddress)
          CallVoidMethodV: invoke a virtual method that returns void
static byte[] JNIGenericHelpers.createByteArrayFromC(Address stringAddress)
          Given an address in C that points to a null-terminated string, create a new Java byte[] with a copy of the string.
static String JNIGenericHelpers.createStringFromC(Address stringAddress)
          Given an address in C that points to a null-terminated string, create a new Java String with a copy of the string.
static void JNIGenericHelpers.createUTFForCFromString(String str, Address copyBuffer, int len)
          Convert a String into a a malloced region
static String JNIGenericHelpers.createUTFStringFromC(Address stringAddress)
          Given an address in C that points to a null-terminated string, create a new UTF encoded Java String with a copy of the string.
private static int JNIFunctions.DefineClass(JNIEnvironment env, Address classNameAddress, int classLoader, Address data, int dataLen)
          DefineClass: Loads a class from a buffer of raw class data.
private static void JNIFunctions.FatalError(JNIEnvironment env, Address messageAddress)
          FatalError: print a message and terminate the VM
private static int JNIFunctions.FindClass(JNIEnvironment env, Address classNameAddress)
          FindClass: given a class name, find its RVMClass, or 0 if not found
private static Address JNIFunctions.GetBooleanArrayElements(JNIEnvironment env, int arrayJREF, Address isCopyAddress)
          GetBooleanArrayElements: get all the elements of a boolean array
private static void JNIFunctions.GetBooleanArrayRegion(JNIEnvironment env, int arrayJREF, int startIndex, int length, Address bufAddress)
          GetBooleanArrayRegion: copy a region of the array into the native buffer
private static Address JNIFunctions.GetByteArrayElements(JNIEnvironment env, int arrayJREF, Address isCopyAddress)
          GetByteArrayElements: get all the elements of a byte array
private static void JNIFunctions.GetByteArrayRegion(JNIEnvironment env, int arrayJREF, int startIndex, int length, Address bufAddress)
          GetByteArrayRegion: copy a region of the array into the native buffer
private static Address JNIFunctions.GetCharArrayElements(JNIEnvironment env, int arrayJREF, Address isCopyAddress)
          GetCharArrayElements: get all the elements of a char array
private static void JNIFunctions.GetCharArrayRegion(JNIEnvironment env, int arrayJREF, int startIndex, int length, Address bufAddress)
          GetCharArrayRegion: copy a region of the array into the native buffer
private static Address JNIFunctions.GetDoubleArrayElements(JNIEnvironment env, int arrayJREF, Address isCopyAddress)
          GetDoubleArrayElements: get all the elements of a double array
private static void JNIFunctions.GetDoubleArrayRegion(JNIEnvironment env, int arrayJREF, int startIndex, int length, Address bufAddress)
          GetDoubleArrayRegion: copy a region of the array into the native buffer
private static int JNIFunctions.GetFieldID(JNIEnvironment env, int classJREF, Address fieldNameAddress, Address descriptorAddress)
          GetFieldID: return a field id, which can be cached in native code and reused
private static Address JNIFunctions.GetFloatArrayElements(JNIEnvironment env, int arrayJREF, Address isCopyAddress)
          GetFloatArrayElements: get all the elements of a float array
private static void JNIFunctions.GetFloatArrayRegion(JNIEnvironment env, int arrayJREF, int startIndex, int length, Address bufAddress)
          GetFloatArrayRegion: copy a region of the array into the native buffer
private static Address JNIFunctions.GetIntArrayElements(JNIEnvironment env, int arrayJREF, Address isCopyAddress)
          GetIntArrayElements: get all the elements of an integer array
private static void JNIFunctions.GetIntArrayRegion(JNIEnvironment env, int arrayJREF, int startIndex, int length, Address bufAddress)
          GetIntArrayRegion: copy a region of the array into the native buffer
private static int JNIFunctions.GetJavaVM(JNIEnvironment env, Address StarStarJavaVM)
           
private static Address JNIFunctions.GetLongArrayElements(JNIEnvironment env, int arrayJREF, Address isCopyAddress)
          GetLongArrayElements: get all the elements of a long array
private static void JNIFunctions.GetLongArrayRegion(JNIEnvironment env, int arrayJREF, int startIndex, int length, Address bufAddress)
          GetLongArrayRegion: copy a region of the array into the native buffer
private static int JNIFunctions.GetMethodID(JNIEnvironment env, int classJREF, Address methodNameAddress, Address methodSigAddress)
          GetMethodID: get the virtual method ID given the name and the signature
private static Address JNIFunctions.GetPrimitiveArrayCritical(JNIEnvironment env, int arrayJREF, Address isCopyAddress)
          GetPrimitiveArrayCritical: return a direct pointer to the primitive array and disable GC so that the array will not be moved.
private static Address JNIFunctions.GetShortArrayElements(JNIEnvironment env, int arrayJREF, Address isCopyAddress)
          GetShortArrayElements: get all the elements of a short array
private static void JNIFunctions.GetShortArrayRegion(JNIEnvironment env, int arrayJREF, int startIndex, int length, Address bufAddress)
          GetShortArrayRegion: copy a region of the array into the native buffer
private static int JNIFunctions.GetStaticFieldID(JNIEnvironment env, int classJREF, Address fieldNameAddress, Address descriptorAddress)
          GetStaticFieldID: return a field id which can be cached in native code and reused
private static int JNIFunctions.GetStaticMethodID(JNIEnvironment env, int classJREF, Address methodNameAddress, Address methodSigAddress)
          GetStaticMethodID: return the method ID for invocation later
private static Address JNIFunctions.GetStringChars(JNIEnvironment env, int strJREF, Address isCopyAddress)
          GetStringChars: return address of buffer containing contents of a String
private static Address JNIFunctions.GetStringCritical(JNIEnvironment env, int strJREF, Address isCopyAddress)
          GetStringCritical: Like GetStringChars and ReleaseStringChars, but in some VM environments the VM may be able to avoid making a copy.
private static void JNIFunctions.GetStringRegion(JNIEnvironment env, int strJREF, int start, int len, Address buf)
          GetStringRegion: Copy a region of Unicode characters from a string to the given buffer.
private static Address JNIFunctions.GetStringUTFChars(JNIEnvironment env, int strJREF, Address isCopyAddress)
          GetStringUTFChars: return address of buffer containing contents of a String
private static void JNIFunctions.GetStringUTFRegion(JNIEnvironment env, int strJREF, int start, int len, Address buf)
          GetStringUTFRegion: Copy a region of Unicode characters from a string to the given buffer, as UTF8 characters.
private static int JNIFunctions.NewDirectByteBuffer(JNIEnvironment env, Address address, long capacity)
          These functions are in JNI 1.4
private static int JNIFunctions.NewObjectA(JNIEnvironment env, int classJREF, int methodID, Address argAddress)
          NewObjectA: create a new object instance
private static int JNIFunctions.NewObjectV(JNIEnvironment env, int classJREF, int methodID, Address argAddress)
          NewObjectV: create a new object instance
private static int JNIFunctions.NewString(JNIEnvironment env, Address uchars, int len)
          NewString: create a String Object from C array of unicode chars
private static int JNIFunctions.NewStringUTF(JNIEnvironment env, Address utf8bytes)
          NewStringUTF: create a String Object from C array of utf8 bytes
private static int JNIFunctions.RegisterNatives(JNIEnvironment env, int classJREF, Address methodsAddress, int nmethods)
          RegisterNatives: registers implementation of native methods
private static void JNIFunctions.ReleaseBooleanArrayElements(JNIEnvironment env, int arrayJREF, Address copyBufferAddress, int releaseMode)
          ReleaseBooleanArrayElements: free the native copy of the array, update changes to Java array as indicated
private static void JNIFunctions.ReleaseByteArrayElements(JNIEnvironment env, int arrayJREF, Address copyBufferAddress, int releaseMode)
          ReleaseByteArrayElements: free the native copy of the array, update changes to Java array as indicated
private static void JNIFunctions.ReleaseCharArrayElements(JNIEnvironment env, int arrayJREF, Address copyBufferAddress, int releaseMode)
          ReleaseCharArrayElements: free the native copy of the array, update changes to Java array as indicated
private static void JNIFunctions.ReleaseDoubleArrayElements(JNIEnvironment env, int arrayJREF, Address copyBufferAddress, int releaseMode)
          ReleaseDoubleArrayElements: free the native copy of the array, update changes to Java array as indicated
private static void JNIFunctions.ReleaseFloatArrayElements(JNIEnvironment env, int arrayJREF, Address copyBufferAddress, int releaseMode)
          ReleaseFloatArrayElements: free the native copy of the array, update changes to Java array as indicated
private static void JNIFunctions.ReleaseIntArrayElements(JNIEnvironment env, int arrayJREF, Address copyBufferAddress, int releaseMode)
          ReleaseIntArrayElements: free the native copy of the array, update changes to Java array as indicated
private static void JNIFunctions.ReleaseLongArrayElements(JNIEnvironment env, int arrayJREF, Address copyBufferAddress, int releaseMode)
          ReleaseLongArrayElements: free the native copy of the array, update changes to Java array as indicated
private static void JNIFunctions.ReleasePrimitiveArrayCritical(JNIEnvironment env, int arrayJREF, Address arrayCopyAddress, int mode)
          ReleasePrimitiveArrayCritical: this function is intended to be paired with the GetPrimitiveArrayCritical function.
private static void JNIFunctions.ReleaseShortArrayElements(JNIEnvironment env, int arrayJREF, Address copyBufferAddress, int releaseMode)
          ReleaseShortArrayElements: free the native copy of the array, update changes to Java array as indicated
private static void JNIFunctions.ReleaseStringChars(JNIEnvironment env, int objJREF, Address bufAddress)
          ReleaseStringChars: release buffer obtained via GetStringChars
private static void JNIFunctions.ReleaseStringCritical(JNIEnvironment env, int strJREF, Address carray)
          ReleaseStringCritical: this function is intended to be paired with the GetStringCritical function.
private static void JNIFunctions.ReleaseStringUTFChars(JNIEnvironment env, int objJREF, Address bufAddress)
          ReleaseStringUTFChars: release buffer obtained via GetStringUTFChars
private static void JNIFunctions.SetBooleanArrayRegion(JNIEnvironment env, int arrayJREF, int startIndex, int length, Address bufAddress)
          SetBooleanArrayRegion: copy a region of the native buffer into the array (1 byte element)
(package private) static void JNIGenericHelpers.setBoolStar(Address boolPtr, boolean val)
          A JNI helper function, to set the value pointed to by a C pointer of type (jboolean *).
private static void JNIFunctions.SetByteArrayRegion(JNIEnvironment env, int arrayJREF, int startIndex, int length, Address bufAddress)
          SetByteArrayRegion: copy a region of the native buffer into the array (1 byte element)
private static void JNIFunctions.SetCharArrayRegion(JNIEnvironment env, int arrayJREF, int startIndex, int length, Address bufAddress)
          SetCharArrayRegion: copy a region of the native buffer into the array (2 byte element)
private static void JNIFunctions.SetDoubleArrayRegion(JNIEnvironment env, int arrayJREF, int startIndex, int length, Address bufAddress)
          SetDoubleArrayRegion: copy a region of the native buffer into the array
private static void JNIFunctions.SetFloatArrayRegion(JNIEnvironment env, int arrayJREF, int startIndex, int length, Address bufAddress)
          SetFloatArrayRegion: copy a region of the native buffer into the array
private static void JNIFunctions.SetIntArrayRegion(JNIEnvironment env, int arrayJREF, int startIndex, int length, Address bufAddress)
          SetIntArrayRegion: copy a region of the native buffer into the array
private static void JNIFunctions.SetLongArrayRegion(JNIEnvironment env, int arrayJREF, int startIndex, int length, Address bufAddress)
          SetLongArrayRegion: copy a region of the native buffer into the array
private static void JNIFunctions.SetShortArrayRegion(JNIEnvironment env, int arrayJREF, int startIndex, int length, Address bufAddress)
          SetShortArrayRegion: copy a region of the native buffer into the array (2 byte element)
static int JNIGenericHelpers.strlen(Address ptr)
          Compute the length of the given null-terminated string
private static int JNIFunctions.ThrowNew(JNIEnvironment env, int throwableClassJREF, Address exceptionNameAddress)
          ThrowNew
private  int JNIEnvironment.uninterruptiblePushJNIRef(Address ref, boolean isRef)
          Push a JNI ref, used on entry to JNI NB only used for Intel
 

Uses of Address in org.jikesrvm.jni.ia32
 

Methods in org.jikesrvm.jni.ia32 that return Address
 Address JNIGCMapIterator.getNextReferenceAddress()
           
 Address JNIGCMapIterator.getNextReturnAddressAddress()
           
private static Address JNIHelpers.getVarArgAddress(boolean skip4Args)
          This method supports var args passed from C.
 

Methods in org.jikesrvm.jni.ia32 with parameters of type Address
 void JNIExceptionDeliverer.deliverException(CompiledMethod compiledMethod, Address catchBlockInstructionAddress, Throwable exceptionObject, ArchitectureSpecific.Registers registers)
          Deliver exception, not possible for JNI methods
static Object JNIHelpers.invokeInitializer(Class<?> cls, int methodID, Address argAddress, boolean isJvalue, boolean isDotDotStyle)
          Common code shared by the JNI functions NewObjectA, NewObjectV, NewObject (object creation)
static Object JNIHelpers.invokeWithJValue(int methodID, Address argAddress, TypeReference expectReturnType)
          Common code shared by the JNI functions CallStaticMethodA
static Object JNIHelpers.invokeWithJValue(Object obj, int methodID, Address argAddress, TypeReference expectReturnType, boolean skip4Args)
          Common code shared by the JNI functions CallMethodA
static Object JNIHelpers.invokeWithVarArg(int methodID, Address argAddress, TypeReference expectReturnType)
          Common code shared by the JNI functions CallStaticMethodV
static Object JNIHelpers.invokeWithVarArg(Object obj, int methodID, Address argAddress, TypeReference expectReturnType, boolean skip4Args)
          Common code shared by the JNI functions CallMethodV
(package private) static Object JNIHelpers.packageAndInvoke(Object obj, int methodID, Address argAddress, TypeReference expectReturnType, boolean skip4Args, boolean isVarArg)
          Common code shared by invokeWithJValue, invokeWithVarArg and invokeWithDotDotVarArg
(package private) static Object[] JNIHelpers.packageParameterFromJValue(RVMMethod targetMethod, Address argAddress)
          Repackage the arguments passed as an array of jvalue into an array of Object, used by the JNI functions CallStaticMethodA
(package private) static Object[] JNIHelpers.packageParameterFromVarArg(RVMMethod targetMethod, Address argAddress)
          Repackage the arguments passed as a variable argument list into an array of Object, used by the JNI functions CallStaticMethodV
 void JNIGCMapIterator.setupIterator(CompiledMethod compiledMethod, Offset instructionOffset, Address framePtr)
           
 

Uses of Address in org.jikesrvm.mm.mminterface
 

Fields in org.jikesrvm.mm.mminterface declared as Address
 Address GCMapIterator.framePtr
          address of stackframe currently being scanned
 

Methods in org.jikesrvm.mm.mminterface that return Address
static Address Barriers.addressFieldRead(Object ref, Offset offset, int locationMetadata)
          Barrier for loads of Address's from fields of instances (i.e. getfield).
static Address AlignmentEncoding.adjustRegion(int alignCode, Address region)
          Adjust a region address so that the object pointer of an object that starts at this address will be aligned so as to encode the specified value.
static Address MemoryManager.allocateSpace(CollectorContext context, int bytes, int align, int offset, int allocator, ObjectReference from)
          Allocate space for GC-time copying of an object
private static Address MemoryManager.allocateSpace(Selected.Mutator mutator, int bytes, int align, int offset, int allocator, int site)
          Allocate space for runtime allocation of an object
abstract  Address GCMapIterator.getNextReferenceAddress()
          Get address of next object reference held by current stackframe.
abstract  Address GCMapIterator.getNextReturnAddressAddress()
          Get address of next JSR return address held by current stackframe.
 

Methods in org.jikesrvm.mm.mminterface with parameters of type Address
static void Barriers.addressFieldWrite(Object ref, Address value, Offset offset, int locationMetadata)
          Barrier for writes of Address's into fields of instances (i.e. putfield).
static boolean MemoryManager.addressInVM(Address address)
          Checks if an address refers to an in-use area of memory.
static boolean Barriers.addressTryCompareAndSwap(Object ref, Offset offset, Address old, Address value)
          Barrier for conditional compare and exchange of Address fields.
static boolean DebugUtil.addrInBootImage(Address addr)
           
static Address AlignmentEncoding.adjustRegion(int alignCode, Address region)
          Adjust a region address so that the object pointer of an object that starts at this address will be aligned so as to encode the specified value.
static int AlignmentEncoding.extractTibCode(Address address)
          Extract the encoded value from a TIB pointer, represented as a raw address.
private static int AlignmentEncoding.getTibCodeForRegion(Address region)
           
static void MemoryManager.initializeHeader(BootImageInterface bootImage, Address ref, TIB tib, int size, boolean isScalar)
          Override the boot-time initialization method here, so that the core JMTk code doesn't need to know about the BootImageInterface type.
static boolean MemoryManager.mightBeFP(Address address)
          Return true if address is in a space which may contain stacks
 void GCMapIteratorGroup.newStackWalk(RVMThread thread, Address registerLocation)
          Prepare to scan a thread's stack for object references.
abstract  void GCMapIterator.setupIterator(CompiledMethod compiledMethod, Offset instructionOffset, Address framePtr)
          Prepare to iterate over object references and JSR return addresses held by a stackframe.
 

Uses of Address in org.jikesrvm.mm.mmtk
 

Fields in org.jikesrvm.mm.mmtk declared as Address
private  Address ScanThread.fp
           
private  Address ScanThread.initialIPLoc
           
private  Address ScanThread.ip
           
private  Address ScanThread.prevFp
           
private  Address ScanThread.topFrame
           
 

Methods in org.jikesrvm.mm.mmtk that return Address
 Address Barriers.addressRead(ObjectReference ref, Word offset, Word location, int mode)
          Perform the actual read of the read barrier, returning the value as a raw Address.
 Address ObjectModel.copyTo(ObjectReference from, ObjectReference to, Address region)
           
protected  Address Memory.getAvailableEndConstant()
           
protected  Address Memory.getAvailableStartConstant()
           
 Address TraceInterface.getBootImageLink()
           
protected  Address Memory.getHeapEndConstant()
           
protected  Address Memory.getHeapStartConstant()
           
 Address ObjectModel.getObjectEndAddress(ObjectReference object)
           
 Address ObjectModel.objectStartRef(ObjectReference object)
           
 Address ObjectModel.refToAddress(ObjectReference object)
           
private  Address ScanThread.scanFrame(int verbosity)
          Scan the current stack frame.
 Address TraceInterface.skipOwnFramesAndDump(ObjectReference typeRef)
           
 

Methods in org.jikesrvm.mm.mmtk with parameters of type Address
 boolean Barriers.addressTryCompareAndSwap(ObjectReference objref, Address expected, Address newValue, Word offset, Word unused, int mode)
          Attempt an atomic compare and exchange in a write barrier sequence.
 void Barriers.addressWrite(ObjectReference ref, Address target, Word offset, Word location, int mode)
          Perform the actual write of the write barrier, writing the value as a raw Address.
 Offset TraceInterface.adjustSlotOffset(boolean isScalar, ObjectReference src, Address slot)
           
private static void ScanThread.checkReference(Address refaddr)
          Check that a reference encountered during scanning is valid.
private static void ScanBootImage.checkReference(Address refaddr)
          Check that a reference encountered during scanning is valid.
private  void ScanThread.checkReference(Address refaddr, int verbosity)
          Check that a reference encountered during scanning is valid.
private static void ScanStatics.checkReference(Address refaddr, int slot)
          Check that a reference encountered during scanning is valid.
 Address ObjectModel.copyTo(ObjectReference from, ObjectReference to, Address region)
           
private static Offset ScanBootImage.decodeLongEncoding(Address cursor)
          Decode a 4-byte encoding, taking a pointer to the first byte of the encoding, and returning the encoded value as an Offset
 void Memory.dumpMemory(Address start, int beforeBytes, int afterBytes)
           
private  void ScanThread.dumpRef(Address refaddr, int verbosity)
          Print out information associated with a reference.
 int Memory.dzmmap(Address start, int size)
           
 ObjectReference ObjectModel.getObjectFromStartAddress(Address start)
           
 ObjectReference ObjectModel.getReferenceWhenCopiedTo(ObjectReference from, Address to)
           
private static boolean ScanBootImage.isAddressAligned(Address address)
          Return true if the given address is address-aligned
 boolean Memory.mprotect(Address start, int size)
           
 boolean Memory.munprotect(Address start, int size)
           
 void Barriers.objectReferenceNonHeapWrite(Address slot, ObjectReference target, Word unusedA, Word unusedB)
          Perform the actual write of the non-heap write barrier.
private static void ScanBootImage.processChunk(Address chunkStart, Address imageStart, Address mapStart, Address mapEnd, TraceLocal trace)
          Process a chunk of encoded reference data, enqueuing each reference (optionally filtering them on whether they point outside the boot image).
private  void ScanThread.processCodeLocation(ObjectReference code, Address ipLoc)
          Push a code pointer location onto the code locations deque, optionally performing a sanity check first.
private static void ScanThread.reportDelayedRootEdge(TraceLocal trace, Address addr)
          Wrapper for TraceLocal.reportDelayedRootEdge(Address) that allows sanity checking of the address.
private static void ScanThread.scanThread(RVMThread thread, TraceLocal trace, boolean processCodeLocations, Address gprs, Address topFrame)
          A more general interface to thread scanning, which permits the scanning of stack segments which are dislocated from the thread structure.
private  void ScanThread.scanThreadInternal(Address gprs, int verbosity)
          The main stack scanning loop.
 void Memory.setHeapRange(int id, Address start, Address end)
           
private  void ScanThread.startScan(TraceLocal trace, boolean processCodeLocations, RVMThread thread, Address gprs, Address ip, Address fp, Address initialIPLoc, Address topFrame)
          Initializes a ScanThread instance, and then scans a stack associated with a thread, and places references in deques (one for object pointers, one for interior code pointers).
 void MMTk_Events.tracePageAcquired(Space space, Address startAddress, int numPages)
           
 void MMTk_Events.tracePageReleased(Space space, Address startAddress, int numPages)
           
 void Memory.zero(boolean useNT, Address start, Extent len)
           
 

Uses of Address in org.jikesrvm.mm.mmtk.gcspy
 

Methods in org.jikesrvm.mm.mmtk.gcspy that return Address
 Address ServerSpace.addStream(int streamId)
           
 Address Util.formatSize(String format, int bufsize, int size)
           
 Address Util.getBytes(String str)
          Convert a String to a 0-terminated array of bytes WARNING: we call out to String.length and String.charAt, both of which are interruptible.
 Address Util.malloc(int size)
           
 

Methods in org.jikesrvm.mm.mmtk.gcspy with parameters of type Address
 void Util.formatSize(Address buffer, int size)
           
 void Util.free(Address addr)
           
 void ServerSpace.setTilename(int i, Address start, Address end)
          Tell the native driver the tile name.
 void ServerSpace.setTilename(int i, Address format, long value)
           
 void ServerSpace.spaceInfo(Address info)
           
 int Util.sprintf(Address str, Address format, Address value)
           
 

Uses of Address in org.jikesrvm.objectmodel
 

Methods in org.jikesrvm.objectmodel that return Address
static Address ObjectModel.allocateArray(BootImageInterface bootImage, RVMArray array, int numElements, boolean needsIdentityHash, int identityHashValue, int alignCode)
          Allocate and initialize space in the bootimage (at bootimage writing time) to be an uninitialized instance of the (array) type specified by array.
static Address ObjectModel.allocateArray(BootImageInterface bootImage, RVMArray array, int numElements, boolean needsIdentityHash, int identityHashValue, int align, int alignCode)
          Allocate and initialize space in the bootimage (at bootimage writing time) to be an uninitialized instance of the (array) type specified by array.
static Address ObjectModel.allocateCode(BootImageInterface bootImage, RVMArray array, int numElements)
          Allocate and initialize space in the bootimage (at bootimage writing time) to be an uninitialized instance of the (array) type specified by array.
 Address BootImageInterface.allocateCodeStorage(int size, int align, int offset)
          Allocate space in code portion of bootimage.
 Address BootImageInterface.allocateDataStorage(int size, int align, int offset)
          Allocate space in data portion of bootimage.
static Address ObjectModel.allocateScalar(BootImageInterface bootImage, RVMClass klass, boolean needsIdentityHash, int identityHashValue)
          Allocate and initialize space in the bootimage (at bootimage writing time) to be an uninitialized instance of the (scalar) type specified by klass.
static Address MiscHeader.getBootImageLink()
           
static Address ObjectModel.getObjectEndAddress(Object obj)
          Get the pointer just past an object
static Address ObjectModel.getObjectEndAddress(Object object, RVMArray type, int elements)
          Get the pointer just past an object
static Address JavaHeader.getObjectEndAddress(Object obj, RVMArray type, int numElements)
          What is the first word after the array?
static Address ObjectModel.getObjectEndAddress(Object object, RVMClass type)
          Get the pointer just past an object
static Address JavaHeader.getObjectEndAddress(Object obj, RVMClass type)
          What is the first word after the class?
static Address ObjectModel.getPointerInMemoryRegion(ObjectReference ref)
          Given a reference, return an address which is guaranteed to be inside the memory region allocated to the object.
static Address JavaHeader.getPointerInMemoryRegion(ObjectReference ref)
          Given a reference, return an address which is guaranteed to be inside the memory region allocated to the object.
static Address JavaHeader.initializeArrayHeader(BootImageInterface bootImage, Address ptr, TIB tib, int size, int numElements, boolean needsIdentityHash, int identityHashValue)
          Perform any required initialization of the JAVA portion of the header.
static Address JavaHeader.initializeScalarHeader(BootImageInterface bootImage, Address ptr, TIB tib, int size, boolean needsIdentityHash, int identityHashValue)
          Perform any required initialization of the JAVA portion of the header.
static Address ObjectModel.maximumObjectRef(Address regionHighAddr)
          Given the largest base address in a region, return the largest object reference that could refer to an object in the region.
static Address JavaHeader.maximumObjectRef(Address regionHighAddr)
          Given the largest base address in a region, return the largest object reference that could refer to an object in the region.
static Address ObjectModel.minimumObjectRef(Address regionBaseAddr)
          Given the smallest base address in a region, return the smallest object reference that could refer to an object in the region.
static Address JavaHeader.minimumObjectRef(Address regionBaseAddr)
          Given the smallest base address in a region, return the smallest object reference that could refer to an object in the region.
static Address ObjectModel.objectStartRef(ObjectReference obj)
          Map from the object ref to the lowest address of the storage associated with the object
static Address JavaHeader.objectStartRef(ObjectReference obj)
          Map from the object ref to the lowest address of the storage associated with the object
 

Methods in org.jikesrvm.objectmodel with parameters of type Address
static void ObjectModel.fillAlignmentGap(BootImageInterface bootImage, Address address, Extent size)
          Fill an alignment gap with the alignment value
static ObjectReference ObjectModel.getArrayFromStartAddress(Address start)
          Get an object reference from the address the lowest word of the object was allocated.
static ObjectReference JavaHeader.getArrayFromStartAddress(Address start)
          Get an object reference from the address the lowest word of the object was allocated.
static ObjectReference ObjectModel.getObjectFromStartAddress(Address start)
          Get an object reference from the address the lowest word of the object was allocated.
static ObjectReference JavaHeader.getObjectFromStartAddress(Address start)
          Get an object reference from the address the lowest word of the object was allocated.
static Object ObjectModel.getReferenceWhenCopiedTo(Object obj, Address to)
          how many bytes are used by the object?
protected static Object JavaHeader.getReferenceWhenCopiedTo(Object obj, Address to)
           
static Object ObjectModel.getReferenceWhenCopiedTo(Object obj, Address region, RVMArray type)
          Get the reference of an object after copying to a specified region.
static Object JavaHeader.getReferenceWhenCopiedTo(Object obj, Address to, RVMArray type)
          Get the reference of an array when copied to the specified region.
static Object ObjectModel.getReferenceWhenCopiedTo(Object obj, Address region, RVMClass type)
          Get the reference of an object after copying to a specified region.
static Object JavaHeader.getReferenceWhenCopiedTo(Object obj, Address to, RVMClass type)
          Get the reference of a scalar when copied to the specified region.
static ObjectReference ObjectModel.getScalarFromStartAddress(Address start)
          Get an object reference from the address the lowest word of the object was allocated.
static ObjectReference JavaHeader.getScalarFromStartAddress(Address start)
          Get an object reference from the address the lowest word of the object was allocated.
static Object ObjectModel.initializeArray(Address ptr, TIB tib, int numElems, int size)
          Initialize raw storage with low memory word ptr of size bytes to be an uninitialized instance of the array type specific by tib with numElems elements.
static Object JavaHeader.initializeArrayHeader(Address ptr, TIB tib, int size)
          Perform any required initialization of the JAVA portion of the header.
static Address JavaHeader.initializeArrayHeader(BootImageInterface bootImage, Address ptr, TIB tib, int size, int numElements, boolean needsIdentityHash, int identityHashValue)
          Perform any required initialization of the JAVA portion of the header.
static void MiscHeader.initializeHeader(BootImageInterface bootImage, Address ref, TIB tib, int size, boolean isScalar)
          Perform any required initialization of the MISC portion of the header.
static Object ObjectModel.initializeScalar(Address ptr, TIB tib, int size)
          Initialize raw storage with low memory word ptr of size bytes to be an uninitialized instance of the (scalar) type specified by tib.
static Object JavaHeader.initializeScalarHeader(Address ptr, TIB tib, int size)
          Perform any required initialization of the JAVA portion of the header.
static Address JavaHeader.initializeScalarHeader(BootImageInterface bootImage, Address ptr, TIB tib, int size, boolean needsIdentityHash, int identityHashValue)
          Perform any required initialization of the JAVA portion of the header.
static Address ObjectModel.maximumObjectRef(Address regionHighAddr)
          Given the largest base address in a region, return the largest object reference that could refer to an object in the region.
static Address JavaHeader.maximumObjectRef(Address regionHighAddr)
          Given the largest base address in a region, return the largest object reference that could refer to an object in the region.
static Address ObjectModel.minimumObjectRef(Address regionBaseAddr)
          Given the smallest base address in a region, return the smallest object reference that could refer to an object in the region.
static Address JavaHeader.minimumObjectRef(Address regionBaseAddr)
          Given the smallest base address in a region, return the smallest object reference that could refer to an object in the region.
static Object ObjectModel.moveObject(Address toAddress, Object fromObj, int numBytes, RVMArray type)
          Copy an array object to the given raw storage address
static Object JavaHeader.moveObject(Address toAddress, Object fromObj, int numBytes, RVMArray type)
          Copy an array to the given raw storage address
static Object ObjectModel.moveObject(Address toAddress, Object fromObj, int numBytes, RVMClass type)
          Copy a scalar object to the given raw storage address
static Object JavaHeader.moveObject(Address toAddress, Object fromObj, int numBytes, RVMClass type)
          Copy a scalar to the given raw storage address
static Object JavaHeader.moveObject(Address toAddress, Object fromObj, Object toObj, int numBytes)
          Copy an object to the given raw storage address
 void BootImageInterface.setAddressWord(Address offset, Word value, boolean objField, boolean root)
          Fill in 4/8 bytes of bootimage, as object reference.
 void BootImageInterface.setByte(Address offset, int value)
          Fill in 1 byte of bootimage.
 void BootImageInterface.setDoubleWord(Address offset, long value)
          Fill in 8 bytes of bootimage.
 void BootImageInterface.setFullWord(Address offset, int value)
          Fill in 4 bytes of bootimage, as numeric.
 void BootImageInterface.setHalfWord(Address offset, int value)
          Fill in 2 bytes of bootimage.
 void BootImageInterface.setNullAddressWord(Address offset, boolean objField, boolean root)
          Fill in 4 bytes of bootimage, as null object reference.
static void ObjectModel.setTIB(BootImageInterface bootImage, Address refAddress, Address tibAddr, RVMType type)
          Set the TIB for an object.
static void JavaHeader.setTIB(BootImageInterface bootImage, Address refOffset, Address tibAddr, RVMType type)
          Set the TIB for an object.
static void JavaHeader.writeAvailableByte(BootImageInterface bootImage, Address ref, byte val)
          Non-atomic write of word containing available bits
 

Uses of Address in org.jikesrvm.osr.ia32
 

Fields in org.jikesrvm.osr.ia32 declared as Address
(package private)  Address TempRegisters.ip
           
 

Uses of Address in org.jikesrvm.runtime
 

Fields in org.jikesrvm.runtime declared as Address
 Address BootRecord.bootImageCodeEnd
           
 Address BootRecord.bootImageCodeStart
           
 Address BootRecord.bootImageDataEnd
           
 Address BootRecord.bootImageDataStart
          address at which image is to be loaded into memory
 Address BootRecord.bootImageRMapEnd
           
 Address BootRecord.bootImageRMapStart
           
private  Address StackBrowser.currentFramePointer
          The frame pointer for the current stack location
 Address BootRecord.gcspyDriverAddStreamIP
           
 Address BootRecord.gcspyDriverEndOutputIP
           
 Address BootRecord.gcspyDriverInitIP
           
 Address BootRecord.gcspyDriverInitOutputIP
           
 Address BootRecord.gcspyDriverResizeIP
           
 Address BootRecord.gcspyDriverSetTileNameIP
           
 Address BootRecord.gcspyDriverSetTileNameRangeIP
           
 Address BootRecord.gcspyDriverSpaceInfoIP
           
 Address BootRecord.gcspyDriverStartCommIP
           
 Address BootRecord.gcspyDriverStreamByteValueIP
           
 Address BootRecord.gcspyDriverStreamIntValueIP
           
 Address BootRecord.gcspyDriverStreamIP
           
 Address BootRecord.gcspyDriverStreamShortValueIP
           
 Address BootRecord.gcspyDriverSummaryIP
           
 Address BootRecord.gcspyDriverSummaryValueIP
           
 Address BootRecord.gcspyFormatSizeIP
           
 Address BootRecord.gcspyIntWriteControlIP
           
 Address BootRecord.gcspyMainServerAddDriverIP
           
 Address BootRecord.gcspyMainServerAddEventIP
           
 Address BootRecord.gcspyMainServerInitIP
           
 Address BootRecord.gcspyMainServerIsConnectedIP
           
 Address BootRecord.gcspyMainServerOuterLoopIP
           
 Address BootRecord.gcspyMainServerSafepointIP
           
 Address BootRecord.gcspyMainServerSetGeneralInfoIP
           
 Address BootRecord.gcspyMainServerStartCompensationTimerIP
           
 Address BootRecord.gcspyMainServerStopCompensationTimerIP
           
 Address BootRecord.gcspySprintfIP
           
 Address BootRecord.gcspyStartserverIP
           
 Address BootRecord.gcspyStreamInitIP
           
 Address BootRecord.ipRegister
           
private  Address DynamicLibrary.jniOnLoad
          Address of JNI_OnLoad method
private  Address DynamicLibrary.jniOnUnload
          Address of JNI_OnUnLoad
private  Address DynamicLibrary.libHandler
          Value returned from dlopen
 Address BootRecord.spRegister
           
 Address BootRecord.sysAccessIP
           
 Address BootRecord.sysArgIP
           
 Address BootRecord.sysBytesAvailableIP
           
 Address BootRecord.sysCallocIP
           
 Address BootRecord.sysConsoleWriteCharIP
           
 Address BootRecord.sysConsoleWriteDoubleIP
           
 Address BootRecord.sysConsoleWriteIntegerIP
           
 Address BootRecord.sysConsoleWriteLongIP
           
 Address BootRecord.sysCopyIP
           
 Address BootRecord.sysCreateThreadSpecificDataKeysIP
           
(package private)  Address BootRecord.sysCurrentTimeMillisIP
           
 Address BootRecord.sysDisableAlignmentCheckingIP
           
(package private)  Address BootRecord.sysDlopenIP
           
(package private)  Address BootRecord.sysDlsymIP
           
 Address BootRecord.sysDoubleRemainderIP
           
 Address BootRecord.sysDoubleToIntIP
           
 Address BootRecord.sysDoubleToLongIP
           
 Address BootRecord.sysEnableAlignmentCheckingIP
           
 Address BootRecord.sysExitIP
           
 Address BootRecord.sysFloatToIntIP
           
 Address BootRecord.sysFloatToLongIP
           
 Address BootRecord.sysFreeIP
           
 Address BootRecord.sysGetenvIP
           
 Address BootRecord.sysGetPageSizeIP
           
 Address BootRecord.sysGetThreadIdIP
           
 Address BootRecord.sysJavaVM
          address of JavaVM, used by JNI_OnLoad and JNIEnv.GetJavaVM, defined in Sys.C
 Address BootRecord.sysLongDivideIP
           
 Address BootRecord.sysLongRemainderIP
           
 Address BootRecord.sysLongToDoubleIP
           
 Address BootRecord.sysLongToFloatIP
           
 Address BootRecord.sysMallocIP
           
 Address BootRecord.sysMMapErrnoIP
           
 Address BootRecord.sysMMapIP
           
 Address BootRecord.sysMonitorBroadcastIP
           
 Address BootRecord.sysMonitorCreateIP
           
 Address BootRecord.sysMonitorDestroyIP
           
 Address BootRecord.sysMonitorEnterIP
           
 Address BootRecord.sysMonitorExitIP
           
 Address BootRecord.sysMonitorTimedWaitAbsoluteIP
           
 Address BootRecord.sysMonitorWaitIP
           
 Address BootRecord.sysMProtectIP
           
(package private)  Address BootRecord.sysNanoSleepIP
           
(package private)  Address BootRecord.sysNanoTimeIP
           
 Address BootRecord.sysNumProcessorsIP
           
 Address BootRecord.sysParseMemorySizeIP
           
 Address BootRecord.sysPerfEventCreateIP
           
 Address BootRecord.sysPerfEventDisableIP
           
 Address BootRecord.sysPerfEventEnableIP
           
 Address BootRecord.sysPerfEventInitIP
           
 Address BootRecord.sysPerfEventReadIP
           
 Address BootRecord.sysPrimitiveParseFloatIP
           
 Address BootRecord.sysPrimitiveParseIntIP
           
 Address BootRecord.sysReadByteIP
           
 Address BootRecord.sysReadBytesIP
           
 Address BootRecord.sysReportAlignmentCheckingIP
           
 Address BootRecord.sysSetFdCloseOnExecIP
           
 Address BootRecord.sysSetupHardwareTrapHandlerIP
           
 Address BootRecord.sysStashVMThreadIP
           
 Address BootRecord.sysStatIP
           
 Address BootRecord.sysSyncCacheIP
           
 Address BootRecord.sysSyncFileIP
           
 Address BootRecord.sysThreadBindIP
           
 Address BootRecord.sysThreadBindSupportedIP
           
 Address BootRecord.sysThreadCreateIP
           
 Address BootRecord.sysThreadTerminateIP
           
 Address BootRecord.sysThreadYieldIP
           
 Address BootRecord.sysVMMathAcosIP
           
 Address BootRecord.sysVMMathAsinIP
           
 Address BootRecord.sysVMMathAtan2IP
           
 Address BootRecord.sysVMMathAtanIP
           
 Address BootRecord.sysVMMathCbrtIP
           
 Address BootRecord.sysVMMathCeilIP
           
 Address BootRecord.sysVMMathCoshIP
           
 Address BootRecord.sysVMMathCosIP
           
 Address BootRecord.sysVMMathExpIP
           
 Address BootRecord.sysVMMathExpm1IP
           
 Address BootRecord.sysVMMathFloorIP
           
 Address BootRecord.sysVMMathHypotIP
           
 Address BootRecord.sysVMMathIEEEremainderIP
           
 Address BootRecord.sysVMMathLog10IP
           
 Address BootRecord.sysVMMathLog1pIP
           
 Address BootRecord.sysVMMathLogIP
           
 Address BootRecord.sysVMMathPowIP
           
 Address BootRecord.sysVMMathRintIP
           
 Address BootRecord.sysVMMathSinhIP
           
 Address BootRecord.sysVMMathSinIP
           
 Address BootRecord.sysVMMathSqrtIP
           
 Address BootRecord.sysVMMathTanhIP
           
 Address BootRecord.sysVMMathTanIP
           
 Address BootRecord.sysWriteByteIP
           
 Address BootRecord.sysWriteBytesIP
           
 Address BootRecord.sysZeroIP
           
 Address BootRecord.sysZeroNTIP
           
 Address BootRecord.sysZeroPagesIP
           
 Address BootRecord.tocRegister
           
 

Methods in org.jikesrvm.runtime that return Address
static Address Memory.alignDown(Address address, int alignment)
           
static Address Memory.alignUp(Address address, int alignment)
           
static Address Memory.dzmmap(Address address, Extent size)
          Do mmap demand zero fixed address memory mapping call
abstract  Address SysCall.gcspyDriverAddStream(Address driver, int id)
           
abstract  Address SysCall.gcspyMainServerAddDriver(Address addr)
           
abstract  Address SysCall.gcspyMainServerInit(int port, int len, Address name, int verbose)
           
abstract  Address SysCall.gcspyMainServerOuterLoop()
           
static Address Magic.getAddressAtOffset(Object object, Offset offset)
          Get Address at arbitrary (byte) offset from object.
static Address Magic.getAddressAtOffset(Object object, Offset offset, int locationMetadata)
          Get Address at arbitrary (byte) offset from object.
static Address Magic.getCallerFramePointer(Address fp)
          Get fp for parent frame
static Address Magic.getFramePointer()
          Get contents of "stack frame pointer" register.
private  Address DynamicLibrary.getJNI_OnLoad()
          Get the unique JNI_OnLoad symbol associated with this library
private  Address DynamicLibrary.getJNI_OnUnload()
          Get the unique JNI_OnUnload symbol associated with this library
static Address Magic.getJTOC()
          Get contents of "JTOC" register
static Address Magic.getNextInstructionAddress(Address fp)
          Get next instruction address for a frame
static Address Magic.getReturnAddress(Address fp)
          Get return address for a frame in the current thread
static Address Magic.getReturnAddress(Address fp, RVMThread thread)
          Get return address for a frame in a specific thread
static Address Magic.getReturnAddressLocation(Address fp)
          Get location containing return address for a frame
static Address Magic.getReturnAddressUnchecked(Address fp)
          Get return address for a frame in a case where the frame is known not to be a trampoline frame.
static Address Statics.getSlotContentsAsAddress(Offset offset)
          Fetch contents of a slot, as an Address.
static Address Statics.getSlots()
          Fetch JTOC object (for JNI environment and GC).
 Address DynamicLibrary.getSymbol(String symbolName)
          look up this dynamic library for a symbol
static Address Magic.getTocPointer()
          Get contents of "JTOC" register.
static Address Memory.mmap(Address address, Extent size, int prot, int flags)
          Do generic mmap non-file memory mapping call
<T> Address
ObjectAddressRemapper.objectAsAddress(T object)
          Map an object to an address.
static
<T> Address
Magic.objectAsAddress(T object)
          Cast bits.
static Address Magic.prepareAddress(Object object, Offset offset)
          Get contents of (object + offset) and begin conditional critical section.
static Address DynamicLibrary.resolveSymbol(String symbol)
          Resolve a symbol to an address in a currently loaded dynamic library.
abstract  Address SysCall.sysCalloc(int length)
           
abstract  Address SysCall.sysDlopen(byte[] libname)
           
abstract  Address SysCall.sysDlsym(Address libHandler, byte[] symbolName)
           
abstract  Address SysCall.sysMalloc(int length)
           
abstract  Address SysCall.sysMMap(Address start, Extent length, int protection, int flags, int fd, Offset offset)
           
abstract  Address SysCall.sysMMapErrno(Address start, Extent length, int protection, int flags, int fd, Offset offset)
           
static Address RuntimeEntrypoints.unwindNativeStackFrame(Address currfp)
          Skip over all frames below currfp with saved code pointers outside of heap (C frames), stopping at the native frame immediately preceding the glue frame which contains the method ID of the native method (this is necessary to allow retrieving the return address of the glue frame).
static Address RuntimeEntrypoints.unwindNativeStackFrameForGC(Address currfp)
          The current frame is expected to be one of the JNI functions called from C, below which is one or more native stack frames.
static Address Reflection.unwrapObject(Object o)
           
 

Methods in org.jikesrvm.runtime with parameters of type Address
static byte[] Magic.addressAsByteArray(Address byte_array)
          Recast.
 Object ObjectAddressRemapper.addressAsObject(Address address)
          Map an address to an object.
static Object Magic.addressAsObject(Address address)
          Cast bits.
static TIB Magic.addressAsTIB(Address address)
          Cast bits.
static Address Memory.alignDown(Address address, int alignment)
           
static void Memory.aligned16Copy(Address dstPtr, Address srcPtr, int copyBytes)
          Low level copy of copyBytes bytes from src[srcPos] to dst[dstPos].
static void Memory.aligned32Copy(Address dst, Address src, int copyBytes)
          Copy copyBytes from src to dst.
static void Memory.aligned64Copy(Address dstPtr, Address srcPtr, int copyBytes)
          Low level copy of copyBytes bytes from src[srcPos] to dst[dstPos].
static void Memory.aligned8Copy(Address dstPtr, Address srcPtr, int copyBytes)
          Low level copy of copyBytes bytes from src[srcPos] to dst[dstPos].
static void Memory.alignedWordCopy(Address dst, Address src, int numBytes)
          Copy numbytes from src to dst.
static Address Memory.alignUp(Address address, int alignment)
           
static boolean Magic.attemptAddress(Object object, Offset offset, Address oldValue, Address newValue)
          Sets the memory at (object + offset) to newValue if its contents are oldValue.
private static void Memory.copy1Bytes(Address dstPtr, Address srcPtr)
           
private static void Memory.copy2Bytes(Address dstPtr, Address srcPtr)
           
private static void Memory.copy4Bytes(Address dstPtr, Address srcPtr)
           
private static void Memory.copy8Bytes(Address dstPtr, Address srcPtr)
           
abstract  void ExceptionDeliverer.deliverException(CompiledMethod compiledMethod, Address catchBlockInstructionAddress, Throwable exceptionObject, ArchitectureSpecific.Registers registers)
          Stackframe's method has a "catch" block for exception being thrown and control is to be passed to that catch block.
static void Memory.dumpMemory(Address start, int beforeBytes, int afterBytes)
           
static Address Memory.dzmmap(Address address, Extent size)
          Do mmap demand zero fixed address memory mapping call
abstract  Address SysCall.gcspyDriverAddStream(Address driver, int id)
           
abstract  void SysCall.gcspyDriverEndOutput(Address driver)
           
abstract  void SysCall.gcspyDriverInit(Address driver, int id, Address serverName, Address driverName, Address title, Address blockInfo, int tileNum, Address unused, int mainSpace)
           
abstract  void SysCall.gcspyDriverInitOutput(Address driver)
           
abstract  void SysCall.gcspyDriverResize(Address driver, int size)
           
abstract  void SysCall.gcspyDriverSetTileName(Address driver, int i, Address start, long value)
           
abstract  void SysCall.gcspyDriverSetTileNameRange(Address driver, int i, Address start, Address end)
           
abstract  void SysCall.gcspyDriverSpaceInfo(Address driver, Address info)
           
abstract  void SysCall.gcspyDriverStartComm(Address driver)
           
abstract  void SysCall.gcspyDriverStream(Address driver, int id, int len)
           
abstract  void SysCall.gcspyDriverStreamByteValue(Address driver, byte value)
           
abstract  void SysCall.gcspyDriverStreamIntValue(Address driver, int value)
           
abstract  void SysCall.gcspyDriverStreamShortValue(Address driver, short value)
           
abstract  void SysCall.gcspyDriverSummary(Address driver, int id, int len)
           
abstract  void SysCall.gcspyDriverSummaryValue(Address driver, int value)
           
abstract  void SysCall.gcspyFormatSize(Address buffer, int size)
           
abstract  void SysCall.gcspyIntWriteControl(Address driver, int id, int tileNum)
           
abstract  Address SysCall.gcspyMainServerAddDriver(Address addr)
           
abstract  void SysCall.gcspyMainServerAddEvent(Address server, int event, Address name)
           
abstract  Address SysCall.gcspyMainServerInit(int port, int len, Address name, int verbose)
           
abstract  int SysCall.gcspyMainServerIsConnected(Address server, int event)
           
abstract  void SysCall.gcspyMainServerSafepoint(Address server, int event)
           
abstract  void SysCall.gcspyMainServerSetGeneralInfo(Address server, Address info)
           
abstract  void SysCall.gcspyMainServerStartCompensationTimer(Address server)
           
abstract  void SysCall.gcspyMainServerStopCompensationTimer(Address server)
           
abstract  int SysCall.gcspySprintf(Address str, Address format, Address value)
           
abstract  void SysCall.gcspyStartserver(Address server, int wait, Address serverOuterLoop)
           
abstract  void SysCall.gcspyStreamInit(Address stream, int id, int dataType, Address name, int minValue, int maxValue, int zeroValue, int defaultValue, Address pre, Address post, int presentation, int paintStyle, int maxStreamIndex, int red, int green, int blue)
           
static Address Magic.getCallerFramePointer(Address fp)
          Get fp for parent frame
static int Magic.getCompiledMethodID(Address fp)
          Get Compiled Method ID for a frame
static Address Magic.getNextInstructionAddress(Address fp)
          Get next instruction address for a frame
static Address Magic.getReturnAddress(Address fp)
          Get return address for a frame in the current thread
static Address Magic.getReturnAddress(Address fp, RVMThread thread)
          Get return address for a frame in a specific thread
static Address Magic.getReturnAddressLocation(Address fp)
          Get location containing return address for a frame
static Address Magic.getReturnAddressUnchecked(Address fp)
          Get return address for a frame in a case where the frame is known not to be a trampoline frame.
private static void Memory.internalAlignedWordCopy(Address dst, Address src, int numBytes)
          Copy numbytes from src to dst.
static boolean Memory.isPageAligned(Address addr)
           
static void Memory.memcopy(Address dst, Address src, Extent cnt)
          Copy a region of memory.
static void Memory.memcopy(Address dst, Address src, int cnt)
           
static Address Memory.mmap(Address address, Extent size, int prot, int flags)
          Do generic mmap non-file memory mapping call
static boolean Memory.mprotect(Address address, Extent size, int prot)
          Do mprotect system call
static void Magic.returnToNewStack(Address fp)
          Return to caller of current method, resuming execution on a new stack that's a copy of the original.
private static int DynamicLibrary.runJNI_OnLoad(Address JNI_OnLoadAddress)
          Method call to run the onload method.
static void Magic.setAddressAtOffset(Object object, Offset offset, Address newvalue)
          Set Address at arbitrary (byte) offset from object.
static void Magic.setAddressAtOffset(Object object, Offset offset, Address newvalue, int locationMetadata)
          Set Address at arbitrary (byte) offset from object.
static void Magic.setCallerFramePointer(Address fp, Address newCallerFP)
          Set fp for parent frame
static void Magic.setCompiledMethodID(Address fp, int newCMID)
          Set the Compiled Method ID for a frame.
 void BootRecord.setHeapRange(int id, Address start, Address end)
           
static void Magic.setReturnAddress(Address fp, Address v)
          Get return address for a frame
static void Statics.setSlotContents(Offset offset, Address value)
          Set contents of a slot, as a Address
static void Memory.sync(Address address, int size)
          Synchronize a region of memory: force data in dcache to be written out to main memory so that it will be seen by icache when instructions are fetched back.
abstract  void SysCall.sysCopy(Address dst, Address src, Extent cnt)
           
abstract  Address SysCall.sysDlsym(Address libHandler, byte[] symbolName)
           
abstract  void SysCall.sysFree(Address location)
           
abstract  Address SysCall.sysMMap(Address start, Extent length, int protection, int flags, int fd, Offset offset)
           
abstract  Address SysCall.sysMMapErrno(Address start, Extent length, int protection, int flags, int fd, Offset offset)
           
abstract  int SysCall.sysMProtect(Address start, Extent length, int prot)
           
abstract  int SysCall.sysReadBytes(int fd, Address buf, int cnt)
           
abstract  void SysCall.sysSyncCache(Address address, int size)
           
abstract  Word SysCall.sysThreadCreate(Address tr, Address ip, Address fp)
          Create a native thread (aka "unix kernel thread", "pthread").
abstract  int SysCall.sysWriteBytes(int fd, Address buf, int cnt)
           
abstract  void SysCall.sysZero(Address dst, Extent cnt)
           
abstract  void SysCall.sysZeroNT(Address dst, Extent cnt)
           
abstract  void SysCall.sysZeroPages(Address dst, int cnt)
           
static Address RuntimeEntrypoints.unwindNativeStackFrame(Address currfp)
          Skip over all frames below currfp with saved code pointers outside of heap (C frames), stopping at the native frame immediately preceding the glue frame which contains the method ID of the native method (this is necessary to allow retrieving the return address of the glue frame).
static Address RuntimeEntrypoints.unwindNativeStackFrameForGC(Address currfp)
          The current frame is expected to be one of the JNI functions called from C, below which is one or more native stack frames.
static void Memory.zero(boolean useNT, Address start, Extent len)
          Zero a region of memory.
 

Uses of Address in org.jikesrvm.scheduler
 

Fields in org.jikesrvm.scheduler declared as Address
(package private)  Address RVMThread.framePointer
          FP for current frame, saved in the prologue of every method
private  Address RVMThread.hijackedReturnAddress
          Return address of stack frame hijacked by return barrier
private  Address RVMThread.hijackedReturnCalleeFp
          Callee frame pointer for stack frame hijacked by return barrier
private  Address RVMThread.hijackedReturnCallerFp
          Caller frame pointer for stack frame hijacked by return barrier
private static Address SpinLock.IN_FLUX
          For MCS locking, indicates that another processor is changing the state of the circular waiting queue.
 Address RVMThread.stackLimit
          The Address of the guard area for RVMThread.stack.
 

Methods in org.jikesrvm.scheduler that return Address
static Address Synchronization.fetchAndAddAddressWithBound(Object base, Offset offset, int increment, Address bound)
           
static Address Synchronization.fetchAndStoreAddress(Object base, Offset offset, Address newValue)
           
static Address Synchronization.fetchAndSubAddressWithBound(Object base, Offset offset, int decrement, Address bound)
           
static Address RVMThread.getHijackedReturnAddress(Address hijackedFp)
          Given a frame that has been hijacked by the stack trampoline, return the real (hijacked) return address.
 Address RVMThread.getHijackedReturnCalleeFp()
           
 Address RVMThread.getNextUnencounteredFrame()
           
private  Address RVMThread.getStackTrampolineBridgeIP()
           
 Address RVMThread.getTrampolineHijackedReturnAddress()
           
 

Methods in org.jikesrvm.scheduler with parameters of type Address
private static void RVMThread.adjustStack(byte[] stack, Address fp, Offset delta)
          A thread's stack has been moved or resized.
private static void RVMThread.dumpFrame(Address fp)
          Dump the specified frame in a format useful for debugging the stack trampoline
static void RVMThread.dumpStack(Address fp)
          Dump state of a (stopped) thread's stack.
static void RVMThread.dumpStack(Address ip, Address fp)
          Dump state of a (stopped) thread's stack.
static void RVMThread.dumpStackAndDie(Address fp)
          Dump state of a (stopped) thread's stack and exit the virtual machine.
static Address Synchronization.fetchAndAddAddressWithBound(Object base, Offset offset, int increment, Address bound)
           
static Address Synchronization.fetchAndStoreAddress(Object base, Offset offset, Address newValue)
           
static Address Synchronization.fetchAndSubAddressWithBound(Object base, Offset offset, int decrement, Address bound)
           
static Address RVMThread.getHijackedReturnAddress(Address hijackedFp)
          Given a frame that has been hijacked by the stack trampoline, return the real (hijacked) return address.
 void RVMThread.installStackTrampolineBridge(Address targetFp)
          Install the stack trampoline bridge at a given frame, hijacking that frame, saving the hijacked return address and callee fp in thread-local state to allow execution of the hijacked frame later.
private static boolean RVMThread.isAddressValidFramePointer(Address address)
          Return true if the supplied address could be a valid frame pointer.
static boolean RVMThread.isTrampolineIP(Address ip)
          Determine whether a given method is the stack trampoline
private static void RVMThread.showMethod(int compiledMethodId, Address fp)
          Show a method where getCompiledMethod returns null
private static void RVMThread.showMethod(RVMMethod method, int lineNumber, Address fp)
          Helper function for RVMThread.dumpStack(Address,Address).
private static void RVMThread.showMethod(String name, Address fp)
          Show a method that we can't show (ie just a text description of the stack frame
private static void RVMThread.showPrologue(Address fp)
           
static void RVMThread.trace(String who, String what, Address addr)
           
static boolean Synchronization.tryCompareAndSwap(Object base, Offset offset, Address testValue, Address newValue)
          Atomically swap test value to new value in the specified object and the specified field
static void RVMThread.yieldpoint(int whereFrom, Address yieldpointServiceMethodFP)
          Process a taken yieldpoint.
 

Uses of Address in org.jikesrvm.tools.header_gen
 

Methods in org.jikesrvm.tools.header_gen with parameters of type Address
(package private) static void GenerateInterfaceDeclarations.pln(String s, Address addr)
           
 

Uses of Address in org.jikesrvm.util
 

Fields in org.jikesrvm.util declared as Address
private  Address AddressInputStream.location
          Address of memory region to be read
 

Constructors in org.jikesrvm.util with parameters of type Address
AddressInputStream(Address location, Offset length)
          Constructor
 

Uses of Address in org.mmtk.plan
 

Methods in org.mmtk.plan that return Address
 Address MutatorContext.addressRead(ObjectReference src, Address slot, Word metaDataA, Word metaDataB, int mode)
          Read an Address.
 Address MutatorContext.alloc(int bytes, int align, int offset, int allocator, int site)
          Allocate memory for an object.
 Address CollectorContext.allocCopy(ObjectReference original, int bytes, int align, int offset, int allocator)
          Allocate space for copying an object (this method does not copy the object, it only allocates space)
 

Methods in org.mmtk.plan with parameters of type Address
 Address MutatorContext.addressRead(ObjectReference src, Address slot, Word metaDataA, Word metaDataB, int mode)
          Read an Address.
 boolean MutatorContext.addressTryCompareAndSwap(ObjectReference src, Address slot, Address old, Address value, Word metaDataA, Word metaDataB, int mode)
          Attempt to atomically exchange the value in the given slot with the passed replacement value.
 void MutatorContext.addressWrite(ObjectReference src, Address slot, Address value, Word metaDataA, Word metaDataB, int mode)
          Write an Address.
 boolean MutatorContext.booleanRead(ObjectReference src, Address slot, Word metaDataA, Word metaDataB, int mode)
          Read a boolean.
 void MutatorContext.booleanWrite(ObjectReference src, Address slot, boolean value, Word metaDataA, Word metaDataB, int mode)
          Write a boolean.
 byte MutatorContext.byteRead(ObjectReference src, Address slot, Word metaDataA, Word metaDataB, int mode)
          Read a byte.
 void MutatorContext.byteWrite(ObjectReference src, Address slot, byte value, Word metaDataA, Word metaDataB, int mode)
          Write a byte.
 char MutatorContext.charRead(ObjectReference src, Address slot, Word metaDataA, Word metaDataB, int mode)
          Read a char.
 void MutatorContext.charWrite(ObjectReference src, Address slot, char value, Word metaDataA, Word metaDataB, int mode)
          Write a char.
 double MutatorContext.doubleRead(ObjectReference src, Address slot, Word metaDataA, Word metaDataB, int mode)
          Read a double.
 void MutatorContext.doubleWrite(ObjectReference src, Address slot, double value, Word metaDataA, Word metaDataB, int mode)
          Write a double.
 Extent MutatorContext.extentRead(ObjectReference src, Address slot, Word metaDataA, Word metaDataB, int mode)
          Read an Extent.
 void MutatorContext.extentWrite(ObjectReference src, Address slot, Extent value, Word metaDataA, Word metaDataB, int mode)
          Write an Extent.
 float MutatorContext.floatRead(ObjectReference src, Address slot, Word metaDataA, Word metaDataB, int mode)
          Read a float.
 void MutatorContext.floatWrite(ObjectReference src, Address slot, float value, Word metaDataA, Word metaDataB, int mode)
          Write a float.
 int MutatorContext.intRead(ObjectReference src, Address slot, Word metaDataA, Word metaDataB, int mode)
          Read a int.
 boolean MutatorContext.intTryCompareAndSwap(ObjectReference src, Address slot, int old, int value, Word metaDataA, Word metaDataB, int mode)
          Attempt to atomically exchange the value in the given slot with the passed replacement value.
 void MutatorContext.intWrite(ObjectReference src, Address slot, int value, Word metaDataA, Word metaDataB, int mode)
          Write a int.
 ObjectReference Plan.loadObjectReference(Address slot)
          Load an object reference
 long MutatorContext.longRead(ObjectReference src, Address slot, Word metaDataA, Word metaDataB, int mode)
          Read a long.
 boolean MutatorContext.longTryCompareAndSwap(ObjectReference src, Address slot, long old, long value, Word metaDataA, Word metaDataB, int mode)
          Attempt to atomically exchange the value in the given slot with the passed replacement value.
 void MutatorContext.longWrite(ObjectReference src, Address slot, long value, Word metaDataA, Word metaDataB, int mode)
          Write a long.
 ObjectReference MutatorContext.objectReferenceNonHeapRead(Address slot, Word metaDataA, Word metaDataB)
          Read an object reference.
 void MutatorContext.objectReferenceNonHeapWrite(Address slot, ObjectReference tgt, Word metaDataA, Word metaDataB)
          A new reference is about to be created in a location that is not a regular heap object.
 ObjectReference MutatorContext.objectReferenceRead(ObjectReference src, Address slot, Word metaDataA, Word metaDataB, int mode)
          Read an object reference.
 boolean MutatorContext.objectReferenceTryCompareAndSwap(ObjectReference src, Address slot, ObjectReference old, ObjectReference tgt, Word metaDataA, Word metaDataB, int mode)
          Attempt to atomically exchange the value in the given slot with the passed replacement value.
 void MutatorContext.objectReferenceWrite(ObjectReference src, Address slot, ObjectReference value, Word metaDataA, Word metaDataB, int mode)
          Write an object reference.
 Offset MutatorContext.offsetRead(ObjectReference src, Address slot, Word metaDataA, Word metaDataB, int mode)
          Read an Offset.
 void MutatorContext.offsetWrite(ObjectReference src, Address slot, Offset value, Word metaDataA, Word metaDataB, int mode)
          Write an Offset.
 void TraceLocal.processEdge(ObjectReference source, Address slot)
          Trace a reference during GC.
 void TransitiveClosure.processEdge(ObjectReference source, Address slot)
          Trace an edge during GC.
 void TraceLocal.processInteriorEdge(ObjectReference target, Address slot, boolean root)
          Trace a reference during GC.
 void TraceLocal.processRootEdge(Address slot, boolean untraced)
          Trace a reference during GC.
 void TraceLocal.reportDelayedRootEdge(Address slot)
          Report a root edge to be processed during GC.
 short MutatorContext.shortRead(ObjectReference src, Address slot, Word metaDataA, Word metaDataB, int mode)
          Read a short.
 void MutatorContext.shortWrite(ObjectReference src, Address slot, short value, Word metaDataA, Word metaDataB, int mode)
          Write a short.
 void Plan.storeObjectReference(Address slot, ObjectReference value)
          Store an object reference
 Word MutatorContext.wordRead(ObjectReference src, Address slot, Word metaDataA, Word metaDataB, int mode)
          Read a Word.
 boolean MutatorContext.wordTryCompareAndSwap(ObjectReference src, Address slot, Word old, Word value, Word metaDataA, Word metaDataB, int mode)
          Attempt to atomically exchange the value in the given slot with the passed replacement value.
 void MutatorContext.wordWrite(ObjectReference src, Address slot, Word value, Word metaDataA, Word metaDataB, int mode)
          Write a Word.
 

Uses of Address in org.mmtk.plan.concurrent
 

Methods in org.mmtk.plan.concurrent with parameters of type Address
 boolean ConcurrentMutator.objectReferenceTryCompareAndSwap(ObjectReference src, Address slot, ObjectReference old, ObjectReference tgt, Word metaDataA, Word metaDataB, int mode)
           
 void ConcurrentMutator.objectReferenceWrite(ObjectReference src, Address slot, ObjectReference tgt, Word metaDataA, Word metaDataB, int mode)
          Write an object reference.
 

Uses of Address in org.mmtk.plan.concurrent.marksweep
 

Methods in org.mmtk.plan.concurrent.marksweep that return Address
 Address CMSMutator.alloc(int bytes, int align, int offset, int allocator, int site)
          Allocate memory for an object.
 

Uses of Address in org.mmtk.plan.copyms
 

Methods in org.mmtk.plan.copyms that return Address
 Address CopyMSMutator.alloc(int bytes, int align, int offset, int allocator, int site)
          Allocate memory for an object.
 Address CopyMSCollector.allocCopy(ObjectReference original, int bytes, int align, int offset, int allocator)
          Allocate space for copying an object (this method does not copy the object, it only allocates space)
 

Uses of Address in org.mmtk.plan.generational
 

Fields in org.mmtk.plan.generational declared as Address
private static Address Gen.NURSERY_START
           
 

Methods in org.mmtk.plan.generational that return Address
 Address GenMutator.alloc(int bytes, int align, int offset, int allocator, int site)
          Allocate memory for an object.
 

Methods in org.mmtk.plan.generational with parameters of type Address
private  void GenMutator.fastPath(Address slot, ObjectReference tgt)
          Perform the root write barrier fast path, which may involve remembering a reference if necessary.
private  void GenMutator.fastPath(ObjectReference src, Address slot, ObjectReference tgt, int mode)
          Perform the write barrier fast path, which may involve remembering a reference if necessary.
(package private) static boolean Gen.inNursery(Address addr)
          Return true if the address resides within the nursery
 void GenMutator.objectReferenceNonHeapWrite(Address slot, ObjectReference tgt, Word metaDataA, Word metaDataB)
          A new reference is about to be created in a location that is not a regular heap object.
 boolean GenMutator.objectReferenceTryCompareAndSwap(ObjectReference src, Address slot, ObjectReference old, ObjectReference tgt, Word metaDataA, Word metaDataB, int mode)
          Attempt to atomically exchange the value in the given slot with the passed replacement value.
 void GenMutator.objectReferenceWrite(ObjectReference src, Address slot, ObjectReference tgt, Word metaDataA, Word metaDataB, int mode)
          Write an object reference.
 

Uses of Address in org.mmtk.plan.generational.copying
 

Methods in org.mmtk.plan.generational.copying that return Address
 Address GenCopyMutator.alloc(int bytes, int align, int offset, int allocator, int site)
          Allocate memory for an object.
 Address GenCopyCollector.allocCopy(ObjectReference original, int bytes, int align, int offset, int allocator)
          Allocate space for copying an object (this method does not copy the object, it only allocates space)
 

Uses of Address in org.mmtk.plan.generational.immix
 

Methods in org.mmtk.plan.generational.immix that return Address
 Address GenImmixMutator.alloc(int bytes, int align, int offset, int allocator, int site)
          Allocate memory for an object.
 Address GenImmixCollector.allocCopy(ObjectReference original, int bytes, int align, int offset, int allocator)
          Allocate space for copying an object (this method does not copy the object, it only allocates space)
 

Uses of Address in org.mmtk.plan.generational.marksweep
 

Methods in org.mmtk.plan.generational.marksweep that return Address
 Address GenMSMutator.alloc(int bytes, int align, int offset, int allocator, int site)
          Allocate memory for an object.
 Address GenMSCollector.allocCopy(ObjectReference original, int bytes, int align, int offset, int allocator)
          Allocate space for copying an object (this method does not copy the object, it only allocates space)
 

Uses of Address in org.mmtk.plan.immix
 

Methods in org.mmtk.plan.immix that return Address
 Address ImmixMutator.alloc(int bytes, int align, int offset, int allocator, int site)
          Allocate memory for an object.
 Address ImmixCollector.allocCopy(ObjectReference original, int bytes, int align, int offset, int allocator)
          Allocate space for copying an object (this method does not copy the object, it only allocates space)
 

Uses of Address in org.mmtk.plan.markcompact
 

Methods in org.mmtk.plan.markcompact that return Address
 Address MCMutator.alloc(int bytes, int align, int offset, int allocator, int site)
          Allocate memory for an object.
 

Uses of Address in org.mmtk.plan.marksweep
 

Methods in org.mmtk.plan.marksweep that return Address
 Address MSMutator.alloc(int bytes, int align, int offset, int allocator, int site)
          Allocate memory for an object.
 

Uses of Address in org.mmtk.plan.nogc
 

Methods in org.mmtk.plan.nogc that return Address
 Address NoGCMutator.alloc(int bytes, int align, int offset, int allocator, int site)
          Allocate memory for an object.
 

Uses of Address in org.mmtk.plan.poisoned
 

Methods in org.mmtk.plan.poisoned with parameters of type Address
 ObjectReference Poisoned.loadObjectReference(Address slot)
           
 ObjectReference PoisonedMutator.objectReferenceRead(ObjectReference src, Address slot, Word metaDataA, Word metaDataB, int mode)
           
 boolean PoisonedMutator.objectReferenceTryCompareAndSwap(ObjectReference src, Address slot, ObjectReference old, ObjectReference tgt, Word metaDataA, Word metaDataB, int mode)
           
 void PoisonedMutator.objectReferenceWrite(ObjectReference src, Address slot, ObjectReference tgt, Word metaDataA, Word metaDataB, int mode)
          Write an object reference.
 void Poisoned.storeObjectReference(Address slot, ObjectReference value)
          Store an object reference
 

Uses of Address in org.mmtk.plan.refcount
 

Methods in org.mmtk.plan.refcount that return Address
 Address RCBaseMutator.alloc(int bytes, int align, int offset, int allocator, int site)
          Allocate memory for an object.
 

Methods in org.mmtk.plan.refcount with parameters of type Address
 boolean RCBaseMutator.objectReferenceTryCompareAndSwap(ObjectReference src, Address slot, ObjectReference old, ObjectReference tgt, Word metaDataA, Word metaDataB, int mode)
           
 void RCBaseMutator.objectReferenceWrite(ObjectReference src, Address slot, ObjectReference tgt, Word metaDataA, Word metaDataB, int mode)
          Write an object reference.
 void RCZero.processEdge(ObjectReference source, Address slot)
           
 

Uses of Address in org.mmtk.plan.refcount.fullheap
 

Methods in org.mmtk.plan.refcount.fullheap with parameters of type Address
 void RCModifiedProcessor.processEdge(ObjectReference source, Address slot)
           
 

Uses of Address in org.mmtk.plan.refcount.generational
 

Methods in org.mmtk.plan.refcount.generational that return Address
 Address GenRCMutator.alloc(int bytes, int align, int offset, int allocator, int site)
          Allocate memory for an object.
 Address GenRCCollector.allocCopy(ObjectReference original, int bytes, int align, int offset, int allocator)
          Allocate space for copying an object (this method does not copy the object, it only allocates space)
 

Methods in org.mmtk.plan.refcount.generational with parameters of type Address
 void GenRCModifiedProcessor.processEdge(ObjectReference source, Address slot)
           
 

Uses of Address in org.mmtk.plan.semispace
 

Methods in org.mmtk.plan.semispace that return Address
 Address SSMutator.alloc(int bytes, int align, int offset, int allocator, int site)
          Allocate memory for an object.
 Address SSCollector.allocCopy(ObjectReference original, int bytes, int align, int offset, int allocator)
          Allocate space for copying an object (this method does not copy the object, it only allocates space)
 

Uses of Address in org.mmtk.plan.semispace.gcspy
 

Methods in org.mmtk.plan.semispace.gcspy that return Address
 Address SSGCspyMutator.alloc(int bytes, int align, int offset, int allocator, int site)
          Allocate memory for an object.
 

Methods in org.mmtk.plan.semispace.gcspy with parameters of type Address
protected  void SSGCspyCollector.checkAllDriversForRootAddress(Address addr)
          Pass a root to all drivers.
 

Uses of Address in org.mmtk.plan.semispace.gctrace
 

Methods in org.mmtk.plan.semispace.gctrace with parameters of type Address
 boolean GCTraceMutator.objectReferenceTryCompareAndSwap(ObjectReference src, Address slot, ObjectReference old, ObjectReference tgt, Word metaDataA, Word metaDataB, int mode)
           
 void GCTraceMutator.objectReferenceWrite(ObjectReference src, Address slot, ObjectReference tgt, Word metaDataA, Word metaDataB, int mode)
          Write an object reference.
 

Uses of Address in org.mmtk.plan.semispace.usePrimitiveWriteBarriers
 

Methods in org.mmtk.plan.semispace.usePrimitiveWriteBarriers with parameters of type Address
 boolean UsePrimitiveWriteBarriersMutator.addressTryCompareAndSwap(ObjectReference src, Address slot, Address old, Address value, Word metaDataA, Word metaDataB, int mode)
          Attempt to atomically exchange the value in the given slot with the passed replacement value.
 void UsePrimitiveWriteBarriersMutator.addressWrite(ObjectReference src, Address slot, Address value, Word metaDataA, Word metaDataB, int mode)
          Write an Address.
 void UsePrimitiveWriteBarriersMutator.booleanWrite(ObjectReference src, Address slot, boolean value, Word metaDataA, Word metaDataB, int mode)
          Write a boolean.
 void UsePrimitiveWriteBarriersMutator.byteWrite(ObjectReference src, Address slot, byte value, Word metaDataA, Word metaDataB, int mode)
          Write a byte.
 void UsePrimitiveWriteBarriersMutator.charWrite(ObjectReference src, Address slot, char value, Word metaDataA, Word metaDataB, int mode)
          Write a char.
 void UsePrimitiveWriteBarriersMutator.doubleWrite(ObjectReference src, Address slot, double value, Word metaDataA, Word metaDataB, int mode)
          Write a double.
 void UsePrimitiveWriteBarriersMutator.extentWrite(ObjectReference src, Address slot, Extent value, Word metaDataA, Word metaDataB, int mode)
          Write an Extent.
 void UsePrimitiveWriteBarriersMutator.floatWrite(ObjectReference src, Address slot, float value, Word metaDataA, Word metaDataB, int mode)
          Write a float.
 boolean UsePrimitiveWriteBarriersMutator.intTryCompareAndSwap(ObjectReference src, Address slot, int old, int value, Word metaDataA, Word metaDataB, int mode)
           
 void UsePrimitiveWriteBarriersMutator.intWrite(ObjectReference src, Address slot, int value, Word metaDataA, Word metaDataB, int mode)
          Write a int.
 boolean UsePrimitiveWriteBarriersMutator.longTryCompareAndSwap(ObjectReference src, Address slot, long old, long value, Word metaDataA, Word metaDataB, int mode)
           
 void UsePrimitiveWriteBarriersMutator.longWrite(ObjectReference src, Address slot, long value, Word metaDataA, Word metaDataB, int mode)
          Write a long.
 void UsePrimitiveWriteBarriersMutator.offsetWrite(ObjectReference src, Address slot, Offset value, Word metaDataA, Word metaDataB, int mode)
          Write an Offset.
 void UsePrimitiveWriteBarriersMutator.shortWrite(ObjectReference src, Address slot, short value, Word metaDataA, Word metaDataB, int mode)
          Write a short.
 boolean UsePrimitiveWriteBarriersMutator.wordTryCompareAndSwap(ObjectReference src, Address slot, Word old, Word value, Word metaDataA, Word metaDataB, int mode)
           
 void UsePrimitiveWriteBarriersMutator.wordWrite(ObjectReference src, Address slot, Word value, Word metaDataA, Word metaDataB, int mode)
          Write a Word.
 

Uses of Address in org.mmtk.plan.stickyimmix
 

Methods in org.mmtk.plan.stickyimmix with parameters of type Address
 boolean StickyImmixMutator.objectReferenceTryCompareAndSwap(ObjectReference src, Address slot, ObjectReference old, ObjectReference tgt, Word metaDataA, Word metaDataB, int mode)
           
 void StickyImmixMutator.objectReferenceWrite(ObjectReference src, Address slot, ObjectReference tgt, Word metaDataA, Word metaDataB, int mode)
          Write an object reference.
 

Uses of Address in org.mmtk.plan.stickyms
 

Methods in org.mmtk.plan.stickyms with parameters of type Address
 boolean StickyMSMutator.objectReferenceTryCompareAndSwap(ObjectReference src, Address slot, ObjectReference old, ObjectReference tgt, Word metaDataA, Word metaDataB, int mode)
           
 void StickyMSMutator.objectReferenceWrite(ObjectReference src, Address slot, ObjectReference tgt, Word metaDataA, Word metaDataB, int mode)
          Write an object reference.
 

Uses of Address in org.mmtk.policy
 

Fields in org.mmtk.policy declared as Address
static Address Space.AVAILABLE_END
           
static Address Space.AVAILABLE_START
           
protected  Address MarkCompactCollector.RegionCursor.cursor
          The current address
protected  Address Space.headDiscontiguousRegion
           
static Address Space.HEAP_END
           
static Address Space.HEAP_START
           
private static Address Space.heapCursor
           
private static Address Space.heapLimit
           
protected  Address MarkCompactCollector.RegionCursor.limit
          The limit of the current region.
protected  Address MarkCompactCollector.RegionCursor.region
          The current region, or zero if the cursor is invalid (eg after advancing past the end of the current work list
private  Address MarkCompactSpace.regionList
          The list of occupied regions
private  Address MarkCompactCollector.regions
          This collector's work list
protected  Address Space.start
           
 

Methods in org.mmtk.policy that return Address
 Address Space.acquire(int pages)
          Acquire a number of pages from the page resource, returning either the address of the first page, or zero on failure.
protected abstract  Address SegregatedFreeListSpace.advanceToBlock(Address block, int sizeClass)
          Prepare a block for allocation, returning a free list into the block.
protected  Address MarkSweepSpace.advanceToBlock(Address block, int sizeClass)
          Prepare the next block in the free block list for use by the free list allocator.
protected  Address ExplicitFreeListSpace.advanceToBlock(Address block, int sizeClass)
          Prepare the next block in the free block list for use by the free list allocator.
private static Address SegregatedFreeListSpace.alignToLiveStride(Address address)
          Align an address so that it corresponds to a live word boundary.
static Address Space.chunkAlign(Address addr, boolean down)
          Align an address to a space chunk
private  Address SegregatedFreeListSpace.expandSizeClass(int sizeClass, AddressArray freeList)
          Expand a particular size class, allocating a new block, breaking the block into cells and placing those cells on a free list for that block.
 Address MarkCompactCollector.RegionCursor.get()
           
 Address SegregatedFreeListSpace.getAllocationBlock(int sizeClass, AddressArray freeList)
          Acquire a new block from the global pool to allocate into.
static Address Space.getDiscontigEnd()
          End of discontig getter @return The end of the discontiguous space
static Address Space.getDiscontigStart()
          Start of discontig getter @return The start of the discontiguous space
protected  Address SegregatedFreeListSpace.getFreeList(Address block)
          In the case where free lists associated with each block are preserved, get the free list for a given block.
 Address Space.getHeadDiscontiguousRegion()
           
 Address MarkCompactCollector.RegionCursor.getLimit()
           
private static Address SegregatedFreeListSpace.getLiveWordAddress(Address address)
          Given an address, return the address of the live word for that address.
 Address MarkCompactSpace.getNextRegion()
           
 Address MarkCompactCollector.RegionCursor.getRegion()
           
 Address Space.getStart()
          Start getter @return The start address of this space
static Address BaseLargeObjectSpace.getSuperPage(Address cell)
          Return the superpage for a given cell.
private  Address SegregatedFreeListSpace.getSweepBlock(int sizeClass)
          Get a block for a parallel sweep.
 Address Space.growDiscontiguousSpace(int chunks)
          Extend the virtual memory associated with a particular discontiguous space.
protected  Address SegregatedFreeListSpace.makeFreeList(Address block, int sizeClass)
          Use the live bits for a block to infer free cells and thus construct a free list for the block.
(package private)  Address MarkCompactCollector.ToCursor.snip()
          Terminate the list of regions here.
protected  Address SegregatedFreeListSpace.sweepBlock(Address block, int sizeClass, Extent blockSize, Address availableHead, boolean clearMarks)
          Sweep a block, freeing it and adding to the list given by availableHead if it contains no free objects.
private  Address SegregatedFreeListSpace.sweepCells(SegregatedFreeListSpace.Sweeper sweeper, Address block, int sizeClass, Address availableHead)
          Sweep a block, freeing it and adding to the list given by availableHead if it contains no free objects.
 

Methods in org.mmtk.policy with parameters of type Address
protected abstract  Address SegregatedFreeListSpace.advanceToBlock(Address block, int sizeClass)
          Prepare a block for allocation, returning a free list into the block.
protected  Address MarkSweepSpace.advanceToBlock(Address block, int sizeClass)
          Prepare the next block in the free block list for use by the free list allocator.
protected  Address ExplicitFreeListSpace.advanceToBlock(Address block, int sizeClass)
          Prepare the next block in the free block list for use by the free list allocator.
private static Address SegregatedFreeListSpace.alignToLiveStride(Address address)
          Align an address so that it corresponds to a live word boundary.
 void MarkCompactSpace.append(Address region)
          Append a region or list of regions to the global list
static void MarkCompactSpace.appendRegion(Address listHead, Address region)
           
static Address Space.chunkAlign(Address addr, boolean down)
          Align an address to a space chunk
protected  void SegregatedFreeListSpace.clearBlockMark(Address block, Extent blockSize)
          Clear block marks for a block
protected static void SegregatedFreeListSpace.clearLiveBit(Address address)
          Clear the live bit for a given address
protected  void SegregatedFreeListSpace.clearLiveBits(Address block, int sizeClass)
          Clear all live bits for a block
protected  boolean SegregatedFreeListSpace.containsLiveCell(Address block, Extent blockSize, boolean clearMarks)
          Does this block contain any live cells.
 void BaseLargeObjectSpace.free(Address cell)
          Free a cell.
protected  Address SegregatedFreeListSpace.getFreeList(Address block)
          In the case where free lists associated with each block are preserved, get the free list for a given block.
private static Address SegregatedFreeListSpace.getLiveWordAddress(Address address)
          Given an address, return the address of the live word for that address.
private static Word SegregatedFreeListSpace.getMask(Address address, boolean set)
          Given an address, produce a bit mask for the live table
 Extent BaseLargeObjectSpace.getSize(Address first)
          Return the size of the super page
static Space Space.getSpaceForAddress(Address addr)
          Return the space for a given address, not necessarily the start address of an object.
static Address BaseLargeObjectSpace.getSuperPage(Address cell)
          Return the superpage for a given cell.
 void Space.growSpace(Address start, Extent bytes, boolean newChunk)
          This hook is called by page resources each time a space grows.
 void MarkCompactCollector.RegionCursor.incTo(Address cursor)
          Increment the cursor to a specific address
(package private) abstract  void MarkCompactCollector.RegionCursor.init(Address region)
          Hook to allow subclasses to initialize the cursor in different ways.
(package private)  void MarkCompactCollector.FromCursor.init(Address region)
          Initialize the cursor - the limit is the end of the allocated data
(package private)  void MarkCompactCollector.ToCursor.init(Address region)
          Initialize the cursor to a given region.
static boolean Space.isInSpace(int descriptor, Address address)
          Return true if the given address is the space associated with the given descriptor.
static boolean Space.isMappedAddress(Address address)
          Return true if the given address is in a space managed by MMTk.
protected static boolean SegregatedFreeListSpace.liveBitSet(Address address)
          Set the live bit for a given address
protected  Address SegregatedFreeListSpace.makeFreeList(Address block, int sizeClass)
          Use the live bits for a block to infer free cells and thus construct a free list for the block.
protected static void SegregatedFreeListSpace.markBlock(Address block)
          Set the live bit for the given block.
protected  void SegregatedFreeListSpace.notifyNewBlock(Address block, int sizeClass)
          Notify that a new block has been installed.
protected  void MarkSweepSpace.notifyNewBlock(Address block, int sizeClass)
          Notify that a new block has been installed.
protected  void ExplicitFreeListSpace.notifyNewBlock(Address block, int sizeClass)
           
 void LargeObjectSpace.release(Address first)
           
 void ExplicitLargeObjectSpace.release(Address first)
          Release a group of pages that were allocated together.
 void ImmortalSpace.release(Address start)
          Release an allocated page or pages.
 void CopySpace.release(Address start)
          Release an allocated page or pages.
 void RawPageSpace.release(Address first)
          Release a group of pages that were allocated together.
 void MarkSweepSpace.release(Address start)
          Release an allocated page or pages
 void MarkCompactSpace.release(Address start)
          Release a unit of allocation (a page or pages)
abstract  void Space.release(Address start)
          Release a unit of allocation (a page or pages)
 void ExplicitFreeListSpace.release(Address start)
          Release an allocated page or pages
 int Space.releaseDiscontiguousChunks(Address chunk)
          Release one or more contiguous chunks associated with a discontiguous space.
 void SegregatedFreeListSpace.returnBlock(Address block, int sizeClass, Address freeCell)
          Return a block to the global pool.
 void SegregatedFreeListSpace.returnConsumedBlock(Address block, int sizeClass)
          Return a block to the global pool.
protected  void SegregatedFreeListSpace.setFreeList(Address block, Address cell)
          In the case where free lists associated with each block are preserved, set the free list for a given block.
protected  Address SegregatedFreeListSpace.sweepBlock(Address block, int sizeClass, Extent blockSize, Address availableHead, boolean clearMarks)
          Sweep a block, freeing it and adding to the list given by availableHead if it contains no free objects.
 boolean SegregatedFreeListSpace.sweepCells(SegregatedFreeListSpace.Sweeper sweeper, Address block, int sizeClass)
          Does this block contain any live cells?
private  Address SegregatedFreeListSpace.sweepCells(SegregatedFreeListSpace.Sweeper sweeper, Address block, int sizeClass, Address availableHead)
          Sweep a block, freeing it and adding to the list given by availableHead if it contains no free objects.
protected static void SegregatedFreeListSpace.unsyncClearLiveBit(Address address)
          Clear the live bit for a given address
private static boolean SegregatedFreeListSpace.updateLiveBit(Address address, boolean set, boolean atomic)
          Set the live bit for a given address
 

Uses of Address in org.mmtk.policy.immix
 

Fields in org.mmtk.policy.immix declared as Address
private  Address ImmixSpace.allocBlockCursor
           
private  Address ImmixSpace.allocBlockSentinel
           
 

Methods in org.mmtk.policy.immix that return Address
 Address ImmixSpace.acquireReusableBlocks()
           
static Address Chunk.align(Address ptr)
           
(package private) static Address Block.align(Address ptr)
           
static Address Line.align(Address ptr)
           
 Address ChunkList.firstChunk(int ordinal, int stride)
           
(package private) static Address Block.getBlockMarkStateAddress(Address address)
           
static Address Line.getBlockMarkTable(Address block)
           
static Address Line.getChunkMarkTable(Address chunk)
           
(package private) static Address Block.getDefragStateAddress(Address address)
           
(package private) static Address Chunk.getFirstUsableBlock(Address chunk)
           
 Address ChunkList.getHeadChunk()
           
static Address Chunk.getHighWater(Address chunk)
           
private  Address ChunkList.getMapAddress(int entry)
           
private static Address Line.getMarkAddress(Address address)
           
private static Address Line.getMetaAddress(Address address, int tableOffset)
           
 Address ImmixSpace.getSpace(boolean hot, boolean copy, int lineUseCount)
          Return a pointer to a set of new usable blocks, or null if none are available.
 Address ChunkList.getTailChunk()
           
 Address ChunkList.nextChunk(Address chunk)
          A chunk iterator.
private  Address ChunkList.nextChunk(Address chunk, Address limit)
          A chunk iterator.
 Address ChunkList.nextChunk(Address chunk, int start, int stride)
          A chunk iterator.
private  Address ChunkList.nextChunk(int entry, int start, int stride)
          A chunk iterator.
 

Methods in org.mmtk.policy.immix with parameters of type Address
(package private)  void ChunkList.addNewChunkToMap(Address chunk)
           
static Address Chunk.align(Address ptr)
           
(package private) static Address Block.align(Address ptr)
           
static Address Line.align(Address ptr)
           
private static void Chunk.checkMetaDataCleared(Address chunk, Address value)
           
(package private) static void Block.clearConservativeSpillCount(Address address)
           
(package private) static void Chunk.clearMetaData(Address chunk)
           
static short Block.getBlockMarkState(Address address)
           
(package private) static Address Block.getBlockMarkStateAddress(Address address)
           
static Address Line.getBlockMarkTable(Address block)
           
(package private) static int Chunk.getByteOffset(Address ptr)
           
private static int Block.getChunkIndex(Address block)
           
(package private) static int Line.getChunkIndex(Address line)
           
static Address Line.getChunkMarkTable(Address chunk)
           
(package private) static short Block.getConservativeSpillCount(Address address)
           
(package private) static Address Block.getDefragStateAddress(Address address)
           
(package private) static Address Chunk.getFirstUsableBlock(Address chunk)
           
static Address Chunk.getHighWater(Address chunk)
           
(package private) static int Chunk.getMap(Address chunk)
           
private static Address Line.getMarkAddress(Address address)
           
(package private) static short Block.getMarkState(Address cursor)
           
private static Address Line.getMetaAddress(Address address, int tableOffset)
           
static int Line.getNextAvailable(Address baseLineAvailAddress, int line, byte unavailableState)
           
 int ImmixSpace.getNextAvailableLine(Address baseLineAvailAddress, int line)
           
static int Line.getNextUnavailable(Address baseLineAvailAddress, int line, byte unavailableState)
           
 int ImmixSpace.getNextUnavailableLine(Address baseLineAvailAddress, int line)
           
private  int ImmixSpace.getUsableLinesInRegion(Address start, Address end, int[] spillAvailHistogram)
          Return the number of lines usable for allocation during defragmentation in the address range specified by start and end.
 void ImmixSpace.growSpace(Address start, Extent bytes, boolean newChunk)
           
(package private) static boolean Chunk.isAligned(Address ptr)
           
static boolean Block.isAligned(Address address)
           
static boolean Line.isAligned(Address address)
           
 boolean ImmixSpace.isDefragSource(Address address)
           
static boolean Block.isDefragSource(Address address)
           
static boolean ImmixSpace.isRecycleAllocChunkAligned(Address ptr)
           
static boolean Block.isUnused(Address address)
           
(package private) static boolean Block.isUnusedState(Address cursor)
           
(package private) static void Line.mark(Address address, byte markValue)
           
(package private) static void Line.markMultiLine(Address start, ObjectReference object, byte markValue)
           
 Address ChunkList.nextChunk(Address chunk)
          A chunk iterator.
private  Address ChunkList.nextChunk(Address chunk, Address limit)
          A chunk iterator.
 Address ChunkList.nextChunk(Address chunk, int start, int stride)
          A chunk iterator.
 void ImmixSpace.release(Address block)
          Release a block.
 int ImmixSpace.releaseDiscontiguousChunks(Address chunk)
          Release one or more contiguous chunks associated with a discontiguous space.
(package private)  void ChunkList.removeChunkFromMap(Address chunk)
           
(package private) static void Chunk.resetLineMarksAndDefragStateTable(Address chunk, short threshold)
           
(package private) static void Block.resetLineMarksAndDefragStateTable(short threshold, Address markStateBase, Address defragStateBase, Address lineMarkBase, int block)
           
(package private) static void Block.setBlockAsInUse(Address address)
           
static void Block.setBlockAsReused(Address address)
           
(package private) static void Block.setBlockAsUnallocated(Address address)
           
private static void Block.setBlockState(Address address, short value)
           
private static void Chunk.setHighWater(Address chunk, Address value)
           
(package private) static void Chunk.setMap(Address chunk, int value)
           
(package private) static void Block.setState(Address cursor, short value)
           
(package private) static void Chunk.sweep(Address chunk, Address end, ImmixSpace space, int[] markHistogram, byte markValue, boolean resetMarks)
           
(package private) static short Block.sweepOneBlock(Address block, int[] markHistogram, byte markState, boolean resetMarkState)
           
(package private) static void Chunk.updateHighWater(Address value)
           
 boolean ImmixSpace.willNotMoveThisGC(Address address)
           
 

Uses of Address in org.mmtk.utility
 

Fields in org.mmtk.utility declared as Address
private  Address SimpleHashtable.base
          The start address of the data table
private  Address DoublyLinkedList.head
           
 

Methods in org.mmtk.utility that return Address
private  Address SimpleHashtable.getEntry(int index)
          Return the address of a specified entry in the table.
 Address SimpleHashtable.getEntry(Word key, boolean create)
          Retrieve a pointer to the entry for the given object, or zero if one does not exist, unless create is passed.
 Address SimpleHashtable.getFirst()
           
 Address DoublyLinkedList.getHead()
           
 Address SimpleHashtable.getNext(Address curr)
          The next element in the table after the passed entry, or null if it is the last entry.
 Address DoublyLinkedList.getNext(Address node)
           
static Address SimpleHashtable.getPayloadAddress(Address entry)
          Given an address of an entry, return a pointer to the payload.
 Address SimpleHashtable.getPayloadAddress(Word key)
          Given a key, return a pointer to the payload.
static Address DoublyLinkedList.midPayloadToNode(Address payload)
           
static Address Treadmill.midPayloadToNode(Address payload)
           
static Address Conversions.mmapChunksToAddress(int chunk)
           
static Address DoublyLinkedList.nodeToPayload(Address node)
           
static Address Treadmill.nodeToPayload(Address payload)
           
static Address Conversions.pageAlign(Address address)
           
static Address Conversions.pagesToAddress(int pages)
           
 Address DoublyLinkedList.pop()
           
 Address Treadmill.pop()
          Remove a node from the mature list.
 Address Treadmill.popNursery()
          Remove a node from the nursery list.
static Address Conversions.roundDownMB(Address addr)
           
 

Methods in org.mmtk.utility with parameters of type Address
 void DoublyLinkedList.add(Address node)
           
static int Conversions.addressToMmapChunksDown(Address addr)
           
static int Conversions.addressToMmapChunksUp(Address addr)
           
static int Conversions.addressToPages(Address addr)
           
static int Conversions.addressToPagesDown(Address addr)
           
 void Treadmill.addToTreadmill(Address node, boolean nursery)
          Add a node to the treadmill.
private static void Memory.assertAligned(Address value)
           
static void Memory.assertIsZeroed(Address start, int bytes)
          Assert that a memory range is zeroed.
static void TraceGenerator.boot(Address bootStart)
          Add the information in the bootImage to the trace.
 void Treadmill.copy(Address node, boolean isInNursery)
          Copy a node (during gc tracing).
static void Memory.dumpMemory(Address addr, int beforeBytes, int afterBytes)
          Dump the contents of memory around a given address
static Word SimpleHashtable.getKey(Address entry)
          Return the key for a given entry.
 Address SimpleHashtable.getNext(Address curr)
          The next element in the table after the passed entry, or null if it is the last entry.
 Address DoublyLinkedList.getNext(Address node)
           
static Address SimpleHashtable.getPayloadAddress(Address entry)
          Given an address of an entry, return a pointer to the payload.
 boolean DoublyLinkedList.isMember(Address node)
          Return true if a cell is on a given treadmill
 boolean DoublyLinkedList.isNode(Address node)
           
static boolean Conversions.isPageAligned(Address address)
           
private static boolean Memory.isSet(Address start, int bytes, boolean verbose, int value)
          Test whether a memory range is set to a given integer value
static boolean Memory.isSet(Address start, int bytes, int value)
          Verbosely check and return true if a memory range is set to some integer value
static boolean Memory.IsZeroed(Address start, int bytes)
          Check that a memory range is zeroed
static Address DoublyLinkedList.midPayloadToNode(Address payload)
           
static Address Treadmill.midPayloadToNode(Address payload)
           
static Address DoublyLinkedList.nodeToPayload(Address node)
           
static Address Treadmill.nodeToPayload(Address payload)
           
static Address Conversions.pageAlign(Address address)
           
static void TraceGenerator.processPointerUpdate(boolean isScalar, ObjectReference src, Address slot, ObjectReference tgt)
          Do any tracing work required at each a pointer store operation.
 void DoublyLinkedList.remove(Address node)
           
static void SimpleHashtable.replaceKey(Address entry, Word key)
          Update the key for a given entry.
static Address Conversions.roundDownMB(Address addr)
           
static void Memory.set(Address start, int bytes, int value)
          Set a region of memory
static byte HeaderByte.setBuildTimeGCByte(Address object, ObjectReference typeRef, int size)
          Perform any required initialization of the GC portion of the header.
static void Log.write(Address a)
          writes an address, in hexadecimal.
static void Log.write(String s, Address a)
          writes a string followed by an address, in hexadecimal.
static void Log.writeln(Address a)
          writes an address, in hexadecimal, and a new-line, then flushes the buffer.
static void Log.writeln(Address a, boolean flush)
          writes an address, in hexadecimal, and a new-line, then optionally flushes the buffer.
static void Log.writeln(String s, Address a)
          writes a string followed by a Address
static void Memory.zero(Address start, Extent bytes)
          Zero a region of memory
static void Memory.zeroSmall(Address start, Extent bytes)
          Zero a small region of memory
 

Uses of Address in org.mmtk.utility.alloc
 

Fields in org.mmtk.utility.alloc declared as Address
private  Address ImmixAllocator.cursor
          bump pointer
protected  Address BumpPointer.cursor
          insertion point
protected  Address BumpPointer.initialRegion
          first contiguous region
private  Address BumpPointer.internalLimit
          current internal slow-path sentinel for bump pointer
private  Address ImmixAllocator.largeCursor
          bump pointer for large objects
private  Address ImmixAllocator.largeLimit
          limit for bump pointer for large objects
private  Address ImmixAllocator.limit
          limit for bump pointer
private  Address BumpPointer.limit
          current external slow-path sentinel for bump pointer
private  Address ImmixAllocator.markTable
           
private  Address ImmixAllocator.recyclableBlock
           
protected  Address BumpPointer.region
          current contiguous region
 

Methods in org.mmtk.utility.alloc that return Address
static Address Allocator.alignAllocation(Address region, int alignment, int offset)
          Aligns up an allocation request.
static Address Allocator.alignAllocation(Address region, int alignment, int offset, int knownAlignment, boolean fillAlignmentGap)
          Aligns up an allocation request.
static Address Allocator.alignAllocationNoFill(Address region, int alignment, int offset)
          Aligns up an allocation request.
 Address ImmixAllocator.alloc(int bytes, int align, int offset)
          Allocate space for a new object.
 Address LargeObjectAllocator.alloc(int bytes, int align, int offset)
          Allocate space for an object
 Address BumpPointer.alloc(int bytes, int align, int offset)
          Allocate space for a new object.
 Address SegregatedFreeList.alloc(int bytes, int align, int offset)
          Allocate bytes contiguous bytes of zeroed memory.
static Address BlockAllocator.alloc(Space space, int blockSizeClass)
          Allocate a block, returning the address of the first usable byte in the block.
private  Address BumpPointer.allocSlow(Address start, Address end, int align, int offset)
          Internal allocation slow path.
 Address Allocator.allocSlow(int bytes, int alignment, int offset)
          Out-of-line slow path allocation.
private  Address ImmixAllocator.allocSlowHot(int bytes, int align, int offset)
          Internal allocation slow path.
 Address Allocator.allocSlowInline(int bytes, int alignment, int offset)
          Inline slow path allocation.
 Address SegregatedFreeListLocal.allocSlowOnce(int bytes, int align, int offset)
          Allocate bytes contiguous bytes of non-zeroed memory.
protected  Address ImmixAllocator.allocSlowOnce(int bytes, int align, int offset)
          External allocation slow path (called by superclass when slow path is actually taken.
protected  Address LargeObjectAllocator.allocSlowOnce(int bytes, int align, int offset)
          Allocate a large object.
protected  Address BumpPointer.allocSlowOnce(int bytes, int align, int offset)
          External allocation slow path (called by superclass when slow path is actually taken.
protected abstract  Address Allocator.allocSlowOnce(int bytes, int alignment, int offset)
          Single slow path allocation attempt.
private  Address BumpPointer.consumeNextRegion(Address nextRegion, int bytes, int align, int offset)
          A bump pointer chunk/region has been consumed but the contiguous region is available, so consume it and then return the address of the start of a memory region satisfying the outstanding allocation request.
static Address BlockAllocator.getBlkStart(Address address)
          Get the address of the start of a block size class a given page within the block.
private static Address BumpPointer.getCard(Address address)
          Return the start of the card corresponding to a given address.
private static Address BumpPointer.getCardMetaData(Address card)
          Return the address of the metadata for a card, given the address of the card.
 Address BumpPointer.getCursor()
           
static Address BumpPointer.getDataEnd(Address region)
           
static Address BumpPointer.getDataStart(Address region)
          The first offset in a region after the header
static Address BlockAllocator.getFreeListMeta(Address address)
          Get the free list meta data field for a given address (this is per-block meta data that is stored along with the block metadata but not used by the block allocator).
private static Address BlockAllocator.getMetaAddress(Address address)
          Get the address of some metadata given the address for which the metadata is required and the offset into the metadata that is of interest.
private static Address BlockAllocator.getMetaAddress(Address address, Offset offset)
          Get the address of some metadata given the address for which the metadata is required and the offset into the metadata that is of interest.
static Address EmbeddedMetaData.getMetaDataBase(Address address)
          Given an address, return the beginning of the meta data for the region containing the address.
static Address BlockAllocator.getNext(Address address)
          Get the prev meta data field for a given address
static Address BumpPointer.getNextRegion(Address region)
          The next region in the linked-list of regions
static Address BumpPointer.getRegionLimit(Address region)
          Return the end address of the given region.
 Address ImmixAllocator.overflowAlloc(int bytes, int align, int offset)
          Allocate space for a new object.
 

Methods in org.mmtk.utility.alloc with parameters of type Address
static Address Allocator.alignAllocation(Address region, int alignment, int offset)
          Aligns up an allocation request.
static Address Allocator.alignAllocation(Address region, int alignment, int offset, int knownAlignment, boolean fillAlignmentGap)
          Aligns up an allocation request.
static Address Allocator.alignAllocationNoFill(Address region, int alignment, int offset)
          Aligns up an allocation request.
private  Address BumpPointer.allocSlow(Address start, Address end, int align, int offset)
          Internal allocation slow path.
static boolean BlockAllocator.checkBlockMeta(Address block)
          Return true if the metadata for this block was set.
static void BumpPointer.checkRegionMetadata(Address region)
          Sanity check a region header
static void BlockAllocator.clearBlockMeta(Address block)
          Clear the metadata for this block
static void BumpPointer.clearNextRegion(Address region)
          Clear the next region pointer in the linked-list of regions
private  Address BumpPointer.consumeNextRegion(Address nextRegion, int bytes, int align, int offset)
          A bump pointer chunk/region has been consumed but the contiguous region is available, so consume it and then return the address of the start of a memory region satisfying the outstanding allocation request.
private  void BumpPointer.createCardAnchor(Address card, Address start, int bytes)
          Given an allocation which starts a new card, create a record of where the start of the object is relative to the start of the card.
static void Allocator.fillAlignmentGap(Address start, Address end)
          Fill the specified region with the alignment value.
static void BlockAllocator.free(Space space, Address block)
          Free a block.
private static byte BlockAllocator.getBlkSizeClass(Address address)
          Get the block size class meta data field for a given page (all blocks on a given page are homogeneous with respect to block size class).
static Address BlockAllocator.getBlkStart(Address address)
          Get the address of the start of a block size class a given page within the block.
private static Address BumpPointer.getCard(Address address)
          Return the start of the card corresponding to a given address.
private static Address BumpPointer.getCardMetaData(Address card)
          Return the address of the metadata for a card, given the address of the card.
static byte BlockAllocator.getClientSizeClass(Address address)
          Get the client size class meta data field for a given page (all blocks on a given page are homogeneous with respect to block size class).
static Address BumpPointer.getDataEnd(Address region)
           
static Address BumpPointer.getDataStart(Address region)
          The first offset in a region after the header
static Address BlockAllocator.getFreeListMeta(Address address)
          Get the free list meta data field for a given address (this is per-block meta data that is stored along with the block metadata but not used by the block allocator).
private static Address BlockAllocator.getMetaAddress(Address address)
          Get the address of some metadata given the address for which the metadata is required and the offset into the metadata that is of interest.
private static Address BlockAllocator.getMetaAddress(Address address, Offset offset)
          Get the address of some metadata given the address for which the metadata is required and the offset into the metadata that is of interest.
static Address EmbeddedMetaData.getMetaDataBase(Address address)
          Given an address, return the beginning of the meta data for the region containing the address.
static Extent EmbeddedMetaData.getMetaDataOffset(Address address, int logCoverage, int logAlign)
          Given an address, the density (coverage) of a meta data type, and the granularity (alignment) of the meta data, return the offset into the meta data the address.
static Address BlockAllocator.getNext(Address address)
          Get the prev meta data field for a given address
static Address BumpPointer.getNextRegion(Address region)
          The next region in the linked-list of regions
static Address BumpPointer.getRegionLimit(Address region)
          Return the end address of the given region.
static boolean BumpPointer.isRegionAligned(Address region)
           
static void BlockAllocator.markBlockMeta(Address block)
          Mark the metadata for this block.
private  void BumpPointer.scanRegion(LinearScan scanner, Address start)
          Perform a linear scan through a single contiguous region
static void BlockAllocator.setAllClientSizeClass(Address block, int blocksc, byte sc)
          Set the client size class meta data field for a given address (all blocks on a given page are homogeneous with respect to block size class).
private static void BlockAllocator.setBlkSizeMetaData(Address block, byte sc)
          Set the block size class meta data field for a given address (all blocks on a given page are homogeneous with respect to block size class).
static void BumpPointer.setDataEnd(Address region, Address endAddress)
           
static void BlockAllocator.setFreeListMeta(Address address, Address value)
          Set the free list meta data field for a given address (this is per-block meta data that is stored along with the block metadata but not used by the block allocator).
static void BlockAllocator.setNext(Address address, Address prev)
          Set the prev meta data field for a given address
static void BumpPointer.setNextRegion(Address region, Address nextRegion)
          Set the next region in the linked-list of regions
static void BumpPointer.setRegionLimit(Address region, Address limit)
          Store the limit value at the end of the region.
protected  void BumpPointer.updateLimit(Address newLimit, Address start, int bytes)
          Update the limit pointer.
private  void BumpPointer.updateMetaData(Address start, Extent size, int bytes)
          Update the metadata to reflect the addition of a new region.
private  void ImmixAllocator.zeroBlock(Address block)
           
 

Uses of Address in org.mmtk.utility.deque
 

Fields in org.mmtk.utility.deque declared as Address
protected  Address LocalQueue.head
          the start of the buffer
protected  Address SharedDeque.head
          Head of the shared deque
protected static Address Deque.HEAD_INITIAL_VALUE
           
protected  Address LocalSSB.tail
          the location in the buffer
protected  Address SharedDeque.tail
          Tail of the shared deque
protected static Address Deque.TAIL_INITIAL_VALUE
           
protected  Address LocalSSB.tailBufferEnd
          the end of the buffer
 

Methods in org.mmtk.utility.deque that return Address
(package private)  Address SharedDeque.alloc()
           
protected  Address Deque.bufferEnd(Address buf)
           
protected  Address Deque.bufferFirst(Address buf)
           
protected  Address Deque.bufferLast(Address buf)
           
protected  Address Deque.bufferLast(Address buf, int arity)
           
protected  Address Deque.bufferStart(Address buf)
           
private  Address SharedDeque.dequeue(boolean waiting, boolean fromTail)
          Dequeue a block from the shared pool.
(package private)  Address SharedDeque.dequeue(int arity)
           
(package private)  Address SharedDeque.dequeue(int arity, boolean fromTail)
           
(package private)  Address SharedDeque.dequeueAndWait(int arity)
           
(package private)  Address SharedDeque.dequeueAndWait(int arity, boolean fromTail)
           
protected  Address SharedDeque.getNext(Address buf)
          Get the "next" pointer in a buffer forming the linked buffer chain.
protected  Address SharedDeque.getPrev(Address buf)
          Get the "next" pointer in a buffer forming the linked buffer chain.
protected  Address LocalSSB.normalizeTail(int arity)
          In the case where a buffer must be flushed before being filled (either to the queue or to the head), the entries must be slid to the base of the buffer in order to preserve the invariant that all non-tail buffers will have entries starting at the base (which allows a simple test against the base to be used when popping entries).
 Address AddressDeque.pop()
          Pop an address from the address queue, return zero if the queue is empty.
 Address SortTODAddressStack.pop()
          Pop an address from the address stack, return zero if the stack is empty.
 Address AddressTripleDeque.pop1()
          Pop the first address in a triple from the address queue, return zero if the queue is empty.
 Address AddressPairDeque.pop1()
          Pop the first address in a pair from the address queue, return zero if the queue is empty.
 Address AddressTripleDeque.pop2()
          Pop the second address in a triple from the address queue.
 Address AddressPairDeque.pop2()
          Pop the second address in a pair from the address queue.
 Address AddressTripleDeque.pop3()
          Pop the third address in a triple from the address queue.
private  Address SortSharedDeque.popStack()
          Pop an address from the stack
protected  Address LocalQueue.uncheckedDequeue()
          Dequeue a value from the buffer.
 

Methods in org.mmtk.utility.deque with parameters of type Address
protected  Address Deque.bufferEnd(Address buf)
           
protected  Address Deque.bufferFirst(Address buf)
           
protected  Address Deque.bufferLast(Address buf)
           
protected  Address Deque.bufferLast(Address buf, int arity)
           
protected  Offset Deque.bufferOffset(Address buf)
           
protected  Address Deque.bufferStart(Address buf)
           
(package private)  void SharedDeque.enqueue(Address buf, int arity, boolean toTail)
          Enqueue a block on the head or tail of the shared queue
(package private)  void SharedDeque.free(Address buf)
           
protected abstract  Word SortSharedDeque.getKey(Address obj)
          Return the sorting key for the object passed as a parameter.
protected  Word SortTODSharedDeque.getKey(Address obj)
           
protected  Address SharedDeque.getNext(Address buf)
          Get the "next" pointer in a buffer forming the linked buffer chain.
protected  Address SharedDeque.getPrev(Address buf)
          Get the "next" pointer in a buffer forming the linked buffer chain.
 void AddressDeque.insert(Address addr)
          Insert an address into the address queue.
 void WriteBuffer.insert(Address addr)
          Insert a value to be remembered into the write buffer.
 void AddressPairDeque.insert(Address addr1, Address addr2)
          Insert an address pair into the address queue.
 void AddressTripleDeque.insert(Address addr1, Address addr2, Address addr3)
          Insert an address triple into the address queue.
private  void SortSharedDeque.insertionSort(Address begin, Address end)
          Perform insertion sort within an intra-block address range.
 void AddressDeque.insertOOL(Address addr)
          Insert an address into the address queue, force this out of line ("OOL"), in some circumstances it is too expensive to have the insert inlined, so this call is made.
private  void SortSharedDeque.partition(Address startAddr, Address startLinkAddr, Address endAddr, Address endLinkAddr, Word bitMask)
          Partition the slots in an address range based on the value in a particular bit.
 void ObjectReferenceBuffer.processEdge(ObjectReference source, Address slot)
           
 void AddressDeque.push(Address addr)
          Push an address onto the address queue.
 void SortTODAddressStack.push(Address addr)
          Push an address onto the address stack.
 void AddressPairDeque.push(Address addr1, Address addr2)
          Push an address pair onto the address queue.
 void AddressTripleDeque.push(Address addr1, Address addr2, Address addr3)
          Push an address pair onto the address queue.
private  void SortSharedDeque.pushOnStack(Address val)
          Push an address on to the stack
 void AddressDeque.pushOOL(Address addr)
          Push an address onto the address queue, force this out of line ("OOL"), in some circumstances it is too expensive to have the push inlined, so this call is made.
private  void SharedDeque.setHead(Address newHead)
           
private static void SharedDeque.setNext(Address buf, Address next)
          Set the "next" pointer in a buffer forming the linked buffer chain.
private  void SharedDeque.setPrev(Address buf, Address prev)
          Set the "prev" pointer in a buffer forming the linked buffer chain.
private  void SharedDeque.setTail(Address newTail)
           
protected  void LocalDeque.uncheckedHeadInsert(Address value)
          Insert a value at the front of the deque (and buffer).
protected  void LocalSSB.uncheckedTailInsert(Address value)
          Insert a value into the buffer.
 

Uses of Address in org.mmtk.utility.gcspy
 

Fields in org.mmtk.utility.gcspy declared as Address
private  Address Subspace.end_
          end address of the subspace.
private  Address Subspace.start_
          start address of the subspace.
 

Methods in org.mmtk.utility.gcspy that return Address
 Address Subspace.getAddress(int index)
          Get the address of start of block from its index
 Address Subspace.getEnd()
          Get the end of this subspace
 Address Subspace.getStart()
          Get the start of the subspace
 

Methods in org.mmtk.utility.gcspy with parameters of type Address
 boolean Subspace.addressInRange(Address addr)
          Is address in the range of this subspace?
 int Subspace.getIndex(Address addr)
          Get the block index from an address
 void Subspace.reset(Address start, Address end, int blockNum)
          Reset a new subspace.
 void Subspace.reset(Address start, Address end, int firstIndex, int blockNum)
          Reset a new subspace
private  void Subspace.reset(Address start, Address end, int firstIndex, int blockSize, int blockNum)
          Reset a subspace.
 int Subspace.spaceRemaining(Address addr)
          Calculate the space remaining in a block after this address
 

Constructors in org.mmtk.utility.gcspy with parameters of type Address
Subspace(Address start, Address end, int firstIndex, int blockSize, int blockNum)
          Create a new subspace
 

Uses of Address in org.mmtk.utility.gcspy.drivers
 

Fields in org.mmtk.utility.gcspy.drivers declared as Address
protected  Address LinearSpaceDriver.lastAddress
           
protected  Address TreadmillDriver.maxAddr
           
 

Methods in org.mmtk.utility.gcspy.drivers with parameters of type Address
protected  int AbstractDriver.countTileNum(Address start, Address end, int tileSize)
          Count number of tiles in an address range.
 boolean TreadmillDriver.handleReferenceFromImmortalSpace(Address addr)
          Handle a direct reference from the immortal space.
 boolean LinearSpaceDriver.handleReferenceFromImmortalSpace(Address addr)
          Handle a direct reference from the immortal space.
 boolean AbstractDriver.handleReferenceFromImmortalSpace(Address addr)
          Handle a direct reference from the immortal space.
 boolean GenImmortalSpaceDriver.handleRemsetAddress(Address addr)
          Handle a remset address
 boolean GenLOSDriver.handleRemsetAddress(Address addr)
          Handle a remset address.
 boolean TreadmillDriver.handleRoot(Address addr)
          Handle a root address
 boolean LinearSpaceDriver.handleRoot(Address addr)
          Handle a root address
 void ImmortalSpaceDriver.Closure.processEdge(ObjectReference source, Address slot)
          Process an edge.
 void TreadmillDriver.scan(Address addr)
          Update the tile statistics In this case, we are accounting for super-page objects, rather than simply for the objects they contain.
 void AbstractDriver.scan(Address obj)
          Scan an object found at a location.
 void AbstractDriver.scan(Address obj, boolean total)
          Scan an object found at a location.
 void LinearSpaceDriver.setRange(Address start, Address end)
          Set the current address range of a contiguous space
 void AbstractDriver.setRange(Address start, Address end)
          Indicate the limits of a space.
 void AbstractDriver.setRange(Address start, Extent extent)
          Indicate the limits of a space.
 

Uses of Address in org.mmtk.utility.heap
 

Fields in org.mmtk.utility.heap declared as Address
private  Address MonotonePageResource.currentChunk
           
private  Address MonotonePageResource.cursor
           
private static Address Map.MAP_BASE_ADDRESS
          set the map base address so that we have an unused null chunk at the bottome of the space for 64 bit
private  Address MonotonePageResource.sentinel
           
 Address VMRequest.start
           
protected  Address PageResource.start
          only for contiguous spaces
private  Address MonotonePageResource.zeroingCursor
           
private  Address MonotonePageResource.zeroingSentinel
           
 

Methods in org.mmtk.utility.heap that return Address
private static Address Map.addressForChunkIndex(int chunk)
           
static Address Map.allocateContiguousChunks(int descriptor, Space space, int chunks, Address head)
          Allocate some number of contiguous chunks within a discontiguous region.
protected  Address MonotonePageResource.allocPages(int reservedPages, int requiredPages, boolean zeroed)
          Allocate pages pages from this resource.
(package private) abstract  Address PageResource.allocPages(int reservedPages, int requiredPages, boolean zeroed)
           
protected  Address FreeListPageResource.allocPages(int reservedPages, int requiredPages, boolean zeroed)
          Allocate pages pages from this resource.
private static Address Mmapper.chunkAlignDown(Address addr)
          Return a given address rounded down to an mmap chunk size
private static Address Mmapper.chunkAlignUp(Address addr)
          Return a given address rounded up to an mmap chunk size
 Address FreeListPageResource.getHighWater()
           
 Address PageResource.getNewPages(int pagesReserved, int pages, boolean zeroed)
          Allocate pages in virtual memory, returning zero on failure.
static Address Map.getNextContiguousRegion(Address start)
          Return the address of the next contiguous region associated with some discontiguous space by following the linked list for that space.
private static Address MonotonePageResource.getRegionStart(Address addr)
           
static Address SpaceDescriptor.getStart(int descriptor)
          Return the start of this region of memory encoded in this descriptor
 

Methods in org.mmtk.utility.heap with parameters of type Address
static boolean Mmapper.addressIsMapped(Address addr)
          Return true if the given address has been mmapped
 int MonotonePageResource.adjustForMetaData(int pages, Address begin)
          Adjust a page request to include metadata requirements, if any.
static Address Map.allocateContiguousChunks(int descriptor, Space space, int chunks, Address head)
          Allocate some number of contiguous chunks within a discontiguous region.
private static Address Mmapper.chunkAlignDown(Address addr)
          Return a given address rounded down to an mmap chunk size
private static Address Mmapper.chunkAlignUp(Address addr)
          Return a given address rounded up to an mmap chunk size
static VMRequest VMRequest.create(Address start, Extent extent)
          A request for an explicit region of memory
static int SpaceDescriptor.createDescriptor(Address start, Address end)
          Create a descriptor for a contiguous space
static void Mmapper.ensureMapped(Address start, int pages)
          Ensure that a range of pages is mmapped (or equivalent).
static void Map.freeAllChunks(Address anyChunk)
          Free all chunks in a linked list of contiguous chunks.
private  void FreeListPageResource.freeContiguousChunk(Address chunk)
          Release a single chunk from a discontiguous region.
static int Map.freeContiguousChunks(Address start)
          Free some set of contiguous chunks, given the chunk address
private static int Map.getChunkIndex(Address address)
          Hash an address to a chunk (this is simply done via bit shifting)
static int Map.getContiguousRegionChunks(Address start)
          Return the size of a contiguous region in chunks.
static Extent Map.getContiguousRegionSize(Address start)
          Return the size of a contiguous region in bytes.
static int Map.getDescriptorForAddress(Address object)
          Return the space descriptor for the space in which this object resides.
static Address Map.getNextContiguousRegion(Address start)
          Return the address of the next contiguous region associated with some discontiguous space by following the linked list for that space.
private static Address MonotonePageResource.getRegionStart(Address addr)
           
 Extent FreeListPageResource.getSize(Address first)
          Return the size of the super page
static Space Map.getSpaceForAddress(Address address)
          Return the space in which this address resides.
static void Map.insert(Address start, Extent extent, int descriptor, Space space)
          Insert a space and its descriptor into the map, associating it with a particular address range.
static void Mmapper.markAsMapped(Address start, int bytes)
          Mark a range of pages as having (already) been mapped.
static void Mmapper.protect(Address start, int pages)
          Memory protect a range of pages (using mprotect or equivalent).
private  void FreeListPageResource.releaseFreeChunks(Address freedPage, int pagesFreed)
          The release of a page may have freed up an entire chunk or set of chunks.
 void FreeListPageResource.releasePages(Address first)
          Release a group of pages, associated with this page resource, that were allocated together, optionally zeroing on release and optionally memory protecting on release.
private  void MonotonePageResource.releasePages(Address first, Extent bytes)
          Release a range of pages associated with this page resource, optionally zeroing on release and optionally memory protecting on release.
 void FreeListPageResource.resizeFreeList(Address startAddress)
          Resize the free list associated with this resource and nail down its start address.
 

Constructors in org.mmtk.utility.heap with parameters of type Address
FreeListPageResource(Space space, Address start, Extent bytes)
          Constructor Contiguous free list resource.
FreeListPageResource(Space space, Address start, Extent bytes, int metaDataPagesPerRegion)
          Constructor Contiguous free list resource.
MonotonePageResource(Space space, Address start, Extent bytes, int metaDataPagesPerRegion)
          Constructor Contiguous monotone resource.
PageResource(Space space, Address start)
          Constructor for contiguous spaces
VMRequest(int type, Address start, Extent bytes, float frac, boolean top)
           
 

Uses of Address in org.mmtk.utility.sanitychecker
 

Methods in org.mmtk.utility.sanitychecker that return Address
 Address SanityDataTable.getEntry(ObjectReference object, boolean create)
          Get an entry for an object.
 

Methods in org.mmtk.utility.sanitychecker with parameters of type Address
static int SanityDataTable.getNormalRC(Address entry)
          Given an address of an entry, read the reference count, excluding root references.
static ObjectReference SanityDataTable.getObjectReference(Address entry)
          Given an address of an entry, read the reference component.
static int SanityDataTable.getRC(Address entry)
          Given an address of an entry, read the total reference count.
static int SanityDataTable.getRootRC(Address entry)
          Given an address of an entry, read the root reference count.
static boolean SanityDataTable.incRC(Address entry, boolean root)
          Increment the data word for an object.
 

Uses of Address in org.mmtk.vm
 

Fields in org.mmtk.vm declared as Address
static Address VM.AVAILABLE_END
          The highest address in the contiguously available memory available to MMTk
static Address VM.AVAILABLE_START
          The lowest address in the contiguously available memory available to MMTk
static Address VM.HEAP_END
          The highest address in virtual memory known to MMTk
static Address VM.HEAP_START
          The lowest address in virtual memory known to MMTk
 

Methods in org.mmtk.vm that return Address
abstract  Address Barriers.addressRead(ObjectReference ref, Word metaDataA, Word metaDataB, int mode)
          Perform the actual read of the read barrier, returning the value as a raw Address.
(package private) static Address Memory.availableEndTrapdoor(Memory m)
           
(package private) static Address Memory.availableStartTrapdoor(Memory m)
           
abstract  Address ObjectModel.copyTo(ObjectReference from, ObjectReference to, Address region)
          Copy an object to be pointer to by the to address.
protected abstract  Address Memory.getAvailableEndConstant()
           
protected abstract  Address Memory.getAvailableStartConstant()
           
abstract  Address TraceInterface.getBootImageLink()
           
protected abstract  Address Memory.getHeapEndConstant()
           
protected abstract  Address Memory.getHeapStartConstant()
           
abstract  Address ObjectModel.getObjectEndAddress(ObjectReference object)
          Gets a pointer to the address just past the end of the object.
(package private) static Address Memory.heapEndTrapdoor(Memory m)
           
(package private) static Address Memory.heapStartTrapdoor(Memory m)
           
abstract  Address ObjectModel.objectStartRef(ObjectReference object)
          Returns the lowest address of the storage associated with an object.
abstract  Address ObjectModel.refToAddress(ObjectReference object)
          Returns an address guaranteed to be inside the storage assocatied with and object.
abstract  Address TraceInterface.skipOwnFramesAndDump(ObjectReference typeRef)
          This skips over the frames added by the tracing algorithm, outputs information identifying the method the containts the "new" call triggering the allocation, and returns the address of the first non-trace, non-alloc stack frame.
 

Methods in org.mmtk.vm with parameters of type Address
abstract  boolean Barriers.addressTryCompareAndSwap(ObjectReference ref, Address old, Address target, Word metaDataA, Word metaDataB, int mode)
          Attempt an atomic compare and exchange in a write barrier sequence.
abstract  void Barriers.addressWrite(ObjectReference ref, Address target, Word metaDataA, Word metaDataB, int mode)
          Perform the actual write of the write barrier, writing the value as a raw Address.
abstract  Offset TraceInterface.adjustSlotOffset(boolean isScalar, ObjectReference src, Address slot)
          This adjusts the offset into an object to reflect what it would look like if the fields were laid out in memory space immediately after the object pointer.
 void Debug.arrayRemsetEntry(Address start, Address guard)
          An array remset entry has been traced during collection.
abstract  Address ObjectModel.copyTo(ObjectReference from, ObjectReference to, Address region)
          Copy an object to be pointer to by the to address.
abstract  void Memory.dumpMemory(Address start, int beforeBytes, int afterBytes)
          Logs the contents of an address and the surrounding memory to the error output.
abstract  int Memory.dzmmap(Address start, int size)
          Demand zero mmaps an area of virtual memory.
abstract  ObjectReference ObjectModel.getObjectFromStartAddress(Address start)
          Return an object reference from knowledge of the low order word
abstract  ObjectReference ObjectModel.getReferenceWhenCopiedTo(ObjectReference from, Address to)
          Return the reference that an object will be referred to after it is copied to the specified region.
abstract  boolean Memory.mprotect(Address start, int size)
          Protects access to an area of virtual memory.
abstract  boolean Memory.munprotect(Address start, int size)
          Allows access to an area of virtual memory.
abstract  void Barriers.objectReferenceNonHeapWrite(Address slot, ObjectReference target, Word metaDataA, Word metaDataB)
          Perform the actual write of the non-heap write barrier.
 void Debug.queueHeadInsert(String queueName, Address value)
          An entry has been inserted at the head of a queue *** Non-standard, requires plumbing into a collector during debugging ***
 void Debug.queueHeadRemove(String queueName, Address value)
          An entry has been inserted at the head of a queue *** Non-standard, requires plumbing into a collector during debugging ***
 void Debug.queueTailInsert(String queueName, Address value)
          An entry has been inserted at the head of a queue *** Non-standard, requires plumbing into a collector during debugging ***
 void Debug.queueTailRemove(String queueName, Address value)
          An entry has been inserted at the head of a queue *** Non-standard, requires plumbing into a collector during debugging ***
 void Debug.remsetEntry(Address slot)
          A remset (slot remembering barrier) entry has been traced during collection.
abstract  void Memory.setHeapRange(int id, Address start, Address end)
          Sets the range of addresses associated with a heap.
abstract  void MMTk_Events.tracePageAcquired(Space space, Address startAddress, int numPages)
           
abstract  void MMTk_Events.tracePageReleased(Space space, Address startAddress, int numPages)
           
abstract  void Memory.zero(boolean useNT, Address start, Extent len)
          Zero a region of memory.
 

Uses of Address in org.mmtk.vm.gcspy
 

Fields in org.mmtk.vm.gcspy declared as Address
protected  Address ServerSpace.driver
          a pointer to the C driver, gcspy_gc_drivert *driver
protected  Address ServerInterpreter.server
           
protected  Address Stream.stream
          The address of the C stream, gcspy_gc_stream_t *stream, used in all calls to the C library
 

Methods in org.mmtk.vm.gcspy that return Address
abstract  Address ServerSpace.addStream(int id)
          Add a stream to the native driver
abstract  Address Util.formatSize(String format, int bufsize, int size)
          Pretty print a size, converting from bytes to kilo- or mega-bytes as appropriate
abstract  Address Util.getBytes(String str)
          Convert a String to a 0-terminated array of bytes
(package private)  Address ServerSpace.getDriverAddress()
          Get a pointer to the native driver
 Address ServerInterpreter.getServerAddress()
          Get a pointer to the C server, gcspy_main_server_t.
abstract  Address Util.malloc(int size)
          Allocate an array of bytes with malloc
 

Methods in org.mmtk.vm.gcspy with parameters of type Address
static void Util.dumpRange(Address start, Address end)
          Dump a range in format [start,end)
abstract  void Util.formatSize(Address buffer, int size)
          Pretty print a size, converting from bytes to kilo- or mega-bytes as appropriate
abstract  void Util.free(Address addr)
          Free an array of bytes previously allocated with malloc
 void Stream.setStream(int id, Address str)
          Set the stream address and id (called by AbstractDriver.addStream).
abstract  void ServerSpace.setTilename(int i, Address start, Address end)
          Tell the native driver the tile name.
abstract  void ServerSpace.setTilename(int i, Address format, long value)
          Tell the native driver the tile name.
abstract  void ServerSpace.spaceInfo(Address info)
          Send info for this space
abstract  int Util.sprintf(Address str, Address format, Address value)
          sprintf(char *str, char *format, char* value)
 

Uses of Address in org.vmmagic.unboxed
 

Methods in org.vmmagic.unboxed that return Address
static Address Address.fromIntSignExtend(int address)
          Fabricate an Address instance from an integer, after sign extending the integer.
static Address Address.fromIntZeroExtend(int address)
          Fabricate an Address instance from an integer, after zero extending the integer.
static Address Address.fromLong(long address)
          Fabricate an Address instance from an integer
 Address AddressArray.get(int index)
           
 Address Address.loadAddress()
          Loads an address value from the memory location pointed to by the current instance.
 Address Address.loadAddress(Offset offset)
          Loads an address value from the memory location pointed to by the current instance.
static Address Address.max()
          Return an Address instance that reflects the maximum allowable Address value.
 Address Address.minus(Extent extent)
          Subtract an Extent from this Address, and return the result.
 Address Address.minus(int v)
          Subtract an integer from this Address, and return the result.
 Address Address.minus(Offset offset)
          Subtract an Offset from this Address, and return the result.
 Address Address.plus(Extent extent)
          Add an Extent to this Address, and return the sum.
 Address Address.plus(int v)
          Add an integer to this Address, and return the sum.
 Address Address.plus(Offset offset)
          Add an Offset to this Address, and return the sum.
 Address Address.prepareAddress()
          Prepare for an atomic store operation.
 Address Address.prepareAddress(Offset offset)
          Prepare for an atomic store operation.
 Address ObjectReference.toAddress()
          Get a heap address for the object.
 Address Word.toAddress()
          Type-cast to an address.
static Address Address.zero()
          Return an Address instance that reflects the value zero.
 

Methods in org.vmmagic.unboxed with parameters of type Address
 boolean Address.attempt(Address old, Address value)
          Attempt an atomic store operation.
 boolean Address.attempt(Address old, Address value, Offset offset)
          Attempt an atomic store operation.
 Offset Address.diff(Address addr2)
          Compute the difference between two Addresses and return the result.
 boolean Address.EQ(Address addr2)
          Return true if this Address instance is equal to addr2.
 boolean Address.GE(Address addr2)
          Return true if this Address instance is greater than or equal to addr2.
 boolean Address.GT(Address addr2)
          Return true if this Address instance is greater than addr2.
 boolean Address.LE(Address addr2)
          Return true if this Address instance is less than or equal to addr2.
 boolean Address.LT(Address addr2)
          Return true if this Address instance is less than addr2.
 boolean Address.NE(Address addr2)
          Return true if this Address instance is not equal to addr2.
 void AddressArray.set(int index, Address v)
           
 void Address.store(Address value)
          Stores the address value in the memory location pointed to by the current instance.
 void Address.store(Address value, Offset offset)
          Stores the address value in the memory location pointed to by the current instance.
 

Uses of Address in org.vmutil.options
 

Fields in org.vmutil.options declared as Address
protected  Address AddressOption.defaultValue
           
protected  Address AddressOption.value
           
 

Methods in org.vmutil.options that return Address
 Address AddressOption.getDefaultValue()
          Read the default value of the option.
 Address AddressOption.getValue()
          Read the current value of the option.
 

Methods in org.vmutil.options with parameters of type Address
 void AddressOption.setDefaultValue(Address value)
          Modify the default value of the option.
 

Constructors in org.vmutil.options with parameters of type Address
AddressOption(OptionSet set, String name, String desc, Address defaultValue)
          Create a new int option.