Misaligned loads should only be allowed for POD types.

For example, we could reimplement the existing `load` and `storeBytes` using an unaligned Builtin, then broaden the existing assert so that it only performs the alignment check for non-POD types.

It would not be difficult to implement this feature but it does require basic knowledge of all the layers of the compiler. Roughly, I think we need something like:

Define a new AST Builtin for unaligned loads.

In SILGen, add an unaligned flag to `emitBuiltinLoadOrTake`

Add an unaligned flag to PointerToAddressInst in SILInstruction.h

Add all the serialization/deserialization support for that flag.

Change IRGen/GenType.cpp to check for this flag here:

Address TypeInfo::getAddressForPointer(llvm::Value *ptr) const {
 assert(ptr->getType()->getPointerElementType() == StorageType);
 return Address(ptr, getBestKnownAlignment());
}

Once we have a prototype, we need a Swift Evolution proposal to decide whether to change the default UnsafeRawPointer behavior or simply an a new flag.

Does the new builtin offer us any benefits over just using memcpy?

(which would make this a Standard-Library-only feature request)

The cleanest thing to do would probably be to either

• change the behavior of the existing Builtin.loadRaw to generate an aligned `pointer_to_address` in SIL

• or add a new `unaligned` flag to the existing `Builtin.loadRaw` if we need both behaviors

Comment by Rick M (JIRA)

Whatever it is would ideally inline nicely.

When the initial API was written, we weren’t sure how we wanted to allow opt-in/opt-out of alignment. It’s possible to move toward allowing misalignment, but not he other way around, hence the current behavior.,

At this point, it’s obvious to me that misalignment should be the default and we need a separate alignment opt-in for code that wants to be vectorized.

Meanwhile, the current workaround goes something like this:

func loadFromData<T>(data: Data, defaultVal: T) -> T {
 data.withUnsafeBytes { dataBytes in
   var value = defaultVal;
   memcpy(&value, dataBytes.baseAddress!, MemoryLayout<T>.size)
   return value
 }
}

This feature was added as part of SE-0349.

Implementation in #40296 and #41033.