assembler.hpp revision 0
0N/A * Copyright 1997-2006 Sun Microsystems, Inc. All Rights Reserved. 0N/A * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 0N/A * This code is free software; you can redistribute it and/or modify it 0N/A * under the terms of the GNU General Public License version 2 only, as 0N/A * published by the Free Software Foundation. 0N/A * This code is distributed in the hope that it will be useful, but WITHOUT 0N/A * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 0N/A * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 0N/A * version 2 for more details (a copy is included in the LICENSE file that 0N/A * accompanied this code). 0N/A * You should have received a copy of the GNU General Public License version 0N/A * 2 along with this work; if not, write to the Free Software Foundation, 0N/A * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 0N/A * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, 0N/A * CA 95054 USA or visit www.sun.com if you need additional information or 0N/A * have any questions. 0N/A// This file contains platform-independant assembler declarations. 0N/A * Labels represent destinations for control transfer instructions. Such 0N/A * instructions can accept a Label as their target argument. A Label is 0N/A * bound to the current location in the code stream by calling the 0N/A * MacroAssembler's 'bind' method, which in turn calls the Label's 'bind' 0N/A * method. A Label may be referenced by an instruction before it's bound 0N/A * (i.e., 'forward referenced'). 'bind' stores the current code offset 0N/A * in the Label object. 0N/A * If an instruction references a bound Label, the offset field(s) within 0N/A * the instruction are immediately filled in based on the Label's code 0N/A * offset. If an instruction references an unbound label, that 0N/A * instruction is put on a list of instructions that must be patched 0N/A * (i.e., 'resolved') when the Label is bound. 0N/A * 'bind' will call the platform-specific 'patch_instruction' method to 0N/A * fill in the offset field(s) for each unresolved instruction (if there 0N/A * are any). 'patch_instruction' lives in one of the 0N/A * Instead of using a linked list of unresolved instructions, a Label has 0N/A * an array of unresolved instruction code offsets. _patch_index 0N/A * contains the total number of forward references. If the Label's array 0N/A * overflows (i.e., _patch_index grows larger than the array size), a 0N/A * GrowableArray is allocated to hold the remaining offsets. (The cache 0N/A * size is 4 for now, which handles over 99.5% of the cases) 0N/A * Labels may only be used within a single CodeSection. If you need 0N/A * to create references between code sections, use explicit relocations. 0N/A // _loc encodes both the binding state (via its sign) 0N/A // and the binding locator (via its value) of a label. 0N/A // _loc >= 0 bound label, loc() encodes the target (jump) position 0N/A // _loc == -1 unbound label 0N/A // References to instructions that jump to this unresolved label. 0N/A // These instructions need to be patched when the label is bound 0N/A // using the platform-specific patchInstruction() method. 0N/A // To avoid having to allocate from the C-heap each time, we provide 0N/A // a local cache and use the overflow only if we exceed the local cache 0N/A * After binding, be sure 'patch_instructions' is called later to link 0N/A // Iterates over all unresolved instructions for printing 0N/A * Returns the position of the the Label in the code buffer 0N/A * The position is a 'locator', which encodes both offset and section. 0N/A * Adds a reference to an unresolved displacement instruction to 0N/A * this unbound label 0N/A * @param cb the code buffer being patched 0N/A * @param branch_loc the locator of the branch instruction in the code buffer 0N/A * Iterate over the list of patches, resolving the instructions 0N/A * Call patch_instruction on each 'branch_loc' value 0N/A// The Abstract Assembler: Pure assembler doing NO optimizations on the 0N/A// instruction level; i.e., what you write is what you get. 0N/A// The Assembler is generating code into a CodeBuffer. 0N/A // Code emission & accessing 0N/A // This routine is called with a label is used for an address. 0N/A // Labels and displacements truck in offsets, but target must return a PC. 0N/A bool is8bit(
int x)
const {
return -
0x80 <= x && x <
0x80; }
0N/A bool isByte(
int x)
const {
return 0 <= x && x <
0x100; }
0N/A void emit_word(
int x);
// emit a 16-bit word (not a wordSize word!) 0N/A // Instruction boundaries (required when emitting relocatable values). 0N/A // Make it return true on platforms which need to verify 0N/A // instruction boundaries for some operations. 0N/A // save end pointer back to code buf. 0N/A int sect()
const;
// return _code_section->index() 0N/A int locator()
const;
// CodeBuffer::locator(offset(), sect()) 0N/A // Constants in code 0N/A // Associate a comment with the current offset. It will be printed 0N/A // along with the disassembly when printing nmethods. Currently 0N/A // only supported in the instruction section of the code buffer. 0N/A void bind(
Label& L);
// binds an unbound label L to the current code position 0N/A // Move to a different section in the same code buffer. 0N/A // Inform assembler when generating stub code and relocation info 0N/A // Ditto for constants. 0N/A // fp constants support 0N/A // Bang stack to trigger StackOverflowError at a safe location 0N/A // implementation delegates to machine-specific bang_stack_with_offset 0N/A * A platform-dependent method to patch a jump instruction that refers 0N/A * @param branch the location of the instruction to patch 0N/A * @param masm the assembler which generated the branch 0N/A * Platform-dependent method of printing an instruction that needs to be 0N/A * @param branch the instruction to be patched in the buffer.