From b5123f2553e90323c55b9f5855d64f54a04d427e Mon Sep 17 00:00:00 2001 From: ghidra1 Date: Tue, 30 May 2023 18:48:39 -0400 Subject: [PATCH] GP-3506 Corrected various issues with data organization retention and revision/upgrade handling for datatypes --- .../plugin/core/datamgr/tree/ArchiveNode.java | 26 +-- .../ghidra/program/database/ProgramDB.java | 8 +- .../database/ProjectDataTypeManager.java | 2 +- .../program/database/data/CompositeDB.java | 12 +- .../database/data/DataTypeManagerDB.java | 157 ++++++++++-------- .../database/data/ProgramDataTypeManager.java | 3 + .../model/data/BitFieldPackingImpl.java | 20 +++ .../model/data/DataOrganizationImpl.java | 46 ++++- .../model/data/DataTypeArchiveIdDumper.java | 2 +- .../model/data/FileDataTypeManager.java | 26 ++- .../model/data/StandAloneDataTypeManager.java | 144 ++++++++++++---- GhidraDocs/languages/versioning.html | 10 +- 12 files changed, 326 insertions(+), 130 deletions(-) diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/datamgr/tree/ArchiveNode.java b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/datamgr/tree/ArchiveNode.java index 56bb376442..a7e571bcc7 100644 --- a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/datamgr/tree/ArchiveNode.java +++ b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/datamgr/tree/ArchiveNode.java @@ -21,9 +21,12 @@ import javax.swing.Icon; import docking.widgets.tree.GTree; import docking.widgets.tree.GTreeNode; +import generic.theme.GColor; import generic.theme.GThemeDefaults.Colors.Messages; import ghidra.app.plugin.core.datamgr.archive.Archive; import ghidra.program.model.data.*; +import ghidra.program.model.data.StandAloneDataTypeManager.ArchiveWarning; +import ghidra.program.model.data.StandAloneDataTypeManager.ArchiveWarningLevel; import ghidra.util.HTMLUtilities; import ghidra.util.task.SwingUpdateManager; @@ -63,26 +66,29 @@ public class ArchiveNode extends CategoryNode { buf.append(HTMLUtilities.HTML_SPACE); buf.append(HTMLUtilities.HTML_SPACE); buf.append(HTMLUtilities.escapeHTML(programArchSummary)); - addArchiveWarnings(dtm, buf); } else { buf.append(DEFAULT_DATA_ORG_DESCRIPTION); } + addArchiveWarnings(dtm, buf); return buf.toString(); } private void addArchiveWarnings(DataTypeManager dtm, StringBuilder buf) { if (dtm instanceof StandAloneDataTypeManager archiveDtm) { - if (archiveDtm.isProgramArchitectureMissing()) { + ArchiveWarning warning = archiveDtm.getWarning(); + if (warning != ArchiveWarning.NONE) { + GColor c = Messages.NORMAL; + ArchiveWarningLevel level = warning.level(); + if (level == ArchiveWarningLevel.ERROR) { + c = Messages.ERROR; + } + else if (level == ArchiveWarningLevel.WARN) { + c = Messages.WARNING; + } + String msg = archiveDtm.getWarningMessage(false); buf.append(HTMLUtilities.BR); - buf.append( - "** Missing Language/Compiler Specification **"); - } - else if (archiveDtm.isProgramArchitectureUpgradeRequired()) { - buf.append(HTMLUtilities.BR); - buf.append("** Language Upgrade Required **"); + buf.append("** " + msg + " **"); } } } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/ProgramDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/ProgramDB.java index abc89b17cf..4219895dec 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/ProgramDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/ProgramDB.java @@ -1775,9 +1775,11 @@ public class ProgramDB extends DomainObjectAdapterDB implements Program, ChangeM monitor.checkCancelled(); - // Upgrade Function Manager - if (openMode == UPGRADE && oldFunctionMgr != null) { - oldFunctionMgr.upgrade(this, monitor); + if (openMode == UPGRADE) { + if (oldFunctionMgr != null) { + // Upgrade Function Manager + oldFunctionMgr.upgrade(this, monitor); + } } for (int i = 0; i < NUM_MANAGERS; i++) { diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/ProjectDataTypeManager.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/ProjectDataTypeManager.java index abace47dc5..5cb1ad359c 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/ProjectDataTypeManager.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/ProjectDataTypeManager.java @@ -69,7 +69,7 @@ public class ProjectDataTypeManager extends StandAloneDataTypeManager TaskMonitor monitor) throws CancelledException, VersionException, IOException { super(handle, openMode, errHandler, lock, monitor); this.dataTypeArchive = dataTypeArchive; - reportWarning(); + logWarning(); } @Override diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDB.java index d17f64ce8c..d9e327b8fa 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/CompositeDB.java @@ -683,13 +683,11 @@ abstract class CompositeDB extends DataTypeDB implements CompositeInternal { } /** - * Perform any neccessary component adjustments based on - * sizes and alignment of components differing from their - * specification which may be influenced by the data organization. - * If this composite changes parents will not be - * notified - handling this is the caller's responsibility. - * It is assumed that this method is invoked on composites - * in dependency order. + * Perform any neccessary component adjustments based on sizes of components differing from + * their specification which may be influenced by the data organization. This method + * does not consider alignment changes and should be used on non-packed structures only. + * If this composite changes parents will not be notified - handling this is the caller's + * responsibility. It is assumed that this method is invoked on composites in dependency order. * @throws IOException if database IO error occurs */ protected abstract void fixupComponents() throws IOException; diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/DataTypeManagerDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/DataTypeManagerDB.java index 0d75de0d40..cadb6561ea 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/DataTypeManagerDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/DataTypeManagerDB.java @@ -238,16 +238,18 @@ abstract public class DataTypeManagerDB implements DataTypeManager { /** * Constructor for a data-type manager backed by a packed database file. When * opening for UPDATE an automatic upgrade will be performed if required. - * NOTE: default DataOrganization will be used. + * NOTE: Default DataOrganization will be used for new archive. * * @param packedDBfile packed datatype archive file (i.e., *.gdt resource). * @param openMode open mode CREATE, READ_ONLY or UPDATE (see * {@link DBConstants}). + * @param monitor task monitor * @throws IOException a low-level IO error. This exception may also be thrown * when a version error occurs (cause is VersionException). + * @throws CancelledException if task cancelled */ - protected DataTypeManagerDB(ResourceFile packedDBfile, int openMode) - throws IOException { + protected DataTypeManagerDB(ResourceFile packedDBfile, int openMode, TaskMonitor monitor) + throws IOException, CancelledException { this.errHandler = new DbErrorHandler(); this.lock = new Lock("DataTypeManagerDB"); @@ -268,19 +270,17 @@ abstract public class DataTypeManagerDB implements DataTypeManager { DataTypeArchiveContentHandler.DATA_TYPE_ARCHIVE_CONTENT_TYPE); } else { - pdb = PackedDatabase.getPackedDatabase(packedDBfile, false, TaskMonitor.DUMMY); - if (openMode == DBConstants.UPDATE) { - dbHandle = pdb.openForUpdate(TaskMonitor.DUMMY); + pdb = PackedDatabase.getPackedDatabase(packedDBfile, false, monitor); + + if (openMode == DBConstants.READ_ONLY) { + dbHandle = pdb.open(monitor); } - else { - dbHandle = pdb.open(TaskMonitor.DUMMY); + else { // UPDATE mode (allows upgrade use) + dbHandle = pdb.openForUpdate(monitor); } } openSuccess = true; } - catch (CancelledException e1) { - throw new AssertException(e1); // can't happen--dummy monitor - } finally { if (!openSuccess && pdb != null) { pdb.dispose(); // dispose on error @@ -290,21 +290,15 @@ abstract public class DataTypeManagerDB implements DataTypeManager { // Initialize datatype manager and save new archive on CREATE boolean initSuccess = false; try { - - initPackedDatabase(packedDBfile, openMode); // performs upgrade if needed - + initPackedDatabase(packedDBfile, openMode, monitor); // performs upgrade if needed if (openMode == DBConstants.CREATE) { // preserve UniversalID if it has been established Long uid = universalID != null ? universalID.getValue() : null; ((PackedDBHandle) dbHandle).saveAs("Archive", file.getParentFile(), - packedDBfile.getName(), uid, TaskMonitor.DUMMY); + packedDBfile.getName(), uid, monitor); } - initSuccess = true; } - catch (CancelledException e) { - throw new AssertException(e); // can't happen--dummy monitor - } finally { if (!initSuccess) { dbHandle.close(); // close on error (packed database will also be disposed) @@ -312,41 +306,43 @@ abstract public class DataTypeManagerDB implements DataTypeManager { } } - private void initPackedDatabase(ResourceFile packedDBfile, int openMode) + private void initPackedDatabase(ResourceFile packedDBfile, int openMode, TaskMonitor monitor) throws CancelledException, IOException { - int id = startTransaction(""); - try { - init(openMode, TaskMonitor.DUMMY); + try (Transaction tx = openTransaction("")) { + init(openMode, monitor); + + if (openMode != DBConstants.CREATE && hasDataOrganizationChange()) { + // check for data organization change with possible upgrade + handleDataOrganizationChange(openMode, monitor); + } + + if (openMode == DBConstants.UPGRADE) { + migrateOldFlexArrayComponentsIfRequired(monitor); + + Msg.showInfo(this, null, "Archive Upgraded", + "Data type archive has been upgraded: " + packedDBfile.getName()); + } } catch (VersionException e) { if (openMode == DBConstants.UPDATE && e.isUpgradable()) { - try { - init(DBConstants.UPGRADE, TaskMonitor.DUMMY); - migrateOldFlexArrayComponentsIfRequired(TaskMonitor.DUMMY); - - Msg.showInfo(this, null, "Archive Upgraded", - "Data type archive schema has been upgraded: " + packedDBfile.getName()); - } - catch (VersionException ve) { - throw new IOException(e); // unexpected - } + initPackedDatabase(packedDBfile, DBConstants.UPGRADE, monitor); } else { - // TODO: Unable to handle required upgrade for read-only without API change + // Unable to handle required upgrade throw new IOException(e); } } - finally { - endTransaction(id, true); - } } /** * Constructor for a database-backed DataTypeManagerDB extension. + * NOTE: This does not check for and handle data organization changes which must be + * handled later (use {@link #hasDataOrganizationChange()} and + * {@link #compilerSpecChanged(TaskMonitor)} to check for and initiate response to changes). * * @param handle database handle * @param addrMap address map (may be null) - * @param openMode open mode CREATE, READ_ONLY or UPDATE (see {@link DBConstants}). + * @param openMode open mode CREATE, READ_ONLY, UPDATE, UPGRADE (see {@link DBConstants}). * @param tablePrefix DB table prefix to be applied to all associated table names. This * need only be specified when using multiple instances with the same * DB handle (null or empty string for no-prefix). @@ -528,6 +524,17 @@ abstract public class DataTypeManagerDB implements DataTypeManager { // do nothing } + protected void handleDataOrganizationChange(int openMode, TaskMonitor monitor) + throws IOException, LanguageVersionException, CancelledException { + if (openMode == DBConstants.UPDATE) { + throw new LanguageVersionException("Data organization change detected", true); + } + if (openMode == DBConstants.UPGRADE) { + compilerSpecChanged(monitor); + } + // NOTE: No change for READ_ONLY mode + } + /** * Build Parent/Child table for tracking dataType usage by other dataTypes * (e.g., arrays, pointers, etc.). Only used to populate the ParentChildAdapter @@ -777,6 +784,10 @@ abstract public class DataTypeManagerDB implements DataTypeManager { * true, to reflect any changes in the data organization. * The caller is resposible for ensuring that this setting is done consistent * with the {@link #addrMap} setting used during construction if applicable. + *
+ * If not storing caller may need to check for data organization change to communicate + * change or to facilitate an upgrade situation. + * * @param programArchitecture program architecture details (may be null) in which case * default data organization will be used. * @param variableStorageMgr variable storage manager (within same database) or null @@ -805,8 +816,13 @@ abstract public class DataTypeManagerDB implements DataTypeManager { saveDataOrganization(); } else if (store) { - compilerSpecChanged(monitor); - updateLastChangeTime(); + try { + compilerSpecChanged(monitor); + updateLastChangeTime(); + } + finally { + invalidateCache(); + } } } @@ -822,46 +838,52 @@ abstract public class DataTypeManagerDB implements DataTypeManager { * @throws CancelledException if processing cancelled - data types may not properly reflect * updated compiler specification */ - private void compilerSpecChanged(TaskMonitor monitor) throws IOException, CancelledException { + protected void compilerSpecChanged(TaskMonitor monitor) throws IOException, CancelledException { if (mode == DBConstants.READ_ONLY) { throw new ReadOnlyException(); } - DataOrganization oldDataOrganization = readDataOrganization(); + boolean hasDataOrgChange = hasDataOrganizationChange(); - try { - saveDataOrganization(); - - if (oldDataOrganization != null && - !oldDataOrganization.equals(dataOrganization)) { - Msg.info(this, - "Fixing datatypes to reflect data organization change: " + getPath()); - doCompositeFixup(monitor); - } - - // FUTURE: may need to handle calling convention and data organization change impact - // on function definitions + saveDataOrganization(); + if (hasDataOrgChange) { + doCompositeFixup(monitor); } - finally { - invalidateCache(); - } + + // FUTURE: may need to handle calling convention and data organization change impact + // on function definitions } - private void saveDataOrganization() throws IOException { - if (dataOrganization == null) { - return; - } - DataOrganizationImpl.save(dataOrganization, getDataMap(true), "dataOrg."); + protected final boolean hasDataOrganizationChange() throws IOException { + // compare DB-stored data organization with the one in affect + return !Objects.equals(readDataOrganization(), getDataOrganization()); } - private DataOrganization readDataOrganization() throws IOException { + protected void saveDataOrganization() throws IOException { + DataOrganizationImpl.save(getDataOrganization(), getDataMap(true), "dataOrg."); + } + + /** + * Read the DB-serialized data organization. If one has not been stored a suitable + * default will be returned. + * @return stored data organization or suitable default. + * @throws IOException if DB error orccurs + */ + protected DataOrganization readDataOrganization() throws IOException { DBStringMapAdapter dataMap = getDataMap(false); if (dataMap == null) { return null; } - return DataOrganizationImpl.restore(dataMap, "dataOrg."); + + DataOrganization dataOrg = DataOrganizationImpl.restore(dataMap, "dataOrg."); + if (dataOrg == null) { + ProgramArchitecture arch = getProgramArchitecture(); + return DataOrganizationImpl + .getDefaultOrganization(arch != null ? arch.getLanguage() : null); + } + return dataOrg; } @Override @@ -4235,7 +4257,12 @@ abstract public class DataTypeManagerDB implements DataTypeManager { int count = 0; for (CompositeDB c : orderedComposites) { monitor.checkCancelled(); - c.fixupComponents(); + if (c.isPackingEnabled()) { + c.repack(true, false); + } + else { + c.fixupComponents(); + } monitor.setProgress(++count); } } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ProgramDataTypeManager.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ProgramDataTypeManager.java index 2f73ce80fd..f32994ef39 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ProgramDataTypeManager.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/ProgramDataTypeManager.java @@ -81,6 +81,9 @@ public class ProgramDataTypeManager extends ProgramBasedDataTypeManagerDB try { setProgramArchitecture(p, p.getSymbolTable().getVariableStorageManager(), false, TaskMonitor.DUMMY); + // NOTE: Due to late manner in which program architecture is established, any + // response to a data organization change must be handled during a language + // upgrade and setLanguage } catch (CancelledException e) { throw new AssertException(e); // unexpected - no IO performed diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/BitFieldPackingImpl.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/BitFieldPackingImpl.java index ff7ae47c9b..e213342e22 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/BitFieldPackingImpl.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/BitFieldPackingImpl.java @@ -19,6 +19,7 @@ import static ghidra.program.model.pcode.AttributeId.*; import static ghidra.program.model.pcode.ElementId.*; import java.io.IOException; +import java.util.Objects; import ghidra.program.database.DBStringMapAdapter; import ghidra.program.model.pcode.Encoder; @@ -189,4 +190,23 @@ public class BitFieldPackingImpl implements BitFieldPacking { } parser.end(); } + + @Override + public int hashCode() { + return Objects.hash(typeAlignmentEnabled, useMSConvention, zeroLengthBoundary); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + BitFieldPackingImpl other = (BitFieldPackingImpl) obj; + return typeAlignmentEnabled == other.typeAlignmentEnabled && + useMSConvention == other.useMSConvention && + zeroLengthBoundary == other.zeroLengthBoundary; + } } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/DataOrganizationImpl.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/DataOrganizationImpl.java index 0c3090979b..e5fa72f872 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/DataOrganizationImpl.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/DataOrganizationImpl.java @@ -701,15 +701,26 @@ public class DataOrganizationImpl implements DataOrganization { * Restore a data organization from the specified DB data map. * @param dataMap DB data map * @param keyPrefix key prefix for all map entries - * @return data organization + * @return stored data organization or null if not stored * @throws IOException if an IO error occurs */ public static DataOrganizationImpl restore(DBStringMapAdapter dataMap, String keyPrefix) throws IOException { + boolean containsDataOrgEntries = false; + for (String key : dataMap.keySet()) { + if (key.startsWith(keyPrefix)) { + containsDataOrgEntries = true; + break; + } + } + if (!containsDataOrgEntries) { + return null; + } + DataOrganizationImpl dataOrg = new DataOrganizationImpl(); - dataOrg.bigEndian = dataMap.getBoolean(BIG_ENDIAN_NAME, false); + dataOrg.bigEndian = dataMap.getBoolean(keyPrefix + BIG_ENDIAN_NAME, false); dataOrg.absoluteMaxAlignment = dataMap.getInt(keyPrefix + ELEM_ABSOLUTE_MAX_ALIGNMENT.name(), @@ -984,4 +995,35 @@ public class DataOrganizationImpl implements DataOrganization { parser.end(); } + + @Override + public int hashCode() { + return Objects.hash(absoluteMaxAlignment, bigEndian, bitFieldPacking, charSize, + defaultAlignment, defaultPointerAlignment, doubleSize, floatSize, integerSize, + isSignedChar, longDoubleSize, longLongSize, longSize, machineAlignment, pointerShift, + pointerSize, shortSize, sizeAlignmentMap, wideCharSize); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + DataOrganizationImpl other = (DataOrganizationImpl) obj; + return absoluteMaxAlignment == other.absoluteMaxAlignment && bigEndian == other.bigEndian && + Objects.equals(bitFieldPacking, other.bitFieldPacking) && charSize == other.charSize && + defaultAlignment == other.defaultAlignment && + defaultPointerAlignment == other.defaultPointerAlignment && + doubleSize == other.doubleSize && floatSize == other.floatSize && + integerSize == other.integerSize && isSignedChar == other.isSignedChar && + longDoubleSize == other.longDoubleSize && longLongSize == other.longLongSize && + longSize == other.longSize && machineAlignment == other.machineAlignment && + pointerShift == other.pointerShift && pointerSize == other.pointerSize && + shortSize == other.shortSize && + Objects.equals(sizeAlignmentMap, other.sizeAlignmentMap) && + wideCharSize == other.wideCharSize; + } } diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/DataTypeArchiveIdDumper.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/DataTypeArchiveIdDumper.java index e077d58298..d59dc90afd 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/DataTypeArchiveIdDumper.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/DataTypeArchiveIdDumper.java @@ -39,7 +39,7 @@ public class DataTypeArchiveIdDumper implements GhidraLaunchable { FileWriter writer = new FileWriter(outputFile); FileDataTypeManager archive = FileDataTypeManager.openFileArchive(archiveFile, false); - archive.reportWarning(); + archive.logWarning(); UniversalID universalID2 = archive.getUniversalID(); writer.write("FILE_ID: " + Long.toHexString(universalID2.getValue())); writer.write("\n"); diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/FileDataTypeManager.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/FileDataTypeManager.java index 97cad08610..594973c4dd 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/FileDataTypeManager.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/FileDataTypeManager.java @@ -61,15 +61,18 @@ public class FileDataTypeManager extends StandAloneDataTypeManager * with a warning condition, architecture-specific data may not be available or up-to-date. * * @param packedDbfile file to load or create based upon openMode - * @param openMode one of the DBConstants: CREATE, UPDATE, READ_ONLY, UPGRADE + * @param openMode one of the DBConstants: CREATE, READ_ONLY or UPDATE + * @param monitor the progress monitor * @throws IOException if an IO error occurs + * @throws CancelledException if task cancelled */ - private FileDataTypeManager(ResourceFile packedDbfile, int openMode) throws IOException { - super(validateFilename(packedDbfile), openMode); + private FileDataTypeManager(ResourceFile packedDbfile, int openMode, TaskMonitor monitor) + throws IOException, CancelledException { + super(validateFilename(packedDbfile), openMode, monitor); file = packedDbfile; name = getRootName(file.getName()); packedDB = ((PackedDBHandle) dbHandle).getPackedDatabase(); - reportWarning(); + logWarning(); } private static ResourceFile validateFilename(ResourceFile packedDbfile) { @@ -86,7 +89,13 @@ public class FileDataTypeManager extends StandAloneDataTypeManager * @throws IOException if an IO error occurs */ public static FileDataTypeManager createFileArchive(File packedDbfile) throws IOException { - return new FileDataTypeManager(new ResourceFile(packedDbfile), DBConstants.CREATE); + try { + return new FileDataTypeManager(new ResourceFile(packedDbfile), DBConstants.CREATE, + TaskMonitor.DUMMY); + } + catch (CancelledException e) { + throw new AssertException(e); // unexpected without task monitor use + } } /** @@ -129,7 +138,12 @@ public class FileDataTypeManager extends StandAloneDataTypeManager public static FileDataTypeManager openFileArchive(ResourceFile packedDbfile, boolean openForUpdate) throws IOException { int mode = openForUpdate ? DBConstants.UPDATE : DBConstants.READ_ONLY; - return new FileDataTypeManager(packedDbfile, mode); + try { + return new FileDataTypeManager(packedDbfile, mode, TaskMonitor.DUMMY); + } + catch (CancelledException e) { + throw new AssertException(e); // unexpected without task monitor use + } } /** diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/StandAloneDataTypeManager.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/StandAloneDataTypeManager.java index caa2da693a..951d8bd8fd 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/StandAloneDataTypeManager.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/StandAloneDataTypeManager.java @@ -59,11 +59,16 @@ public class StandAloneDataTypeManager extends DataTypeManagerDB implements Clos protected String name; + public static enum ArchiveWarningLevel { + INFO, WARN, ERROR; + } + public static enum ArchiveWarning { + /** * {@link #NONE} indicates a normal archive condition */ - NONE, + NONE(ArchiveWarningLevel.INFO), /** * {@link #UPGRADED_LANGUAGE_VERSION} indicates an archive which has been open for update @@ -72,7 +77,7 @@ public class StandAloneDataTypeManager extends DataTypeManagerDB implements Clos * which involves significant {@link Register} changes. Sharing an upgraded archive * may impact others who do not have access to the updated {@link Language} module. */ - UPGRADED_LANGUAGE_VERSION, + UPGRADED_LANGUAGE_VERSION(ArchiveWarningLevel.INFO), // programArchitectureSummary must be set for the warnings below @@ -82,7 +87,7 @@ public class StandAloneDataTypeManager extends DataTypeManagerDB implements Clos * a problem being loaded. The {@link FileDataTypeManager#getWarningDetail()} may provide * additional insight to the underlying cause. */ - LANGUAGE_NOT_FOUND, + LANGUAGE_NOT_FOUND(ArchiveWarningLevel.ERROR), /** * {@link #COMPILER_SPEC_NOT_FOUND} indicates the {@link CompilerSpec}, @@ -91,7 +96,7 @@ public class StandAloneDataTypeManager extends DataTypeManagerDB implements Clos * additional insight to the underlying cause. This condition can only occur if the * required {@link Language} was found. */ - COMPILER_SPEC_NOT_FOUND, + COMPILER_SPEC_NOT_FOUND(ArchiveWarningLevel.ERROR), /** * {@link #LANGUAGE_UPGRADE_REQURED} indicates an archive which has been open read-only @@ -103,7 +108,27 @@ public class StandAloneDataTypeManager extends DataTypeManagerDB implements Clos * who do not have access to the updated {@link Language} module and should be * coordinated with others who may be affected. */ - LANGUAGE_UPGRADE_REQURED, + LANGUAGE_UPGRADE_REQURED(ArchiveWarningLevel.WARN), + + /** + * {@link #DATA_ORG_CHANGED} indicates an archive which has been open read-only + * requires an upgraded to adjust for changes in the associated data organization. + */ + DATA_ORG_CHANGED(ArchiveWarningLevel.WARN); + + final ArchiveWarningLevel level; + + ArchiveWarning(ArchiveWarningLevel level) { + this.level = level; + } + + /** + * Get the warning level + * @return warning level + */ + public ArchiveWarningLevel level() { + return level; + } } private ArchiveWarning warning; @@ -134,35 +159,37 @@ public class StandAloneDataTypeManager extends DataTypeManagerDB implements Clos * Constructor for a data-type manager backed by a packed database file. * When opening for UPDATE an automatic upgrade will be performed if required. *

- * NOTE: {@link #reportWarning()} should be invoked immediately after + * NOTE: {@link #logWarning()} should be invoked immediately after * instantiating a {@link StandAloneDataTypeManager} for an existing database after * {@link #getName()} and {@link #getPath()} can be invoked safely. In addition, it * may be appropriate to use {@link #getWarning() check for warnings} prior to use. * * @param packedDbfile packed datatype archive file (i.e., *.gdt resource). * @param openMode open mode CREATE, READ_ONLY or UPDATE (see {@link DBConstants}) + * @param monitor the progress monitor * @throws IOException a low-level IO error. This exception may also be thrown * when a version error occurs (cause is VersionException). + * @throws CancelledException if task cancelled */ - protected StandAloneDataTypeManager(ResourceFile packedDbfile, int openMode) - throws IOException { - super(packedDbfile, openMode); + protected StandAloneDataTypeManager(ResourceFile packedDbfile, int openMode, + TaskMonitor monitor) throws IOException, CancelledException { + super(packedDbfile, openMode, monitor); } /** * Constructor for a data-type manager using a specified DBHandle. *

- * NOTE: {@link #reportWarning()} should be invoked immediately after + * NOTE: {@link #logWarning()} should be invoked immediately after * instantiating a {@link StandAloneDataTypeManager} for an existing database after * {@link #getName()} and {@link #getPath()} can be invoked safely. In addition, it * may be appropriate to use {@link #getWarning() check for warnings} prior to use. * * @param handle open database handle - * @param openMode the program open mode + * @param openMode open mode CREATE, READ_ONLY or UPDATE (see {@link DBConstants}) * @param errHandler the database I/O error handler * @param lock the program synchronization lock * @param monitor the progress monitor - * @throws CancelledException if the user cancels an upgrade + * @throws CancelledException if task cancelled * @throws VersionException if the database does not match the expected version. * @throws IOException if a database I/O error occurs. */ @@ -170,6 +197,9 @@ public class StandAloneDataTypeManager extends DataTypeManagerDB implements Clos Lock lock, TaskMonitor monitor) throws CancelledException, VersionException, IOException { super(handle, null, openMode, null, errHandler, lock, monitor); + if (openMode != DBConstants.CREATE && hasDataOrganizationChange()) { + handleDataOrganizationChange(openMode, monitor); + } } /** @@ -193,41 +223,77 @@ public class StandAloneDataTypeManager extends DataTypeManagerDB implements Clos } /** - * Due to the supression of error and warning conditions during instantiation this method should - * be invoked at the end of instatiation when {@link #getName()} and {@link #getPath()} are - * ready to be invoked safely. Logging will be performed via {@link Msg}. + * Get a suitable warning message. See {@link #getWarning()} for type and its severity level + * {@link ArchiveWarning#level()}. + * @param includeDetails if false simple message returned, otherwise more details are included. + * @return warning message or null if {@link #getWarning()} is {@link ArchiveWarning#NONE}. */ - protected void reportWarning() { - String msg; + public String getWarningMessage(boolean includeDetails) { + String msg = null; switch (warning) { - case NONE: - break; case LANGUAGE_NOT_FOUND: - msg = "Language not found for Archive '" + getName() + "': " + - warningDetail.getMessage(); - Msg.error(this, msg); + msg = "Language not found for Archive"; + if (includeDetails) { + msg += " '" + getName() + "': " + warningDetail.getMessage(); + } break; case COMPILER_SPEC_NOT_FOUND: - msg = "Compiler specification not found for Archive '" + getName() + "': " + - warningDetail.getMessage(); - Msg.error(this, msg); + msg = "Compiler specification not found for Archive"; + if (includeDetails) { + msg += " '" + getName() + "': " + warningDetail.getMessage(); + } break; case LANGUAGE_UPGRADE_REQURED: - msg = "Language upgrade required for Archive '" + getName() + "': " + - programArchitectureSummary; - Msg.warn(this, msg); + msg = "Language upgrade required for Archive"; + if (includeDetails) { + msg += " '" + getName() + "': " + programArchitectureSummary; + } break; case UPGRADED_LANGUAGE_VERSION: - ProgramArchitecture arch = getProgramArchitecture(); - LanguageDescription languageDescription = - arch.getLanguage().getLanguageDescription(); - msg = - "Upgraded program-architecture for Archive: '" + getName() + + msg = "Upgraded program-architecture for Archive"; + if (includeDetails) { + ProgramArchitecture arch = getProgramArchitecture(); + LanguageDescription languageDescription = + arch.getLanguage().getLanguageDescription(); + msg += " '" + getName() + "'\n Language: " + languageDescription.getLanguageID() + " Version " + languageDescription.getVersion() + ".x" + ", CompilerSpec: " + arch.getCompilerSpec().getCompilerSpecID(); + } + break; + case DATA_ORG_CHANGED: + msg = "Data organization upgrade required for Archive"; + if (includeDetails) { + msg += " '" + getName() + "': " + programArchitectureSummary; + } + break; + default: + break; + } + return msg; + } + + /** + * Due to the supression of error and warning conditions during instantiation this method should + * be invoked at the end of instatiation when {@link #getName()} and {@link #getPath()} are + * ready to be invoked safely. Logging will be performed via {@link Msg}. + */ + protected void logWarning() { + String msg = getWarningMessage(true); + if (msg == null) { + return; + } + switch (warning.level) { + case ERROR: + Msg.error(this, msg); + break; + case WARN: + Msg.warn(this, msg); + break; + default: Msg.info(this, msg); + break; } } @@ -238,6 +304,7 @@ public class StandAloneDataTypeManager extends DataTypeManagerDB implements Clos warning = ArchiveWarning.NONE; if (openMode == DBConstants.CREATE) { + saveDataOrganization(); // save default dataOrg return; // optional program architecture is set after initialization is complete } @@ -369,9 +436,18 @@ public class StandAloneDataTypeManager extends DataTypeManagerDB implements Clos if (variableStorageMgr != null) { variableStorageMgr.setProgramArchitecture(getProgramArchitecture()); } - } + @Override + protected void handleDataOrganizationChange(int openMode, TaskMonitor monitor) + throws LanguageVersionException, CancelledException, IOException { + if (openMode == DBConstants.READ_ONLY) { + warning = ArchiveWarning.DATA_ORG_CHANGED; + } + super.handleDataOrganizationChange(openMode, monitor); + } + + /** * Get the program architecture information which has been associated with this * datatype manager. If {@link #getProgramArchitecture()} returns null this method diff --git a/GhidraDocs/languages/versioning.html b/GhidraDocs/languages/versioning.html index 89a7307c35..3cf05020b2 100644 --- a/GhidraDocs/languages/versioning.html +++ b/GhidraDocs/languages/versioning.html @@ -48,7 +48,15 @@ re-disassembly of all instructions.

a user to make certain transitions between similar language implementations.  Such transitions are generally facilitated via a default translator, although certain limitations are imposed based upon -address space sizes and register mappings.
+address space sizes and register mappings.

+

Any changes made to a Data Organization could impact the packing of +components within a structure or union. While such changes should be avoided +due to the possible fallout, any such change to a +*.cspec should be made +in conjuction with a version change to all affected languages within +the relavent *.ldefs files. The +resulting program upgrade will allow affected data types to be updated. +

Language Versioning

A language's version is specified as a