Golf this Thumb-2 Constant! One thing that is constantly frustrating when golfing ARM Thumb-2 code is generating constants.
Since Thumb only has 16-bit and 32-bit instructions, it is impossible to encode every immediate 32-bit value into a single instruction.
Additionally, since it is a variable length instruction set, some methods of generating a constant are smaller than others.
I hate that. Write a program or function that does this work for me so I don't have to think about it. (*shudder*)
There are four different variants of the mov instruction as well as a pseudo instruction which loads from a constant pool.
They are either 2 bytes, 4 bytes, or 6 bytes long.
These are the following:

movs: 2 bytes. Generates any 8-bit unsigned value from 0x00 to 0xFF in the low 8 bits, setting the other bits to 0.
mov: 4 bytes. Generates any 8-bit unsigned value bitwise rotated any number of bits,† filling the rest with 0 bits.
mvn: 4 bytes. The same as mov, but generates the one's complement of that rotated 8-bit value, filling the rest with 1 bits.
movw: 4 bytes. Can set the low 16 bits to any 16-bit unsigned value from 0x0000-0xFFFF, and the high 16 bits to 0.
ldr: 6 bytes. The last resort. Can generate any 32-bit value, but is slow and larger than the other options.

†: Note that this is dramatically oversimplified, the real encoding would make this challenge quite frustrating.
The input will be a 32-bit integer, either by string (base 10 signed/unsigned or hex), stdin, or value.
Every value from 0x00000000 to 0xFFFFFFFF must be handled. It is a critical part of the challenge. Watch out for signed shift issues.
However, you can safely assume all inputs will fit into 32 bits, since ARM is a 32-bit architecture.
The output will be the shortest instruction to encode this constant.
The output format is whatever is easiest, as long as the values are distinct and you indicate which instruction corresponds to each output.
There will be a few cases where multiple answers are correct. You may either output one of the correct answers, or all of them. However, you must only display the shortest answers. So, for example, you must only output ldr when none of the other instructions can generate it.
Test cases (values are in hex to show the bit patterns)
0x00000000 -&gt; movs
0x00000013 -&gt; movs
0x000000ff -&gt; movs
0x12345678 -&gt; ldr
0x02300000 -&gt; mov
0xffffffff -&gt; mvn
0x00ffffff -&gt; mvn
0x00001200 -&gt; mov or movw
0x11800000 -&gt; mov
0x80000000 -&gt; mov
0x00000100 -&gt; mov or movw
0x0000f00d -&gt; movw
0xfff3dfff -&gt; mvn
0x03dc0000 -&gt; mov
0xf000000f -&gt; mov
0x00003dc0 -&gt; mov or movw
0x0021f300 -&gt; ldr
0x00100010 -&gt; ldr
0xffff0000 -&gt; ldr

Standard loopholes apply.
Note that as and objdump will not help; they will use the real encoding which is wrong. 
Being code-golf, the smallest answer in bytes per language wins.
JavaScript (ES6), 57 bytes
Returns false for &quot;mov&quot;, true for &quot;movs&quot;, 2 for &quot;ldr&quot;, 3 for &quot;mvn&quot; or 4 for &quot;movw&quot;.

f=(n,r)=&gt;n&gt;&gt;8?~n&gt;&gt;8?r&gt;31?n&gt;&gt;16?2:4:f(n&gt;&gt;&gt;31|n*2,-~r):3:!r

Try it online!
Commented
f = (                       // f is a recursive function taking:
  n,                        //   n = input
  r                         //   r = rotation counter, initially undefined
) =&gt;                        //
  n &gt;&gt; 8 ?                  // if some of the upper 24 bits of n are not 0's:
    ~n &gt;&gt; 8 ?               //   if some of the upper 24 bits of n are not 1's:
      r &gt; 31 ?              //     if the input was rotated 32 times (which means
                            //     that we've tried all possible rotations and we
                            //     are back to the original value):
        n &gt;&gt; 16 ?           //       if some of the upper 16 bits of n are not 0's:
          2                 //         return 2 for &quot;ldr&quot;
        :                   //       else:
          4                 //         return 4 for &quot;movw&quot;
      :                     //     else:
        f(                  //       do a recursive call:
          n &gt;&gt;&gt; 31 | n * 2, //         rotate n by 1 position to the left
          -~r               //         increment r
        )                   //       end of recursive call
    :                       //   else:
      3                     //     return 3 for &quot;mvn&quot;
  :                         // else:
    !r                      //   return true for &quot;movs&quot; if r is zero'ish
                            //   or false for &quot;mov&quot; if r is greater than 0