You can make the ApplyParameterBindings to take bindings as an argument, and then do the switch for x86 inside the method. I believe there will be less duplicated code that way.

Comment highlighting the difference in the x86 version may be useful

I see the same ifdef on many other structs in this file. Do all of them need to be fixed?

Either that or we shoukd remove the attributes/defines for them

The other structs will need to be fixed as well. I can take those up in another PR. I vote for this particular fix to be merged as this has been reported by users and can be caught in the tests as well (while running on x86 platform). The tests are not catching the other cases, so I think there may be more tests needed to validate the changes to the other structs here.

I am fine with doing just a baby step if we believe that this library is useful for real workloads on x86 without fixing all/most of these. What are the chances that customers hitting this crash will immediately hit the next once once this one is fixed? Do we have some more complex sample app that uses this library that we can use to validate that it can work for a real app on x86?

The old defines referenced "ARCH_arm". (I assume that referred to 32 bit.) Do we expect this library to work on ARM/ARM64? If so will the right things happen?

Yes, the right things will happen for ARM/ARM64. This is the condition that we are replicating from oledb.h from Windows SDK:

#if defined(_WIN64) || defined(_ARM_)
#include <pshpack8.h>	// 8-byte structure packing
#else
#include <pshpack2.h>	// 2-byte structure packing
#endif

Ternary expression might be neater for these (?)

Either that or we shoukd remove the attributes/defines for them

If you keep this I suggest "#if 0" since one would only need it in DEBUG if specifically looking at this problem. It's not a big deal but it does override a member that in theory other code could call.

I did this to keep the style in the rest of this file. Otherwise I don't mind just removing the whole thing

@jkotas Would it be better to take the bindInfo here and check if we are running on x86 platform, and if we are, then create an array of tagDBPARAMBINDINFO_x86 and Marshal the tagDBPARAMBINDINFO to the array of x86 structs?
This would avoid all the if statements and multiple parameters accepting multiple structures based on the platform. I mean something like the following.

private unsafe void ApplyParameterBindings(UnsafeNativeMethods.ICommandWithParameters commandWithParameters, tagDBPARAMBINDINFO[] bindInfo)
        {
            IntPtr[] ordinals = new IntPtr[bindInfo.Length];
            for (int i = 0; i < ordinals.Length; ++i)
            {
                ordinals[i] = (IntPtr)(i + 1);
            }

            OleDbHResult hr;

            if (s_runningOnX86)
            {
                tagDBPARAMBINDINFO_x86[] bindInfo_x86 = new tagDBPARAMBINDINFO_x86[bindInfo.Length];
                for (int i = 0; i < bindInfo.Length; i++)
                {
                    fixed (tagDBPARAMBINDINFO* p = &bindInfo[i])
                    {
                        bindInfo_x86[i] = (tagDBPARAMBINDINFO_x86)Marshal.PtrToStructure((IntPtr)p, typeof(tagDBPARAMBINDINFO_x86));
                    }
                }
                fixed (tagDBPARAMBINDINFO_x86* p = &bindInfo_x86[0])
                {
                    hr = commandWithParameters.SetParameterInfo((IntPtr)bindInfo.Length, ordinals, (IntPtr)p);
                }
            }
            else
            {
                fixed (tagDBPARAMBINDINFO* p = &bindInfo[0])
                {
                    hr = commandWithParameters.SetParameterInfo((IntPtr)bindInfo.Length, ordinals, (IntPtr)p);
                }
            }

            if (hr < 0)
            {
                ProcessResults(hr);
            }
        }

And ofcourse we change the signature of SetParameterInfo to

System.Data.OleDb.OleDbHResult SetParameterInfo(
                [In] IntPtr cParams,
                [In, MarshalAs(UnmanagedType.LPArray)] IntPtr[] rgParamOrdinals,
                [In] IntPtr rgParamBindInfo);

as @maryamariyan has already done?

There would be data duplication and manipulation for x86 scenario, but it does simplify the code greatly.

Would it be better to take the bindInfo here and check if we are running on x86 platform, and if we are, then create an array of tagDBPARAMBINDINFO_x86 and Marshal the tagDBPARAMBINDINFO to the array of x86 structs?

Yes, that would be an option as well, especially given that this fix will need replicated in many more places. As you have said, it will result into extra data copies on x86, and the code will take very different path on x86 in general. We need to make sure to test it well.