public DataType getBaseType(String name, int dwarfSize, int dwarfEncoding,
			boolean isBigEndian, boolean isExplictSize) {

		DataType dt = null;
		String mangledName = null;
		if (name != null) {
			dt = baseDataTypes.get(name);
			if (dt != null && dt.getAlignedLength() == dwarfSize &&
				isEncodingCompatible(dwarfEncoding, dt)) {
				return dt;
			}
			mangledName = name + mangleDataTypeInfo(dwarfSize, dwarfEncoding);
			dt = baseDataTypes.get(mangledName);
			if (dt != null) {
				return dt;
			}
		}
		dt = switch (dwarfEncoding) {
			case DWARFEncoding.DW_ATE_address -> baseDataTypeVoid; // TODO: Check if bytesize != 0 - may want to make a void pointer
			case DWARFEncoding.DW_ATE_boolean -> dwarfSize == 1 ? baseDataTypeBool : null;
			// TODO: Float lookup by length must use "raw" encoding size since "aligned" lengths
			// may be duplicated across different float types.  Lookup by name is preferred.
			// May need to add name lookup capability to AbstractFloatDataType
			case DWARFEncoding.DW_ATE_float -> AbstractFloatDataType.getFloatDataType(dwarfSize,
				getCorrectDTMForFixedLengthTypes(name, dwarfSize, isExplictSize));
			case DWARFEncoding.DW_ATE_signed -> AbstractIntegerDataType.getSignedDataType(dwarfSize,
				getCorrectDTMForFixedLengthTypes(name, dwarfSize, isExplictSize));
			case DWARFEncoding.DW_ATE_unsigned -> AbstractIntegerDataType.getUnsignedDataType(
				dwarfSize, getCorrectDTMForFixedLengthTypes(name, dwarfSize, isExplictSize));
			case DWARFEncoding.DW_ATE_signed_char -> baseDataTypeChar;
			case DWARFEncoding.DW_ATE_unsigned_char -> baseDataTypeUchar;
			case DWARFEncoding.DW_ATE_UTF -> findMatchingDataTypeBySize(baseDataTypeChars,
				dwarfSize);
			default -> null;
		};

		if (dt == null) {
			dt = findMatchingDataTypeBySize(baseDataTypeUntyped, dwarfSize);
		}

		if (dt == null) {
			dt = new ArrayDataType(DataType.DEFAULT, dwarfSize, -1, dataTypeManager);
		}

		if (name != null /* mangledName also will be non-null */) {
			dt = new TypedefDataType(prog.getRootDNI().asCategoryPath(), name, dt, dataTypeManager);

			dt = dataTypeManager.addDataType(dt, DataTypeConflictHandler.DEFAULT_HANDLER);

			baseDataTypes.put(mangledName, dt);
		}

		return dt;
	}
Returns a Ghidra {@link DataType datatype} that corresponds to the DWARF named type.
<p>
If there is no direct matching named Ghidra type, generic types of matching
size will be returned for integer and floating numeric dwarf encoding types, boolean,
and character types.  Failing that, generic storage types of matching size
(word, dword, etc) will be returned, and failing that, an array of the correct size
will be returned.
<p>
If the returned data type is not a direct named match, the returned data type
will be wrapped in a Ghidra typedef using the dwarf type's name.
<p>
Any newly created Ghidra data types will be cached and the same instance will be returned
if the same DWARF named base type is requested again.

@param name
@param dwarfSize
@param dwarfEncoding
@param isBigEndian
@param isExplictSize boolean flag, if true the returned data type will not be linked to
the dataOrganization's compiler specified data types (eg. if type is something like int32_t, 
the returned type should never change size, even if the dataOrg changes).  If false,
the returned type will be linked to the dataOrg's compiler specified data types if possible,
except for data types that have a name that include a bitsize in the name, such as "int64_t". 
@return
Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/dwarf/DWARFDataTypeManager.java