%%% -*- erlang-indent-level: 2 -*-
%%%
%%% %CopyrightBegin%
%%%
%%% Copyright Ericsson AB 2005-2009. All Rights Reserved.
%%%
%%% The contents of this file are subject to the Erlang Public License,
%%% Version 1.1, (the "License"); you may not use this file except in
%%% compliance with the License. You should have received a copy of the
%%% Erlang Public License along with this software. If not, it can be
%%% retrieved online at http://www.erlang.org/.
%%%
%%% Software distributed under the License is distributed on an "AS IS"
%%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
%%% the License for the specific language governing rights and limitations
%%% under the License.
%%%
%%% %CopyrightEnd%
%%%
%%% Encode symbolic ARM instructions to binary form.
%%% Copyright (C) 2005 Mikael Pettersson
%%%
%%% Implementation Notes:
%%% - The Thumb instruction set is a different entity, and is
%%% not and never will be supported by this module.
%%% - Instructions and instruction forms that are unpredictable
%%% or useless in User mode are not supported. They include:
%%% + Data Processing Instructions with S=1 and Rd=15.
%%% + The LDM(2), LDM(3), and STM(2) instructions.
%%% + MRS instructions that access the SPSR.
%%% + MSR instructions that access the SPSR.
%%% + The LDBRT, LDRT, STBRT, and STRT instructions.
%%%
%%% Instruction Operands:
%%%
%%% S ::= {s,0} | {s,1}
%%% L ::= {l,0} | {l,1}
%%% R ::= {r,RNum}
%%% CR ::= {cr,CRNum}
%%%
%%% Cond ::= {cond,CondName}
%%% CondName ::= eq | ne | cs | hs | cc | lo | mi | pl | vs
%%% | vc | hi | ls | ge | lt | gt | ge | al
%%%
%%% Imm<N> ::= {imm<N>,<N bits>} for N in 4, 5, 8, 12, 16, 24, and 25
%%%
%%% Am1ShifterOperand
%%% ::= {Imm8,Imm4}
%%% | Rm
%%% | {Rm,Am1ShiftOp}
%%% Am1ShiftOp ::= {ShiftOp,Imm5}
%%% | {ShiftOp,Rs}
%%% | rrx
%%% ShiftOp ::= lsl | lsr | asr | ror
%%%
%%% Am2LSWUBOperand ::= {immediate_offset,Rn,Sign,Imm12}
%%% | {register_offset,Rn,Sign,Rm} // redundant
%%% | {scaled_register_offset,Rn,Sign,Rm,Am2ShiftOp}
%%% | {immediate_pre_indexed,Rn,Sign,Imm12}
%%% | {register_pre_indexed,Rn,Sign,Rm} // redundant
%%% | {scaled_register_pre_indexed,Rn,Sign,Rm,Am2ShiftOp}
%%% | {immediate_post_indexed,Rn,Sign,Imm12}
%%% | {register_post_indexed,Rn,Sign,Rm} // redundant
%%% | {scaled_register_post_indexed,Rn,Sign,Rm,Am2ShiftOp}
%%% Am2ShiftOp ::= {ShiftOp,Imm5}
%%% | rrx
%%% Sign ::= + | -
%%%
%%% Am3MiscLSOperand::= {immediate_offset,Rn,Sign,Imm8}
%%% | {register_offset,Rn,Sign,Rm}
%%% | {immediate_pre_indexed,Rn,Sign,Imm8}
%%% | {register_pre_indexed,Rn,Sign,Rm}
%%% | {immediate_post_indexed,Rn,Sign,Imm8}
%%% | {register_post_indexed,Rn,Sign,Rm}
%%%
%%% Am4LSMultiple ::= ia | ib | da | db
%%% | fd | ed | fa | ea
%%%
%%% Am5LSCoprocessor::= {offset,Rn,Sign,Imm8}
%%% | {pre_indexed,Rn,Sign,Imm8}
%%% | {post_indexed,Rn,Sign,Imm8}
%%% | {unindexed,Rn,Imm8}
-module(hipe_arm_encode).
-export([insn_encode/2]).
%%-define(TESTING,1).
-ifdef(TESTING).
-export([dotest/0, dotest/1]).
-endif.
-define(ASSERT(G),
if G -> [];
true -> exit({assertion_failed,?MODULE,?LINE,??G})
end).
bf(LeftBit, RightBit, Value) ->
?ASSERT(32 > LeftBit),
?ASSERT(LeftBit >= RightBit),
?ASSERT(RightBit >= 0),
?ASSERT(Value >= 0),
?ASSERT(Value < (1 bsl ((LeftBit - RightBit) + 1))),
Value bsl RightBit.
-define(BF(LB,RB,V), bf(LB,RB,V)).
-define(BIT(Pos,Val), ?BF(Pos,Pos,Val)).
%%-define(BITS(N,Val), ?BF(N,0,Val)).
%%%
%%% Addressing Modes
%%%
am1_shifter_operand(Rn, Rd, ShifterOperand) ->
case ShifterOperand of
{{imm8,Imm8},{imm4,RotImm4}} ->
?BIT(25,1) bor ?BF(11,8,RotImm4) bor ?BF(7,0,Imm8);
{r,Rm} ->
%% same as Rm LSL #0
?BF(3,0,Rm);
{{r,Rm},ShiftOp} ->
am1_shift_op(Rn, Rd, Rm, ShiftOp) bor ?BF(3,0,Rm)
end.
am1_shift_op(_Rn, _Rd, _Rm, {ShiftOp,{imm5,ShiftImm5}}) ->
case ShiftOp of
'ror' -> ?ASSERT(ShiftImm5 =/= 0); % denotes RRX form
_ -> []
end,
?BF(11,7,ShiftImm5) bor shift_op_bits65(ShiftOp);
am1_shift_op(Rn, Rd, Rm, {ShiftOp,{r,Rs}}) ->
?ASSERT(Rn =/= 15), % UNPREDICTABLE
?ASSERT(Rd =/= 15), % UNPREDICTABLE
?ASSERT(Rm =/= 15), % UNPREDICTABLE
?ASSERT(Rs =/= 15), % UNPREDICTABLE
?BF(11,8,Rs) bor shift_op_bits65(ShiftOp) bor ?BIT(4,1);
am1_shift_op(_Rn, _Rd, _Rm, 'rrx') ->
?BF(6,5,2#11).
shift_op_bits65(ShiftOp) ->
case ShiftOp of
'lsl' -> ?BF(6,5,2#00);
'lsr' -> ?BF(6,5,2#01);
'asr' -> ?BF(6,5,2#10);
'ror' -> ?BF(6,5,2#11)
end.
sign('+') -> ?BIT(23,1);
sign('-') -> 0.
am2_lswub(Rd, AddressingMode) ->
case AddressingMode of
{immediate_offset,{r,Rn},Sign,{imm12,Imm12}} ->
?BIT(24,1) bor sign(Sign) bor ?BF(19,16,Rn) bor ?BF(11,0,Imm12);
{register_offset,{r,Rn},Sign,{r,Rm}} ->
%% same as scaled_register_offset LSL #0
?ASSERT(Rm =/= 15), % UNPREDICTABLE
?BIT(25,1) bor ?BIT(24,1) bor sign(Sign) bor ?BF(19,16,Rn) bor ?BF(3,0,Rm);
{scaled_register_offset,{r,Rn},Sign,{r,Rm},ShiftOp} ->
?ASSERT(Rm =/= 15), % UNPREDICTABLE
?BIT(25,1) bor ?BIT(24,1) bor sign(Sign) bor ?BF(19,16,Rn) bor am2_shift_op(ShiftOp) bor ?BF(3,0,Rm);
{immediate_pre_indexed,{r,Rn},Sign,{imm12,Imm12}} ->
?ASSERT(Rd =/= Rn), % UNPREDICTABLE
?ASSERT(Rn =/= 15), % UNPREDICTABLE
?BIT(24,1) bor sign(Sign) bor ?BIT(21,1) bor ?BF(19,16,Rn) bor ?BF(11,0,Imm12);
{register_pre_indexed,{r,Rn},Sign,{r,Rm}} ->
%% same as scaled_register_pre_indexed LSL #0
?ASSERT(Rd =/= Rn), % UNPREDICTABLE
?ASSERT(Rn =/= 15), % UNPREDICTABLE
?ASSERT(Rm =/= 15), % UNPREDICTABLE
?ASSERT(Rn =/= Rm), % UNPREDICTABLE
?BIT(25,1) bor ?BIT(24,1) bor sign(Sign) bor ?BIT(21,1) bor ?BF(19,16,Rn) bor ?BF(3,0,Rm);
{scaled_register_pre_indexed,{r,Rn},Sign,{r,Rm},ShiftOp} ->
?ASSERT(Rd =/= Rn), % UNPREDICTABLE
?ASSERT(Rn =/= 15), % UNPREDICTABLE
?ASSERT(Rm =/= 15), % UNPREDICTABLE
?ASSERT(Rn =/= Rm), % UNPREDICTABLE
?BIT(25,1) bor ?BIT(24,1) bor sign(Sign) bor ?BIT(21,1) bor ?BF(19,16,Rn) bor am2_shift_op(ShiftOp) bor ?BF(3,0,Rm);
{immediate_post_indexed,{r,Rn},Sign,{imm12,Imm12}} ->
?ASSERT(Rd =/= Rn), % UNPREDICTABLE
?ASSERT(Rn =/= 15), % UNPREDICTABLE
sign(Sign) bor ?BF(19,16,Rn) bor ?BF(11,0,Imm12);
{register_post_indexed,{r,Rn},Sign,{r,Rm}} ->
%% same as scaled_register_post_indexed LSL #0
?ASSERT(Rd =/= Rn), % UNPREDICTABLE
?BIT(25,1) bor sign(Sign) bor ?BF(19,6,Rn) bor ?BF(3,0,Rm);
{scaled_register_post_indexed,{r,Rn},Sign,{r,Rm},ShiftOp} ->
?ASSERT(Rd =/= Rn), % UNPREDICTABLE
?ASSERT(Rn =/= 15), % UNPREDICTABLE
?ASSERT(Rm =/= 15), % UNPREDICTABLE
?ASSERT(Rn =/= Rm), % UNPREDICTABLE
?BIT(25,1) bor sign(Sign) bor ?BF(19,16,Rn) bor am2_shift_op(ShiftOp) bor ?BF(3,0,Rm)
end.
am2_shift_op({ShiftOp,{imm5,ShiftImm5}}) ->
case ShiftOp of
'ror' -> ?ASSERT(ShiftImm5 =/= 0); % denotes RRX form
_ -> []
end,
?BF(11,7,ShiftImm5) bor shift_op_bits65(ShiftOp);
am2_shift_op('rrx') ->
?BF(6,5,2#11).
am3_miscls(Rd, AddressingMode) ->
case AddressingMode of
{immediate_offset,{r,Rn},Sign,{imm8,Imm8}} ->
?BIT(24,1) bor sign(Sign) bor ?BF(22,21,2#10) bor ?BF(19,16,Rn) bor ?BF(11,8,Imm8 bsr 4) bor ?BF(3,0,Imm8 band 2#1111);
{register_offset,{r,Rn},Sign,{r,Rm}} ->
?ASSERT(Rm =/= 15), % UNPREDICTABLE
?BIT(24,1) bor sign(Sign) bor ?BF(22,21,2#00) bor ?BF(19,16,Rn) bor ?BF(3,0,Rm);
{immediate_pre_indexed,{r,Rn},Sign,{imm8,Imm8}} ->
?ASSERT(Rd =/= Rn), % UNPREDICTABLE
?ASSERT(Rn =/= 15), % UNPREDICTABLE
?BIT(24,1) bor sign(Sign) bor ?BF(22,21,2#11) bor ?BF(19,16,Rn) bor ?BF(11,8,Imm8 bsr 4) bor ?BF(3,0,Imm8 band 2#1111);
{register_pre_indexed,{r,Rn},Sign,{r,Rm}} ->
?ASSERT(Rd =/= Rn), % UNPREDICTABLE
?ASSERT(Rm =/= 15), % UNPREDICTABLE
?ASSERT(Rn =/= 15), % UNPREDICTABLE
?ASSERT(Rm =/= Rn), % UNPREDICTABLE
?BIT(24,1) bor sign(Sign) bor ?BF(22,21,2#01) bor ?BF(19,16,Rn) bor ?BF(3,0,Rm);
{immediate_post_indexed,{r,Rn},Sign,{imm8,Imm8}} ->
?ASSERT(Rd =/= Rn), % UNPREDICTABLE
?ASSERT(Rn =/= 15), % UNPREDICTABLE
?BIT(24,0) bor sign(Sign) bor ?BF(22,21,2#10) bor ?BF(19,16,Rn) bor ?BF(11,8,Imm8 bsr 4) bor ?BF(3,0,Imm8 band 2#1111);
{register_post_indexed,{r,Rn},Sign,{r,Rm}} ->
?ASSERT(Rd =/= Rn), % UNPREDICTABLE
?ASSERT(Rm =/= 15), % UNPREDICTABLE
?ASSERT(Rn =/= 15), % UNPREDICTABLE
?ASSERT(Rm =/= Rn), % UNPREDICTABLE
?BIT(24,0) bor sign(Sign) bor ?BF(22,21,2#00) bor ?BF(19,16,Rn) bor ?BF(3,0,Rm)
end.
am4_ls_multiple(L, AddressingMode) ->
case AddressingMode of
'ia' -> ?BF(24,23,2#01);
'ib' -> ?BF(24,23,2#11);
'da' -> ?BF(24,23,2#00);
'db' -> ?BF(24,23,2#10);
_ ->
%% context-sensitive alias crap
case {L,AddressingMode} of
{1,'fa'} -> ?BF(24,23,2#00);
{1,'fd'} -> ?BF(24,23,2#01);
{1,'ea'} -> ?BF(24,23,2#10);
{1,'ed'} -> ?BF(24,23,2#11);
{0,'ed'} -> ?BF(24,23,2#00);
{0,'ea'} -> ?BF(24,23,2#01);
{0,'fd'} -> ?BF(24,23,2#10);
{0,'fa'} -> ?BF(24,23,2#11)
end
end.
am5_ls_coprocessor(AddressingMode) ->
case AddressingMode of
{offset,{r,Rn},Sign,{imm8,Imm8}} ->
?BIT(24,1) bor sign(Sign) bor ?BF(19,16,Rn) bor ?BF(7,0,Imm8);
{pre_indexed,{r,Rn},Sign,{imm8,Imm8}} ->
?ASSERT(Rn =/= 15), % UNPREDICTABLE
?BIT(24,1) bor sign(Sign) bor ?BIT(21,1) bor ?BF(19,16,Rn) bor ?BF(7,0,Imm8);
{post_indexed,{r,Rn},Sign,{imm8,Imm8}} ->
?ASSERT(Rn =/= 15), % UNPREDICTABLE
sign(Sign) bor ?BIT(21,1) bor ?BF(19,16,Rn) bor ?BF(7,0,Imm8);
{unindexed,{r,Rn},{imm8,Imm8}} ->
?BIT(23,1) bor ?BF(19,16,Rn) bor ?BF(7,0,Imm8)
end.
%%%
'cond'(Cond) ->
case Cond of
'eq' -> ?BF(31,28,2#0000); % equal
'ne' -> ?BF(31,28,2#0001); % not equal
'cs' -> ?BF(31,28,2#0010); % carry set
'hs' -> ?BF(31,28,2#0010); % unsigned higher or same
'cc' -> ?BF(31,28,2#0011); % carry clear
'lo' -> ?BF(31,28,2#0011); % unsigned lower
'mi' -> ?BF(31,28,2#0100); % minus/negative
'pl' -> ?BF(31,28,2#0101); % plus/positive or zero
'vs' -> ?BF(31,28,2#0110); % overflow
'vc' -> ?BF(31,28,2#0111); % no overflow
'hi' -> ?BF(31,28,2#1000); % unsigned higher
'ls' -> ?BF(31,28,2#1001); % unsigned lower or same
'ge' -> ?BF(31,28,2#1010); % signed greater than or equal
'lt' -> ?BF(31,28,2#1011); % signed less than
'gt' -> ?BF(31,28,2#1100); % signed greater than
'le' -> ?BF(31,28,2#1101); % signed less than or equal
'al' -> ?BF(31,28,2#1110) % always
end.
%%%
%%% ARM Instructions
%%%
data_processing_form(Cond, OpCode, S, Rn, Rd, ShifterOperand) ->
case S of
1 -> ?ASSERT(Rd =/= 15); % UNPREDICTABLE in User or System mode
_ -> []
end,
'cond'(Cond) bor ?BF(24,21,OpCode) bor ?BIT(20,S) bor ?BF(19,16,Rn) bor ?BF(15,12,Rd) bor am1_shifter_operand(Rn,Rd,ShifterOperand).
data_processing_form(OpCode, {{'cond',Cond},{s,S},{r,Rd},{r,Rn},ShifterOperand}) ->
data_processing_form(Cond, OpCode, S, Rn, Rd, ShifterOperand).
adc(Opnds) -> data_processing_form(2#0101, Opnds).
add(Opnds) -> data_processing_form(2#0100, Opnds).
'and'(Opnds) -> data_processing_form(2#0000, Opnds).
bic(Opnds) -> data_processing_form(2#1110, Opnds).
eor(Opnds) -> data_processing_form(2#0001, Opnds).
orr(Opnds) -> data_processing_form(2#1100, Opnds).
rsb(Opnds) -> data_processing_form(2#0011, Opnds).
rsc(Opnds) -> data_processing_form(2#0111, Opnds).
sbc(Opnds) -> data_processing_form(2#0110, Opnds).
sub(Opnds) -> data_processing_form(2#0010, Opnds).
cmp_form(OpCode, {{'cond',Cond},{r,Rn},ShifterOperand}) ->
data_processing_form(Cond, OpCode, 1, Rn, 0, ShifterOperand).
cmn(Opnds) -> cmp_form(2#1011, Opnds).
cmp(Opnds) -> cmp_form(2#1010, Opnds).
teq(Opnds) -> cmp_form(2#1001, Opnds).
tst(Opnds) -> cmp_form(2#1000, Opnds).
mov_form(OpCode, {{'cond',Cond},{s,S},{r,Rd},ShifterOperand}) ->
data_processing_form(Cond, OpCode, S, 0, Rd, ShifterOperand).
mov(Opnds) -> mov_form(2#1101, Opnds).
mvn(Opnds) -> mov_form(2#1111, Opnds).
%%%
b_form(L, {{'cond',Cond},{imm24,Imm24}}) ->
'cond'(Cond) bor ?BF(27,25,2#101) bor ?BIT(24,L) bor ?BF(23,0,Imm24).
b(Opnds) -> b_form(0, Opnds).
bl(Opnds) -> b_form(1, Opnds).
bkpt({{imm16,Imm16}}) ->
?BF(31,28,2#1110) bor ?BF(27,20,2#00010010) bor ?BF(19,8,Imm16 bsr 4) bor ?BF(7,4,2#0111) bor ?BF(3,0,Imm16 band 2#1111).
bx_form(SubOpcode, {{'cond',Cond},{r,Rm}}, IsBlx) ->
case IsBlx of
true -> ?ASSERT(Rm =/= 15); % UNPREDICTABLE
_ -> []
end,
'cond'(Cond) bor ?BF(27,20,2#00010010) bor ?BF(19,16,2#1111) bor ?BF(15,12,2#1111) bor ?BF(11,8,2#1111) bor ?BF(7,4,SubOpcode) bor ?BF(3,0,Rm).
blx(Opnds) ->
case Opnds of
{{imm25,Imm25}} -> % u16-offset!
?BF(31,28,2#1111) bor ?BF(27,25,2#101) bor ?BIT(24,Imm25 band 1) bor ?BF(23,0,Imm25 bsr 1);
_ ->
bx_form(2#0011, Opnds, true)
end.
bx(Opnds) -> bx_form(2#0001, Opnds, false).
cdp_form(Cond, CpOp4, CRn, CRd, CpNum, CpOp3, CRm) ->
Cond bor ?BF(27,24,2#1110) bor ?BF(23,20,CpOp4) bor ?BF(19,16,CRn) bor ?BF(15,12,CRd) bor ?BF(11,8,CpNum) bor ?BF(7,5,CpOp3) bor ?BF(3,0,CRm).
cdp({{'cond',Cond},{cpnum,CpNum},{cpop4,CpOp4},{cr,CRd},{cr,CRn},{cr,CRm},{cpop3,CpOp3}}) ->
cdp_form('cond'(Cond), CpOp4, CRn, CRd, CpNum, CpOp3, CRm).
cdp2({{cpnum,CpNum},{cpop4,CpOp4},{cr,CRd},{cr,CRn},{cr,CRm},{cpop3,CpOp3}}) ->
cdp_form(?BF(31,28,2#1111), CpOp4, CRn, CRd, CpNum, CpOp3, CRm).
clz({{'cond',Cond},{r,Rd},{r,Rm}}) ->
?ASSERT(Rd =/= 15), % UNPREDICTABLE
?ASSERT(Rm =/= 15), % UNPREDICTABLE
'cond'(Cond) bor ?BF(27,20,2#00010110) bor ?BF(19,16,2#1111) bor ?BF(15,12,Rd) bor ?BF(11,8,2#1111) bor ?BF(7,4,2#0001) bor ?BF(3,0,Rm).
ldstc_form(Cond, L, B20, CRd, CpNum, AddressingMode) ->
Cond bor ?BF(27,25,2#110) bor ?BIT(22,L) bor ?BIT(20,B20) bor ?BF(15,12,CRd) bor ?BF(11,8,CpNum) bor am5_ls_coprocessor(AddressingMode).
ldstc(B20, {{'cond',Cond},{l,L},{cpnum,CpNum},{cr,CRd},AddressingMode}) ->
ldstc_form('cond'(Cond), L, B20, CRd, CpNum, AddressingMode).
ldc(Opnds) -> ldstc(1, Opnds).
stc(Opnds) -> ldstc(0, Opnds).
ldstc2(B20, {{l,L},{cpnum,CpNum},{cr,CRd},AddressingMode}) ->
ldstc_form(?BF(31,28,2#1111), L, B20, CRd, CpNum, AddressingMode).
ldc2(Opnds) -> ldstc2(1, Opnds).
stc2(Opnds) -> ldstc2(0, Opnds).
ldstm_form(Cond, AddressingMode, W, L, Rn, Registers) ->
RegisterList = register_list(Registers),
?ASSERT(RegisterList =/= 0), % UNPREDICTABLE
?ASSERT(Rn =/= 15), % UNPREDICTABLE
case W of
1 ->
BitRn = 1 bsl Rn,
case L of
1 ->
%% LDM! Rn in Registers is UNPREDICTABLE
?ASSERT((RegisterList band BitRn) =:= 0);
0 ->
%% STM! Rn in Registers and not lowest is UNPREDICTABLE
case RegisterList band BitRn of
0 -> [];
_ ->
?ASSERT((RegisterList band (-RegisterList)) =:= BitRn)
end
end;
_ -> []
end,
'cond'(Cond) bor ?BF(27,25,2#100) bor am4_ls_multiple(L, AddressingMode) bor ?BIT(21,W) bor ?BIT(20,L) bor ?BF(19,16,Rn) bor ?BF(15,0,RegisterList).
register_list(Registers) -> register_list(Registers, 0).
register_list([{r,R}|Rs], Mask) -> register_list(Rs, Mask bor (1 bsl R));
register_list([], Mask) -> Mask.
ldstm(L, Opnds) ->
case Opnds of
{{'cond',Cond},AddressingMode,{r,Rn},'!',Registers} ->
ldstm_form(Cond, AddressingMode, 1, L, Rn, Registers);
{{'cond',Cond},AddressingMode,{r,Rn},Registers} ->
ldstm_form(Cond, AddressingMode, 0, L, Rn, Registers)
%% the ldm(2), ldm(3), and stm(2) forms are UNPREDICTABLE
%% in User or System mode
end.
ldm(Opnds) -> ldstm(1, Opnds).
stm(Opnds) -> ldstm(0, Opnds).
ldstr_form2(B, L, {{'cond',Cond},{r,Rd},AddressingMode}) ->
'cond'(Cond) bor ?BF(27,26,2#01) bor am2_lswub(Rd, AddressingMode) bor ?BIT(22,B) bor ?BIT(20,L) bor ?BF(15,12,Rd).
ldr(Opnds) -> ldstr_form2(0, 1, Opnds).
ldrb(Opnds) -> ldstr_form2(1, 1, Opnds).
str(Opnds) -> ldstr_form2(0, 0, Opnds).
strb(Opnds) -> ldstr_form2(1, 0, Opnds).
ldstr_form3(L, SubOpcode, {{'cond',Cond},{r,Rd},AddressingMode}) ->
?ASSERT(Rd =/= 15), % UNPREDICTABLE
'cond'(Cond) bor am3_miscls(Rd, AddressingMode) bor ?BIT(20,L) bor ?BF(15,12,Rd) bor ?BF(7,4,SubOpcode).
ldrh(Opnds) -> ldstr_form3(1, 2#1011, Opnds).
ldrsb(Opnds) -> ldstr_form3(1, 2#1101, Opnds).
ldrsh(Opnds) -> ldstr_form3(1, 2#1111, Opnds).
strh(Opnds) -> ldstr_form3(0, 2#1011, Opnds).
mcr_form(Cond, OP1, CRn, Rd, CpNum, OP2, CRm) ->
?ASSERT(Rd =/= 15), % UNPREDICTABLE
Cond bor ?BF(27,24,2#1110) bor ?BF(23,21,OP1) bor ?BF(19,16,CRn) bor ?BF(15,12,Rd) bor ?BF(11,8,CpNum) bor ?BF(7,5,OP2) bor ?BIT(4,1) bor ?BF(3,0,CRm).
mcr({{'cond',Cond},{cpnum,CpNum},{cpop3,OP1},{r,Rd},{cr,CRn},{cr,CRm},{cpop3,OP2}}) ->
mcr_form('cond'(Cond), OP1, CRn, Rd, CpNum, OP2, CRm).
mcr2({{cpnum,CpNum},{cpop3,OP1},{r,Rd},{cr,CRn},{cr,CRm},{cpop3,OP2}}) ->
mcr_form(?BF(31,28,2#1111), OP1, CRn, Rd, CpNum, OP2, CRm).
mla({{'cond',Cond},{s,S},{r,Rd},{r,Rm},{r,Rs},{r,Rn}}) ->
?ASSERT(Rd =/= 15), % UNPREDICTABLE
?ASSERT(Rm =/= 15), % UNPREDICTABLE
?ASSERT(Rs =/= 15), % UNPREDICTABLE
?ASSERT(Rn =/= 15), % UNPREDICTABLE
?ASSERT(Rd =/= Rm), % UNPREDICTABLE
'cond'(Cond) bor ?BIT(21,1) bor ?BIT(20,S) bor ?BF(19,16,Rd) bor ?BF(15,12,Rn) bor ?BF(11,8,Rs) bor ?BF(7,4,2#1001) bor ?BF(3,0,Rm).
mrc_form(Cond, OP1, CRn, Rd, CpNum, OP2, CRm) ->
Cond bor ?BF(27,24,2#1110) bor ?BF(23,21,OP1) bor ?BIT(20,1) bor ?BF(19,16,CRn) bor ?BF(15,12,Rd) bor ?BF(11,8,CpNum) bor ?BF(7,5,OP2) bor ?BIT(4,1) bor ?BF(3,0,CRm).
mrc({{'cond',Cond},{cpnum,CpNum},{cpop3,OP1},{r,Rd},{cr,CRn},{cr,CRm},{cpop3,OP2}}) ->
mrc_form('cond'(Cond), OP1, CRn, Rd, CpNum, OP2, CRm).
mrc2({{cpnum,CpNum},{cpop3,OP1},{r,Rd},{cr,CRn},{cr,CRm},{cpop3,OP2}}) ->
mrc_form(?BF(31,28,2#1111), OP1, CRn, Rd, CpNum, OP2, CRm).
mrs({{'cond',Cond},{r,Rd},'cpsr'}) ->
%% the SPSR form is UNPREDICTABLE in User or System mode
?ASSERT(Rd =/= 15), % UNPREDICTABLE
'cond'(Cond) bor ?BIT(24,1) bor ?BF(19,16,2#1111) bor ?BF(15,12,Rd).
msr_form(Cond, FieldMask4, Operand) ->
'cond'(Cond) bor ?BIT(24,1) bor ?BIT(21,1) bor ?BF(19,16,FieldMask4) bor ?BF(15,12,2#1111) bor Operand.
msr(Opnds) ->
%% the SPSR form is UNPREDICTABLE in User or System mode
case Opnds of
{{'cond',Cond},'cpsr',{field_mask,FieldMask4},{imm8,Imm8},{imm4,RotImm4}} ->
msr_form(Cond, FieldMask4, ?BIT(25,1) bor ?BF(11,8,RotImm4) bor ?BF(7,0,Imm8));
{{'cond',Cond},'cpsr',{field_mask,FieldMask4},{r,Rm}} ->
msr_form(Cond, FieldMask4, ?BF(3,0,Rm))
end.
mul({{'cond',Cond},{s,S},{r,Rd},{r,Rm},{r,Rs}}) ->
?ASSERT(Rd =/= 15), % UNPREDICTABLE
?ASSERT(Rm =/= 15), % UNPREDICTABLE
?ASSERT(Rs =/= 15), % UNPREDICTABLE
?ASSERT(Rd =/= Rm), % UNPREDICTABLE
'cond'(Cond) bor ?BIT(20,S) bor ?BF(19,16,Rd) bor ?BF(11,8,Rs) bor ?BF(7,4,2#1001) bor ?BF(3,0,Rm).
ml_form2(OpCode, Cond, S, RdLo, RdHi, Rm, Rs) ->
?ASSERT(RdHi =/= 15), % UNPREDICTABLE
?ASSERT(RdLo =/= 15), % UNPREDICTABLE
?ASSERT(Rm =/= 15), % UNPREDICTABLE
?ASSERT(Rs =/= 15), % UNPREDICTABLE
?ASSERT(RdHi =/= RdLo),% UNPREDICTABLE
?ASSERT(RdHi =/= Rm), % UNPREDICTABLE
?ASSERT(RdLo =/= Rm), % UNPREDICTABLE
'cond'(Cond) bor ?BF(27,21,OpCode) bor ?BIT(20,S) bor ?BF(19,16,RdHi) bor ?BF(15,12,RdLo) bor ?BF(11,8,Rs) bor ?BF(7,4,2#1001) bor ?BF(3,0,Rm).
ml_form(OpCode, {{'cond',Cond},{s,S},{r,RdLo},{r,RdHi},{r,Rm},{r,Rs}}) ->
ml_form2(OpCode, Cond, S, RdLo, RdHi, Rm, Rs).
%%smlal(Opnds) -> ml_form(2#0000111, Opnds).
smull(Opnds) -> ml_form(2#0000110, Opnds).
umlal(Opnds) -> ml_form(2#0000101, Opnds).
umull(Opnds) -> ml_form(2#0000100, Opnds).
swi({{'cond',Cond},{imm24,Imm24}}) ->
'cond'(Cond) bor ?BF(27,24,2#1111) bor ?BF(23,0,Imm24).
swp_form(B22, {{'cond',Cond},{r,Rd},{r,Rm},{r,Rn}}) ->
?ASSERT(Rd =/= 15), % UNPREDICTABLE
?ASSERT(Rm =/= 15), % UNPREDICTABLE
?ASSERT(Rn =/= 15), % UNPREDICTABLE
?ASSERT(Rn =/= Rm), % UNPREDICTABLE
?ASSERT(Rn =/= Rd), % UNPREDICTABLE
'cond'(Cond) bor ?BIT(24,1) bor ?BIT(22,B22) bor ?BF(19,16,Rn) bor ?BF(15,12,Rd) bor ?BF(7,4,2#1001) bor ?BF(3,0,Rm).
swp(Opnds) -> swp_form(0, Opnds).
swpb(Opnds) -> swp_form(1, Opnds).
%%%
%%% Enhanced DSP Extension Instructions
%%%
ldstrd_form(OpCode, {{'cond',Cond},{r,Rd},AddressingMode}) ->
?ASSERT(Rd =/= 14), % UNPREDICTABLE
?ASSERT((Rd band 1) =:= 0), % UNDEFINED
%% XXX: unpredictable if write-back and base reg Rn equals Rd or Rd+1
%% XXX: if is load then unpredictable if index reg Rm and Rm equals Rd or Rd+1
'cond'(Cond) bor am3_miscls(Rd, AddressingMode) bor ?BF(15,12,Rd) bor ?BF(7,4,OpCode).
ldrd(Opnds) -> ldstrd_form(2#1101, Opnds).
strd(Opnds) -> ldstrd_form(2#1111, Opnds).
mcrr({{'cond',Cond},{cpnum,CpNum},{cpop4,OP},{r,Rd},{r,Rn},{cr,CRm}}) ->
?ASSERT(Rd =/= 15), % UNPREDICTABLE
?ASSERT(Rn =/= 15), % UNPREDICTABLE
'cond'(Cond) bor ?BF(27,20,2#11000100) bor ?BF(19,16,Rn) bor ?BF(15,12,Rd) bor ?BF(11,8,CpNum) bor ?BF(7,4,OP) bor ?BF(3,0,CRm).
mrrc({{'cond',Cond},{cpnum,CpNum},{cpop4,OP},{r,Rd},{r,Rn},{cr,CRm}}) ->
?ASSERT(Rd =/= 15), % UNPREDICTABLE
?ASSERT(Rn =/= 15), % UNPREDICTABLE
?ASSERT(Rd =/= Rn), % UNPREDICTABLE
'cond'(Cond) bor ?BF(27,20,2#11000101) bor ?BF(19,16,Rn) bor ?BF(15,12,Rd) bor ?BF(11,8,CpNum) bor ?BF(7,4,OP) bor ?BF(3,0,CRm).
pld({AddressingMode}) ->
AM = am2_lswub(42, AddressingMode), % 42 is a dummy reg nr
%% not all adressing modes are allowed: bit 24 must be 1
%% and bit 21 must be 0
?ASSERT(((AM bsr 21) band 2#1001) =:= 2#1000),
16#F550F000 bor AM.
q_form(OpCode, {{'cond',Cond},{r,Rd},{r,Rm},{r,Rn}}) ->
?ASSERT(Rd =/= 15), % UNPREDICTABLE
?ASSERT(Rm =/= 15), % UNPREDICTABLE
?ASSERT(Rn =/= 15), % UNPREDICTABLE
'cond'(Cond) bor ?BF(27,20,OpCode) bor ?BF(19,16,Rn) bor ?BF(15,11,Rd) bor ?BF(7,4,2#0101) bor ?BF(3,0,Rm).
qadd(Opnds) -> q_form(2#00010000, Opnds).
qdadd(Opnds) -> q_form(2#00010100, Opnds).
qdsub(Opnds) -> q_form(2#00010110, Opnds).
qsub(Opnds) -> q_form(2#00010010, Opnds).
smlaxy_form(Cond, OpCode, Rd, Rn, Rs, Y, X, Rm) ->
?ASSERT(Rd =/= 15), % UNPREDICTABLE
?ASSERT(Rm =/= 15), % UNPREDICTABLE
?ASSERT(Rs =/= 15), % UNPREDICTABLE
?ASSERT(Rn =/= 15), % UNPREDICTABLE
'cond'(Cond) bor ?BF(27,20,OpCode) bor ?BF(19,16,Rd) bor ?BF(15,12,Rn) bor ?BF(11,8,Rs) bor ?BIT(7,1) bor ?BIT(6,Y) bor ?BIT(5,X) bor ?BF(3,0,Rm).
smla({{bt,X},{bt,Y},{'cond',Cond},{r,Rd},{r,Rm},{r,Rs},{r,Rn}}) ->
smlaxy_form(Cond, 2#00010000, Rd, Rn, Rs, Y, X, Rm).
smlal(Opnds) -> % may be regular ARM or DSP insn :-(
case Opnds of
{{'cond',Cond},{s,S},{r,RdLo},{r,RdHi},{r,Rm},{r,Rs}} ->
ml_form2(2#0000111, Cond, S, RdLo, RdHi, Rm, Rs);
{{bt,X},{bt,Y},{'cond',Cond},{r,RdLo},{r,RdHi},{r,Rm},{r,Rs}} ->
?ASSERT(RdLo =/= RdHi), % UNPREDICTABLE
smlaxy_form(Cond, 2#00010100, RdHi, RdLo, Rs, Y, X, Rm)
end.
smlaw({{bt,Y},{'cond',Cond},{r,Rd},{r,Rm},{r,Rs},{r,Rn}}) ->
smlaxy_form(Cond, 2#00010010, Rd, Rn, Rs, Y, 0, Rm).
smul({{bt,X},{bt,Y},{'cond',Cond},{r,Rd},{r,Rm},{r,Rs}}) ->
smlaxy_form(Cond, 2#00010110, Rd, 0, Rs, Y, X, Rm).
smulw({{bt,Y},{'cond',Cond},{r,Rd},{r,Rm},{r,Rs}}) ->
smlaxy_form(Cond, 2#00010010, Rd, 0, Rs, Y, 1, Rm).
%%%
%%% Main Encode Dispatch
%%%
insn_encode(Op, Opnds) ->
case Op of
'adc' -> adc(Opnds);
'add' -> add(Opnds);
'and' -> 'and'(Opnds);
'b' -> b(Opnds);
'bic' -> bic(Opnds);
'bkpt' -> bkpt(Opnds);
'bl' -> bl(Opnds);
'blx' -> blx(Opnds);
'bx' -> bx(Opnds);
'cdp' -> cdp(Opnds);
'cdp2' -> cdp2(Opnds);
'clz' -> clz(Opnds);
'cmn' -> cmn(Opnds);
'cmp' -> cmp(Opnds);
'eor' -> eor(Opnds);
'ldc' -> ldc(Opnds);
'ldc2' -> ldc2(Opnds);
'ldm' -> ldm(Opnds);
'ldr' -> ldr(Opnds);
'ldrb' -> ldrb(Opnds);
'ldrd' -> ldrd(Opnds);
%% ldrbt: omitted
'ldrh' -> ldrh(Opnds);
'ldrsb' -> ldrsb(Opnds);
'ldrsh' -> ldrsh(Opnds);
%% ldrt: omitted
'mcr' -> mcr(Opnds);
'mcr2' -> mcr2(Opnds);
'mcrr' -> mcrr(Opnds);
'mla' -> mla(Opnds);
'mov' -> mov(Opnds);
'mrc' -> mrc(Opnds);
'mrc2' -> mrc2(Opnds);
'mrrc' -> mrrc(Opnds);
'mrs' -> mrs(Opnds);
'msr' -> msr(Opnds);
'mul' -> mul(Opnds);
'mvn' -> mvn(Opnds);
'orr' -> orr(Opnds);
'pld' -> pld(Opnds);
'qadd' -> qadd(Opnds);
'qdadd' -> qdadd(Opnds);
'qdsub' -> qdsub(Opnds);
'qsub' -> qsub(Opnds);
'rsb' -> rsb(Opnds);
'rsc' -> rsc(Opnds);
'sbc' -> sbc(Opnds);
'smla' -> smla(Opnds);
'smlal' -> smlal(Opnds); % may be regular ARM or DSP insn :-(
'smlaw' -> smlaw(Opnds);
'smull' -> smull(Opnds);
'smul' -> smul(Opnds);
'smulw' -> smulw(Opnds);
'stc' -> stc(Opnds);
'stc2' -> stc2(Opnds);
'stm' -> stm(Opnds);
'str' -> str(Opnds);
'strb' -> strb(Opnds);
%% strbt: omitted
'strd' -> strd(Opnds);
'strh' -> strh(Opnds);
%% strt: omitted
'sub' -> sub(Opnds);
'swi' -> swi(Opnds);
'swp' -> swp(Opnds);
'swpb' -> swpb(Opnds);
'teq' -> teq(Opnds);
'tst' -> tst(Opnds);
'umlal' -> umlal(Opnds);
'umull' -> umull(Opnds);
_ -> exit({?MODULE,insn_encode,Op})
end.
%%%
%%% Testing Interface
%%%
-ifdef(TESTING).
say(OS, Str) ->
file:write(OS, Str).
hex_digit(Dig0) ->
Dig = Dig0 band 16#F,
if Dig >= 16#A -> $A + (Dig - 16#A);
true -> $0 + Dig
end.
say_byte(OS, Byte) ->
say(OS, [hex_digit(Byte bsr 4)]),
say(OS, [hex_digit(Byte)]).
say_word(OS, Word) ->
say(OS, "0x"),
say_byte(OS, Word bsr 24),
say_byte(OS, Word bsr 16),
say_byte(OS, Word bsr 8),
say_byte(OS, Word).
t(OS, Op, Opnds) ->
Word = insn_encode(Op, Opnds),
say(OS, "\t.long "),
say_word(OS, Word),
say(OS, "\n").
dotest1(OS) ->
say(OS, "\t.text\n\t.align 4\n"),
%%
Rn = {r,9},
Rd = {r,8}, % must be even and less than 14 for some insns
Rm = {r,7},
Rs = {r,6},
RdLo = Rn,
RdHi = Rd,
Registers = [Rm,Rs,Rd], % must exclude Rn for some insns
CRd = {cr,15},
CRn = {cr,14},
CRm = {cr,13},
BT0 = {bt,0},
BT1 = {bt,1},
CpNum = {cpnum,15},
CpOp3 = {cpop3,16#3},
CpOp4 = {cpop4,16#F},
L0 = {l,0},
L1 = {l,1},
S0 = {s,0},
S1 = {s,1},
FieldMask4 = {field_mask,16#F},
Imm4 = {imm4,16#F},
Imm5 = {imm5,16#1F},
Imm8 = {imm8,16#FF},
Imm12 = {imm12,16#FFF},
Imm16 = {imm16,16#FFFF},
Imm24 = {imm24,16#FFFFF},
Imm25 = {imm25,16#FFFFF1},
%%
AM1_1 = {Imm8,Imm4},
AM1_2 = Rm,
AM1_3_1 = {Rm,{'lsl',Imm5}},
AM1_3_2 = {Rm,{'lsr',Imm5}},
AM1_3_3 = {Rm,{'asr',Imm5}},
AM1_3_4 = {Rm,{'ror',Imm5}},
AM1_3_5 = {Rm,{'lsl',Rs}},
AM1_3_6 = {Rm,{'lsr',Rs}},
AM1_3_7 = {Rm,{'asr',Rs}},
AM1_3_8 = {Rm,{'ror',Rs}},
AM1_3_9 = {Rm,'rrx'},
%%
AM2ShiftOp1 = {'lsl',Imm5},
AM2ShiftOp2 = {'lsr',Imm5},
AM2ShiftOp3 = {'asr',Imm5},
AM2ShiftOp4 = {'ror',Imm5},
AM2ShiftOp5 = 'rrx',
SignP = '+',
SignM = '-',
AM2_1_1 = {immediate_offset,Rn,SignP,Imm12},
AM2_1_2 = {immediate_offset,Rn,SignM,Imm12},
AM2_2_1 = {register_offset,Rn,SignP,Rm},
AM2_2_2 = {register_offset,Rn,SignM,Rm},
AM2_3_1 = {scaled_register_offset,Rn,SignP,Rm,AM2ShiftOp1},
AM2_3_2 = {scaled_register_offset,Rn,SignM,Rm,AM2ShiftOp2},
AM2_3_3 = {scaled_register_offset,Rn,SignP,Rm,AM2ShiftOp3},
AM2_3_4 = {scaled_register_offset,Rn,SignM,Rm,AM2ShiftOp4},
AM2_3_5 = {scaled_register_offset,Rn,SignP,Rm,AM2ShiftOp5},
AM2_4_1 = {immediate_pre_indexed,Rn,SignP,Imm12},
AM2_4_2 = {immediate_pre_indexed,Rn,SignM,Imm12},
AM2_5_1 = {register_pre_indexed,Rn,SignP,Rm},
AM2_5_2 = {register_pre_indexed,Rn,SignM,Rm},
AM2_6_1 = {scaled_register_pre_indexed,Rn,SignP,Rm,AM2ShiftOp1},
AM2_6_2 = {scaled_register_pre_indexed,Rn,SignM,Rm,AM2ShiftOp2},
AM2_6_3 = {scaled_register_pre_indexed,Rn,SignP,Rm,AM2ShiftOp3},
AM2_6_4 = {scaled_register_pre_indexed,Rn,SignM,Rm,AM2ShiftOp4},
AM2_6_5 = {scaled_register_pre_indexed,Rn,SignP,Rm,AM2ShiftOp5},
AM2_7_1 = {immediate_post_indexed,Rn,SignP,Imm12},
AM2_7_2 = {immediate_post_indexed,Rn,SignM,Imm12},
AM2_8_1 = {register_post_indexed,Rn,SignP,Rm},
AM2_8_2 = {register_post_indexed,Rn,SignM,Rm},
AM2_9_1 = {scaled_register_post_indexed,Rn,SignP,Rm,AM2ShiftOp1},
AM2_9_2 = {scaled_register_post_indexed,Rn,SignM,Rm,AM2ShiftOp2},
AM2_9_3 = {scaled_register_post_indexed,Rn,SignP,Rm,AM2ShiftOp3},
AM2_9_4 = {scaled_register_post_indexed,Rn,SignM,Rm,AM2ShiftOp4},
AM2_9_5 = {scaled_register_post_indexed,Rn,SignP,Rm,AM2ShiftOp5},
%%
AM3_1_1 = {immediate_offset,Rn,SignP,Imm8},
AM3_1_2 = {immediate_offset,Rn,SignM,Imm8},
AM3_2_1 = {register_offset,Rn,SignP,Rm},
AM3_2_2 = {register_offset,Rn,SignM,Rm},
AM3_3_1 = {immediate_pre_indexed,Rn,SignP,Imm8},
AM3_3_2 = {immediate_pre_indexed,Rn,SignM,Imm8},
AM3_4_1 = {register_pre_indexed,Rn,SignP,Rm},
AM3_4_2 = {register_pre_indexed,Rn,SignM,Rm},
AM3_5_1 = {immediate_post_indexed,Rn,SignP,Imm8},
AM3_5_2 = {immediate_post_indexed,Rn,SignM,Imm8},
AM3_6_1 = {register_post_indexed,Rn,SignP,Rm},
AM3_6_2 = {register_post_indexed,Rn,SignM,Rm},
%%
AM4_1 = 'ia',
AM4_2 = 'ib',
AM4_3 = 'da',
AM4_4 = 'db',
AM4_5 = 'fa',
AM4_6 = 'fd',
AM4_7 = 'ea',
AM4_8 = 'ed',
%%
AM5_1_1 = {offset,Rn,SignP,Imm8},
AM5_1_2 = {offset,Rn,SignM,Imm8},
AM5_2_1 = {pre_indexed,Rn,SignP,Imm8},
AM5_2_2 = {pre_indexed,Rn,SignM,Imm8},
AM5_3_1 = {post_indexed,Rn,SignP,Imm8},
AM5_3_2 = {post_indexed,Rn,SignM,Imm8},
AM5_4 = {unindexed,Rn,Imm8},
%%
Cond_eq = {'cond','eq'},
Cond_ne = {'cond','ne'},
Cond_cs = {'cond','cs'},
Cond_hs = {'cond','hs'},
Cond_cc = {'cond','cc'},
Cond_lo = {'cond','lo'},
Cond_mi = {'cond','mi'},
Cond_pl = {'cond','pl'},
Cond_vs = {'cond','vs'},
Cond_vc = {'cond','vc'},
Cond_hi = {'cond','hi'},
Cond_ls = {'cond','ls'},
Cond_ge = {'cond','ge'},
Cond_lt = {'cond','lt'},
Cond_gt = {'cond','gt'},
Cond_le = {'cond','le'},
Cond_al = {'cond','al'},
%%
t(OS,'adc',{Cond_al,S0,Rd,Rn,AM1_1}), % test all AM1 operands
t(OS,'adc',{Cond_al,S0,Rd,Rn,AM1_2}),
t(OS,'adc',{Cond_al,S0,Rd,Rn,AM1_3_1}),
t(OS,'adc',{Cond_al,S0,Rd,Rn,AM1_3_2}),
t(OS,'adc',{Cond_al,S0,Rd,Rn,AM1_3_3}),
t(OS,'adc',{Cond_al,S0,Rd,Rn,AM1_3_4}),
t(OS,'adc',{Cond_al,S0,Rd,Rn,AM1_3_5}),
t(OS,'adc',{Cond_al,S0,Rd,Rn,AM1_3_6}),
t(OS,'adc',{Cond_al,S0,Rd,Rn,AM1_3_7}),
t(OS,'adc',{Cond_al,S0,Rd,Rn,AM1_3_8}),
t(OS,'adc',{Cond_al,S0,Rd,Rn,AM1_3_9}),
t(OS,'add',{Cond_al,S0,Rd,Rn,AM1_1}), % test all S operands
t(OS,'add',{Cond_al,S1,Rd,Rn,AM1_1}),
t(OS,'and',{Cond_eq,S0,Rd,Rn,AM1_1}), % test all Cond operands
t(OS,'and',{Cond_ne,S0,Rd,Rn,AM1_1}),
t(OS,'and',{Cond_cs,S0,Rd,Rn,AM1_1}),
t(OS,'and',{Cond_hs,S0,Rd,Rn,AM1_1}),
t(OS,'and',{Cond_cc,S0,Rd,Rn,AM1_1}),
t(OS,'and',{Cond_lo,S0,Rd,Rn,AM1_1}),
t(OS,'and',{Cond_mi,S0,Rd,Rn,AM1_1}),
t(OS,'and',{Cond_pl,S0,Rd,Rn,AM1_1}),
t(OS,'and',{Cond_vs,S0,Rd,Rn,AM1_1}),
t(OS,'and',{Cond_vc,S0,Rd,Rn,AM1_1}),
t(OS,'and',{Cond_hi,S0,Rd,Rn,AM1_1}),
t(OS,'and',{Cond_ls,S0,Rd,Rn,AM1_1}),
t(OS,'and',{Cond_ge,S0,Rd,Rn,AM1_1}),
t(OS,'and',{Cond_lt,S0,Rd,Rn,AM1_1}),
t(OS,'and',{Cond_gt,S0,Rd,Rn,AM1_1}),
t(OS,'and',{Cond_le,S0,Rd,Rn,AM1_1}),
t(OS,'and',{Cond_al,S0,Rd,Rn,AM1_1}),
t(OS,'b',{Cond_al,Imm24}),
t(OS,'bic',{Cond_al,S0,Rd,Rn,AM1_1}),
t(OS,'bkpt',{Imm16}),
t(OS,'bl',{Cond_al,Imm24}),
t(OS,'blx',{Imm25}),
t(OS,'blx',{Cond_al,Rm}),
t(OS,'bx',{Cond_al,Rm}),
t(OS,'cdp',{Cond_al,CpNum,CpOp4,CRd,CRn,CRm,CpOp3}),
t(OS,'cdp2',{CpNum,CpOp4,CRd,CRn,CRm,CpOp3}),
t(OS,'clz',{Cond_al,Rd,Rm}),
t(OS,'cmn',{Cond_al,Rn,AM1_1}),
t(OS,'cmp',{Cond_al,Rn,AM1_1}),
t(OS,'eor',{Cond_al,S0,Rd,Rn,AM1_1}),
t(OS,'ldc',{Cond_al,L0,CpNum,CRd,AM5_1_1}), % test all AM5 operands
t(OS,'ldc',{Cond_al,L1,CpNum,CRd,AM5_1_2}),
t(OS,'ldc',{Cond_al,L0,CpNum,CRd,AM5_2_1}),
t(OS,'ldc',{Cond_al,L1,CpNum,CRd,AM5_2_2}),
t(OS,'ldc',{Cond_al,L0,CpNum,CRd,AM5_3_1}),
t(OS,'ldc',{Cond_al,L1,CpNum,CRd,AM5_3_2}),
t(OS,'ldc',{Cond_al,L0,CpNum,CRd,AM5_4}),
t(OS,'ldc2',{L0,CpNum,CRd,AM5_1_1}),
t(OS,'ldm',{Cond_al,AM4_1,Rn,'!',Registers}),
t(OS,'ldm',{Cond_al,AM4_1,Rn,Registers}), % test all AM4 operands
t(OS,'ldm',{Cond_al,AM4_2,Rn,Registers}), % test all AM4 operands
t(OS,'ldm',{Cond_al,AM4_3,Rn,Registers}), % test all AM4 operands
t(OS,'ldm',{Cond_al,AM4_4,Rn,Registers}), % test all AM4 operands
t(OS,'ldm',{Cond_al,AM4_5,Rn,Registers}), % test all AM4 operands
t(OS,'ldm',{Cond_al,AM4_6,Rn,Registers}), % test all AM4 operands
t(OS,'ldm',{Cond_al,AM4_7,Rn,Registers}), % test all AM4 operands
t(OS,'ldm',{Cond_al,AM4_8,Rn,Registers}), % test all AM4 operands
t(OS,'ldr',{Cond_al,Rd,AM2_1_1}), % test all AM2 operands
t(OS,'ldr',{Cond_al,Rd,AM2_1_2}),
t(OS,'ldr',{Cond_al,Rd,AM2_2_1}),
t(OS,'ldr',{Cond_al,Rd,AM2_2_2}),
t(OS,'ldr',{Cond_al,Rd,AM2_3_1}),
t(OS,'ldr',{Cond_al,Rd,AM2_3_2}),
t(OS,'ldr',{Cond_al,Rd,AM2_3_3}),
t(OS,'ldr',{Cond_al,Rd,AM2_3_4}),
t(OS,'ldr',{Cond_al,Rd,AM2_3_5}),
t(OS,'ldr',{Cond_al,Rd,AM2_4_1}),
t(OS,'ldr',{Cond_al,Rd,AM2_4_2}),
t(OS,'ldr',{Cond_al,Rd,AM2_5_1}),
t(OS,'ldr',{Cond_al,Rd,AM2_5_2}),
t(OS,'ldr',{Cond_al,Rd,AM2_6_1}),
t(OS,'ldr',{Cond_al,Rd,AM2_6_2}),
t(OS,'ldr',{Cond_al,Rd,AM2_6_3}),
t(OS,'ldr',{Cond_al,Rd,AM2_6_4}),
t(OS,'ldr',{Cond_al,Rd,AM2_6_5}),
t(OS,'ldr',{Cond_al,Rd,AM2_7_1}),
t(OS,'ldr',{Cond_al,Rd,AM2_7_2}),
t(OS,'ldr',{Cond_al,Rd,AM2_8_1}),
t(OS,'ldr',{Cond_al,Rd,AM2_8_2}),
t(OS,'ldr',{Cond_al,Rd,AM2_9_1}),
t(OS,'ldr',{Cond_al,Rd,AM2_9_2}),
t(OS,'ldr',{Cond_al,Rd,AM2_9_3}),
t(OS,'ldr',{Cond_al,Rd,AM2_9_4}),
t(OS,'ldr',{Cond_al,Rd,AM2_9_5}),
t(OS,'ldrb',{Cond_al,Rd,AM2_1_1}),
t(OS,'ldrd',{Cond_al,Rd,AM3_1_1}),
t(OS,'ldrh',{Cond_al,Rd,AM3_1_1}), % test all AM3 operands
t(OS,'ldrh',{Cond_al,Rd,AM3_1_2}),
t(OS,'ldrh',{Cond_al,Rd,AM3_2_1}),
t(OS,'ldrh',{Cond_al,Rd,AM3_2_2}),
t(OS,'ldrh',{Cond_al,Rd,AM3_3_1}),
t(OS,'ldrh',{Cond_al,Rd,AM3_3_2}),
t(OS,'ldrh',{Cond_al,Rd,AM3_4_1}),
t(OS,'ldrh',{Cond_al,Rd,AM3_4_2}),
t(OS,'ldrh',{Cond_al,Rd,AM3_5_1}),
t(OS,'ldrh',{Cond_al,Rd,AM3_5_2}),
t(OS,'ldrh',{Cond_al,Rd,AM3_6_1}),
t(OS,'ldrh',{Cond_al,Rd,AM3_6_2}),
t(OS,'ldrsb',{Cond_al,Rd,AM3_1_1}),
t(OS,'ldrsh',{Cond_al,Rd,AM3_1_1}),
t(OS,'mcr',{Cond_al,CpNum,CpOp3,Rd,CRn,CRm,CpOp3}),
t(OS,'mcr2',{CpNum,CpOp3,Rd,CRn,CRm,CpOp3}),
t(OS,'mcrr',{Cond_al,CpNum,CpOp4,Rd,Rn,CRm}),
t(OS,'mla',{Cond_al,S0,Rd,Rm,Rs,Rn}),
t(OS,'mov',{Cond_al,S0,Rd,AM1_1}),
t(OS,'mrc',{Cond_al,CpNum,CpOp3,Rd,CRn,CRm,CpOp3}),
t(OS,'mrc2',{CpNum,CpOp3,Rd,CRn,CRm,CpOp3}),
t(OS,'mrrc',{Cond_al,CpNum,CpOp4,Rd,Rn,CRm}),
t(OS,'mrs',{Cond_al,Rd,'cpsr'}),
t(OS,'msr',{Cond_al,'cpsr',FieldMask4,Imm8,Imm4}),
t(OS,'msr',{Cond_al,'cpsr',FieldMask4,Rm}),
t(OS,'mul',{Cond_al,S0,Rd,Rm,Rs}),
t(OS,'mvn',{Cond_al,S1,Rd,AM1_1}),
t(OS,'orr',{Cond_al,S0,Rd,Rn,AM1_1}),
t(OS,'pld',{AM2_1_1}),
t(OS,'qadd',{Cond_al,Rd,Rm,Rn}),
t(OS,'qdadd',{Cond_al,Rd,Rm,Rn}),
t(OS,'qdsub',{Cond_al,Rd,Rm,Rn}),
t(OS,'qsub',{Cond_al,Rd,Rm,Rn}),
t(OS,'rsb',{Cond_al,S0,Rd,Rn,AM1_1}),
t(OS,'rsc',{Cond_al,S0,Rd,Rn,AM1_1}),
t(OS,'sbc',{Cond_al,S0,Rd,Rn,AM1_1}),
t(OS,'smla',{BT0,BT0,Cond_al,Rd,Rm,Rs,Rn}),
t(OS,'smla',{BT0,BT1,Cond_al,Rd,Rm,Rs,Rn}),
t(OS,'smla',{BT1,BT0,Cond_al,Rd,Rm,Rs,Rn}),
t(OS,'smla',{BT1,BT1,Cond_al,Rd,Rm,Rs,Rn}),
t(OS,'smlal',{Cond_al,S0,RdLo,RdHi,Rm,Rs}),
t(OS,'smlal',{BT0,BT1,Cond_al,RdLo,RdHi,Rm,Rs}),
t(OS,'smlaw',{BT1,Cond_al,Rd,Rm,Rs,Rn}),
t(OS,'smull',{Cond_al,S0,RdLo,RdHi,Rm,Rs}),
t(OS,'smul',{BT1,BT0,Cond_al,Rd,Rm,Rs}),
t(OS,'smulw',{BT1,Cond_al,Rd,Rm,Rs}),
t(OS,'stc',{Cond_al,L0,CpNum,CRd,AM5_1_1}),
t(OS,'stc2',{L0,CpNum,CRd,AM5_1_1}),
t(OS,'stm',{Cond_al,AM4_1,Rn,Registers}),
t(OS,'str',{Cond_al,Rd,AM2_1_1}),
t(OS,'strb',{Cond_al,Rd,AM2_1_1}),
t(OS,'strd',{Cond_al,Rd,AM3_1_1}),
t(OS,'strh',{Cond_al,Rd,AM3_1_1}),
t(OS,'sub',{Cond_al,S0,Rd,Rn,AM1_1}),
t(OS,'swi',{Cond_al,Imm24}),
t(OS,'swp',{Cond_al,Rd,Rm,Rn}),
t(OS,'swpb',{Cond_al,Rd,Rm,Rn}),
t(OS,'teq',{Cond_al,Rn,AM1_1}),
t(OS,'tst',{Cond_al,Rn,AM1_1}),
t(OS,'umlal',{Cond_al,S0,RdLo,RdHi,Rm,Rs}),
t(OS,'umull',{Cond_al,S0,RdLo,RdHi,Rm,Rs}),
[].
dotest() -> dotest1(group_leader()).
dotest(File) ->
{ok,OS} = file:open(File, [write]),
dotest1(OS),
file:close(OS).
-endif.
