Subversion Repositories ao486

/*
 * Copyright (c) 2014, Aleksander Osman
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * 
 * * Redistributions of source code must retain the above copyright notice, this
 *   list of conditions and the following disclaimer.
 * 
 * * Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
package ao486.test.layers;
 
import ao486.test.TestUnit.Descriptor;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Random;
 
public class DescriptorTableLayer extends Layer {
 
    public DescriptorTableLayer(Random random, LinkedList<Pair<Long, Long>> prohibited_list, boolean ldtr_valid) {
        this.random = random;
 
        while(true) {
            gdtr_base = norm(random.nextInt());
            gdtr_limit = random.nextInt(0xFFFF + 1);
 
            if( gdtr_base + gdtr_limit < 4294967296L &&
                collides(prohibited_list, gdtr_base, gdtr_base + gdtr_limit) == false    
            ) break;
        }
        prohibited_list.add(new Pair<>(gdtr_base, gdtr_base+gdtr_limit));
 
        while(true) {
            ldtr_base = norm(random.nextInt());
            ldtr_limit = random.nextInt(0xFFFF + 1);
 
            if( ldtr_base + ldtr_limit < 4294967296L &&
                collides(prohibited_list, (int)ldtr_base, (int)(ldtr_base + ldtr_limit)) == false    
            ) break;
        }
        prohibited_list.add(new Pair<>(ldtr_base, ldtr_base+ldtr_limit));
 
        this.ldtr_valid = ldtr_valid;
    }
 
    /** @return -1 : no index that is out of bounds
     */
    public int getOutOfBoundsIndex(boolean is_ldtr) {
        if(is_ldtr) {
            long limit = (new_ldtr_enabled)? new_ldtr_limit : ldtr_limit;
 
            if(limit >= 65535) return -1;
 
            long offset = random.nextInt(65535-(int)limit);
            offset += limit + 1;
 
            return (int)(offset >> 3);
        }
        else {
            if(gdtr_limit >= 65535) return -1;
 
            long offset = random.nextInt(65535-(int)gdtr_limit);
            offset += gdtr_limit + 1;
 
            return (int)(offset >> 3);
        }
    }
 
    public int addDescriptor(boolean is_ldtr, Descriptor desc) {
        long offset = 0;
        long index = 0;
 
        while(true) {
            if(is_ldtr) {
                long limit              = (new_ldtr_enabled)? new_ldtr_limit : ldtr_limit;
                long base               = (new_ldtr_enabled)? new_ldtr_base : ldtr_base;
                HashSet<Integer> set    = (new_ldtr_enabled)? new_ldtr_set : ldtr_set;
 
                if(limit <= 6) return -1;
 
                long ldtr_limit_norm = (limit+1) & 0xFFF8;
                int ldtr_max = (int)(ldtr_limit_norm/8);
                if(set.size() >= ldtr_max) return -1;
 
                offset = random.nextInt((int)((limit+1) & 0xFFF8));
                offset &= 0xFFF8;
 
                if(set.contains((int)offset)) continue;
                set.add((int)offset);
 
                index = offset >> 3; 
                offset += base;
            }
            else {
                if(gdtr_limit <= 6) return -1;
 
                long gdtr_limit_norm = (gdtr_limit+1) & 0xFFF8;
                int gdtr_max = (int)(gdtr_limit_norm/8);
                if(gdtr_set.size() >= gdtr_max) return -1;
 
                offset = random.nextInt((int)((gdtr_limit+1) & 0xFFF8));
                offset &= 0xFFF8;
 
                if(gdtr_set.contains((int)offset)) continue;
                gdtr_set.add((int)offset);
 
                index = offset >> 3;
                offset += gdtr_base;
            }
            break;
        }
 
        for(int i=0; i<8; i++) {
            descr_map.put(offset+i, desc.get_byte(i));
        }
 
        return (int)index;
    }
 
    public void setup_new_ldt(int new_ldtr_base, int new_ldtr_limit) {
        if(new_ldtr_enabled) return;
 
        new_ldtr_enabled = true;
 
        this.new_ldtr_base  = norm(new_ldtr_base);
        this.new_ldtr_limit = norm(new_ldtr_limit);
    }
 
    //----------
    public long    gdtr_base()  { return gdtr_base; }
    public long    gdtr_limit() { return gdtr_limit; }
 
    public long    ldtr_base()  { return ldtr_base; }
    public long    ldtr_limit() { return ldtr_limit; }
 
    public long    ldtr_valid() { return ldtr_valid? 1 : 0; }
 
    public boolean is_memory_not_random(long address) { return descr_map.containsKey(address); }
 
    public Byte get_memory(long address) {
        return (descr_map.containsKey(address) == false)? null : descr_map.get(address);
    }
 
    //----------
    long gdtr_base, gdtr_limit;
    long ldtr_base, ldtr_limit;
    boolean ldtr_valid;
 
    HashMap<Long, Byte>    descr_map = new HashMap<>();
    HashSet<Integer>       ldtr_set  = new HashSet<>();
    HashSet<Integer>       gdtr_set  = new HashSet<>();
 
    //--- new ldt
    boolean new_ldtr_enabled;
    long new_ldtr_base, new_ldtr_limit;
    HashSet<Integer> new_ldtr_set  = new HashSet<>();
}