libmeminfo/libelf64/comparator.cpp

/*
 * Copyright (C) 2024 The Android Open Source Project
 *
 * Licensed 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.
 */

#include <libelf64/comparator.h>

#include <libelf64/elf64.h>

#include <cstring>
#include <iostream>
#include <string>
#include <vector>

#include <elf.h>

namespace android {
namespace elf64 {

static void printEhdrDiff(const std::string& name, unsigned long long hdrField1,
                          unsigned long long hdrField2) {
    std::cout << "\tDiff ehdr1." << name << " = 0x" << std::hex << hdrField1 << " != " << "ehdr2."
              << name << " = 0x" << std::hex << hdrField2 << std::endl;
}

static void printFieldDiff(const std::string& strPrefix, const std::string& fieldName, int index,
                           unsigned long long shdrField1, unsigned long long shdrField2) {
    std::cout << "\tDiff " << strPrefix << "1[" << index << "]." << fieldName << " = 0x" << std::hex
              << shdrField1 << " != " << strPrefix << "2[" << index << "]." << fieldName << " = 0x"
              << std::hex << shdrField2 << std::endl;
}

// Compares the ELF64 Executable Header.
// Returns true if they are equal, otherwise false.
bool Elf64Comparator::compare(const Elf64_Ehdr& ehdr1, const Elf64_Ehdr& ehdr2) {
    bool equal = true;

    std::cout << "\nComparing ELF64 Executable Headers ..." << std::endl;

    // Comparing magic number and other info.
    for (int i = 0; i < EI_NIDENT; i++) {
        if (ehdr1.e_ident[i] != ehdr2.e_ident[i]) {
            std::cout << "Diff ehdr1.e_ident[" << std::dec << i << "]=" << ehdr1.e_ident[i]
                      << " != " << "ehdr2.e_ident[" << i << "]=" << ehdr2.e_ident[i] << std::endl;
            equal = false;
        }
    }

    if (ehdr1.e_type != ehdr2.e_type) {
        printEhdrDiff("e_type", ehdr1.e_type, ehdr2.e_type);
        equal = false;
    }

    if (ehdr1.e_machine != ehdr2.e_machine) {
        printEhdrDiff("e_machine", ehdr1.e_machine, ehdr2.e_machine);
        equal = false;
    }

    if (ehdr1.e_version != ehdr2.e_version) {
        printEhdrDiff("e_version", ehdr1.e_version, ehdr2.e_version);
        equal = false;
    }

    if (ehdr1.e_entry != ehdr2.e_entry) {
        printEhdrDiff("e_entry", ehdr1.e_entry, ehdr2.e_entry);
        equal = false;
    }

    if (ehdr1.e_phoff != ehdr2.e_phoff) {
        printEhdrDiff("e_phoff", ehdr1.e_phoff, ehdr2.e_phoff);
        equal = false;
    }

    if (ehdr1.e_shoff != ehdr2.e_shoff) {
        printEhdrDiff("e_shoff", ehdr1.e_shoff, ehdr2.e_shoff);
        equal = false;
    }

    if (ehdr1.e_flags != ehdr2.e_flags) {
        printEhdrDiff("e_flags", ehdr1.e_flags, ehdr2.e_flags);
        equal = false;
    }

    if (ehdr1.e_ehsize != ehdr2.e_ehsize) {
        printEhdrDiff("e_ehsize", ehdr1.e_ehsize, ehdr2.e_ehsize);
        equal = false;
    }

    if (ehdr1.e_phentsize != ehdr2.e_phentsize) {
        printEhdrDiff("e_phentsize", ehdr1.e_phentsize, ehdr2.e_phentsize);
        equal = false;
    }

    if (ehdr1.e_phnum != ehdr2.e_phnum) {
        printEhdrDiff("e_phnum", ehdr1.e_phnum, ehdr2.e_phnum);
        equal = false;
    }

    if (ehdr1.e_shentsize != ehdr2.e_shentsize) {
        printEhdrDiff("e_shentsize", ehdr1.e_shentsize, ehdr2.e_shentsize);
        equal = false;
    }

    if (ehdr1.e_shnum != ehdr2.e_shnum) {
        printEhdrDiff("e_shnum", ehdr1.e_shnum, ehdr2.e_shnum);
        equal = false;
    }

    if (ehdr1.e_shstrndx != ehdr2.e_shstrndx) {
        printEhdrDiff("e_shstrndx", ehdr1.e_shstrndx, ehdr2.e_shstrndx);
        equal = false;
    }

    return equal;
}

// Compares the ELF64 Program (Segment) Headers.
// Returns true if they are equal, otherwise false.
bool Elf64Comparator::compare(const std::vector<Elf64_Phdr>& phdrs1,
                              const std::vector<Elf64_Phdr>& phdrs2) {
    bool equal = true;

    std::cout << "\nComparing ELF64 Program Headers ..." << std::endl;

    if (phdrs1.size() != phdrs2.size()) {
        std::cout << "\tDiff phdrs1.size() = " << std::dec << phdrs1.size()
                  << " != " << "phdrs2.size() = " << phdrs2.size() << std::endl;
        return false;
    }

    for (int i = 0; i < phdrs1.size(); i++) {
        Elf64_Phdr phdr1 = phdrs1.at(i);
        Elf64_Phdr phdr2 = phdrs2.at(i);

        if (phdr1.p_type != phdr2.p_type) {
            printFieldDiff("phdrs", "p_type", i, phdr1.p_type, phdr2.p_type);
            equal = false;
        }

        if (phdr1.p_flags != phdr2.p_flags) {
            printFieldDiff("phdrs", "p_flags", i, phdr1.p_flags, phdr2.p_flags);
            equal = false;
        }

        if (phdr1.p_offset != phdr2.p_offset) {
            printFieldDiff("phdrs", "p_offset", i, phdr1.p_offset, phdr2.p_offset);
            equal = false;
        }

        if (phdr1.p_vaddr != phdr2.p_vaddr) {
            printFieldDiff("phdrs", "p_vaddr", i, phdr1.p_vaddr, phdr2.p_vaddr);
            equal = false;
        }

        if (phdr1.p_paddr != phdr2.p_paddr) {
            printFieldDiff("phdrs", "p_paddr", i, phdr1.p_paddr, phdr2.p_paddr);
            equal = false;
        }

        if (phdr1.p_filesz != phdr2.p_filesz) {
            printFieldDiff("phdrs", "p_filesz", i, phdr1.p_filesz, phdr2.p_filesz);
            equal = false;
        }

        if (phdr1.p_memsz != phdr2.p_memsz) {
            printFieldDiff("phdrs", "p_memsz", i, phdr1.p_memsz, phdr2.p_memsz);
            equal = false;
        }

        if (phdr1.p_align != phdr2.p_align) {
            printFieldDiff("phdrs", "p_align", i, phdr1.p_align, phdr2.p_align);
            equal = false;
        }
    }

    return equal;
}

// Compares the ELF64 Section Headers.
// Returns true if they are equal, otherwise false.
bool Elf64Comparator::compare(const std::vector<Elf64_Shdr>& shdrs1,
                              const std::vector<Elf64_Shdr>& shdrs2) {
    bool equal = true;

    std::cout << "\nComparing ELF64 Section Headers ..." << std::endl;

    if (shdrs1.size() != shdrs2.size()) {
        std::cout << "\tDiff shdrs1.size() = " << std::dec << shdrs1.size()
                  << " != " << "shdrs2.size() = " << shdrs2.size() << std::endl;
        return false;
    }

    for (int i = 0; i < shdrs1.size(); i++) {
        Elf64_Shdr shdr1 = shdrs1.at(i);
        Elf64_Shdr shdr2 = shdrs2.at(i);

        if (shdr1.sh_name != shdr2.sh_name) {
            printFieldDiff("shdrs", "sh_name", i, shdr1.sh_name, shdr2.sh_name);
            equal = false;
        }

        if (shdr1.sh_type != shdr2.sh_type) {
            printFieldDiff("shdrs", "sh_type", i, shdr1.sh_type, shdr2.sh_type);
            equal = false;
        }

        if (shdr1.sh_flags != shdr2.sh_flags) {
            printFieldDiff("shdrs", "sh_flags", i, shdr1.sh_flags, shdr2.sh_flags);
            equal = false;
        }

        if (shdr1.sh_addr != shdr2.sh_addr) {
            printFieldDiff("shdrs", "sh_addr", i, shdr1.sh_addr, shdr2.sh_addr);
            equal = false;
        }

        if (shdr1.sh_offset != shdr2.sh_offset) {
            printFieldDiff("shdrs", "sh_offset", i, shdr1.sh_offset, shdr2.sh_offset);
            equal = false;
        }

        if (shdr1.sh_size != shdr2.sh_size) {
            printFieldDiff("shdrs", "sh_size", i, shdr1.sh_size, shdr2.sh_size);
            equal = false;
        }

        if (shdr1.sh_link != shdr2.sh_link) {
            printFieldDiff("shdrs", "sh_link", i, shdr1.sh_link, shdr2.sh_link);
            equal = false;
        }

        if (shdr1.sh_info != shdr2.sh_info) {
            printFieldDiff("shdrs", "sh_info", i, shdr1.sh_info, shdr2.sh_info);
            equal = false;
        }

        if (shdr1.sh_addralign != shdr2.sh_addralign) {
            printFieldDiff("shdrs", "sh_addralign", i, shdr1.sh_addralign, shdr2.sh_addralign);
            equal = false;
        }

        if (shdr1.sh_entsize != shdr2.sh_entsize) {
            printFieldDiff("shdrs", "sh_entsize", i, shdr1.sh_entsize, shdr2.sh_entsize);
            equal = false;
        }
    }

    return equal;
}

// Compares the ELF64 Section content.
// Returns true if they are equal, otherwise false.
bool Elf64Comparator::compare(const std::vector<Elf64_Sc>& sections1,
                              const std::vector<Elf64_Sc>& sections2) {
    bool equal = true;

    std::cout << "\nComparing ELF64 Sections (content) ..." << std::endl;

    if (sections1.size() != sections2.size()) {
        std::cout << "\tDiff sections1.size() = " << std::dec << sections1.size()
                  << " != " << "sections2.size() = " << sections2.size() << std::endl;
        return false;
    }

    for (int i = 0; i < sections1.size(); i++) {
        if (sections1.at(i).size != sections2.at(i).size) {
            std::cout << "\tDiff sections1[" << std::dec << i << "].size = " << sections1.at(i).size
                      << " != " << "sections2[" << i << "].size = " << sections2.at(i).size
                      << std::endl;
            equal = false;
            // If size is different, data is not compared.
            continue;
        }

        if (sections1.at(i).data.empty() && sections2.at(i).data.empty()) {
            // The .bss section is empty.
            continue;
        }

        if (sections1.at(i).data.empty() || sections2.at(i).data.empty()) {
            // The index of the .bss section is different for both files.
            equal = false;
            continue;
        }

        if (sections1.at(i).data != sections2.at(i).data) {
            std::cout << "\tDiff " << std::dec << "section1[" << i << "].data != " << "section2["
                      << i << "].data" << std::endl;

            equal = false;
        }
    }

    return equal;
}

}  // namespace elf64
}  // namespace android