C++ BVariant::SwapEndianess方法代码示例

//.........这里部分代码省略.........
    if (totalBitSize > 64) {
        TRACE_LOCALS("  -> longer than 64 bits: unsupported\n");
        return B_UNSUPPORTED;
    }

    uint64 valueBitSize = BVariant::SizeOfType(valueType) * 8;
    if (!shortValueIsFine && totalBitSize < valueBitSize) {
        TRACE_LOCALS("  -> too short for value type (%" B_PRIu64 " vs. %"
                     B_PRIu64 " bits)\n", totalBitSize, valueBitSize);
        return B_BAD_VALUE;
    }

    // Load the data. Since the BitBuffer class we're using only supports big
    // endian bit semantics, we convert all data to big endian before pushing
    // them to the buffer. For later conversion to BVariant we need to make sure
    // the final buffer has the size of the value type, so we pad the most
    // significant bits with zeros.
    BitBuffer valueBuffer;
    if (totalBitSize < valueBitSize)
        valueBuffer.AddZeroBits(valueBitSize - totalBitSize);

    bool bigEndian = fArchitecture->IsBigEndian();
    const Register* registers = fArchitecture->Registers();
    for (int32 i = 0; i < count; i++) {
        ValuePieceLocation piece = location->PieceAt(
                                       bigEndian ? i : count - i - 1);
        uint32 bytesToRead = piece.size;
        uint32 bitSize = piece.bitSize;
        uint8 bitOffset = piece.bitOffset;
        // TODO: the offset's ordinal position and direction aren't
        // specified by DWARF, and simply follow the target language.
        // To handle non C/C++ languages properly, the corresponding
        // SourceLanguage will need to be passed in and extended to
        // return the relevant information.

        switch (piece.type) {
        case VALUE_PIECE_LOCATION_INVALID:
        case VALUE_PIECE_LOCATION_UNKNOWN:
            return B_ENTRY_NOT_FOUND;
        case VALUE_PIECE_LOCATION_MEMORY:
        {
            target_addr_t address = piece.address;

            TRACE_LOCALS("  piece %" B_PRId32 ": memory address: %#"
                         B_PRIx64 ", bits: %" B_PRIu32 "\n", i, address, bitSize);

            uint8 pieceBuffer[kMaxPieceSize];
            ssize_t bytesRead = fTeamMemory->ReadMemory(address,
                                pieceBuffer, bytesToRead);
            if (bytesRead < 0)
                return bytesRead;
            if ((uint32)bytesRead != bytesToRead)
                return B_BAD_ADDRESS;

            TRACE_LOCALS_ONLY(
                TRACE_LOCALS("  -> read: ");
                for (ssize_t k = 0; k < bytesRead; k++)
                TRACE_LOCALS("%02x", pieceBuffer[k]);
                TRACE_LOCALS("\n");
            )

                // convert to big endian
                if (!bigEndian) {
                    for (int32 k = bytesRead / 2 - 1; k >= 0; k--) {
                        std::swap(pieceBuffer[k],
                                  pieceBuffer[bytesRead - k - 1]);
                    }
                }

            valueBuffer.AddBits(pieceBuffer, bitSize, bitOffset);
            break;
        }
        case VALUE_PIECE_LOCATION_REGISTER:
        {
            TRACE_LOCALS("  piece %" B_PRId32 ": register: %" B_PRIu32
                         ", bits: %" B_PRIu32 "\n", i, piece.reg, bitSize);

            if (fCpuState == NULL) {
                WARNING("ValueLoader::LoadValue(): register piece, but no "
                        "CpuState\n");
                return B_UNSUPPORTED;
            }

            BVariant registerValue;
            if (!fCpuState->GetRegisterValue(registers + piece.reg,
                                             registerValue)) {
                return B_ENTRY_NOT_FOUND;
            }
            if (registerValue.Size() < bytesToRead)
                return B_ENTRY_NOT_FOUND;

            if (!bigEndian) {
                registerValue.SwapEndianess();
                bitOffset = registerValue.Size() * 8 - bitOffset - bitSize;
            }
            valueBuffer.AddBits(registerValue.Bytes(), bitSize, bitOffset);
            break;
        }
        }
    }