AStoreable.java

/*
 * Licensed to Elasticsearch under one or more contributor
 * license agreements. See the NOTICE file distributed with
 * this work for additional information regarding copyright
 * ownership. Elasticsearch licenses this file to you under
 * the Apache License, Version 2.0 (the "License"); you may
 * not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.elasticsearch.painless.node;

import org.elasticsearch.painless.Definition.Type;
import org.elasticsearch.painless.Globals;
import org.elasticsearch.painless.Location;
import org.elasticsearch.painless.MethodWriter;
import org.objectweb.asm.Label;
import org.objectweb.asm.Opcodes;

import java.util.Objects;
import java.util.function.Consumer;

/**
 * The super class for an expression that can store a value in local memory.
 */
abstract class AStoreable extends AExpression {

    /**
     * Set to true when this node is an lhs-expression and will be storing
     * a value from an rhs-expression.
     */
    boolean write = false;

    /**
     * Standard constructor with location used for error tracking.
     */
    AStoreable(Location location) {
        super(location);

        prefix = null;
    }

    /**
     * This constructor is used by variable/method chains when postfixes are specified.
     */
    AStoreable(Location location, AExpression prefix) {
        super(location);

        this.prefix = Objects.requireNonNull(prefix);
    }

    /**
     * Returns a value based on the number of elements previously placed on the
     * stack to load/store a certain piece of a variable/method chain.  This is
     * used during the writing phase to dup stack values from this storeable as
     * necessary during certain store operations.
     * <p>
     * Examples:
     * {@link EVariable} returns 0 because it requires nothing extra to perform
     *                   a load/store
     * {@link PSubField} returns 1 because it requires the name of the field as
     *                   an index on the stack to perform a load/store
     * {@link PSubBrace} returns 2 because it requires both the variable slot and
     *                   an index into the array on the stack to perform a
     *                   load/store
     */
    abstract int accessElementCount();

    /**
     * Returns true if this node or a sub-node of this node can be optimized with
     * rhs actual type to avoid an unnecessary cast.
     */
    abstract boolean isDefOptimized();

    /**
     * If this node or a sub-node of this node uses dynamic calls then
     * actual will be set to this value. This is used for an optimization
     * during assignment to def type targets.
     */
    abstract void updateActual(Type actual);

    /**
     * Called before a storeable node is loaded or stored.  Used to load prefixes and
     * push load/store constants onto the stack if necessary.
     */
    abstract void setup(MethodWriter writer, Globals globals);

    /**
     * Called to load a storable used for compound assignments.
     */
    abstract void load(MethodWriter writer, Globals globals);

    /**
     * Called to store a storabable to local memory.
     */
    abstract void store(MethodWriter writer, Globals globals);

    /**
     * Writes the opcodes to flip a negative array index (meaning slots from the end of the array) into a 0-based one (meaning slots from
     * the start of the array).
     */
    static void writeIndexFlip(MethodWriter writer, Consumer<MethodWriter> writeGetLength) {
        Label noFlip = new Label();
        // Everywhere when it says 'array' below that could also be a list
        // The stack after each instruction:       array, unnormalized_index
        writer.dup();                           // array, unnormalized_index, unnormalized_index
        writer.ifZCmp(Opcodes.IFGE, noFlip);    // array, unnormalized_index
        writer.swap();                          // negative_index, array
        writer.dupX1();                         // array, negative_index, array
        writeGetLength.accept(writer);          // array, negative_index, length
        writer.visitInsn(Opcodes.IADD);         // array, noralized_index
        writer.mark(noFlip);                    // array, noralized_index
    }
}