Ghidra is a software reverse engineering (SRE) framework
GP-6627 cleanup NumericUtils hex string and mem byte iteration
dev7473681678fe1670fa
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/checksums/BasicChecksumAlgorithm.java b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/checksums/BasicChecksumAlgorithm.javaindex 63b75d0620..635158c04d 100644--- a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/checksums/BasicChecksumAlgorithm.java+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/checksums/BasicChecksumAlgorithm.java@@ -4,9 +4,9 @@* 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.@@ -101,7 +101,7 @@ public abstract class BasicChecksumAlgorithm extends ChecksumAlgorithm {if (monitor.isCancelled()) {throw new CancelledException();}- long b = bytes.next() & 0xFF;+ long b = Byte.toUnsignedLong(bytes.nextByte());long next = (size == SupportedByteSize.CHECKSUM8) ? b: b << ((numBytes - 1) - i % numBytes) * 8;if (xor) {diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/checksums/CRC16CCITTChecksumAlgorithm.java b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/checksums/CRC16CCITTChecksumAlgorithm.javaindex 1b250f1261..dd0b4a08d6 100644--- a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/checksums/CRC16CCITTChecksumAlgorithm.java+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/checksums/CRC16CCITTChecksumAlgorithm.java@@ -4,9 +4,9 @@* 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.@@ -87,7 +87,7 @@ public class CRC16CCITTChecksumAlgorithm extends ChecksumAlgorithm {if (monitor.isCancelled()) {throw new CancelledException();}- byte b = it.next();+ byte b = it.nextByte();int value = 0;if (b < 0) {value = b + 256;diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/checksums/CRC16ChecksumAlgorithm.java b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/checksums/CRC16ChecksumAlgorithm.javaindex cf8273e81a..f79bf7bd43 100644--- a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/checksums/CRC16ChecksumAlgorithm.java+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/checksums/CRC16ChecksumAlgorithm.java@@ -4,9 +4,9 @@* 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.@@ -88,7 +88,7 @@ public class CRC16ChecksumAlgorithm extends ChecksumAlgorithm {if (monitor.isCancelled())throw new CancelledException();- byte b = it.next();+ byte b = it.nextByte();crc = crctab16[(int) ((crc ^ b) & 0xff)] ^ (crc >> 8);}if (onesComp) {diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/checksums/DigestChecksumAlgorithm.java b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/checksums/DigestChecksumAlgorithm.javaindex e3b497a92d..c42b1a36d1 100644--- a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/checksums/DigestChecksumAlgorithm.java+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/checksums/DigestChecksumAlgorithm.java@@ -4,9 +4,9 @@* 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.@@ -53,7 +53,7 @@ public abstract class DigestChecksumAlgorithm extends ChecksumAlgorithm {if (monitor.isCancelled()) {throw new CancelledException();}- digester.update(bytes.next());+ digester.update(bytes.nextByte());}checksum = digester.digest();}diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/checksums/MemoryInputStream.java b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/checksums/MemoryInputStream.javaindex 3e6fd68689..7800574984 100644--- a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/checksums/MemoryInputStream.java+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/checksums/MemoryInputStream.java@@ -1,13 +1,12 @@/* ###* IP: GHIDRA- * REVIEWED: YES** 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.@@ -16,33 +15,22 @@*/package ghidra.app.plugin.core.checksums;+import java.io.IOException;+import java.io.InputStream;+import ghidra.program.model.address.AddressSetView;import ghidra.program.model.mem.Memory;-import ghidra.program.model.mem.MemoryAccessException;import ghidra.program.model.util.MemoryByteIterator;-import java.io.IOException;-import java.io.InputStream;-class MemoryInputStream extends InputStream {MemoryByteIterator it;+MemoryInputStream(Memory mem, AddressSetView set) {it = new MemoryByteIterator(mem, set);}- /**- * @see java.io.InputStream#read()- */+@Override- public int read() throws IOException {- try {- if (it.hasNext()) {- return it.next() & 0xff;- }- }- catch (MemoryAccessException e) {- StackTraceElement ste = e.getStackTrace()[0];- throw new IOException(e.toString());- }- return -1;+ public int read() throws IOException {+ return it.hasNext() ? Byte.toUnsignedInt(it.nextByte()) : -1;}}diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/ByteCopier.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/ByteCopier.javaindex a8d28f1df5..dac8139f74 100644--- a/Ghidra/Features/Base/src/main/java/ghidra/app/util/ByteCopier.java+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/ByteCopier.java@@ -221,7 +221,7 @@ public abstract class ByteCopier {TaskMonitor monitor) {Memory memory = currentProgram.getMemory();- ByteIterator bytes = new ByteIterator(addresses, memory);+ MemoryByteIterator bytes = new MemoryByteIterator(memory, addresses);return NumericUtilities.convertBytesToString(bytes, delimiter);}@@ -545,53 +545,6 @@ public abstract class ByteCopier {}}- /**- * An iterator of bytes from memory. This class exists because the {@link MemoryByteIterator}- * throws an exception from its next() method, which will not work for us.- */- private static class ByteIterator implements Iterator<Byte> {-- private MemoryByteIterator byteIterator;- private Byte next;-- ByteIterator(AddressSetView addresses, Memory memory) {- byteIterator = new MemoryByteIterator(memory, addresses);- }-- @Override- public boolean hasNext() {-- if (next != null) {- return true;- }-- if (!byteIterator.hasNext()) {- return false;- }-- try {- next = byteIterator.next();- }- catch (MemoryAccessException e) {- Msg.error(this, "Unable to read next byte", e);- return false;- }- return true;- }-- @Override- public Byte next() {-- if (next == null) {- throw new NoSuchElementException();- }-- Byte result = next;- next = null;- return result;- }- }-public static class ProgrammingByteStringTransferable implements Transferable {private List<DataFlavor> flavorList;diff --git a/Ghidra/Features/Base/src/test.slow/java/ghidra/program/model/util/MemoryByteIteratorTest.java b/Ghidra/Features/Base/src/test.slow/java/ghidra/program/model/util/MemoryByteIteratorTest.javaindex f63802e56a..3ea7819784 100644--- a/Ghidra/Features/Base/src/test.slow/java/ghidra/program/model/util/MemoryByteIteratorTest.java+++ b/Ghidra/Features/Base/src/test.slow/java/ghidra/program/model/util/MemoryByteIteratorTest.java@@ -4,9 +4,9 @@* 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.@@ -15,7 +15,10 @@*/package ghidra.program.model.util;-import static org.junit.Assert.assertEquals;+import static org.junit.Assert.*;++import java.util.Spliterators;+import java.util.stream.StreamSupport;import org.junit.*;@@ -25,17 +28,11 @@ import ghidra.program.model.listing.Program;import ghidra.test.AbstractGhidraHeadedIntegrationTest;import ghidra.test.TestEnv;-public class MemoryByteIteratorTest extends AbstractGhidraHeadedIntegrationTest {private TestEnv env;private Program program;private AddressFactory af;- /**- * @param arg0- */- public MemoryByteIteratorTest() {- super();- }+private Address addr(String a) {return af.getAddress(a);}@@ -45,46 +42,113 @@ public class MemoryByteIteratorTest extends AbstractGhidraHeadedIntegrationTestbuilder.createMemory("test1", "0x1001000", 0x6600);builder.setBytes("0x1001000", "00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F");builder.setBytes("0x1001140", "DE AD BE EF");+ builder.setBytes("0x1004ffe", "EE FF"); // these values are right before the buffer boundary+ builder.setBytes("0x1005000", "AA BB CC DD"); // these values are right after the buffer boundaryreturn builder.getProgram();}- @Before- public void setUp() throws Exception {+ @Before+ public void setUp() throws Exception {env = new TestEnv();program = buildProgram("notepad", ProgramBuilder._TOY);- af = program.getAddressFactory();+ af = program.getAddressFactory();}- @After- public void tearDown() {++ @After+ public void tearDown() {env.release(program);env.dispose();}-@Test- public void testIterator() throws Exception {++ @Test+ public void testEmptyRange() {+ MemoryByteIterator it = new MemoryByteIterator(program.getMemory(), new AddressSet());+ long count =+ StreamSupport.stream(Spliterators.spliteratorUnknownSize(it, 0), false).count();+ assertEquals(0, count);+ }++ @Test+ public void test1Byte() {+ MemoryByteIterator it =+ new MemoryByteIterator(program.getMemory(), new AddressSet(addr("0x1001000")));+ long count =+ StreamSupport.stream(Spliterators.spliteratorUnknownSize(it, 0), false).count();+ assertEquals(1, count);+ }++ @Test+ public void test2Byte() {+ MemoryByteIterator it = new MemoryByteIterator(program.getMemory(),+ new AddressSet(addr("0x1001000"), addr("0x1001001")));+ long count =+ StreamSupport.stream(Spliterators.spliteratorUnknownSize(it, 0), false).count();+ assertEquals(2, count);+ }++ @Test+ public void testIterator() throws Exception {AddressSet set = new AddressSet(addr("0x1000000"), addr("0x100100f"));set.addRange(addr("0x1001140"), addr("0x1001144"));MemoryByteIterator it = new MemoryByteIterator(program.getMemory(), set);int total = 0;- int n = 0;- while(it.hasNext()) {+ int count = 0;+ while (it.hasNext()) {byte b = it.next();- n++;+ count++;total += b;}- assertEquals(21, n);+ assertEquals(21, count);assertEquals(-80, total);-}-@Test- public void testIterator2() throws Exception {++ @Test+ public void testIterator2() throws Exception {+ AddressSet set = new AddressSet(addr("0x1001000"), addr("0x10075ff"));+ MemoryByteIterator it = new MemoryByteIterator(program.getMemory(), set);+ long count =+ StreamSupport.stream(Spliterators.spliteratorUnknownSize(it, 0), false).count();+ assertEquals(0x6600, count);+ }++ @Test+ public void testReadBytesNearBufferBoundary() {AddressSet set = new AddressSet(addr("0x1001000"), addr("0x10075ff"));MemoryByteIterator it = new MemoryByteIterator(program.getMemory(), set);- int n = 0;- while(it.hasNext()) {- it.next();- n++;+ int index = 0;+ int testcount = 0;+ while (it.hasNext()) {+ int b = Byte.toUnsignedInt(it.nextByte());+ switch (index) {+ //@formatter:off+ case MemoryByteIterator.MAX_BUF_SIZE - 2: assertEquals(0xee, b); testcount++; break;+ case MemoryByteIterator.MAX_BUF_SIZE - 1: assertEquals(0xff, b); testcount++; break;+ case MemoryByteIterator.MAX_BUF_SIZE: assertEquals(0xaa, b); testcount++; break;+ case MemoryByteIterator.MAX_BUF_SIZE + 1: assertEquals(0xbb, b); testcount++; break;+ //@formatter:on+ }+ index++;}- assertEquals(0x6600, n);-+ assertEquals(4, testcount);+ }++ @Test+ public void testOOBAddrRange() {+ // Test that invalid / unmapped addresses cause the iterator to signal end-of-iteration+ AddressSet set = new AddressSet(addr("0x10075ff"), addr("0x1007700"));+ MemoryByteIterator it = new MemoryByteIterator(program.getMemory(), set);+ long count =+ StreamSupport.stream(Spliterators.spliteratorUnknownSize(it, 0), false).count();+ assertEquals(1, count);+ }++ @Test+ public void testOOBAddrRange2() {+ // Test that invalid / unmapped addresses cause the iterator to signal end-of-iteration+ AddressSet set = new AddressSet(addr("0x1007600"), addr("0x1007700"));+ MemoryByteIterator it = new MemoryByteIterator(program.getMemory(), set);+ long count =+ StreamSupport.stream(Spliterators.spliteratorUnknownSize(it, 0), false).count();+ assertEquals(0, count);}}diff --git a/Ghidra/Framework/Generic/src/main/java/ghidra/util/NumericUtilities.java b/Ghidra/Framework/Generic/src/main/java/ghidra/util/NumericUtilities.javaindex d297136b50..dff5258aa5 100644--- a/Ghidra/Framework/Generic/src/main/java/ghidra/util/NumericUtilities.java+++ b/Ghidra/Framework/Generic/src/main/java/ghidra/util/NumericUtilities.java@@ -18,15 +18,12 @@ package ghidra.util;import java.math.BigInteger;import java.util.*;import java.util.concurrent.atomic.AtomicLong;+import java.util.function.BiFunction;import java.util.function.Function;-import java.util.stream.Collectors;import java.util.stream.Stream;-import org.apache.commons.collections4.IteratorUtils;import org.apache.commons.lang3.StringUtils;-import util.CollectionUtils;-public final class NumericUtilities {public static final BigInteger MAX_UNSIGNED_LONG = new BigInteger("ffffffffffffffff", 16);public static final BigInteger MAX_SIGNED_LONG = new BigInteger("7fffffffffffffff", 16);@@ -38,23 +35,9 @@ public final class NumericUtilities {private final static String BIN_PREFIX = "0B";private final static String OCT_PREFIX = "0";- private final static Set<Class<? extends Number>> INTEGER_TYPES = new HashSet<>();- static {- INTEGER_TYPES.add(Byte.class);- INTEGER_TYPES.add(Short.class);- INTEGER_TYPES.add(Integer.class);- INTEGER_TYPES.add(Long.class);- }- private static final Set<Class<? extends Number>> FLOATINGPOINT_TYPES = new HashSet<>();- static {- FLOATINGPOINT_TYPES.add(Float.class);- FLOATINGPOINT_TYPES.add(Double.class);- }-// @formatter:off- private static IntegerRadixRenderer SIGNED_INTEGER_RENDERER = new SignedIntegerRadixRenderer();- private static IntegerRadixRenderer UNSIGNED_INTEGER_RENDERER = new UnsignedIntegerRadixRenderer();- private static IntegerRadixRenderer DEFAULT_INTEGER_RENDERER = new DefaultIntegerRadixRenderer();+ private final static Set<Class<? extends Number>> INTEGER_TYPES = Set.of(Byte.class, Short.class, Integer.class, Long.class);+ private static final Set<Class<? extends Number>> FLOATINGPOINT_TYPES = Set.of(Float.class, Double.class);// @formatter:onprivate NumericUtilities() {@@ -678,7 +661,7 @@ public final class NumericUtilities {/*** Provide renderings of <code>number</code> in different bases:* <ul>- * <li><code>0</code> - renders <code>number</code> as an escaped character sequence</li>+ * <li><code>0</code> - renders <code>number</code> as a big endian escaped character sequence</li>* <li><code>2</code> - renders <code>number</code> as a <code>base-2</code> integer</li>* <li><code>8</code> - renders <code>number</code> as a <code>base-8</code> integer</li>* <li><code>10</code> - renders <code>number</code> as a <code>base-10</code> integer</li>@@ -807,32 +790,16 @@ public final class NumericUtilities {*/public static String formatNumber(long number, int radix, SignednessFormatMode mode) {if (radix == 0) {- byte[] bytes = new byte[8];- bytes[0] = (byte) (number >> 56);- bytes[1] = (byte) (number >> 48);- bytes[2] = (byte) (number >> 40);- bytes[3] = (byte) (number >> 32);- bytes[4] = (byte) (number >> 24);- bytes[5] = (byte) (number >> 16);- bytes[6] = (byte) (number >> 8);- bytes[7] = (byte) (number >> 0);+ byte[] bytes = BigEndianDataConverter.INSTANCE.getBytes(number);return StringUtilities.toQuotedString(bytes);}- IntegerRadixRenderer renderer = null;- switch (mode) {- case SIGNED:- renderer = SIGNED_INTEGER_RENDERER;- break;- case UNSIGNED:- renderer = UNSIGNED_INTEGER_RENDERER;- break;- case DEFAULT:- renderer = DEFAULT_INTEGER_RENDERER;- break;- }- return renderer.toString(number, radix);-+ BiFunction<Long, Integer, String> renderer = switch (mode) {+ case SIGNED -> NumericUtilities::signedIntegerRadixToString;+ case UNSIGNED -> NumericUtilities::unsignedIntegerRadixToString;+ case DEFAULT -> NumericUtilities::defaultIntegerRadixToString;+ };+ return renderer.apply(number, radix);}/**@@ -888,20 +855,6 @@ public final class NumericUtilities {return null;}- /**- * Convert the given byte into a two character String, padding with a leading 0 if needed.- *- * @param b the byte- * @return the byte string- */- public static String toString(byte b) {- String bs = Integer.toHexString(b & 0xff);- if (bs.length() == 1) {- return "0" + bs;- }- return bs;- }-/*** Convert a byte array into a hexadecimal string.*@@ -909,21 +862,18 @@ public final class NumericUtilities {* @return hex string representation*/public static String convertBytesToString(byte[] bytes) {- return convertBytesToString(bytes, null);+ return convertBytesToString(bytes, 0, bytes.length, null);}/*** Convert a byte array into a hexadecimal string.** @param bytes byte array- * @param delimeter the text between byte strings+ * @param delimiter the text between byte strings, {@code null} ok* @return hex string representation*/- public static String convertBytesToString(byte[] bytes, String delimeter) {- if (bytes == null) {- return null;- }- return convertBytesToString(bytes, 0, bytes.length, delimeter);+ public static String convertBytesToString(byte[] bytes, String delimiter) {+ return convertBytesToString(bytes, 0, bytes.length, delimiter);}/**@@ -932,49 +882,77 @@ public final class NumericUtilities {* @param bytes byte array* @param start start index* @param len number of bytes to convert- * @param delimeter the text between byte strings+ * @param delimiter the text between byte strings, {@code null} ok* @return hex string representation*/- public static String convertBytesToString(byte[] bytes, int start, int len, String delimeter) {+ public static String convertBytesToString(byte[] bytes, int start, int len, String delimiter) {+ if (bytes == null) {+ return null;+ }+ delimiter = Objects.requireNonNullElse(delimiter, "");- Iterator<Byte> iterator = IteratorUtils.arrayIterator(bytes, start, start + len);- return convertBytesToString(iterator, delimeter);+ int end = start + len;+ Objects.checkFromToIndex(start, end, bytes.length);++ StringBuilder sb = new StringBuilder(len * (2 + delimiter.length()));+ for (int i = start; i < end; i++) {+ if (!sb.isEmpty()) {+ sb.append(delimiter);+ }+ String s = Integer.toHexString(Byte.toUnsignedInt(bytes[i]));+ if (s.length() < 2) {+ sb.append('0');+ }+ sb.append(s);+ }+ return sb.toString();}/**- * Convert a bytes into a hexadecimal string.+ * Convert bytes into a hexadecimal string.** @param bytes an iterator of bytes- * @param delimiter the text between byte strings; null is allowed+ * @param delimiter the text between byte strings, {@code null} ok* @return hex string representation*/public static String convertBytesToString(Iterator<Byte> bytes, String delimiter) {+ delimiter = Objects.requireNonNullElse(delimiter, "");- return convertBytesToString(() -> bytes, delimiter);+ StringBuilder sb = new StringBuilder();+ while (bytes.hasNext()) {+ Byte b = bytes.next();+ if (!sb.isEmpty()) {+ sb.append(delimiter);+ }+ String s = Integer.toHexString(Byte.toUnsignedInt(b));+ if (s.length() < 2) {+ sb.append('0');+ }+ sb.append(s);+ }+ return sb.toString();}/**- * Convert a bytes into a hexadecimal string.+ * Convert bytes into a hexadecimal string.** @param bytes an iterable of bytes- * @param delimiter the text between byte strings; null is allowed+ * @param delimiter the text between byte strings, {@code null} ok* @return hex string representation*/public static String convertBytesToString(Iterable<Byte> bytes, String delimiter) {- return convertBytesToString(CollectionUtils.asStream(bytes), delimiter);+ return convertBytesToString(bytes.iterator(), delimiter);}/**- * Convert a bytes into a hexadecimal string.+ * Convert bytes into a hexadecimal string.** @param bytes an stream of bytes- * @param delimiter the text between byte strings; null is allowed+ * @param delimiter the text between byte strings, {@code null} ok* @return hex string representation*/public static String convertBytesToString(Stream<Byte> bytes, String delimiter) {-- delimiter = (delimiter == null) ? "" : delimiter;- return bytes.map(NumericUtilities::toString).collect(Collectors.joining(delimiter));+ return convertBytesToString(bytes.iterator(), delimiter);}/**@@ -1020,94 +998,53 @@ public final class NumericUtilities {}/**- * Provides the protocol for rendering integer-type numbers in different signed-ness modes.- */- private static interface IntegerRadixRenderer {- /**- * Format the given number in the provided radix base.- *- * @param number the number to render- * @param radix the base in which to render- * @return a string representing the provided number in the given base- */- public String toString(long number, int radix);-- }-- /**- * Renders provided numbers as signed values+ * Renders provided numbers as signed values.+ *+ * @param number value+ * @param radix 2,8,10,16+ * @return formatted string*/- private final static class SignedIntegerRadixRenderer implements IntegerRadixRenderer {- /**- * {@inheritDoc}- * <p>- * All values are rendered in their <i>signed</i> form- **/- @Override- public String toString(long number, int radix) {- switch (radix) {- case 2:- return Long.toString(number, radix) + "b";- case 8:- return Long.toString(number, radix) + "o";- case 10:- return Long.toString(number, radix);- case 16:- return Long.toString(number, radix) + "h";- }- throw new IllegalArgumentException("Unsupported radix");- }+ private static String signedIntegerRadixToString(long number, int radix) {+ return switch (radix) {+ case 2 -> Long.toString(number, radix) + "b";+ case 8 -> Long.toString(number, radix) + "o";+ case 10 -> Long.toString(number, radix);+ case 16 -> Long.toString(number, radix) + "h";+ default -> throw new IllegalArgumentException("Unsupported radix " + radix);+ };}/**- * Renders provided numbers as unsigned values+ * Renders provided numbers as unsigned values.+ *+ * @param number value+ * @param radix 2,8,10,16+ * @return formatted string*/- private final static class UnsignedIntegerRadixRenderer implements IntegerRadixRenderer {- /**- * {@inheritDoc}- * <p>- * All values are rendered in their <i>unsigned</i> form- **/- @Override- public String toString(long number, int radix) {- switch (radix) {- case 2:- return Long.toBinaryString(number) + "b";- case 8:- return Long.toOctalString(number) + "o";- case 10:- return Long.toUnsignedString(number);- case 16:- return Long.toHexString(number) + "h";- }- throw new IllegalArgumentException("Unsupported radix");- }+ private static String unsignedIntegerRadixToString(long number, int radix) {+ return switch (radix) {+ case 2 -> Long.toBinaryString(number) + "b";+ case 8 -> Long.toOctalString(number) + "o";+ case 10 -> Long.toUnsignedString(number);+ case 16 -> Long.toHexString(number) + "h";+ default -> throw new IllegalArgumentException("Unsupported radix " + radix);+ };}/*** Renders provided numbers in a more human-friendly manner+ *+ * @param number value+ * @param radix 2,8,10,16+ * @return formatted string*/- private final static class DefaultIntegerRadixRenderer implements IntegerRadixRenderer {- /**- * {@inheritDoc}- * <p>- * Values to be rendered in binary, octal, or hexadecimal bases are rendered as unsigned,- * numbers rendered in decimal are rendered as signed.- */- @Override- public String toString(long number, int radix) {- switch (radix) {- case 2:- return new UnsignedIntegerRadixRenderer().toString(number, radix);- case 8:- return new UnsignedIntegerRadixRenderer().toString(number, radix);- case 10:- return new SignedIntegerRadixRenderer().toString(number, radix);- case 16:- return new UnsignedIntegerRadixRenderer().toString(number, radix);- }- throw new IllegalArgumentException("Unsupported radix");- }+ private static String defaultIntegerRadixToString(long number, int radix) {+ return switch (radix) {+ case 2 -> unsignedIntegerRadixToString(number, radix);+ case 8 -> unsignedIntegerRadixToString(number, radix);+ case 10 -> signedIntegerRadixToString(number, radix);+ case 16 -> unsignedIntegerRadixToString(number, radix);+ default -> throw new IllegalArgumentException("Unsupported radix " + radix);+ };}-}diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/util/MemoryByteIterator.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/util/MemoryByteIterator.javaindex 3bd0a9378c..afc826ea82 100644--- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/util/MemoryByteIterator.java+++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/util/MemoryByteIterator.java@@ -4,9 +4,9 @@* 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.@@ -15,6 +15,9 @@*/package ghidra.program.model.util;+import java.util.Iterator;+import java.util.NoSuchElementException;+import ghidra.program.model.address.*;import ghidra.program.model.mem.Memory;import ghidra.program.model.mem.MemoryAccessException;@@ -22,13 +25,14 @@ import ghidra.program.model.mem.MemoryAccessException;/*** Class to iterate over the bytes in memory for an address set.*/-public class MemoryByteIterator {- private static final int BUF_SIZE = 16 * 1024;+public class MemoryByteIterator implements Iterator<Byte> {+ public static final int MAX_BUF_SIZE = 16 * 1024;private Memory mem;private AddressSet addrSet;- byte[] buf;- int count = 0;- int pos;++ private byte[] buf;+ private int bufSize;+ private int pos;/*** Construct a memoryIterator@@ -37,39 +41,53 @@ public class MemoryByteIterator {*/public MemoryByteIterator(Memory mem, AddressSetView set) {this.mem = mem;- addrSet = set.intersect(mem);- buf = new byte[BUF_SIZE];-+ this.addrSet = set.intersect(mem);+ this.buf = new byte[(int) Math.min(MAX_BUF_SIZE, set.getNumAddresses())];}- /**- * Returns true if there are more bytes to iterate over- */+ @Overridepublic boolean hasNext() {- return count != 0 || !addrSet.isEmpty();+ ensureBuffer();+ return pos < bufSize;+ }++ @Override+ public Byte next() {+ return nextByte();}/**- * Returns the next byte.- * @throws MemoryAccessException if the next byte could not be read+ * {@return the next primitive byte. Use this method if you want to avoid the cost of+ * boxing Bytes the normal next() method returns}+ *+ * @throws NoSuchElementException if the iteration has no more elements*/- public byte next() throws MemoryAccessException {- if (count == 0) {- AddressRange range = addrSet.iterator().next();- Address start = range.getMinAddress();- long size = range.getLength();- if (size > BUF_SIZE) {- range = new AddressRangeImpl(start, start.add(BUF_SIZE - 1));- size = BUF_SIZE;- }- count = (int) size;- pos = 0;- addrSet.delete(range);+ public byte nextByte() {+ ensureBuffer();+ if (pos < bufSize) {+ byte result = buf[pos];+ pos++;+ return result;+ }+ throw new NoSuchElementException();+ }++ private void ensureBuffer() {+ if (pos >= bufSize && !addrSet.isEmpty()) {+ AddressRange firstRange = addrSet.getFirstRange();+ Address addr = firstRange.getMinAddress();- mem.getBytes(start, buf, 0, count);+ int readSize = (int) Math.min(firstRange.getLength(), buf.length);+ addrSet.deleteFromMin(addr.add(readSize - 1)); // remove from addrSet before possible exception in getBytes()++ pos = 0;+ try {+ bufSize = mem.getBytes(addr, buf, 0, readSize);+ }+ catch (MemoryAccessException e) {+ bufSize = 0;+ }}- count--;- return buf[pos++];}}