#!/usr/bin/perl -w
# **********************************************************
# Copyright 2004 VMware, Inc.  All rights reserved.
# -- VMware Confidential
# **********************************************************
use strict;
no strict "refs";
use Getopt::Long;

my $execname = $0;
my (%shared_hash, %peer_hash, %scb_hash,
    %shared_file_hash, %peer_file_hash, %scb_file_hash);
my @vcpu_padding;               # [0] <-> 32 bit, [1] <-> 64-bit
my $error_count = 0;
my $order       = 0;
my $page_size   = 4096;
my ($arg_vmm32_path,
    $arg_vmm64_path,
    $arg_output_path,
    $arg_nm);

sub generating_64bit()
{
    return $arg_output_path =~ m/vmm64/;
}


sub generate_overlay_head(*)
{
    local *FP = shift;
    printf(FP <<EOF
SECTIONS {
    OVERLAY 0 : {
        /* 
         * .mon_addrs contains the addresses of static
         * variables in tc.c that are needed to include TC
         * metadata in core files. These addresses are loaded
         * while the VMM is being processed, but the section is
         * not loaded into VMM memory
         *
         * For some reason, this causes a BFD warning message
         * "warning: allocated section `.vmmaddr' not in segment"
         *
         */
        
        .vmmaddr {
            *(.vmmaddr_tc)
        }
        .patch {
            *(.patch)
        }
        .hws_32h_32v {   /* vmx 32-bit vmm to 32-bit host worldswitch */
            *(.hws_32h_32v)
        }
        .hws_64h_32v { /* vmx 64-bit host to 32-bit vmm worldswitch */
            *(.hws_64h_32v)
        }
        .hws_64h_64v { /* vmx 64-bit host to 64-bit vmm worldswitch */
            *(.hws_64h_64v)
        }
        .vws_64h_32v { /* 32-bit vmm to 64-bit host worldswitch */
            *(.vws_64h_32v)
        }
        .hws_32h_64v { /* vmx 32-bit host to 64-bit vmm worldswitch */
            *(.hws_32h_64v)
        }
        .vws_32h_64v { /* vmx 64-bit vmm to 32-bit host worldswitch */
            *(.vws_32h_64v)
        }
        .scb { /* Table of shared callback function pointers. */
            KEEP(*(.scb))
        }
EOF
    );
}

sub generate_overlay_tail(*)
{
    local *FP = shift;
    printf(FP
           "    } :NONE\n" .
           "}\n");
}

sub generate_overlay_metadata(*$$)
{
    local *FP     = shift;
    my $sect_name = shift;
    my $hash      = shift;

    printf(FP "        .%s_meta {\n", $sect_name);
    printf(FP "            __%s_meta_start = ABSOLUTE(.);\n", $sect_name);
    foreach my $symbol (keys %{$hash}) {
        my $string_length = 40; # '\0'-included (metadata is 48 bytes)
        my $i;

        printf(FP "            _meta_$symbol = .;\n");
        if (length($symbol) >= $string_length) {
            die("'$execname: $symbol' length is greater than $string_length\n");
        }
        for ($i = 0; $i < length($symbol); ++$i) {
            my $ch = substr($symbol, $i, 1);
            printf(FP "            BYTE(%3d);   /* %1s */ \n", ord($ch), $ch);
        }
        while ($i < $string_length) {
            printf(FP "            BYTE(0);\n");
            ++$i;
        }
        printf(FP "\n");
        printf(FP "            LONG($symbol - __%s_start);\n", $sect_name);

        my ($def_order, $def_size, $def_kind) = split(/:/, $hash->{$symbol});
        printf(FP "            LONG($def_size);  /* sizeof */\n");
    }
    printf(FP "        }\n");
}

sub generate_scb_references($)
{
#    return ;   # REMOVE THIS

    my $file = (shift) . "/callbacks.extern";
    open(FP, ">$file") || die("Unable to create '$file'\n");
    
    foreach my $symbol (keys %{scb_hash}) {
        my ($def_order, $def_size, $def_kind) = split(/:/, $scb_hash{$symbol});
        if ($def_kind == 3 ||
            (generating_64bit() && ($def_kind & 2)) ||
            (!generating_64bit() && ($def_kind & 1))) {
            printf(FP "EXTERN($symbol)\n");
        }
    }
}

sub generate_overlay($)
{
    my $file = (shift) . "/overlay.ld";
    open(OVERLAY, ">$file") || die("Unable to create '$file'\n");
    generate_overlay_head(*OVERLAY{IO});
    generate_overlay_metadata(*OVERLAY{IO}, "shared", \%shared_hash);
    generate_overlay_metadata(*OVERLAY{IO}, "peer", \%peer_hash);
    generate_overlay_tail(*OVERLAY{IO});
    close(OVERLAY);
}

sub read_symbols($$$$)
{
    my $symfile      = shift;
    my $symbol_hash  = shift;
    my $file_hash    = shift;
    my $symfile_kind = shift; # 1 -> 32 bit symbols; 2 -> 64 bit symbols
    my ($sym_name, $sym_size, $sym_objfile);

    open(INPUT, "<$symfile") || die("Unable to open '$symfile'\n");
    LINE: while (<INPUT>) {
        chop;
        if (/^(\d+)$/) {
            if (!defined($vcpu_padding[$symfile_kind - 1])) {
                $vcpu_padding[$symfile_kind - 1] = int($1);
            } else {
                die("vcpu padding already defined as " .
                    "'%d'.  New value '$1' illegal\n",
                    $vcpu_padding[$symfile_kind - 1]);
            }
        } else {
            ($sym_name, $sym_size, $sym_objfile) = split(/:/);
            $sym_size = hex($sym_size);
            if (defined($symbol_hash->{$sym_name})) {
                # Symbol already defined.
                # Make sure:
                #   - not defined already in the current vmm size
                #   - size is the same
                my ($def_order,
                    $def_size,
                    $def_kind) = split(/:/, $symbol_hash->{$sym_name});
                $def_kind      = hex($def_kind);
                
                if ($def_kind & $symfile_kind) {
                    printf(STDERR "$execname: " .
                           "symbol '$sym_name' multiply defined in '$symfile'\n");
                    $error_count++;
                }
                if ($def_size != $sym_size) {
                    printf(STDERR "$execname: " .
                           "symbol '$sym_name' has size '$def_size'; " .
                           "new size '$sym_size' from '$symfile' does not match \n");
                    $error_count++;
                    next LINE;
                }
                $def_kind |= $symfile_kind; # incl bit to denote symfile
                $symbol_hash->{$sym_name}   = join(':', $def_order, $def_size,
                                            $def_kind);
                if ($file_hash->{$sym_name} ne $sym_objfile) {
                   $file_hash->{$sym_name} =
                       join(':', $file_hash->{$sym_name}, $sym_objfile);
                }
            } else {
                $symbol_hash->{$sym_name}   = join(':', $order, $sym_size,
                                            $symfile_kind);
                $file_hash->{$sym_name} = $sym_objfile;
            }
            ++$order;
        }
    }
    close(INPUT);
}

sub validate_padding()
{
    # Check that at least one of the vcpu padding sizes was defined.
    if (!defined($vcpu_padding[0]) && !defined($vcpu_padding[1])) {
        die("No vcpu padding was specified\n");
    }
    if (!defined($vcpu_padding[0])) {
        warn("32-bit VCPU padding not defined\n");
    }
    if (!defined($vcpu_padding[1])) {
        warn("64-bit VCPU padding not defined; see PR46756\n");
    }
    if (defined($vcpu_padding[0]) && defined($vcpu_padding[1]) &&
        ($vcpu_padding[0] != $vcpu_padding[1])) {
        die("32- and 64-bit vcpu paddings do not match (%d -vs- %d)\n",
            $vcpu_padding[0], $vcpu_padding[1]);
    }
        
}

sub alignment($$)
{
    my $symbol   = shift;
    my $def_size = shift;
    my $align    = $def_size > 4 ? 4 : $def_size;
    if ($align & ($align - 1)) {
        die("Alignment for '$symbol' is not a power of 2\n");
    }
    return $align;
}
    
sub allocate_symbol(*$$$)
{
    local *FP     = shift;
    my $symbol    = shift;
    my $hash      = shift;
    my $file_hash = shift;

    my ($i, $sym_size, $sym_defn);
    my ($def_order,
        $def_size, $def_kind) = split(/:/,
                                      $hash->{$symbol});

    printf(FP
           "\t. = ALIGN(%d);\n" .
           "\t%-32s /* [%2s %2s] %s */\n" .
           "\t. += %d;\n",
           alignment($symbol, $def_size),
           "$symbol = .;",
           $def_kind & 1 ? "32" : "", $def_kind & 2 ? "64" : "",
           defined($file_hash->{$symbol}) ?
              "$file_hash->{$symbol}" : "<script internal>",
           $def_size);
}

sub fill_in_padded_area(*$$$)
{
    local *FP          = shift;
    my $space_in_bytes = shift;
    my $hash           = shift;
    my $file_hash      = shift;
    my $give_up        = 0;
    my $page_offset    = $page_size - $space_in_bytes;
    my ($alignment, $new_offset, $key);

    while ($page_offset < $page_size && !$give_up) {
        $give_up = 1;
        foreach $key (keys(%{$hash})) {
            my ($def_order,
                $def_size,
                $def_kind) = split(/:/, $hash->{$key});

            $alignment  = alignment($key, $def_size);
            $new_offset = ($page_offset + $alignment - 1) & ~($alignment - 1);

            if ($new_offset + $def_size <= $page_size) {
                allocate_symbol(*FP{IO}, $key, $hash, $file_hash);
                delete $hash->{$key};
                $page_offset = $new_offset + $def_size;
                $give_up     = 0;
            }
        }
        
    }
}

sub generate_per_vcpu(*$$)
{
    local *FP       = shift;
    my $hash        = shift;
    my $file_hash   = shift;
    my $symbol_name = "perVcpu";
    my ($n_elements, $actual_size);

    # The perVcpu variable is treated specially so that the 'padding'
    # contained internally to each array element can be reused for
    # shared area storage.

    validate_padding();
    # inv: $vcpu_padding[0] == $vcpu_padding[1]

    if (defined($hash->{$symbol_name})) {
        my ($def_order,
            $def_size,
            $def_kind) = split(/:/, $hash->{$symbol_name});
        delete $hash->{$symbol_name};
        $n_elements = $def_size / $page_size;
        $actual_size = ($def_size / $n_elements) - $vcpu_padding[0];

        # The actual skulduggery occurs from this point on.  In the
        # source there is a single 'perVcpu' variable which is defined
        # as an array.  The generated object code will be able to
        # correctly access the fields of each index, but it's up to
        # the programmer to ensure that the '_pad_recycled' field is
        # not touched.  Since it is expected that '_pad_recycled' is
        # not touched, it can be used to allocate other shared area
        # variables.
        #
        # A base 'perVcpu' variable is allocated, and the
        # '_pad_recycled' area is overwritten with other variables.
        # Following that, the names of the remaining 'perVcpu' array
        # indices are given names which are not accessible from C.

        # Base 'perVcpu' symbol
        $hash->{$symbol_name} = join(':', 0, $actual_size, $def_kind);
        allocate_symbol(*FP{IO}, $symbol_name, $hash, $file_hash);
        delete $hash->{$symbol_name};
        fill_in_padded_area(*FP{IO}, $vcpu_padding[0], $hash, $file_hash);

        # Remaining array elements
        for (my $i = 1; $i < $n_elements; ++$i) {
            my $mangled_name = "." . $symbol_name . "_$i";
            $hash->{$mangled_name} = join(':', 0, $actual_size, $def_kind);
            printf(FP
                   "\n" .
                   "\t. = ALIGN($page_size);\n");
            allocate_symbol(*FP{IO}, $mangled_name, $hash, $file_hash);
            delete $hash->{$mangled_name};
            fill_in_padded_area(*FP{IO}, $vcpu_padding[0], $hash, $file_hash);
        }
    }
}

sub get_area_address_32($)
{
    my $sect_name = shift;
    my $regex     = "__" . $sect_name . "_start";
    my $vmm32     = "$arg_vmm32_path/vmm32";

    open(NM, "$arg_nm $vmm32|") || die "Unable to use 'nm' on $vmm32\n";
    while (<NM>) {
        chop;
        if (/$regex/) {
            my ($addr, $type, $name) = split(/ /, $_);
            close(NM);
            return hex($addr);
        }
    }
    close(NM);
    die "No '$regex' found in '$vmm32'\n";
}

sub generate_section(*$$$)
{
    local *FP     = shift;
    my $sect_name = shift;
    my $hash      = shift;
    my $file_hash = shift;
    my ($key, $value, $order);
    my %tmp_hash;

    printf(FP "\t. = ALIGN($page_size);\n" .
           "\t__%s_start = .;\n", $sect_name);

    printf(FP "\n");
    if (!generating_64bit()) {
        printf(FP "\t__%s_start_vmm32 = __%s_start;\n",
               $sect_name, $sect_name);
    } else {
        printf(FP "\t__%s_start_vmm32 = %#x;\n",
               $sect_name,
               get_area_address_32($sect_name));
    }

    printf(FP "\n");
    if ($sect_name eq "shared") {
        generate_per_vcpu(*FP{IO}, $hash, $file_hash);
    }

    # Create a hash table of symbol names based on definition order
    # Use definition order to help keep lock and locked variables
    # close together.
    while (($key, $value) = each %{$hash}) {
        my ($def_order, $def_size, $def_kind) = split(/:/, $value);
        if (!defined($tmp_hash{$def_order})) {
            $tmp_hash{$def_order} = $key;
        } else {
            die("Definition order '$def_order' error; " .
                "first '$tmp_hash{$def_order}', second '$key'\n");
        }
    }

    # Output symbols, ordered by symbol definition order
    printf(FP "\n");
    foreach $order (sort { $a <=> $b } keys(%tmp_hash)) {
        allocate_symbol(*FP{IO}, $tmp_hash{$order}, $hash, $file_hash);
    }

    printf(FP "\t__%s_end = .;\n\n", $sect_name);
}

sub generate_sections($)
{
    my $pathname = shift;

    open(FP, ">$pathname/shared.section") ||
        die("Unable to open output file '$pathname'\n");
    printf(FP "SECTIONS {\n");
    generate_section(*FP{IO}, "peer", \%peer_hash, \%peer_file_hash);
    generate_section(*FP{IO}, "shared", \%shared_hash, \%shared_file_hash);

    # .peer output section allocation
    printf(FP
           "\n" .
           "\t.peer __peer_start : {\n" .
           "\t      *(.peer*)\n" .
           "\t} > monitor\n" .
           "");

    # Ensure that the by-hand allocation of the peer symbols is no
    # bigger than the linker allocation of the section through the
    # object modules (in fact, the linker allocation is probably
    # slightly larger due to padding between object modules by ld64).
    printf(FP
           "\t__peer_assert = " .
           "ASSERT((. - __peer_start) >= (__peer_end - __peer_start), " .
           '"Peer area allocation failure");' .
           "\n");

    # .shared output section allocation
    printf(FP
           "\n" .
           "\tOVERLAY __shared_start : {\n" .
           "\t   .pervcpu {\n" .
           "\t      *sharedAreaPerVcpu.o(.shared*)\n" .
           "\t   }\n" .
           "\t   .shared {\n" .
           "\t      *(EXCLUDE_FILE (*sharedAreaPerVcpu.o) .shared*)\n" .
           "\t      . += __shared_end - .;\n" .
           "\t   }\n" .
           "\t} > monitor\n" .
           "");

    # Ensure that the by-hand allocation of the shared symbols is
    # exactly the same size as the linker allocation of the section
    # through the object modules.
    printf(FP "\t__shared_assert = " .
           "ASSERT(. - __shared_end == 0, " .
           '"Shared area allocation failure");'  .
           "\n");

    printf(FP "}\n");
    close(FP);
}

sub process_args()
{
    my $ok = GetOptions("-path32=s" => \$arg_vmm32_path,
                        "-path64=s" => \$arg_vmm64_path,
                        "-output=s" => \$arg_output_path,
                        "-nm=s"     => \$arg_nm);

    if (!$ok) {
        die "Unable to process command line arguments\n";
    }
    if (!defined($arg_vmm32_path)) {
        die "-path32 was not specified\n";
    }
    if (!defined($arg_vmm64_path)) {
        die "-path64 was not specified\n";
    }
    if (!defined($arg_output_path)) {
        die "-output was not specified\n";
    }
    if (!defined($arg_nm)) {
        die "-nm was not specified\n";
    }
}

$execname =~ s/.*\///;
process_args();

read_symbols($arg_vmm32_path . "/shared.symbols",
             \%shared_hash, \%shared_file_hash, 1);
read_symbols($arg_vmm32_path . "/peer.symbols",
             \%peer_hash, \%peer_file_hash, 1);
read_symbols($arg_vmm32_path . "/scb.symbols",
             \%scb_hash, \%scb_file_hash, 1);

read_symbols($arg_vmm64_path . "/shared.symbols",
             \%shared_hash, \%shared_file_hash, 2);
read_symbols($arg_vmm64_path . "/peer.symbols",
             \%peer_hash, \%peer_file_hash, 2);
read_symbols($arg_vmm64_path . "/scb.symbols",
             \%scb_hash, \%scb_file_hash, 2);

generate_scb_references($arg_output_path);
generate_overlay($arg_output_path);
generate_sections($arg_output_path);

if ($error_count > 0) {
    die("$execname: processing failed; error count: $error_count\n");
}