private void processSectionHeader(ElfSectionHeader elfSectionToLoad,
			RelocatableImageBaseProvider relocatableImageBaseProvider)
			throws AddressOutOfBoundsException {

		long addr = elfSectionToLoad.getAddress();
		long sectionByteLength = elf.getLoadAdapter().getAdjustedSize(elfSectionToLoad); // size in bytes
		long loadOffset = elfSectionToLoad.getOffset(); // file offset in bytes
		Long nextRelocOffset = null;

		// In a relocatable ELF (object module), the address of all sections is zero.
		// Therefore, we shall assign an arbitrary address that
		// will pack the sections together with proper alignment.

		if (elfSectionToLoad.isAlloc() && elf.isRelocatable() && addr == 0) {
			// TODO: if program headers are present (very unlikely for object module) 
			// they should be used to determine section load address since they would 
			// be assigned first.
			AddressSpace space = getSectionAddressSpace(elfSectionToLoad);
			long relocOffset = relocatableImageBaseProvider.getNextRelocatableOffset(space);
			addr = NumericUtilities.getUnsignedAlignedValue(relocOffset,
				elfSectionToLoad.getAddressAlignment());
			elfSectionToLoad.setAddress(addr);
			nextRelocOffset = addr + (sectionByteLength / space.getAddressableUnitSize());
		}

		Address address = null;

		if (sectionByteLength == 0 &&
			elfSectionToLoad.getType() == ElfSectionHeaderConstants.SHT_PROGBITS) {
			// Check for and consume uninitialized portion of PT_LOAD segment if possible
			ElfProgramHeader loadHeader = elf.getProgramLoadHeaderContaining(addr);
			if (loadHeader != null) {
				// NOTE: should never apply to relocatable ELF
				Address segmentStart = getSegmentLoadAddress(loadHeader);
				AddressSpace segmentSpace = segmentStart.getAddressSpace();
				long loadSizeBytes = loadHeader.getAdjustedLoadSize();
				long fullSizeBytes =
					loadHeader.getAdjustedMemorySize() * segmentSpace.getAddressableUnitSize();
				long segmentByteOffset =
					(addr - loadHeader.getVirtualAddress()) * segmentSpace.getAddressableUnitSize();
				// TODO: should we match-up file offset?  This could be difficult
				// if using adjusted sizes
				if (segmentByteOffset >= loadSizeBytes) {
					// create as uninitialized section block
					loadOffset = -1; // don't load bytes
					address = segmentStart.add(segmentByteOffset);
					sectionByteLength = fullSizeBytes - segmentByteOffset;
				}
			}
		}

		if (sectionByteLength == 0) {
			log("Skipping empty section [" + elfSectionToLoad.getNameAsString() + "]");
			return;
		}

		if (address == null) {
			address = getSectionLoadAddress(elfSectionToLoad);
		}
		AddressSpace space = address.getAddressSpace();

		if (!space.isValidRange(address.getOffset(), sectionByteLength)) {
			log("Skipping unloadable section [" + elfSectionToLoad.getNameAsString() +
				"] at address " + address.toString(true) + " (size=" + sectionByteLength + ")");
			return;
		}

		final String blockName = elfSectionToLoad.getNameAsString();

		try {
			if (loadOffset == -1 ||
				elfSectionToLoad.getType() == ElfSectionHeaderConstants.SHT_NOBITS) {
				if (!elfSectionToLoad.isAlloc() &&
					elfSectionToLoad.getType() != ElfSectionHeaderConstants.SHT_PROGBITS) {
					return; // non-allocate at runtime
				}
				String comment =
					getSectionComment(addr, sectionByteLength, space.getAddressableUnitSize(),
						elfSectionToLoad.getTypeAsString(), address.isLoadedMemoryAddress());
				addUninitializedMemorySection(elfSectionToLoad, sectionByteLength, address,
					blockName, true, elfSectionToLoad.isWritable(), elfSectionToLoad.isExecutable(),
					comment, false);
			}
			else {
				String comment =
					getSectionComment(addr, sectionByteLength, space.getAddressableUnitSize(),
						elfSectionToLoad.getTypeAsString(), address.isLoadedMemoryAddress());
				addInitializedMemorySection(elfSectionToLoad, loadOffset, sectionByteLength,
					address, blockName, elfSectionToLoad.isAlloc(), elfSectionToLoad.isWritable(),
					elfSectionToLoad.isExecutable(), comment, false, elfSectionToLoad.isAlloc());
			}
		}
		catch (AddressOverflowException e) {
			log("Failed to load section [" + elfSectionToLoad.getNameAsString() + "]: " +
				getMessage(e));
		}

		if (nextRelocOffset != null) {
			relocatableImageBaseProvider.setNextRelocatableOffset(space, nextRelocOffset);
		}
	}
Process the specified section header by ensuring that it has a suitable memory address assigned
and added to the memory resolver.
@param elfSectionToLoad ELF section header to be processed
@param relocatableImageBaseProvider section address provider for relocatable ELF binaries.
@throws AddressOutOfBoundsException if an invalid memory address is encountered
Ghidra/Features/Base/src/main/java/ghidra/app/util/opinion/ElfProgramBuilder.java