Skip to content

Commit 53ce5bc

Browse files
qunaibitqunaibit
committed
Resolve truffle warnings
1 parent 6f2b9b0 commit 53ce5bc

File tree

3 files changed

+92
-36
lines changed

3 files changed

+92
-36
lines changed

‎graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/common/SequenceStorageNodes.java

Lines changed: 80 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -2134,12 +2134,14 @@ SequenceStorage doManagedEmptySameType(SequenceStorage dest, SequenceStorage lef
21342134

21352135
@Specialization
21362136
SequenceStorage doGeneric(SequenceStorage dest, SequenceStorage left, SequenceStorage right,
2137+
@Cached LenNode lenLeft,
2138+
@Cached LenNode lenRight,
21372139
@Cached("createClassProfile()") ValueProfile leftProfile,
21382140
@Cached("createClassProfile()") ValueProfile rightProfile) {
21392141
SequenceStorage leftProfiled = leftProfile.profile(left);
21402142
SequenceStorage rightProfiled = rightProfile.profile(right);
2141-
int len1 = leftProfiled.length();
2142-
int len2 = rightProfiled.length();
2143+
int len1 = lenLeft.execute(leftProfiled);
2144+
int len2 = lenRight.execute(rightProfiled);
21432145
for (int i = 0; i < len1; i++) {
21442146
getSetItemNode().execute(dest, i, getGetItemNode().execute(leftProfiled, i));
21452147
}
@@ -2213,15 +2215,17 @@ public abstract static class ConcatNode extends SequenceStorageBaseNode {
22132215

22142216
@Specialization
22152217
SequenceStorage doRight(SequenceStorage left, SequenceStorage right,
2218+
@Cached LenNode lenLeft,
2219+
@Cached LenNode lenRight,
22162220
@Cached PRaiseNode raiseNode,
22172221
@Cached("createClassProfile()") ValueProfile leftProfile,
22182222
@Cached("createClassProfile()") ValueProfile rightProfile,
22192223
@Cached("create()") BranchProfile outOfMemProfile) {
22202224
try {
22212225
SequenceStorage leftProfiled = leftProfile.profile(left);
22222226
SequenceStorage rightProfiled = rightProfile.profile(right);
2223-
int len1 = leftProfiled.length();
2224-
int len2 = rightProfiled.length();
2227+
int len1 = lenLeft.execute(leftProfiled);
2228+
int len2 = lenRight.execute(rightProfiled);
22252229
// we eagerly generalize the store to avoid possible cascading generalizations
22262230
SequenceStorage generalized = generalizeStore(createEmpty(leftProfiled, rightProfiled, Math.addExact(len1, len2)), rightProfiled);
22272231
return doConcat(generalized, leftProfiled, rightProfiled);
@@ -2233,11 +2237,9 @@ SequenceStorage doRight(SequenceStorage left, SequenceStorage right,
22332237

22342238
private SequenceStorage createEmpty(SequenceStorage l, SequenceStorage r, int len) {
22352239
if (l instanceof EmptySequenceStorage) {
2236-
return createEmptyNode.execute(r, len);
2240+
return createEmptyNode.execute(r, len, -1);
22372241
}
2238-
SequenceStorage empty = createEmptyNode.execute(l, len);
2239-
empty.ensureCapacity(len);
2240-
empty.setNewLength(len);
2242+
SequenceStorage empty = createEmptyNode.execute(l, len, len);
22412243
return empty;
22422244
}
22432245

@@ -2273,7 +2275,6 @@ public static ConcatNode create(Supplier<GeneralizationNode> genNodeProvider) {
22732275

22742276
@ImportStatic(PGuards.class)
22752277
public abstract static class ExtendNode extends SequenceStorageBaseNode {
2276-
@Child private CreateEmptyNode createEmptyNode = CreateEmptyNode.create();
22772278
@Child private GeneralizationNode genNode;
22782279

22792280
private final GenNodeSupplier genNodeProvider;
@@ -2297,6 +2298,8 @@ protected LazyPythonClass getClass(Object value) {
22972298
@Specialization(guards = {"hasStorage(seq)", "cannotBeOverridden(getClass(seq))"})
22982299
SequenceStorage doWithStorage(SequenceStorage s, PSequence seq,
22992300
@Cached PRaiseNode raiseNode,
2301+
@Cached LenNode lenLeft,
2302+
@Cached LenNode lenRight,
23002303
@Cached("createClassProfile()") ValueProfile leftProfile,
23012304
@Cached("createClassProfile()") ValueProfile rightProfile,
23022305
@Cached("createClassProfile()") ValueProfile sequenceProfile,
@@ -2305,8 +2308,8 @@ SequenceStorage doWithStorage(SequenceStorage s, PSequence seq,
23052308
@Cached("create()") ConcatBaseNode concatStoragesNode) {
23062309
SequenceStorage leftProfiled = leftProfile.profile(s);
23072310
SequenceStorage rightProfiled = rightProfile.profile(sequenceProfile.profile(seq).getSequenceStorage());
2308-
int len1 = leftProfiled.length();
2309-
int len2 = rightProfiled.length();
2311+
int len1 = lenLeft.execute(leftProfiled);
2312+
int len2 = lenRight.execute(rightProfiled);
23102313
SequenceStorage dest = null;
23112314
try {
23122315
dest = ensureCapacityNode.execute(leftProfiled, Math.addExact(len1, len2));
@@ -2376,7 +2379,7 @@ SequenceStorage doEmpty(EmptySequenceStorage s, @SuppressWarnings("unused") int
23762379
@Specialization(guards = "times <= 0")
23772380
SequenceStorage doZeroRepeat(SequenceStorage s, @SuppressWarnings("unused") int times,
23782381
@Cached CreateEmptyNode createEmptyNode) {
2379-
return createEmptyNode.execute(s, 0);
2382+
return createEmptyNode.execute(s, 0, -1);
23802383
}
23812384

23822385
/* special but common case: something like '[False] * n' */
@@ -2515,7 +2518,7 @@ SequenceStorage doGeneric(SequenceStorage s, int times,
25152518
@Cached("create()") LenNode lenNode) {
25162519
try {
25172520
int len = lenNode.execute(s);
2518-
SequenceStorage repeated = createEmptyNode.execute(s, Math.multiplyExact(len, times));
2521+
SequenceStorage repeated = createEmptyNode.execute(s, Math.multiplyExact(len, times), -1);
25192522

25202523
for (int i = 0; i < len; i++) {
25212524
setItemNode.execute(repeated, i, getGetItemNode().execute(s, i));
@@ -2951,7 +2954,7 @@ public abstract static class CreateEmptyNode extends SequenceStorageBaseNode {
29512954

29522955
@Child private GetElementType getElementType;
29532956

2954-
public abstract SequenceStorage execute(SequenceStorage s, int cap);
2957+
public abstract SequenceStorage execute(SequenceStorage s, int cap, int len);
29552958

29562959
private ListStorageType getElementType(SequenceStorage s) {
29572960
if (getElementType == null) {
@@ -3002,49 +3005,94 @@ protected boolean isList(SequenceStorage s) {
30023005
}
30033006

30043007
@Specialization(guards = "isBoolean(s)")
3005-
BoolSequenceStorage doBoolean(@SuppressWarnings("unused") SequenceStorage s, int cap) {
3006-
return new BoolSequenceStorage(cap);
3008+
BoolSequenceStorage doBoolean(@SuppressWarnings("unused") SequenceStorage s, int cap, int len) {
3009+
BoolSequenceStorage ss = new BoolSequenceStorage(cap);
3010+
if (len != -1) {
3011+
ss.ensureCapacity(len);
3012+
ss.setNewLength(len);
3013+
}
3014+
return ss;
30073015
}
30083016

30093017
@Specialization(guards = "isByte(s)")
3010-
ByteSequenceStorage doByte(@SuppressWarnings("unused") SequenceStorage s, int cap) {
3011-
return new ByteSequenceStorage(cap);
3018+
ByteSequenceStorage doByte(@SuppressWarnings("unused") SequenceStorage s, int cap, int len) {
3019+
ByteSequenceStorage ss = new ByteSequenceStorage(cap);
3020+
if (len != -1) {
3021+
ss.ensureCapacity(len);
3022+
ss.setNewLength(len);
3023+
}
3024+
return ss;
30123025
}
30133026

30143027
@Specialization(guards = "isChar(s)")
3015-
CharSequenceStorage doChar(@SuppressWarnings("unused") SequenceStorage s, int cap) {
3016-
return new CharSequenceStorage(cap);
3028+
CharSequenceStorage doChar(@SuppressWarnings("unused") SequenceStorage s, int cap, int len) {
3029+
CharSequenceStorage ss = new CharSequenceStorage(cap);
3030+
if (len != -1) {
3031+
ss.ensureCapacity(len);
3032+
ss.setNewLength(len);
3033+
}
3034+
return ss;
30173035
}
30183036

30193037
@Specialization(guards = "isInt(s)")
3020-
IntSequenceStorage doInt(@SuppressWarnings("unused") SequenceStorage s, int cap) {
3021-
return new IntSequenceStorage(cap);
3038+
IntSequenceStorage doInt(@SuppressWarnings("unused") SequenceStorage s, int cap, int len) {
3039+
IntSequenceStorage ss = new IntSequenceStorage(cap);
3040+
if (len != -1) {
3041+
ss.ensureCapacity(len);
3042+
ss.setNewLength(len);
3043+
}
3044+
return ss;
30223045
}
30233046

30243047
@Specialization(guards = "isLong(s)")
3025-
LongSequenceStorage doLong(@SuppressWarnings("unused") SequenceStorage s, int cap) {
3026-
return new LongSequenceStorage(cap);
3048+
LongSequenceStorage doLong(@SuppressWarnings("unused") SequenceStorage s, int cap, int len) {
3049+
LongSequenceStorage ss = new LongSequenceStorage(cap);
3050+
if (len != -1) {
3051+
ss.ensureCapacity(len);
3052+
ss.setNewLength(len);
3053+
}
3054+
return ss;
30273055
}
30283056

30293057
@Specialization(guards = "isDouble(s)")
3030-
DoubleSequenceStorage doDouble(@SuppressWarnings("unused") SequenceStorage s, int cap) {
3031-
return new DoubleSequenceStorage(cap);
3058+
DoubleSequenceStorage doDouble(@SuppressWarnings("unused") SequenceStorage s, int cap, int len) {
3059+
DoubleSequenceStorage ss = new DoubleSequenceStorage(cap);
3060+
if (len != -1) {
3061+
ss.ensureCapacity(len);
3062+
ss.setNewLength(len);
3063+
}
3064+
return ss;
30323065
}
30333066

30343067
@Specialization(guards = "isList(s)")
3035-
ListSequenceStorage doList(@SuppressWarnings("unused") SequenceStorage s, int cap) {
3068+
ListSequenceStorage doList(@SuppressWarnings("unused") SequenceStorage s, int cap, int len) {
30363069
// TODO not quite accurate in case of native sequence storage
3037-
return new ListSequenceStorage(cap);
3070+
ListSequenceStorage ss = new ListSequenceStorage(cap);
3071+
if (len != -1) {
3072+
ss.ensureCapacity(len);
3073+
ss.setNewLength(len);
3074+
}
3075+
return ss;
30383076
}
30393077

30403078
@Specialization(guards = "isTuple(s)")
3041-
TupleSequenceStorage doTuple(@SuppressWarnings("unused") SequenceStorage s, int cap) {
3042-
return new TupleSequenceStorage(cap);
3079+
TupleSequenceStorage doTuple(@SuppressWarnings("unused") SequenceStorage s, int cap, int len) {
3080+
TupleSequenceStorage ss = new TupleSequenceStorage(cap);
3081+
if (len != -1) {
3082+
ss.ensureCapacity(len);
3083+
ss.setNewLength(len);
3084+
}
3085+
return ss;
30433086
}
30443087

30453088
@Fallback
3046-
ObjectSequenceStorage doObject(@SuppressWarnings("unused") SequenceStorage s, int cap) {
3047-
return new ObjectSequenceStorage(cap);
3089+
ObjectSequenceStorage doObject(@SuppressWarnings("unused") SequenceStorage s, int cap, int len) {
3090+
ObjectSequenceStorage ss = new ObjectSequenceStorage(cap);
3091+
if (len != -1) {
3092+
ss.ensureCapacity(len);
3093+
ss.setNewLength(len);
3094+
}
3095+
return ss;
30483096
}
30493097

30503098
public static CreateEmptyNode create() {

‎graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/sequence/storage/ListSequenceStorage.java

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -232,11 +232,15 @@ public Object getIndicativeValue() {
232232
@Override
233233
public boolean equals(SequenceStorage other) {
234234
// TODO: equal algorithm might need more tests
235-
if (other.length() != length() || !(other instanceof ListSequenceStorage)) {
235+
if (!(other instanceof ListSequenceStorage)) {
236+
return false;
237+
}
238+
ListSequenceStorage otherList = (ListSequenceStorage) other;
239+
if (otherList.length() != length()) {
236240
return false;
237241
}
238242

239-
PList[] otherArray = ((ListSequenceStorage) other).getInternalListArray();
243+
PList[] otherArray = otherList.getInternalListArray();
240244
for (int i = 0; i < length(); i++) {
241245
if (values[i] != otherArray[i]) {
242246
return false;

‎graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/sequence/storage/TupleSequenceStorage.java

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -235,11 +235,15 @@ public Object getIndicativeValue() {
235235

236236
@Override
237237
public boolean equals(SequenceStorage other) {
238-
if (other.length() != length() || !(other instanceof TupleSequenceStorage)) {
238+
if (!(other instanceof TupleSequenceStorage)) {
239+
return false;
240+
}
241+
TupleSequenceStorage otherTuple = (TupleSequenceStorage) other;
242+
if (otherTuple.length() != length()) {
239243
return false;
240244
}
241245

242-
PTuple[] otherArray = ((TupleSequenceStorage) other).getInternalPTupleArray();
246+
PTuple[] otherArray = otherTuple.getInternalPTupleArray();
243247
for (int i = 0; i < length(); i++) {
244248
if (values[i] != otherArray[i]) {
245249
return false;

0 commit comments

Comments
 (0)