Mercurial > hg > graal-compiler

comparison graal/com.oracle.jvmci.asm.amd64/src/com/oracle/jvmci/asm/amd64/AMD64Address.java @ 21708:6df25b1418be

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
moved com.oracle.asm.** to jvmci-util.jar (JBS:GRAAL-53)
author Doug Simon <doug.simon@oracle.com>
date Wed, 03 Jun 2015 18:06:44 +0200
parents graal/com.oracle.graal.asm.amd64/src/com/oracle/graal/asm/amd64/AMD64Address.java@48c1ebd24120
children
comparison
equal deleted inserted replaced
21707:e0f311284930 21708:6df25b1418be
1 /*
2 * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23 package com.oracle.jvmci.asm.amd64;
24
25 import com.oracle.jvmci.code.Register;
26 import com.oracle.jvmci.code.AbstractAddress;
27
28 /**
29 * Represents an address in target machine memory, specified via some combination of a base
30 * register, an index register, a displacement and a scale. Note that the base and index registers
31 * may be a variable that will get a register assigned later by the register allocator.
32 */
33 public final class AMD64Address extends AbstractAddress {
34
35 private final Register base;
36 private final Register index;
37 private final Scale scale;
38 private final int displacement;
39
40 /**
41 * Creates an {@link AMD64Address} with given base register, no scaling and no displacement.
42 *
43 * @param base the base register
44 */
45 public AMD64Address(Register base) {
46 this(base, Register.None, Scale.Times1, 0);
47 }
48
49 /**
50 * Creates an {@link AMD64Address} with given base register, no scaling and a given
51 * displacement.
52 *
53 * @param base the base register
54 * @param displacement the displacement
55 */
56 public AMD64Address(Register base, int displacement) {
57 this(base, Register.None, Scale.Times1, displacement);
58 }
59
60 /**
61 * Creates an {@link AMD64Address} with given base and index registers, scaling and
62 * displacement. This is the most general constructor.
63 *
64 * @param base the base register
65 * @param index the index register
66 * @param scale the scaling factor
67 * @param displacement the displacement
68 */
69 public AMD64Address(Register base, Register index, Scale scale, int displacement) {
70 this.base = base;
71 this.index = index;
72 this.scale = scale;
73 this.displacement = displacement;
74
75 assert scale != null;
76 }
77
78 /**
79 * A scaling factor used in the SIB addressing mode.
80 */
81 public enum Scale {
82 Times1(1, 0),
83 Times2(2, 1),
84 Times4(4, 2),
85 Times8(8, 3);
86
87 private Scale(int value, int log2) {
88 this.value = value;
89 this.log2 = log2;
90 }
91
92 /**
93 * The value (or multiplier) of this scale.
94 */
95 public final int value;
96
97 /**
98 * The {@linkplain #value value} of this scale log 2.
99 */
100 public final int log2;
101
102 public static Scale fromInt(int scale) {
103 switch (scale) {
104 case 1:
105 return Times1;
106 case 2:
107 return Times2;
108 case 4:
109 return Times4;
110 case 8:
111 return Times8;
112 default:
113 return null;
114 }
115 }
116 }
117
118 @Override
119 public String toString() {
120 StringBuilder s = new StringBuilder();
121 s.append("[");
122 String sep = "";
123 if (!getBase().equals(Register.None)) {
124 s.append(getBase());
125 sep = " + ";
126 }
127 if (!getIndex().equals(Register.None)) {
128 s.append(sep).append(getIndex()).append(" * ").append(getScale().value);
129 sep = " + ";
130 }
131 if (getDisplacement() < 0) {
132 s.append(" - ").append(-getDisplacement());
133 } else if (getDisplacement() > 0) {
134 s.append(sep).append(getDisplacement());
135 }
136 s.append("]");
137 return s.toString();
138 }
139
140 /**
141 * @return Base register that defines the start of the address computation. If not present, is
142 * denoted by {@link Register#None}.
143 */
144 public Register getBase() {
145 return base;
146 }
147
148 /**
149 * @return Index register, the value of which (possibly scaled by {@link #getScale}) is added to
150 * {@link #getBase}. If not present, is denoted by {@link Register#None}.
151 */
152 public Register getIndex() {
153 return index;
154 }
155
156 /**
157 * @return Scaling factor for indexing, dependent on target operand size.
158 */
159 public Scale getScale() {
160 return scale;
161 }
162
163 /**
164 * @return Optional additive displacement.
165 */
166 public int getDisplacement() {
167 return displacement;
168 }
169 }