mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-21 12:02:58 +02:00
ae65e281f3
to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351636
1042 lines
44 KiB
TableGen
1042 lines
44 KiB
TableGen
//===-- MSP430InstrInfo.td - MSP430 Instruction defs -------*- tablegen -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file describes the MSP430 instructions in TableGen format.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
include "MSP430InstrFormats.td"
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Type Constraints.
|
|
//===----------------------------------------------------------------------===//
|
|
class SDTCisI8<int OpNum> : SDTCisVT<OpNum, i8>;
|
|
class SDTCisI16<int OpNum> : SDTCisVT<OpNum, i16>;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Type Profiles.
|
|
//===----------------------------------------------------------------------===//
|
|
def SDT_MSP430Call : SDTypeProfile<0, -1, [SDTCisVT<0, iPTR>]>;
|
|
def SDT_MSP430CallSeqStart : SDCallSeqStart<[SDTCisVT<0, i16>,
|
|
SDTCisVT<1, i16>]>;
|
|
def SDT_MSP430CallSeqEnd : SDCallSeqEnd<[SDTCisVT<0, i16>, SDTCisVT<1, i16>]>;
|
|
def SDT_MSP430Wrapper : SDTypeProfile<1, 1, [SDTCisSameAs<0, 1>,
|
|
SDTCisPtrTy<0>]>;
|
|
def SDT_MSP430Cmp : SDTypeProfile<0, 2, [SDTCisSameAs<0, 1>]>;
|
|
def SDT_MSP430BrCC : SDTypeProfile<0, 2, [SDTCisVT<0, OtherVT>,
|
|
SDTCisVT<1, i8>]>;
|
|
def SDT_MSP430SelectCC : SDTypeProfile<1, 3, [SDTCisSameAs<0, 1>,
|
|
SDTCisSameAs<1, 2>,
|
|
SDTCisVT<3, i8>]>;
|
|
def SDT_MSP430DAdd : SDTypeProfile<1, 2, [SDTCisSameAs<0, 1>,
|
|
SDTCisSameAs<0, 2>,
|
|
SDTCisInt<0>]>;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// MSP430 Specific Node Definitions.
|
|
//===----------------------------------------------------------------------===//
|
|
def MSP430retflag : SDNode<"MSP430ISD::RET_FLAG", SDTNone,
|
|
[SDNPHasChain, SDNPOptInGlue, SDNPVariadic]>;
|
|
def MSP430retiflag : SDNode<"MSP430ISD::RETI_FLAG", SDTNone,
|
|
[SDNPHasChain, SDNPOptInGlue, SDNPVariadic]>;
|
|
|
|
def MSP430rra : SDNode<"MSP430ISD::RRA", SDTIntUnaryOp, []>;
|
|
def MSP430rla : SDNode<"MSP430ISD::RLA", SDTIntUnaryOp, []>;
|
|
def MSP430rrc : SDNode<"MSP430ISD::RRC", SDTIntUnaryOp, []>;
|
|
def MSP430rrcl : SDNode<"MSP430ISD::RRCL", SDTIntUnaryOp, []>;
|
|
|
|
def MSP430call : SDNode<"MSP430ISD::CALL", SDT_MSP430Call,
|
|
[SDNPHasChain, SDNPOutGlue, SDNPOptInGlue, SDNPVariadic]>;
|
|
def MSP430callseq_start :
|
|
SDNode<"ISD::CALLSEQ_START", SDT_MSP430CallSeqStart,
|
|
[SDNPHasChain, SDNPOutGlue]>;
|
|
def MSP430callseq_end :
|
|
SDNode<"ISD::CALLSEQ_END", SDT_MSP430CallSeqEnd,
|
|
[SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
|
|
def MSP430Wrapper : SDNode<"MSP430ISD::Wrapper", SDT_MSP430Wrapper>;
|
|
def MSP430cmp : SDNode<"MSP430ISD::CMP", SDT_MSP430Cmp, [SDNPOutGlue]>;
|
|
def MSP430brcc : SDNode<"MSP430ISD::BR_CC", SDT_MSP430BrCC,
|
|
[SDNPHasChain, SDNPInGlue]>;
|
|
def MSP430selectcc: SDNode<"MSP430ISD::SELECT_CC", SDT_MSP430SelectCC,
|
|
[SDNPInGlue]>;
|
|
def MSP430dadd : SDNode<"MSP430ISD::DADD", SDT_MSP430DAdd, []>;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// MSP430 Operand Definitions.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def MemAsmOperand : AsmOperandClass {
|
|
let Name = "Mem";
|
|
}
|
|
|
|
// Address operands
|
|
def memsrc : Operand<i16> {
|
|
let PrintMethod = "printSrcMemOperand";
|
|
let MIOperandInfo = (ops GR16, i16imm);
|
|
let ParserMatchClass = MemAsmOperand;
|
|
let EncoderMethod = "getMemOpValue";
|
|
let DecoderMethod = "DecodeMemOperand";
|
|
}
|
|
|
|
def memdst : Operand<i16> {
|
|
let PrintMethod = "printSrcMemOperand";
|
|
let MIOperandInfo = (ops GR16, i16imm);
|
|
let ParserMatchClass = MemAsmOperand;
|
|
let EncoderMethod = "getMemOpValue";
|
|
let DecoderMethod = "DecodeMemOperand";
|
|
}
|
|
|
|
def IndRegAsmOperand : AsmOperandClass {
|
|
let Name = "IndReg";
|
|
let RenderMethod = "addRegOperands";
|
|
}
|
|
|
|
def indreg : Operand<i16> {
|
|
let PrintMethod = "printIndRegOperand";
|
|
let MIOperandInfo = (ops GR16);
|
|
let ParserMatchClass = IndRegAsmOperand;
|
|
let DecoderMethod = "DecodeGR16RegisterClass";
|
|
}
|
|
|
|
def PostIndRegAsmOperand : AsmOperandClass {
|
|
let Name = "PostIndReg";
|
|
let RenderMethod = "addRegOperands";
|
|
}
|
|
|
|
def postreg : Operand<i16> {
|
|
let PrintMethod = "printPostIndRegOperand";
|
|
let MIOperandInfo = (ops GR16);
|
|
let ParserMatchClass = PostIndRegAsmOperand;
|
|
let DecoderMethod = "DecodeGR16RegisterClass";
|
|
}
|
|
|
|
// Short jump targets have OtherVT type and are printed as pcrel imm values.
|
|
def jmptarget : Operand<OtherVT> {
|
|
let PrintMethod = "printPCRelImmOperand";
|
|
let EncoderMethod = "getPCRelImmOpValue";
|
|
}
|
|
|
|
// Operand for printing out a condition code.
|
|
def cc : Operand<i8> {
|
|
let PrintMethod = "printCCOperand";
|
|
let EncoderMethod = "getCCOpValue";
|
|
}
|
|
|
|
def CGImmAsmOperand : AsmOperandClass {
|
|
let Name = "CGImm";
|
|
let RenderMethod = "addImmOperands";
|
|
}
|
|
|
|
def cg8imm : Operand<i8>,
|
|
ImmLeaf<i8, [{return Imm == 0 || Imm == 1 || Imm == 2 ||
|
|
Imm == 4 || Imm == 8 || Imm == -1;}]> {
|
|
let ParserMatchClass = CGImmAsmOperand;
|
|
let EncoderMethod = "getCGImmOpValue";
|
|
let DecoderMethod = "DecodeCGImm";
|
|
}
|
|
|
|
def cg16imm : Operand<i16>,
|
|
ImmLeaf<i16, [{return Imm == 0 || Imm == 1 || Imm == 2 ||
|
|
Imm == 4 || Imm == 8 || Imm == -1;}]> {
|
|
let ParserMatchClass = CGImmAsmOperand;
|
|
let EncoderMethod = "getCGImmOpValue";
|
|
let DecoderMethod = "DecodeCGImm";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// MSP430 Complex Pattern Definitions.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def addr : ComplexPattern<iPTR, 2, "SelectAddr", [], []>;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Pattern Fragments
|
|
def zextloadi16i8 : PatFrag<(ops node:$ptr), (i16 (zextloadi8 node:$ptr))>;
|
|
def extloadi16i8 : PatFrag<(ops node:$ptr), (i16 ( extloadi8 node:$ptr))>;
|
|
def bic : PatFrag<(ops node:$lhs, node:$rhs), (and node:$lhs, (not node:$rhs))>;
|
|
def and_su : PatFrag<(ops node:$lhs, node:$rhs), (and node:$lhs, node:$rhs), [{
|
|
return N->hasOneUse();
|
|
}]>;
|
|
//===----------------------------------------------------------------------===//
|
|
// Instruction list..
|
|
|
|
// ADJCALLSTACKDOWN/UP implicitly use/def SP because they may be expanded into
|
|
// a stack adjustment and the codegen must know that they may modify the stack
|
|
// pointer before prolog-epilog rewriting occurs.
|
|
// Pessimistically assume ADJCALLSTACKDOWN / ADJCALLSTACKUP will become
|
|
// sub / add which can clobber SR.
|
|
let isCodeGenOnly = 1, Defs = [SP, SR], Uses = [SP] in {
|
|
def ADJCALLSTACKDOWN : Pseudo<(outs), (ins i16imm:$amt1, i16imm:$amt2),
|
|
"#ADJCALLSTACKDOWN $amt1 $amt2",
|
|
[(MSP430callseq_start timm:$amt1, timm:$amt2)]>;
|
|
def ADJCALLSTACKUP : Pseudo<(outs), (ins i16imm:$amt1, i16imm:$amt2),
|
|
"#ADJCALLSTACKUP $amt1 $amt2",
|
|
[(MSP430callseq_end timm:$amt1, timm:$amt2)]>;
|
|
}
|
|
|
|
let isCodeGenOnly = 1, Defs = [SR], Uses = [SP] in {
|
|
def ADDframe : Pseudo<(outs GR16:$dst), (ins i16imm:$base, i16imm:$offset),
|
|
"# ADDframe PSEUDO", []>;
|
|
}
|
|
|
|
let isCodeGenOnly = 1, usesCustomInserter = 1 in {
|
|
let Uses = [SR] in {
|
|
def Select8 : Pseudo<(outs GR8:$dst), (ins GR8:$src, GR8:$src2, i8imm:$cc),
|
|
"# Select8 PSEUDO",
|
|
[(set GR8:$dst,
|
|
(MSP430selectcc GR8:$src, GR8:$src2, imm:$cc))]>;
|
|
def Select16 : Pseudo<(outs GR16:$dst), (ins GR16:$src, GR16:$src2, i8imm:$cc),
|
|
"# Select16 PSEUDO",
|
|
[(set GR16:$dst,
|
|
(MSP430selectcc GR16:$src, GR16:$src2, imm:$cc))]>;
|
|
}
|
|
let Defs = [SR] in {
|
|
def Shl8 : Pseudo<(outs GR8:$dst), (ins GR8:$src, GR8:$cnt),
|
|
"# Shl8 PSEUDO",
|
|
[(set GR8:$dst, (shl GR8:$src, GR8:$cnt))]>;
|
|
def Shl16 : Pseudo<(outs GR16:$dst), (ins GR16:$src, GR8:$cnt),
|
|
"# Shl16 PSEUDO",
|
|
[(set GR16:$dst, (shl GR16:$src, GR8:$cnt))]>;
|
|
def Sra8 : Pseudo<(outs GR8:$dst), (ins GR8:$src, GR8:$cnt),
|
|
"# Sra8 PSEUDO",
|
|
[(set GR8:$dst, (sra GR8:$src, GR8:$cnt))]>;
|
|
def Sra16 : Pseudo<(outs GR16:$dst), (ins GR16:$src, GR8:$cnt),
|
|
"# Sra16 PSEUDO",
|
|
[(set GR16:$dst, (sra GR16:$src, GR8:$cnt))]>;
|
|
def Srl8 : Pseudo<(outs GR8:$dst), (ins GR8:$src, GR8:$cnt),
|
|
"# Srl8 PSEUDO",
|
|
[(set GR8:$dst, (srl GR8:$src, GR8:$cnt))]>;
|
|
def Srl16 : Pseudo<(outs GR16:$dst), (ins GR16:$src, GR8:$cnt),
|
|
"# Srl16 PSEUDO",
|
|
[(set GR16:$dst, (srl GR16:$src, GR8:$cnt))]>;
|
|
def Rrcl8 : Pseudo<(outs GR8:$dst), (ins GR8:$src), "",
|
|
[(set GR8:$dst, (MSP430rrcl GR8:$src))]>;
|
|
def Rrcl16 : Pseudo<(outs GR16:$dst), (ins GR16:$src), "",
|
|
[(set GR16:$dst, (MSP430rrcl GR16:$src))]>;
|
|
}
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Control Flow Instructions...
|
|
//
|
|
|
|
let isReturn = 1, isTerminator = 1, isBarrier = 1 in {
|
|
def RET : IForm16<0b0100, DstReg, SrcPostInc, 2,
|
|
(outs), (ins), "ret", [(MSP430retflag)]> {
|
|
let DecoderNamespace = "Delta";
|
|
let rs = 1;
|
|
let rd = 0;
|
|
}
|
|
def RETI : IIForm16<0b110, SrcReg, 2,
|
|
(outs), (ins), "reti", [(MSP430retiflag)]> {
|
|
let rs = 0;
|
|
}
|
|
}
|
|
|
|
let isBranch = 1, isTerminator = 1 in {
|
|
|
|
// FIXME: expand opcode & cond field for branches!
|
|
|
|
// Direct branch
|
|
let isBarrier = 1 in {
|
|
// Short branch
|
|
def JMP : CJForm<(outs), (ins jmptarget:$dst),
|
|
"jmp\t$dst",
|
|
[(br bb:$dst)]> {
|
|
let cond = 0b111;
|
|
}
|
|
let isIndirectBranch = 1, rd = 0 in {
|
|
// Long branches
|
|
def Bi : I16ri<0b0100, (outs), (ins i16imm:$imm),
|
|
"br\t$imm",
|
|
[(brind tblockaddress:$imm)]>;
|
|
def Br : I16rr<0b0100, (outs), (ins GR16:$rs),
|
|
"br\t$rs",
|
|
[(brind GR16:$rs)]>;
|
|
def Bm : I16rm<0b0100, (outs), (ins memsrc:$src),
|
|
"br\t$src",
|
|
[(brind (load addr:$src))]>;
|
|
}
|
|
}
|
|
|
|
// Conditional branches
|
|
let Uses = [SR] in
|
|
def JCC : CJForm<(outs), (ins jmptarget:$dst, cc:$cond),
|
|
"j$cond\t$dst",
|
|
[(MSP430brcc bb:$dst, imm:$cond)]>;
|
|
} // isBranch, isTerminator
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Call Instructions...
|
|
//
|
|
// All calls clobber the non-callee saved registers. SPW is marked as
|
|
// a use to prevent stack-pointer assignments that appear immediately
|
|
// before calls from potentially appearing dead. Uses for argument
|
|
// registers are added manually.
|
|
let isCall = 1,
|
|
Defs = [R11, R12, R13, R14, R15, SR],
|
|
Uses = [SP] in {
|
|
def CALLi : II16i<0b101,
|
|
(outs), (ins i16imm:$imm),
|
|
"call\t$imm", [(MSP430call imm:$imm)]>;
|
|
def CALLr : II16r<0b101,
|
|
(outs), (ins GR16:$rs),
|
|
"call\t$rs", [(MSP430call GR16:$rs)]>;
|
|
def CALLm : II16m<0b101,
|
|
(outs), (ins memsrc:$src),
|
|
"call\t$src", [(MSP430call (load addr:$src))]>;
|
|
def CALLn : II16n<0b101, (outs), (ins indreg:$rs), "call\t$rs", []>;
|
|
def CALLp : II16p<0b101, (outs), (ins postreg:$rs), "call\t$rs", []>;
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Miscellaneous Instructions...
|
|
//
|
|
let Defs = [SP], Uses = [SP], hasSideEffects = 0 in {
|
|
let mayLoad = 1 in
|
|
def POP16r : IForm16<0b0100, DstReg, SrcPostInc, 2,
|
|
(outs GR16:$rd), (ins), "pop\t$rd", []> {
|
|
let DecoderNamespace = "Delta";
|
|
let rs = 1;
|
|
}
|
|
|
|
let mayStore = 1 in
|
|
def PUSH8r : II8r<0b100, (outs), (ins GR8:$rs), "push.b\t$rs", []>;
|
|
def PUSH16r : II16r<0b100, (outs), (ins GR16:$rs), "push\t$rs", []>;
|
|
def PUSH16c : II16c<0b100, (outs), (ins cg16imm:$imm), "push\t$imm", []>;
|
|
def PUSH16i : II16i<0b100, (outs), (ins i16imm:$imm), "push\t$imm", []>;
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Move Instructions
|
|
|
|
let hasSideEffects = 0 in {
|
|
def MOV8rr : I8rr<0b0100,
|
|
(outs GR8:$rd), (ins GR8:$rs),
|
|
"mov.b\t{$rs, $rd}",
|
|
[]>;
|
|
def MOV16rr : I16rr<0b0100,
|
|
(outs GR16:$rd), (ins GR16:$rs),
|
|
"mov\t{$rs, $rd}",
|
|
[]>;
|
|
}
|
|
|
|
let isReMaterializable = 1, isAsCheapAsAMove = 1 in {
|
|
def MOV8rc : I8rc<0b0100,
|
|
(outs GR8:$rd), (ins cg8imm:$imm),
|
|
"mov.b\t$imm, $rd",
|
|
[(set GR8:$rd, cg8imm:$imm)]>;
|
|
def MOV16rc : I16rc<0b0100,
|
|
(outs GR16:$rd), (ins cg16imm:$imm),
|
|
"mov\t$imm, $rd",
|
|
[(set GR16:$rd, cg16imm:$imm)]>;
|
|
def MOV8ri : I8ri<0b0100,
|
|
(outs GR8:$rd), (ins i8imm:$imm),
|
|
"mov.b\t{$imm, $rd}",
|
|
[(set GR8:$rd, imm:$imm)]>;
|
|
def MOV16ri : I16ri<0b0100,
|
|
(outs GR16:$rd), (ins i16imm:$imm),
|
|
"mov\t{$imm, $rd}",
|
|
[(set GR16:$rd, imm:$imm)]>;
|
|
}
|
|
|
|
let canFoldAsLoad = 1, isReMaterializable = 1 in {
|
|
def MOV8rm : I8rm<0b0100,
|
|
(outs GR8:$rd), (ins memsrc:$src),
|
|
"mov.b\t{$src, $rd}",
|
|
[(set GR8:$rd, (load addr:$src))]>;
|
|
def MOV16rm : I16rm<0b0100,
|
|
(outs GR16:$rd), (ins memsrc:$src),
|
|
"mov\t{$src, $rd}",
|
|
[(set GR16:$rd, (load addr:$src))]>;
|
|
def MOV8rn : I8rn<0b0100,
|
|
(outs GR8:$rd), (ins indreg:$rs),
|
|
"mov.b\t{$rs, $rd}",
|
|
[(set GR8:$rd, (load addr:$rs))]>;
|
|
def MOV16rn : I16rn<0b0100,
|
|
(outs GR16:$rd), (ins indreg:$rs),
|
|
"mov\t{$rs, $rd}",
|
|
[(set GR16:$rd, (load addr:$rs))]>;
|
|
}
|
|
|
|
let isCodeGenOnly = 1 in {
|
|
def MOVZX16rr8 : I8rr<0b0100,
|
|
(outs GR16:$rd), (ins GR8:$rs),
|
|
"mov.b\t{$rs, $rd}",
|
|
[(set GR16:$rd, (zext GR8:$rs))]>;
|
|
def MOVZX16rm8 : I8rm<0b0100,
|
|
(outs GR16:$rd), (ins memsrc:$src),
|
|
"mov.b\t{$src, $rd}",
|
|
[(set GR16:$rd, (zextloadi16i8 addr:$src))]>;
|
|
}
|
|
|
|
let mayLoad = 1, hasExtraDefRegAllocReq = 1, Constraints = "$rs = $wb" in {
|
|
def MOV8rp : I8rp<0b0100,
|
|
(outs GR8:$rd, GR16:$wb), (ins postreg:$rs),
|
|
"mov.b\t{$rs, $rd}", []>;
|
|
def MOV16rp : I16rp<0b0100,
|
|
(outs GR16:$rd, GR16:$wb), (ins postreg:$rs),
|
|
"mov\t{$rs, $rd}", []>;
|
|
}
|
|
|
|
// Any instruction that defines a 8-bit result leaves the high half of the
|
|
// register. Truncate can be lowered to EXTRACT_SUBREG, and CopyFromReg may
|
|
// be copying from a truncate, but any other 8-bit operation will zero-extend
|
|
// up to 16 bits.
|
|
def def8 : PatLeaf<(i8 GR8:$src), [{
|
|
return N->getOpcode() != ISD::TRUNCATE &&
|
|
N->getOpcode() != TargetOpcode::EXTRACT_SUBREG &&
|
|
N->getOpcode() != ISD::CopyFromReg;
|
|
}]>;
|
|
|
|
// In the case of a 8-bit def that is known to implicitly zero-extend,
|
|
// we can use a SUBREG_TO_REG.
|
|
def : Pat<(i16 (zext def8:$src)),
|
|
(SUBREG_TO_REG (i16 0), GR8:$src, subreg_8bit)>;
|
|
|
|
def MOV8mc : I8mc<0b0100,
|
|
(outs), (ins memdst:$dst, cg8imm:$imm),
|
|
"mov.b\t{$imm, $dst}",
|
|
[(store (i8 cg8imm:$imm), addr:$dst)]>;
|
|
def MOV16mc : I16mc<0b0100,
|
|
(outs), (ins memdst:$dst, cg16imm:$imm),
|
|
"mov\t{$imm, $dst}",
|
|
[(store (i16 cg16imm:$imm), addr:$dst)]>;
|
|
|
|
def MOV8mi : I8mi<0b0100,
|
|
(outs), (ins memdst:$dst, i8imm:$imm),
|
|
"mov.b\t{$imm, $dst}",
|
|
[(store (i8 imm:$imm), addr:$dst)]>;
|
|
def MOV16mi : I16mi<0b0100,
|
|
(outs), (ins memdst:$dst, i16imm:$imm),
|
|
"mov\t{$imm, $dst}",
|
|
[(store (i16 imm:$imm), addr:$dst)]>;
|
|
|
|
def MOV8mr : I8mr<0b0100,
|
|
(outs), (ins memdst:$dst, GR8:$rs),
|
|
"mov.b\t{$rs, $dst}",
|
|
[(store GR8:$rs, addr:$dst)]>;
|
|
def MOV16mr : I16mr<0b0100,
|
|
(outs), (ins memdst:$dst, GR16:$rs),
|
|
"mov\t{$rs, $dst}",
|
|
[(store GR16:$rs, addr:$dst)]>;
|
|
|
|
def MOV8mm : I8mm<0b0100,
|
|
(outs), (ins memdst:$dst, memsrc:$src),
|
|
"mov.b\t{$src, $dst}",
|
|
[(store (i8 (load addr:$src)), addr:$dst)]>;
|
|
def MOV16mm : I16mm<0b0100,
|
|
(outs), (ins memdst:$dst, memsrc:$src),
|
|
"mov\t{$src, $dst}",
|
|
[(store (i16 (load addr:$src)), addr:$dst)]>;
|
|
|
|
def MOV8mn : I8mn<0b0100, (outs), (ins memdst:$dst, indreg:$rs),
|
|
"mov.b\t{$rs, $dst}", []>;
|
|
def MOV16mn : I16mn<0b0100, (outs), (ins memdst:$dst, indreg:$rs),
|
|
"mov\t{$rs, $dst}", []>;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Arithmetic Instructions
|
|
|
|
multiclass Arith<bits<4> opcode, string asmstring, SDNode node,
|
|
bit commutes, list<Register> uses> {
|
|
let Defs = [SR], Uses = uses in {
|
|
let Constraints = "$src2 = $rd" in {
|
|
let isCommutable = commutes in {
|
|
def 8rr : I8rr<opcode, (outs GR8:$rd), (ins GR8:$src2, GR8:$rs),
|
|
!strconcat(asmstring, ".b\t$rs, $rd"),
|
|
[(set GR8:$rd, (node GR8:$src2, GR8:$rs)),
|
|
(implicit SR)]>;
|
|
def 16rr : I16rr<opcode, (outs GR16:$rd), (ins GR16:$src2, GR16:$rs),
|
|
!strconcat(asmstring, "\t$rs, $rd"),
|
|
[(set GR16:$rd, (node GR16:$src2, GR16:$rs)),
|
|
(implicit SR)]>;
|
|
}
|
|
def 8rm : I8rm<opcode, (outs GR8:$rd), (ins GR8:$src2, memsrc:$src),
|
|
!strconcat(asmstring, ".b\t$src, $rd"),
|
|
[(set GR8:$rd, (node GR8:$src2, (load addr:$src))),
|
|
(implicit SR)]>;
|
|
def 16rm : I16rm<opcode, (outs GR16:$rd), (ins GR16:$src2, memsrc:$src),
|
|
!strconcat(asmstring, "\t$src, $rd"),
|
|
[(set GR16:$rd, (node GR16:$src2, (load addr:$src))),
|
|
(implicit SR)]>;
|
|
def 8rn : I8rn<opcode, (outs GR8:$rd), (ins GR8:$src2, indreg:$rs),
|
|
!strconcat(asmstring, ".b\t$rs, $rd"), []>;
|
|
def 16rn : I16rn<opcode, (outs GR16:$rd), (ins GR16:$src2, indreg:$rs),
|
|
!strconcat(asmstring, "\t$rs, $rd"), []>;
|
|
let mayLoad = 1,
|
|
hasExtraDefRegAllocReq = 1,
|
|
Constraints = "$rs = $wb, $src2 = $rd" in {
|
|
def 8rp : I8rp<opcode, (outs GR8:$rd, GR16:$wb), (ins GR8:$src2, postreg:$rs),
|
|
!strconcat(asmstring, ".b\t$rs, $rd"), []>;
|
|
def 16rp : I16rp<opcode, (outs GR16:$rd, GR16:$wb), (ins GR16:$src2, postreg:$rs),
|
|
!strconcat(asmstring, "\t$rs, $rd"), []>;
|
|
}
|
|
def 8rc : I8rc<opcode, (outs GR8:$rd), (ins GR8:$src2, cg8imm:$imm),
|
|
!strconcat(asmstring, ".b\t$imm, $rd"),
|
|
[(set GR8:$rd, (node GR8:$src2, cg8imm:$imm)),
|
|
(implicit SR)]>;
|
|
def 16rc : I16rc<opcode, (outs GR16:$rd), (ins GR16:$src2, cg16imm:$imm),
|
|
!strconcat(asmstring, "\t$imm, $rd"),
|
|
[(set GR16:$rd, (node GR16:$src2, cg16imm:$imm)),
|
|
(implicit SR)]>;
|
|
def 8ri : I8ri<opcode, (outs GR8:$rd), (ins GR8:$src2, i8imm:$imm),
|
|
!strconcat(asmstring, ".b\t$imm, $rd"),
|
|
[(set GR8:$rd, (node GR8:$src2, imm:$imm)),
|
|
(implicit SR)]>;
|
|
def 16ri : I16ri<opcode, (outs GR16:$rd), (ins GR16:$src2, i16imm:$imm),
|
|
!strconcat(asmstring, "\t$imm, $rd"),
|
|
[(set GR16:$rd, (node GR16:$src2, imm:$imm)),
|
|
(implicit SR)]>;
|
|
}
|
|
def 8mr : I8mr<opcode, (outs), (ins memdst:$dst, GR8:$rs),
|
|
!strconcat(asmstring, ".b\t$rs, $dst"),
|
|
[(store (node (load addr:$dst), GR8:$rs), addr:$dst),
|
|
(implicit SR)]>;
|
|
def 16mr : I16mr<opcode, (outs), (ins memdst:$dst, GR16:$rs),
|
|
!strconcat(asmstring, "\t$rs, $dst"),
|
|
[(store (node (load addr:$dst), GR16:$rs), addr:$dst),
|
|
(implicit SR)]>;
|
|
def 8mc : I8mc<opcode, (outs), (ins memdst:$dst, cg8imm:$imm),
|
|
!strconcat(asmstring, ".b\t$imm, $dst"),
|
|
[(store (node (load addr:$dst), (i8 cg8imm:$imm)), addr:$dst),
|
|
(implicit SR)]>;
|
|
def 16mc : I16mc<opcode, (outs), (ins memdst:$dst, cg16imm:$imm),
|
|
!strconcat(asmstring, "\t$imm, $dst"),
|
|
[(store (node (load addr:$dst), (i16 cg16imm:$imm)), addr:$dst),
|
|
(implicit SR)]>;
|
|
def 8mi : I8mi<opcode, (outs), (ins memdst:$dst, i8imm:$imm),
|
|
!strconcat(asmstring, ".b\t$imm, $dst"),
|
|
[(store (node (load addr:$dst), (i8 imm:$imm)), addr:$dst),
|
|
(implicit SR)]>;
|
|
def 16mi : I16mi<opcode, (outs), (ins memdst:$dst, i16imm:$imm),
|
|
!strconcat(asmstring, "\t$imm, $dst"),
|
|
[(store (node (load addr:$dst), (i16 imm:$imm)), addr:$dst),
|
|
(implicit SR)]>;
|
|
def 8mm : I8mm<opcode, (outs), (ins memdst:$dst, memsrc:$src),
|
|
!strconcat(asmstring, ".b\t$src, $dst"),
|
|
[(store (node (load addr:$dst),
|
|
(i8 (load addr:$src))), addr:$dst),
|
|
(implicit SR)]>;
|
|
def 16mm : I16mm<opcode, (outs), (ins memdst:$dst, memsrc:$src),
|
|
!strconcat(asmstring, "\t$src, $dst"),
|
|
[(store (node (load addr:$dst),
|
|
(i16 (load addr:$src))), addr:$dst),
|
|
(implicit SR)]>;
|
|
def 8mn : I8mn<opcode, (outs), (ins memdst:$dst, indreg:$rs),
|
|
!strconcat(asmstring, ".b\t$rs, $dst"), []>;
|
|
def 16mn : I16mn<opcode, (outs), (ins memdst:$dst, indreg:$rs),
|
|
!strconcat(asmstring, "\t$rs, $dst"), []>;
|
|
def 8mp : I8mp<opcode, (outs), (ins memdst:$dst, postreg:$rs),
|
|
!strconcat(asmstring, ".b\t$rs, $dst"), []>;
|
|
def 16mp : I16mp<opcode, (outs), (ins memdst:$dst, postreg:$rs),
|
|
!strconcat(asmstring, "\t$rs, $dst"), []>;
|
|
}
|
|
}
|
|
|
|
defm ADD : Arith<0b0101, "add", add, 1, []>;
|
|
defm ADDC : Arith<0b0110, "addc", adde, 1, [SR]>;
|
|
defm AND : Arith<0b1111, "and", and, 1, []>;
|
|
defm BIS : Arith<0b1101, "bis", or, 1, []>;
|
|
defm BIC : Arith<0b1100, "bic", bic, 0, []>;
|
|
defm XOR : Arith<0b1110, "xor", xor, 1, []>;
|
|
defm SUB : Arith<0b1000, "sub", sub, 0, []>;
|
|
defm SUBC : Arith<0b0111, "subc", sube, 0, [SR]>;
|
|
defm DADD : Arith<0b1010, "dadd", MSP430dadd, 1, [SR]>;
|
|
|
|
def ADC8r : InstAlias<"adc.b\t$dst", (ADDC8rc GR8:$dst, 0)>;
|
|
def ADC16r : InstAlias<"adc\t$dst", (ADDC16rc GR16:$dst, 0)>;
|
|
def ADC8m : InstAlias<"adc.b\t$dst", (ADDC8mc memdst:$dst, 0)>;
|
|
def ADC16m : InstAlias<"adc\t$dst", (ADDC16mc memdst:$dst, 0)>;
|
|
|
|
def DADC8r : InstAlias<"dadc.b\t$dst", (DADD8rc GR8:$dst, 0)>;
|
|
def DADC16r : InstAlias<"dadc\t$dst", (DADD16rc GR16:$dst, 0)>;
|
|
def DADC8m : InstAlias<"dadc.b\t$dst", (DADD8mc memdst:$dst, 0)>;
|
|
def DADC16m : InstAlias<"dadc\t$dst", (DADD16mc memdst:$dst, 0)>;
|
|
|
|
def DEC8r : InstAlias<"dec.b\t$dst", (SUB8rc GR8:$dst, 1)>;
|
|
def DEC16r : InstAlias<"dec\t$dst", (SUB16rc GR16:$dst, 1)>;
|
|
def DEC8m : InstAlias<"dec.b\t$dst", (SUB8mc memdst:$dst, 1)>;
|
|
def DEC16m : InstAlias<"dec\t$dst", (SUB16mc memdst:$dst, 1)>;
|
|
|
|
def DECD8r : InstAlias<"decd.b\t$dst", (SUB8rc GR8:$dst, 2)>;
|
|
def DECD16r : InstAlias<"decd\t$dst", (SUB16rc GR16:$dst, 2)>;
|
|
def DECD8m : InstAlias<"decd.b\t$dst", (SUB8mc memdst:$dst, 2)>;
|
|
def DECD16m : InstAlias<"decd\t$dst", (SUB16mc memdst:$dst, 2)>;
|
|
|
|
def INC8r : InstAlias<"inc.b\t$dst", (ADD8rc GR8:$dst, 1)>;
|
|
def INC16r : InstAlias<"inc\t$dst", (ADD16rc GR16:$dst, 1)>;
|
|
def INC8m : InstAlias<"inc.b\t$dst", (ADD8mc memdst:$dst, 1)>;
|
|
def INC16m : InstAlias<"inc\t$dst", (ADD16mc memdst:$dst, 1)>;
|
|
|
|
def INCD8r : InstAlias<"incd.b\t$dst", (ADD8rc GR8:$dst, 2)>;
|
|
def INCD16r : InstAlias<"incd\t$dst", (ADD16rc GR16:$dst, 2)>;
|
|
def INCD8m : InstAlias<"incd.b\t$dst", (ADD8mc memdst:$dst, 2)>;
|
|
def INCD16m : InstAlias<"incd\t$dst", (ADD16mc memdst:$dst, 2)>;
|
|
|
|
def SBC8r : InstAlias<"sbc.b\t$dst", (SUBC8rc GR8:$dst, 0)>;
|
|
def SBC16r : InstAlias<"sbc\t$dst", (SUBC16rc GR16:$dst, 0)>;
|
|
def SBC8m : InstAlias<"sbc.b\t$dst", (SUBC8mc memdst:$dst, 0)>;
|
|
def SBC16m : InstAlias<"sbc\t$dst", (SUBC16mc memdst:$dst, 0)>;
|
|
|
|
def INV8r : InstAlias<"inv.b\t$dst", (XOR8rc GR8:$dst, -1)>;
|
|
def INV16r : InstAlias<"inv\t$dst", (XOR16rc GR16:$dst, -1)>;
|
|
def INV8m : InstAlias<"inv.b\t$dst", (XOR8mc memdst:$dst, -1)>;
|
|
def INV16m : InstAlias<"inv\t$dst", (XOR16mc memdst:$dst, -1)>;
|
|
|
|
// printAliasInstr() doesn't check $dst operands are actually equal
|
|
// for RLA and RLC aliases below, so disable printing aliases.
|
|
|
|
def RLA8r : InstAlias<"rla.b\t$dst", (ADD8rr GR8:$dst, GR8:$dst), 0>;
|
|
def RLA16r : InstAlias<"rla\t$dst", (ADD16rr GR16:$dst, GR16:$dst), 0>;
|
|
def RLA8m : InstAlias<"rla.b\t$dst", (ADD8mm memdst:$dst, memdst:$dst), 0>;
|
|
def RLA16m : InstAlias<"rla\t$dst", (ADD16mm memdst:$dst, memdst:$dst), 0>;
|
|
|
|
def RLC8r : InstAlias<"rlc.b\t$dst", (ADDC8rr GR8:$dst, GR8:$dst), 0>;
|
|
def RLC16r : InstAlias<"rlc\t$dst", (ADDC16rr GR16:$dst, GR16:$dst), 0>;
|
|
def RLC8m : InstAlias<"rlc.b\t$dst", (ADDC8mm memdst:$dst, memdst:$dst), 0>;
|
|
def RLC16m : InstAlias<"rlc\t$dst", (ADDC16mm memdst:$dst, memdst:$dst), 0>;
|
|
|
|
def DINT : InstAlias<"dint", (BIC16rc SR, 8)>;
|
|
def EINT : InstAlias<"eint", (BIS16rc SR, 8)>;
|
|
|
|
def NOP : InstAlias<"nop", (MOV16rc CG, 0)>;
|
|
|
|
def CLR8r : InstAlias<"clr.b\t$dst", (MOV8rc GR8:$dst, 0)>;
|
|
def CLR16r : InstAlias<"clr\t$dst", (MOV16rc GR16:$dst, 0)>;
|
|
def CLR8m : InstAlias<"clr.b\t$dst", (MOV8mc memdst:$dst, 0)>;
|
|
def CLR16m : InstAlias<"clr\t$dst", (MOV16mc memdst:$dst, 0)>;
|
|
|
|
def CLRC : InstAlias<"clrc", (BIC16rc SR, 1)>;
|
|
def CLRN : InstAlias<"clrn", (BIC16rc SR, 4)>;
|
|
def CLRZ : InstAlias<"clrz", (BIC16rc SR, 2)>;
|
|
def SETC : InstAlias<"setc", (BIS16rc SR, 1)>;
|
|
def SETN : InstAlias<"setn", (BIS16rc SR, 4)>;
|
|
def SETZ : InstAlias<"setz", (BIS16rc SR, 2)>;
|
|
|
|
def : Pat<(MSP430rla GR8:$dst), (ADD8rr $dst, $dst)>;
|
|
def : Pat<(MSP430rla GR16:$dst), (ADD16rr $dst, $dst)>;
|
|
|
|
// Format-II (Single Operand) Instruction
|
|
// Register mode
|
|
let Constraints = "$rs = $rd" in {
|
|
|
|
let Defs = [SR] in {
|
|
def RRA8r : II8r<0b010,
|
|
(outs GR8:$rd), (ins GR8:$rs),
|
|
"rra.b\t$rd",
|
|
[(set GR8:$rd, (MSP430rra GR8:$rs)),
|
|
(implicit SR)]>;
|
|
def RRA16r : II16r<0b010,
|
|
(outs GR16:$rd), (ins GR16:$rs),
|
|
"rra\t$rd",
|
|
[(set GR16:$rd, (MSP430rra GR16:$rs)),
|
|
(implicit SR)]>;
|
|
|
|
let Uses = [SR] in {
|
|
def RRC8r : II8r<0b000,
|
|
(outs GR8:$rd), (ins GR8:$rs),
|
|
"rrc.b\t$rd",
|
|
[(set GR8:$rd, (MSP430rrc GR8:$rs)),
|
|
(implicit SR)]>;
|
|
def RRC16r : II16r<0b000,
|
|
(outs GR16:$rd), (ins GR16:$rs),
|
|
"rrc\t$rd",
|
|
[(set GR16:$rd, (MSP430rrc GR16:$rs)),
|
|
(implicit SR)]>;
|
|
} // Uses = [SR]
|
|
|
|
def SEXT16r : II16r<0b011,
|
|
(outs GR16:$rd), (ins GR16:$rs),
|
|
"sxt\t$rd",
|
|
[(set GR16:$rd, (sext_inreg GR16:$rs, i8)),
|
|
(implicit SR)]>;
|
|
|
|
} // Defs = [SR]
|
|
|
|
let isCodeGenOnly = 1 in
|
|
def ZEXT16r : I8rr<0b0100,
|
|
(outs GR16:$rd), (ins GR16:$rs),
|
|
"mov.b\t{$rs, $rd}",
|
|
[(set GR16:$rd, (zext (trunc GR16:$rs)))]>;
|
|
|
|
def SWPB16r : II16r<0b001,
|
|
(outs GR16:$rd), (ins GR16:$rs),
|
|
"swpb\t$rd",
|
|
[(set GR16:$rd, (bswap GR16:$rs))]>;
|
|
|
|
} // Constraints = "$src = $dst"
|
|
|
|
// Indexed, indirect register and indirect autoincrement modes
|
|
let Defs = [SR] in {
|
|
def RRA8m : II8m<0b010,
|
|
(outs), (ins memsrc:$src),
|
|
"rra.b\t$src",
|
|
[(store (MSP430rra (i8 (load addr:$src))), addr:$src),
|
|
(implicit SR)]>;
|
|
def RRA16m : II16m<0b010,
|
|
(outs), (ins memsrc:$src),
|
|
"rra\t$src",
|
|
[(store (MSP430rra (i16 (load addr:$src))), addr:$src),
|
|
(implicit SR)]>;
|
|
|
|
def RRA8n : II8n<0b010, (outs), (ins indreg:$rs), "rra.b\t$rs", []>;
|
|
def RRA16n : II16n<0b010, (outs), (ins indreg:$rs), "rra\t$rs", []>;
|
|
def RRA8p : II8p<0b010, (outs), (ins postreg:$rs), "rra.b\t$rs", []>;
|
|
def RRA16p : II16p<0b010, (outs), (ins postreg:$rs), "rra\t$rs", []>;
|
|
|
|
let Uses = [SR] in {
|
|
def RRC8m : II8m<0b000,
|
|
(outs), (ins memsrc:$src),
|
|
"rrc.b\t$src",
|
|
[(store (MSP430rrc (i8 (load addr:$src))), addr:$src),
|
|
(implicit SR)]>;
|
|
def RRC16m : II16m<0b000,
|
|
(outs), (ins memsrc:$src),
|
|
"rrc\t$src",
|
|
[(store (MSP430rrc (i16 (load addr:$src))), addr:$src),
|
|
(implicit SR)]>;
|
|
|
|
def RRC8n : II8n<0b000, (outs), (ins indreg:$rs), "rrc.b\t$rs", []>;
|
|
def RRC16n : II16n<0b000, (outs), (ins indreg:$rs), "rrc\t$rs", []>;
|
|
def RRC8p : II8p<0b000, (outs), (ins postreg:$rs), "rrc.b\t$rs", []>;
|
|
def RRC16p : II16p<0b000, (outs), (ins postreg:$rs), "rrc\t$rs", []>;
|
|
|
|
} // Uses = [SR]
|
|
|
|
def SEXT16m : II16m<0b011,
|
|
(outs), (ins memsrc:$src),
|
|
"sxt\t$src",
|
|
[(store (sext_inreg (extloadi16i8 addr:$src), i8),
|
|
addr:$src),
|
|
(implicit SR)]>;
|
|
def SEXT16n : II16n<0b011, (outs), (ins indreg:$rs), "sxt\t$rs", []>;
|
|
def SEXT16p : II16p<0b011, (outs), (ins postreg:$rs), "sxt\t$rs", []>;
|
|
|
|
} // Defs = [SR]
|
|
|
|
def SWPB16m : II16m<0b001,
|
|
(outs), (ins memsrc:$src),
|
|
"swpb\t$src",
|
|
[(store (bswap (i16 (load addr:$src))), addr:$src)]>;
|
|
def SWPB16n : II16n<0b001, (outs), (ins indreg:$rs), "swpb\t$rs", []>;
|
|
def SWPB16p : II16p<0b001, (outs), (ins postreg:$rs), "swpb\t$rs", []>;
|
|
|
|
// Integer comparisons
|
|
let Defs = [SR] in {
|
|
def CMP8rr : I8rr<0b1001,
|
|
(outs), (ins GR8:$rd, GR8:$rs),
|
|
"cmp.b\t$rs, $rd",
|
|
[(MSP430cmp GR8:$rd, GR8:$rs), (implicit SR)]>;
|
|
def CMP16rr : I16rr<0b1001,
|
|
(outs), (ins GR16:$rd, GR16:$rs),
|
|
"cmp\t$rs, $rd",
|
|
[(MSP430cmp GR16:$rd, GR16:$rs), (implicit SR)]>;
|
|
|
|
def CMP8rc : I8rc<0b1001,
|
|
(outs), (ins GR8:$rd, cg8imm:$imm),
|
|
"cmp.b\t$imm, $rd",
|
|
[(MSP430cmp GR8:$rd, cg8imm:$imm), (implicit SR)]>;
|
|
def CMP16rc : I16rc<0b1001,
|
|
(outs), (ins GR16:$rd, cg16imm:$imm),
|
|
"cmp\t$imm, $rd",
|
|
[(MSP430cmp GR16:$rd, cg16imm:$imm), (implicit SR)]>;
|
|
|
|
def CMP8ri : I8ri<0b1001,
|
|
(outs), (ins GR8:$rd, i8imm:$imm),
|
|
"cmp.b\t$imm, $rd",
|
|
[(MSP430cmp GR8:$rd, imm:$imm), (implicit SR)]>;
|
|
def CMP16ri : I16ri<0b1001,
|
|
(outs), (ins GR16:$rd, i16imm:$imm),
|
|
"cmp\t$imm, $rd",
|
|
[(MSP430cmp GR16:$rd, imm:$imm), (implicit SR)]>;
|
|
|
|
def CMP8mc : I8mc<0b1001,
|
|
(outs), (ins memsrc:$dst, cg8imm:$imm),
|
|
"cmp.b\t$imm, $dst",
|
|
[(MSP430cmp (load addr:$dst), (i8 cg8imm:$imm)),
|
|
(implicit SR)]>;
|
|
def CMP16mc : I16mc<0b1001,
|
|
(outs), (ins memsrc:$dst, cg16imm:$imm),
|
|
"cmp\t$imm, $dst",
|
|
[(MSP430cmp (load addr:$dst), (i16 cg16imm:$imm)),
|
|
(implicit SR)]>;
|
|
|
|
def CMP8mi : I8mi<0b1001,
|
|
(outs), (ins memsrc:$dst, i8imm:$imm),
|
|
"cmp.b\t$imm, $dst",
|
|
[(MSP430cmp (load addr:$dst),
|
|
(i8 imm:$imm)), (implicit SR)]>;
|
|
def CMP16mi : I16mi<0b1001,
|
|
(outs), (ins memsrc:$dst, i16imm:$imm),
|
|
"cmp\t$imm, $dst",
|
|
[(MSP430cmp (load addr:$dst),
|
|
(i16 imm:$imm)), (implicit SR)]>;
|
|
|
|
def CMP8rm : I8rm<0b1001,
|
|
(outs), (ins GR8:$rd, memsrc:$src),
|
|
"cmp.b\t$src, $rd",
|
|
[(MSP430cmp GR8:$rd, (load addr:$src)),
|
|
(implicit SR)]>;
|
|
def CMP16rm : I16rm<0b1001,
|
|
(outs), (ins GR16:$rd, memsrc:$src),
|
|
"cmp\t$src, $rd",
|
|
[(MSP430cmp GR16:$rd, (load addr:$src)),
|
|
(implicit SR)]>;
|
|
|
|
def CMP8rn : I8rn<0b1001,
|
|
(outs), (ins GR8:$rd, indreg:$rs), "cmp.b\t$rs, $rd", []>;
|
|
def CMP16rn : I16rn<0b1001,
|
|
(outs), (ins GR16:$rd, indreg:$rs), "cmp\t$rs, $rd", []>;
|
|
|
|
def CMP8rp : I8rp<0b1001,
|
|
(outs), (ins GR8:$rd, postreg:$rs), "cmp.b\t$rs, $rd", []>;
|
|
def CMP16rp : I16rp<0b1001,
|
|
(outs), (ins GR16:$rd, postreg:$rs), "cmp\t$rs, $rd", []>;
|
|
|
|
def CMP8mr : I8mr<0b1001,
|
|
(outs), (ins memsrc:$dst, GR8:$rs),
|
|
"cmp.b\t$rs, $dst",
|
|
[(MSP430cmp (load addr:$dst), GR8:$rs),
|
|
(implicit SR)]>;
|
|
def CMP16mr : I16mr<0b1001,
|
|
(outs), (ins memsrc:$dst, GR16:$rs),
|
|
"cmp\t$rs, $dst",
|
|
[(MSP430cmp (load addr:$dst), GR16:$rs),
|
|
(implicit SR)]>;
|
|
def CMP8mm : I8mm<0b1001,
|
|
(outs), (ins memdst:$dst, memsrc:$src),
|
|
"cmp.b\t$src, $dst",
|
|
[(MSP430cmp (load addr:$dst), (i8 (load addr:$src))),
|
|
(implicit SR)]>;
|
|
def CMP16mm : I16mm<0b1001, (outs), (ins memdst:$dst, memsrc:$src),
|
|
"cmp\t$src, $dst",
|
|
[(MSP430cmp (load addr:$dst), (i16 (load addr:$src))),
|
|
(implicit SR)]>;
|
|
|
|
def CMP8mn : I8mn<0b1001, (outs), (ins memsrc:$dst, indreg:$rs),
|
|
"cmp.b\t$rs, $dst", []>;
|
|
def CMP16mn : I16mn<0b1001, (outs), (ins memsrc:$dst, indreg:$rs),
|
|
"cmp\t$rs, $dst", []>;
|
|
|
|
def CMP8mp : I8mp<0b1001, (outs), (ins memsrc:$dst, postreg:$rs),
|
|
"cmp.b\t$rs, $dst", []>;
|
|
def CMP16mp : I16mp<0b1001, (outs), (ins memsrc:$dst, postreg:$rs),
|
|
"cmp\t$rs, $dst", []>;
|
|
|
|
// BIT TESTS, just sets condition codes
|
|
// Note that the C condition is set differently than when using CMP.
|
|
let isCommutable = 1 in {
|
|
def BIT8rr : I8rr<0b1011,
|
|
(outs), (ins GR8:$rd, GR8:$rs),
|
|
"bit.b\t$rs, $rd",
|
|
[(MSP430cmp (and_su GR8:$rd, GR8:$rs), 0),
|
|
(implicit SR)]>;
|
|
def BIT16rr : I16rr<0b1011,
|
|
(outs), (ins GR16:$rd, GR16:$rs),
|
|
"bit\t$rs, $rd",
|
|
[(MSP430cmp (and_su GR16:$rd, GR16:$rs), 0),
|
|
(implicit SR)]>;
|
|
}
|
|
def BIT8rc : I8rc<0b1011,
|
|
(outs), (ins GR8:$rd, cg8imm:$imm),
|
|
"bit.b\t$imm, $rd",
|
|
[(MSP430cmp (and_su GR8:$rd, cg8imm:$imm), 0),
|
|
(implicit SR)]>;
|
|
def BIT16rc : I16rc<0b1011,
|
|
(outs), (ins GR16:$rd, cg16imm:$imm),
|
|
"bit\t$imm, $rd",
|
|
[(MSP430cmp (and_su GR16:$rd, cg16imm:$imm), 0),
|
|
(implicit SR)]>;
|
|
|
|
def BIT8ri : I8ri<0b1011,
|
|
(outs), (ins GR8:$rd, i8imm:$imm),
|
|
"bit.b\t$imm, $rd",
|
|
[(MSP430cmp (and_su GR8:$rd, imm:$imm), 0),
|
|
(implicit SR)]>;
|
|
def BIT16ri : I16ri<0b1011,
|
|
(outs), (ins GR16:$rd, i16imm:$imm),
|
|
"bit\t$imm, $rd",
|
|
[(MSP430cmp (and_su GR16:$rd, imm:$imm), 0),
|
|
(implicit SR)]>;
|
|
|
|
def BIT8rm : I8rm<0b1011,
|
|
(outs), (ins GR8:$rd, memdst:$src),
|
|
"bit.b\t$src, $rd",
|
|
[(MSP430cmp (and_su GR8:$rd, (load addr:$src)), 0),
|
|
(implicit SR)]>;
|
|
def BIT16rm : I16rm<0b1011,
|
|
(outs), (ins GR16:$rd, memdst:$src),
|
|
"bit\t$src, $rd",
|
|
[(MSP430cmp (and_su GR16:$rd, (load addr:$src)), 0),
|
|
(implicit SR)]>;
|
|
|
|
def BIT8rn : I8rn<0b1011, (outs), (ins GR8:$rd, indreg:$rs),
|
|
"bit.b\t$rs, $rd", []>;
|
|
def BIT16rn : I16rn<0b1011, (outs), (ins GR16:$rd, indreg:$rs),
|
|
"bit\t$rs, $rd", []>;
|
|
|
|
def BIT8rp : I8rp<0b1011, (outs), (ins GR8:$rd, postreg:$rs),
|
|
"bit.b\t$rs, $rd", []>;
|
|
def BIT16rp : I16rp<0b1011, (outs), (ins GR16:$rd, postreg:$rs),
|
|
"bit\t$rs, $rd", []>;
|
|
|
|
def BIT8mr : I8mr<0b1011,
|
|
(outs), (ins memsrc:$dst, GR8:$rs),
|
|
"bit.b\t$rs, $dst",
|
|
[(MSP430cmp (and_su (load addr:$dst), GR8:$rs), 0),
|
|
(implicit SR)]>;
|
|
def BIT16mr : I16mr<0b1011,
|
|
(outs), (ins memsrc:$dst, GR16:$rs),
|
|
"bit\t$rs, $dst",
|
|
[(MSP430cmp (and_su (load addr:$dst), GR16:$rs), 0),
|
|
(implicit SR)]>;
|
|
|
|
def BIT8mc : I8mc<0b1011,
|
|
(outs), (ins memsrc:$dst, cg8imm:$imm),
|
|
"bit.b\t$imm, $dst",
|
|
[(MSP430cmp (and_su (load addr:$dst), (i8 cg8imm:$imm)), 0),
|
|
(implicit SR)]>;
|
|
def BIT16mc : I16mc<0b1011,
|
|
(outs), (ins memdst:$dst, cg16imm:$imm),
|
|
"bit\t$imm, $dst",
|
|
[(MSP430cmp (and_su (load addr:$dst), (i16 cg16imm:$imm)), 0),
|
|
(implicit SR)]>;
|
|
|
|
def BIT8mi : I8mi<0b1011,
|
|
(outs), (ins memsrc:$dst, i8imm:$imm),
|
|
"bit.b\t$imm, $dst",
|
|
[(MSP430cmp (and_su (load addr:$dst), (i8 imm:$imm)), 0),
|
|
(implicit SR)]>;
|
|
def BIT16mi : I16mi<0b1011,
|
|
(outs), (ins memsrc:$dst, i16imm:$imm),
|
|
"bit\t$imm, $dst",
|
|
[(MSP430cmp (and_su (load addr:$dst), (i16 imm:$imm)), 0),
|
|
(implicit SR)]>;
|
|
|
|
def BIT8mm : I8mm<0b1011,
|
|
(outs), (ins memsrc:$dst, memsrc:$src),
|
|
"bit.b\t$src, $dst",
|
|
[(MSP430cmp (and_su (i8 (load addr:$dst)),
|
|
(load addr:$src)),
|
|
0),
|
|
(implicit SR)]>;
|
|
def BIT16mm : I16mm<0b1011,
|
|
(outs), (ins memsrc:$dst, memsrc:$src),
|
|
"bit\t$src, $dst",
|
|
[(MSP430cmp (and_su (i16 (load addr:$dst)),
|
|
(load addr:$src)),
|
|
0),
|
|
(implicit SR)]>;
|
|
def BIT8mn : I8mn<0b1011, (outs), (ins memsrc:$dst, indreg:$rs),
|
|
"bit.b\t$rs, $dst", []>;
|
|
def BIT16mn : I16mn<0b1011, (outs), (ins memsrc:$dst, indreg:$rs),
|
|
"bit\t$rs, $dst", []>;
|
|
|
|
def BIT8mp : I8mp<0b1011, (outs), (ins memsrc:$dst, postreg:$rs),
|
|
"bit.b\t$rs, $dst", []>;
|
|
def BIT16mp : I16mp<0b1011, (outs), (ins memsrc:$dst, postreg:$rs),
|
|
"bit\t$rs, $dst", []>;
|
|
|
|
} // Defs = [SR]
|
|
|
|
def TST8r : InstAlias<"tst.b\t$dst", (CMP8rc GR8:$dst, 0)>;
|
|
def TST16r : InstAlias<"tst\t$dst", (CMP16rc GR16:$dst, 0)>;
|
|
def TST8m : InstAlias<"tst.b\t$dst", (CMP8mc memdst:$dst, 0)>;
|
|
def TST16m : InstAlias<"tst\t$dst", (CMP16mc memdst:$dst, 0)>;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Non-Instruction Patterns
|
|
|
|
// extload
|
|
def : Pat<(extloadi16i8 addr:$src), (MOVZX16rm8 addr:$src)>;
|
|
|
|
// anyext
|
|
def : Pat<(i16 (anyext GR8:$src)),
|
|
(SUBREG_TO_REG (i16 0), GR8:$src, subreg_8bit)>;
|
|
|
|
// truncs
|
|
def : Pat<(i8 (trunc GR16:$src)),
|
|
(EXTRACT_SUBREG GR16:$src, subreg_8bit)>;
|
|
|
|
// GlobalAddress, ExternalSymbol
|
|
def : Pat<(i16 (MSP430Wrapper tglobaladdr:$dst)), (MOV16ri tglobaladdr:$dst)>;
|
|
def : Pat<(i16 (MSP430Wrapper texternalsym:$dst)), (MOV16ri texternalsym:$dst)>;
|
|
def : Pat<(i16 (MSP430Wrapper tblockaddress:$dst)), (MOV16ri tblockaddress:$dst)>;
|
|
|
|
def : Pat<(add GR16:$src, (MSP430Wrapper tglobaladdr :$src2)),
|
|
(ADD16ri GR16:$src, tglobaladdr:$src2)>;
|
|
def : Pat<(add GR16:$src, (MSP430Wrapper texternalsym:$src2)),
|
|
(ADD16ri GR16:$src, texternalsym:$src2)>;
|
|
def : Pat<(add GR16:$src, (MSP430Wrapper tblockaddress:$src2)),
|
|
(ADD16ri GR16:$src, tblockaddress:$src2)>;
|
|
|
|
def : Pat<(store (i16 (MSP430Wrapper tglobaladdr:$src)), addr:$dst),
|
|
(MOV16mi addr:$dst, tglobaladdr:$src)>;
|
|
def : Pat<(store (i16 (MSP430Wrapper texternalsym:$src)), addr:$dst),
|
|
(MOV16mi addr:$dst, texternalsym:$src)>;
|
|
def : Pat<(store (i16 (MSP430Wrapper tblockaddress:$src)), addr:$dst),
|
|
(MOV16mi addr:$dst, tblockaddress:$src)>;
|
|
|
|
// calls
|
|
def : Pat<(MSP430call (i16 tglobaladdr:$dst)),
|
|
(CALLi tglobaladdr:$dst)>;
|
|
def : Pat<(MSP430call (i16 texternalsym:$dst)),
|
|
(CALLi texternalsym:$dst)>;
|
|
|
|
// add and sub always produce carry
|
|
def : Pat<(addc GR16:$src, GR16:$src2),
|
|
(ADD16rr GR16:$src, GR16:$src2)>;
|
|
def : Pat<(addc GR16:$src, (load addr:$src2)),
|
|
(ADD16rm GR16:$src, addr:$src2)>;
|
|
def : Pat<(addc GR16:$src, imm:$src2),
|
|
(ADD16ri GR16:$src, imm:$src2)>;
|
|
def : Pat<(store (addc (load addr:$dst), GR16:$src), addr:$dst),
|
|
(ADD16mr addr:$dst, GR16:$src)>;
|
|
def : Pat<(store (addc (load addr:$dst), (i16 (load addr:$src))), addr:$dst),
|
|
(ADD16mm addr:$dst, addr:$src)>;
|
|
|
|
def : Pat<(addc GR8:$src, GR8:$src2),
|
|
(ADD8rr GR8:$src, GR8:$src2)>;
|
|
def : Pat<(addc GR8:$src, (load addr:$src2)),
|
|
(ADD8rm GR8:$src, addr:$src2)>;
|
|
def : Pat<(addc GR8:$src, imm:$src2),
|
|
(ADD8ri GR8:$src, imm:$src2)>;
|
|
def : Pat<(store (addc (load addr:$dst), GR8:$src), addr:$dst),
|
|
(ADD8mr addr:$dst, GR8:$src)>;
|
|
def : Pat<(store (addc (load addr:$dst), (i8 (load addr:$src))), addr:$dst),
|
|
(ADD8mm addr:$dst, addr:$src)>;
|
|
|
|
def : Pat<(subc GR16:$src, GR16:$src2),
|
|
(SUB16rr GR16:$src, GR16:$src2)>;
|
|
def : Pat<(subc GR16:$src, (load addr:$src2)),
|
|
(SUB16rm GR16:$src, addr:$src2)>;
|
|
def : Pat<(subc GR16:$src, imm:$src2),
|
|
(SUB16ri GR16:$src, imm:$src2)>;
|
|
def : Pat<(store (subc (load addr:$dst), GR16:$src), addr:$dst),
|
|
(SUB16mr addr:$dst, GR16:$src)>;
|
|
def : Pat<(store (subc (load addr:$dst), (i16 (load addr:$src))), addr:$dst),
|
|
(SUB16mm addr:$dst, addr:$src)>;
|
|
|
|
def : Pat<(subc GR8:$src, GR8:$src2),
|
|
(SUB8rr GR8:$src, GR8:$src2)>;
|
|
def : Pat<(subc GR8:$src, (load addr:$src2)),
|
|
(SUB8rm GR8:$src, addr:$src2)>;
|
|
def : Pat<(subc GR8:$src, imm:$src2),
|
|
(SUB8ri GR8:$src, imm:$src2)>;
|
|
def : Pat<(store (subc (load addr:$dst), GR8:$src), addr:$dst),
|
|
(SUB8mr addr:$dst, GR8:$src)>;
|
|
def : Pat<(store (subc (load addr:$dst), (i8 (load addr:$src))), addr:$dst),
|
|
(SUB8mm addr:$dst, addr:$src)>;
|
|
|
|
// peephole patterns
|
|
def : Pat<(and GR16:$src, 255), (ZEXT16r GR16:$src)>;
|
|
def : Pat<(MSP430cmp (trunc (and_su GR16:$src, GR16:$src2)), 0),
|
|
(BIT8rr (EXTRACT_SUBREG GR16:$src, subreg_8bit),
|
|
(EXTRACT_SUBREG GR16:$src2, subreg_8bit))>;
|