private GoString tryCreateInlineString(AddressSetView funcBody, AddressSet stringDataRange,
			Address stringDataAddr, Instruction instr1, Predicate<String> stringContentValidator) {
		// Precondition: instr1 has a ref to a location that could be the chars of a 
		// string (stringDataAddr).
		// The logic matches on 2 consecutive instructions that load 2 consecutive go param 
		// storage allocator registers (ex AX, then BX), because we know that a go string struct 
		// can fit into 2 registers when passed to a function
		// This needs to be improved to handle initializing a stack parameter.

		Instruction instr2 = instr1.getNext();
		if (instr2 == null || !funcBody.contains(instr2.getAddress())) {
			return null;
		}

		Register strAddrReg = getRegisterFromInstr(instr1);
		Register strLenReg = storageAllocator.getNextIntParamRegister(strAddrReg);
		if (strLenReg != null && strLenReg.contains(getRegisterFromInstr(instr2))) {
			// the first register was from the set of param passing registers, and we now know
			// what the second register must be to match the pattern
			long strLen = getScalarFromInstr(instr2);
			try {
				GoString str = GoString.createInlineString(goBinary, stringDataAddr, strLen);
				if (str.isValidInlineString(stringDataRange, stringContentValidator)) {
					return str;
				}
			}
			catch (IOException e) {
				// fail
			}
		}
		return null;
	}
Analyzer that finds Golang strings (and optionally slices) and marks up the found instances.
<p>
The char[] data for Golang strings does not contain null terminators, so the normal logic already
built into Ghidra to find terminated strings doesn't work.
<p>
This implementation looks for data that matches what a Golang string 
struct { char* data, long len } would look like, and follows the pointer to the char[] data 
and creates a fixed-length string at that location using the length info from the struct.
<p>
The string struct is found in a couple of different ways:
<ul>
	<li>References from an instruction (see markupStaticStructRefsInFunction)</li>
 <li>Iterating through data segments and making educated guesses (see markupDataSegmentStructs)</li>
</ul>
Some char[] data is only referenced from Golang string structs that exist temporarily
in registers after being set by an instruction that statically references the char[] data,
and an instruction that statically contains the length. (see tryCreateInlineString) 
<p>
Because slice structures can look like string structs, possible string struct locations are also
examined for slice-ness.  When marking a struct as a slice instead of as a string, the data
pointed to by the slice is not marked up because there is no information about the size of the
elements that the slice points to.
Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/analysis/GolangStringAnalyzer.java