[CSKY 6/n] Add support branch and symbol series instruction

[zixuan-wu]

Summary

This patch adds basic CSKY branch instructions and symbol address series instructions.
Those two kinds of instruction have relationship between each other, and it involves much work about Fixups.

For now, basic instructions are enabled except for disassembler support. We would support to generate basic codegen asm firstly and delay disassembler work later.

[myhsu]

llvm/lib/Target/CSKY/AsmParser/CSKYAsmParser.cpp

184

can you condense these three lines into a single return statement?

192

ditto

373

please remove unused comment. Or add FIXME/TODO with explanations

540

can you combine this declaration with line 572? I didn't see any reference of Res until line 572

[rengolin]

+1 to @myhsu's points, plus a few comments, but otherwise, is looking good.

llvm/lib/Target/CSKY/MCTargetDesc/CSKYAsmBackend.cpp

52

What's the probability that Kind will be within the range? I'm assuming high, so it would be better if return Infos[Kind] was the first thing that checks.

So maybe:

if (FirstTargetFixupKind <= Kind < FirstLiteralRelocationKind)
  return Infos[Kind]
else if (Kind < FirstTargetFixupKind)
  return MCAsmBackend::getFixupKindInfo(Kind);
else
  return MCAsmBackend::getFixupKindInfo(FK_NONE);

llvm/lib/Target/CSKY/MCTargetDesc/CSKYMCCodeEmitter.h

84

Do constant pools and branches really accept any kind of fixup? If not, then maybe an assert on the kinds that work here just to make sure we don't generate bad code.

[rengolin]

Sorry, you haven't said anything about the comments, I didn't know you had updated the patch to address them.

Phab isn't great at communication, so when you do address all comments, a simple line saying "addressing all comments" helps us know that we should look at it again.

Anyway, LGTM, thanks!

[zixuan-wu]

In D95029#2694364, @rengolin wrote:

Sorry, you haven't said anything about the comments, I didn't know you had updated the patch to address them.

Phab isn't great at communication, so when you do address all comments, a simple line saying "addressing all comments" helps us know that we should look at it again.

Anyway, LGTM, thanks!

OK. Thank you for your review. I will mark Done to track every comment next time as the Phab provides the Done button.

llvm/lib/Target/CSKY/AsmParser/CSKYAsmParser.cpp

 //===-- CSKYAsmParser.cpp - Parse CSKY assembly to MCInst instructions --===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+#include "MCTargetDesc/CSKYMCExpr.h"
 #include "MCTargetDesc/CSKYMCTargetDesc.h"
 #include "TargetInfo/CSKYTargetInfo.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/CodeGen/Register.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"

 
 // Auto-generated instruction matching functions
 #define GET_ASSEMBLER_HEADER
 #include "CSKYGenAsmMatcher.inc"
 
   OperandMatchResultTy parseImmediate(OperandVector &Operands);
   OperandMatchResultTy parseRegister(OperandVector &Operands);
   OperandMatchResultTy parseBaseRegImm(OperandVector &Operands);
+  OperandMatchResultTy parseCSKYSymbol(OperandVector &Operands);
+  OperandMatchResultTy parseConstpoolSymbol(OperandVector &Operands);
 
   bool parseOperand(OperandVector &Operands, StringRef Mnemonic);
 
 public:
   enum CSKYMatchResultTy {
     Match_Dummy = FIRST_TARGET_MATCH_RESULT_TY,
 #define GET_OPERAND_DIAGNOSTIC_TYPES
 #include "CSKYGenAsmMatcher.inc"
public:
   bool isUImm16() const { return isUImm<16>(); }
 
   bool isOImm12() const { return isOImm<12>(); }
   bool isOImm16() const { return isOImm<16>(); }
 
   bool isUImm12Shift1() { return isUImm<12, 1>(); }
   bool isUImm12Shift2() { return isUImm<12, 2>(); }
 
+  bool isSImm16Shift1() { return isSImm<16, 1>(); }
+
+  bool isCSKYSymbol() const {
+    int64_t Imm;
+    // Must be of 'immediate' type but not a constant.
+    return isImm() && !evaluateConstantImm(getImm(), Imm);
+  }
+
+  bool isConstpoolSymbol() const {
+    int64_t Imm;
+    // Must be of 'immediate' type but not a constant.
+    return isImm() && !evaluateConstantImm(getImm(), Imm);
+  }
+
   /// Gets location of the first token of this operand.
   SMLoc getStartLoc() const override { return StartLoc; }
   /// Gets location of the last token of this operand.
   SMLoc getEndLoc() const override { return EndLoc; }
 
   unsigned getReg() const override {
     assert(Kind == Register && "Invalid type access!");
     return Reg.RegNum;
   }
 
return generateImmOutOfRangeError(
         Operands, ErrorInfo, 0, (1 << 12) - 2,
         "immediate must be a multiple of 2 bytes in the range");
   case Match_InvalidUImm12Shift2:
     return generateImmOutOfRangeError(
         Operands, ErrorInfo, 0, (1 << 12) - 4,
         "immediate must be a multiple of 4 bytes in the range");
   case Match_InvalidUImm16:
     return generateImmOutOfRangeError(Operands, ErrorInfo, 0, (1 << 16) - 1);
+  case Match_InvalidCSKYSymbol: {
+    SMLoc ErrorLoc = ((CSKYOperand &)*Operands[ErrorInfo]).getStartLoc();
+    return Error(ErrorLoc, "operand must be a symbol name");
+  }
+  case Match_InvalidConstpool: {
+    SMLoc ErrorLoc = ((CSKYOperand &)*Operands[ErrorInfo]).getStartLoc();
+    return Error(ErrorLoc, "operand must be a constpool symbol name");
+  }
   }
 
   llvm_unreachable("Unknown match type detected!");
 }
 
 // Attempts to match Name as a register (either using the default name or
 // alternative ABI names), setting RegNo to the matching register. Upon
 // failure, returns true and sets RegNo to 0.
OperandMatchResultTy CSKYAsmParser::parseImmediate(OperandVector &Operands) {
   Operands.push_back(CSKYOperand::createImm(IdVal, S, E));
   return MatchOperand_Success;
 }
 
 /// Looks at a token type and creates the relevant operand from this
 /// information, adding to Operands. If operand was parsed, returns false, else
 /// true.
 bool CSKYAsmParser::parseOperand(OperandVector &Operands, StringRef Mnemonic) {
+  // Check if the current operand has a custom associated parser, if so, try to
+  // custom parse the operand, or fallback to the general approach.
+  OperandMatchResultTy Result =
+      MatchOperandParserImpl(Operands, Mnemonic, /*ParseForAllFeatures=*/true);
+  if (Result == MatchOperand_Success)
+    return false;
+  if (Result == MatchOperand_ParseFail)
+    return true;
+
   // Attempt to parse token as register
   if (parseRegister(Operands) == MatchOperand_Success)
     return false;
 
   // Attempt to parse token as (register, imm)
   if (getLexer().is(AsmToken::LParen))
     if (parseBaseRegImm(Operands) == MatchOperand_Success)
       return false;
 
   // Attempt to parse token as a imm.
   if (parseImmediate(Operands) == MatchOperand_Success)
     return false;
 
   // Finally we have exhausted all options and must declare defeat.
   Error(getLoc(), "unknown operand");
   return true;
 }
 
+OperandMatchResultTy CSKYAsmParser::parseCSKYSymbol(OperandVector &Operands) {
+  SMLoc S = getLoc();
+  SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
+
+  if (getLexer().getKind() != AsmToken::Identifier)
+    return MatchOperand_NoMatch;
+
+  StringRef Identifier;
+  if (getParser().parseIdentifier(Identifier))
+    return MatchOperand_ParseFail;
+
+  CSKYMCExpr::VariantKind Kind = CSKYMCExpr::VK_CSKY_None;
+
+  if (Identifier.consume_back("@GOT"))
+    Kind = CSKYMCExpr::VK_CSKY_GOT;
+  else if (Identifier.consume_back("@GOTOFF"))
+    Kind = CSKYMCExpr::VK_CSKY_GOTOFF;
+  else if (Identifier.consume_back("@PLT"))
+    Kind = CSKYMCExpr::VK_CSKY_PLT;
+  else if (Identifier.consume_back("@GOTPC"))
+    Kind = CSKYMCExpr::VK_CSKY_GOTPC;
+
+  MCSymbol *Sym = getContext().getOrCreateSymbol(Identifier);
+  const MCExpr *Res =
+      MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, getContext());
+
+  if (Kind != CSKYMCExpr::VK_CSKY_None)
+    Res = CSKYMCExpr::create(Res, Kind, getContext());
+
+  Operands.push_back(CSKYOperand::createImm(Res, S, E));
+  return MatchOperand_Success;
+}
+
+OperandMatchResultTy
+CSKYAsmParser::parseConstpoolSymbol(OperandVector &Operands) {
+  SMLoc S = getLoc();
+  SMLoc E = SMLoc::getFromPointer(S.getPointer() - 1);
+
+  if (getLexer().getKind() != AsmToken::LBrac)
+    return MatchOperand_NoMatch;
+
+  getLexer().Lex(); // Eat '['.
+
+  if (getLexer().getKind() != AsmToken::Identifier)
+    return MatchOperand_NoMatch;
+
+  StringRef Identifier;
+  if (getParser().parseIdentifier(Identifier))
+    return MatchOperand_ParseFail;
+
+  if (getLexer().getKind() != AsmToken::RBrac)
+    return MatchOperand_NoMatch;
+
+  getLexer().Lex(); // Eat ']'.
+
+  MCSymbol *Sym = getContext().getOrCreateSymbol(Identifier);
+  const MCExpr *Res =
+      MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, getContext());
+  Operands.push_back(CSKYOperand::createImm(Res, S, E));
+  return MatchOperand_Success;
+}
+
 bool CSKYAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
                                      SMLoc NameLoc, OperandVector &Operands) {
   // First operand is token for instruction.
   Operands.push_back(CSKYOperand::createToken(Name, NameLoc));
 
   // If there are no more operands, then finish.
   if (getLexer().is(AsmToken::EndOfStatement))
     return false;

llvm/lib/Target/CSKY/CSKYInstrFormats.td

 // CSKY 32-bit instruction
 // Format< OP[6] | Offset[26] >
 // Instruction(1): bsr32
 class J<bits<6> opcode, dag outs, dag ins, string op, list<dag> pattern>
     : CSKY32Inst<AddrModeNone, opcode, outs, ins, !strconcat(op, "\t$offset"),
                  pattern> {
   bits<26> offset;
   let Inst{25 - 0} = offset;
+  let isCall = 1;
+  let Defs = [ R15 ];
 }
 
 // Format< OP[6] | RZ[5] | SOP[3] | OFFSET[18] >
 // Instructions(7): grs, lrs32.b, lrs32.h, lrs32.w, srs32.b, srs32.h, srs32.w
-class I_18_Z_L<bits<3> sop, string op, dag outs, dag ins, list<dag> pattern>
-    : CSKY32Inst<AddrModeNone, 0x33, outs, ins,
-                 !strconcat(op, "\t$rz, $offset"), pattern> {
+class I_18_Z_L<bits<3> sop, string asm, dag outs, dag ins, list<dag> pattern>
+    : CSKY32Inst<AddrModeNone, 0x33, outs, ins, asm, pattern> {
   bits<5> rz;
   bits<18> offset;
   let Inst{25 - 21} = rz;
   let Inst{20 - 18} = sop;
   let Inst{17 - 0} = offset;
 }
 
 // Format< OP[6] | RZ[5] | RX[5] | IMM[16] >
class I_16_MOV<bits<5> sop, string op, ImmLeaf ImmType>
   let isAsCheapAsAMove = 1;
   let isMoveImm = 1;
 }
 
 // Format< OP[6] | SOP[5] | RZ[5] | OFFSET[16] >
 // Instructions(1): lrw32
 class I_16_Z_L<bits<5> sop, string op, dag ins, list<dag> pattern>
   : CSKY32Inst<AddrModeNone, 0x3a, (outs GPR:$rz), ins,
-  !strconcat(op, "\t$rz, [$imm16]"), pattern> {
+  !strconcat(op, "\t$rz, $imm16"), pattern> {
   bits<5> rz;
   bits<16> imm16;
   let Inst{25 - 21} = sop;
   let Inst{20 - 16} = rz;
   let Inst{15 - 0} = imm16;
 }
 
 // Format< OP[6] | SOP[5] | 00000[5] | OFFSET[16] >
 // Instructions(5): bt32, bf32, br32, jmpi32, jsri32
-class I_16_L<bits<5> sop, dag outs, dag ins, string op, list<dag> pattern>
-    : CSKY32Inst<AddrModeNone, 0x3a, outs, ins, !strconcat(op, "\t$imm16"),
-                 pattern> {
+class I_16_L<bits<5> sop, dag outs, dag ins, string asm, list<dag> pattern>
+    : CSKY32Inst<AddrModeNone, 0x3a, outs, ins, asm, pattern> {
   bits<16> imm16;
   let Inst{25 - 21} = sop;
   let Inst{20 - 16} = 0;
   let Inst{15 - 0} = imm16;
 }
 
 // Format< OP[6] | SOP[5] | RX[5] | 0000000000000000[16] >
 // Instructions(2): jmp32, jsr32
class I_16_RET<bits<5> sop, bits<5> pcode, string op, list<dag> pattern>
   let Inst{25 - 21} = sop;
   let Inst{20 - 16} = pcode;
   let Inst{15 - 0} = 0;
   let isTerminator = 1;
   let isReturn = 1;
   let isBarrier = 1;
 }
 
+// Instructions(1): rte32
+class I_16_RET_I<bits<5> sop, bits<5> pcode, string op, list<dag> pattern>
+    : CSKY32Inst<AddrModeNone, 0x30, (outs), (ins), op, pattern> {
+  let Inst{25 - 21} = sop;
+  let Inst{20 - 16} = pcode;
+  let Inst{15 - 10} = 0x10;
+  let Inst{9 - 5} = 1;
+  let Inst{4 - 0} = 0;
+  let isTerminator = 1;
+  let isReturn = 1;
+  let isBarrier = 1;
+}
+
 // Format< OP[6] | SOP[5] | RX[5] | IMM16[16] >
 // Instructions(3): cmpnei32, cmphsi32, cmplti32
 class I_16_X<bits<5> sop, string op, Operand operand>
     : CSKY32Inst<AddrModeNone, 0x3a, (outs CARRY:$ca),
     (ins GPR:$rx, operand:$imm16), !strconcat(op, "\t$rx, $imm16"), []> {
   bits<16> imm16;
   bits<5> rx;
   let Inst{25 - 21} = sop;

llvm/lib/Target/CSKY/CSKYInstrInfo.td

 //
 //===----------------------------------------------------------------------===//
 
 
 //===----------------------------------------------------------------------===//
 // CSKY specific DAG Nodes.
 //===----------------------------------------------------------------------===//
 
-// TODO: Add CSKY specific DAG Nodes.
+// Target-dependent nodes.
+def CSKY_RET : SDNode<"CSKYISD::RET", SDTNone,
+    [SDNPHasChain, SDNPOptInGlue, SDNPVariadic]>;
 
 //===----------------------------------------------------------------------===//
 // Operand and SDNode transformation definitions.
 //===----------------------------------------------------------------------===//
 class ImmAsmOperand<string prefix, int width, string suffix> : AsmOperandClass {
   let Name = prefix # "Imm" # width # suffix;
   let RenderMethod = "addImmOperands";
   let DiagnosticType = !strconcat("Invalid", Name);
def uimm16_16_xform : Operand<i32>,
   let ParserMatchClass = UImmAsmOperand<16>;
 }
 
 def uimm_shift : Operand<i32>, ImmLeaf<i32, "return isUInt<2>(Imm);"> {
   let EncoderMethod = "getImmShiftOpValue";
   let ParserMatchClass = UImmAsmOperand<2>;
 }
 
+def CSKYSymbol : AsmOperandClass {
+  let Name = "CSKYSymbol";
+  let RenderMethod = "addImmOperands";
+  let DiagnosticType = "InvalidCSKYSymbol";
+  let ParserMethod = "parseCSKYSymbol";
+}
+
+def br_symbol : Operand<iPTR> {
+  let EncoderMethod =
+    "getBranchSymbolOpValue<CSKY::fixup_csky_pcrel_imm16_scale2>";
+  let ParserMatchClass = CSKYSymbol;
+}
+
+def call_symbol : Operand<iPTR> {
+  let ParserMatchClass = CSKYSymbol;
+  let EncoderMethod = "getCallSymbolOpValue";
+}
+
+def Constpool : AsmOperandClass {
+  let Name = "ConstpoolSymbol";
+  let RenderMethod = "addImmOperands";
+  let DiagnosticType = "InvalidConstpool";
+  let ParserMethod = "parseConstpoolSymbol";
+}
+
+def constpool_symbol : Operand<iPTR> {
+  let ParserMatchClass = Constpool;
+  let EncoderMethod =
+    "getConstpoolSymbolOpValue<CSKY::fixup_csky_pcrel_uimm16_scale4>";
+}
+
+def bare_symbol : Operand<iPTR> {
+  let ParserMatchClass = CSKYSymbol;
+  let EncoderMethod = "getBareSymbolOpValue";
+}
 
 def oimm12 : oimm<12>;
 def oimm16 : oimm<16>;
 
 def nimm12 : nimm<12>;
 
 def uimm5 : uimm<5>;
 def uimm12 : uimm<12>;

 def MOVT32 : R_ZX<0x3, 0x2, "movt32", []>;
 def MOVF32 : R_ZX<0x3, 0x1, "movf32", []>;
 def MOV32 : R_XZ<0x12, 0x1, "mov32">;
 def MOVI32 : I_16_MOV<0x10, "movi32", uimm16>;
 def MOVIH32 : I_16_MOV<0x11, "movih32", uimm16_16_xform>;
 
 def MVC32 : R_Z_1<0x1, 0x8, "mvc32">;
 def MVCV32 : R_Z_1<0x1, 0x10, "mvcv32">;
+
+//===----------------------------------------------------------------------===//
+// Branch and call instructions.
+//===----------------------------------------------------------------------===//
+
+let isBranch = 1, isTerminator = 1 in {
+  let isBarrier = 1, isPredicable = 1 in
+    def BR32 : I_16_L<0x0, (outs), (ins br_symbol:$imm16), "br32\t$imm16",
+                     [(br bb:$imm16)]>;
+
+  def BT32 : I_16_L<0x3, (outs), (ins CARRY:$ca, br_symbol:$imm16),
+    "bt32\t$imm16", [(brcond CARRY:$ca, bb:$imm16)]>;
+  def BF32 : I_16_L<0x2, (outs), (ins CARRY:$ca, br_symbol:$imm16),
+    "bf32\t$imm16", []>;
+}
+
+
+def BEZ32 : I_16_X_L<0x8, "bez32", br_symbol>;
+def BNEZ32 : I_16_X_L<0x9, "bnez32", br_symbol>;
+def BHZ32 : I_16_X_L<0xA, "bhz32", br_symbol>;
+def BLSZ32 : I_16_X_L<0xB, "blsz32", br_symbol>;
+def BLZ32 : I_16_X_L<0xC, "blz32", br_symbol>;
+def BHSZ32 : I_16_X_L<0xD, "bhsz32", br_symbol>;
+
+let isBranch = 1, isTerminator = 1, isBarrier = 1, isIndirectBranch = 1 in {
+  def JMP32 : I_16_JX<0x6, "jmp32", [(brind GPR:$rx)]>; // jmp to register
+  def JMPI32 : I_16_L<0x16, (outs), (ins constpool_symbol:$imm16),
+                   "jmpi32\t$imm16", []>;
+}
+
+let isCall = 1, Defs = [ R15 ] in
+  def JSR32 : I_16_JX<0x7, "jsr32", []>;
+
+let isCall = 1, Defs = [ R15 ] , mayLoad = 1 in
+  def JSRI32: I_16_L<0x17, (outs),
+    (ins constpool_symbol:$imm16), "jsri32\t$imm16", []>;
+
+
+def BSR32 : J<0x38, (outs), (ins call_symbol:$offset), "bsr32", []>;
+
+def BSR32_BR : J<0x38, (outs), (ins call_symbol:$offset), "bsr32", []>{
+  let isCodeGenOnly = 1;
+  let isBranch = 1;
+  let isTerminator = 1;
+  let isBarrier = 1;
+  let isPredicable = 1;
+  let Defs = [ R15 ];
+}
+
+def RTS32 : I_16_RET<0x6, 0xF, "rts32", [(CSKY_RET)]>;
+
+
+def RTE32 : I_16_RET_I<0, 0, "rte32", []>;
+
+//===----------------------------------------------------------------------===//
+// Symbol address instructions.
+//===----------------------------------------------------------------------===//
+
+def GRS32 : I_18_Z_L<0x3, "grs32\t$rz, $offset",
+                    (outs GPR:$rz), (ins bare_symbol:$offset), []>;
+
+let mayLoad = 1, mayStore = 0 in {
+def LRW32 : I_16_Z_L<0x14, "lrw32", (ins constpool_symbol:$imm16), []>;
+let isCodeGenOnly = 1 in
+def LRW32_Gen : I_16_Z_L<0x14, "lrw32", (ins bare_symbol:$src1, constpool_symbol:$imm16), []>;
+}
 No newline at end of file

llvm/lib/Target/CSKY/MCTargetDesc/CMakeLists.txt

 add_llvm_component_library(LLVMCSKYDesc
   CSKYAsmBackend.cpp
   CSKYELFObjectWriter.cpp
   CSKYInstPrinter.cpp
   CSKYMCAsmInfo.cpp
+  CSKYMCExpr.cpp
   CSKYMCTargetDesc.cpp
   CSKYMCCodeEmitter.cpp
 
   LINK_COMPONENTS
   CSKYInfo
   MC
   Support
 
   ADD_TO_COMPONENT
   CSKY
 )

llvm/lib/Target/CSKY/MCTargetDesc/CSKYAsmBackend.h

 //===-- CSKYAsmBackend.h - CSKY Assembler Backend -------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_TARGET_CSKY_MCTARGETDESC_CSKYASMBACKEND_H
 #define LLVM_LIB_TARGET_CSKY_MCTARGETDESC_CSKYASMBACKEND_H
 
+#include "MCTargetDesc/CSKYFixupKinds.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCTargetOptions.h"
 
 namespace llvm {
 
 class CSKYAsmBackend : public MCAsmBackend {
 
 public:
   CSKYAsmBackend(const MCSubtargetInfo &STI, const MCTargetOptions &OP)
       : MCAsmBackend(support::little) {}
 
-  unsigned int getNumFixupKinds() const override;
+  unsigned int getNumFixupKinds() const override {
+    return CSKY::NumTargetFixupKinds;
+  }
+
   void applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
                   const MCValue &Target, MutableArrayRef<char> Data,
                   uint64_t Value, bool IsResolved,
                   const MCSubtargetInfo *STI) const override;
+
+  const MCFixupKindInfo &getFixupKindInfo(MCFixupKind Kind) const override;
+
   bool fixupNeedsRelaxation(const MCFixup &Fixup, uint64_t Value,
                             const MCRelaxableFragment *DF,
                             const MCAsmLayout &Layout) const override;
+
   void relaxInstruction(MCInst &Inst,
                         const MCSubtargetInfo &STI) const override;
+
   bool writeNopData(raw_ostream &OS, uint64_t Count) const override;
+
   std::unique_ptr<MCObjectTargetWriter>
   createObjectTargetWriter() const override;
 };
 } // namespace llvm
 
 #endif // LLVM_LIB_TARGET_CSKY_MCTARGETDESC_CSKYASMBACKEND_H

llvm/lib/Target/CSKY/MCTargetDesc/CSKYAsmBackend.cpp

 //===-- CSKYAsmBackend.cpp - CSKY Assembler Backend -----------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "CSKYAsmBackend.h"
 #include "MCTargetDesc/CSKYMCTargetDesc.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/MC/MCAsmLayout.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCFixupKindInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "csky-asmbackend"
 
 using namespace llvm;
 
 std::unique_ptr<MCObjectTargetWriter>
 CSKYAsmBackend::createObjectTargetWriter() const {
   return createCSKYELFObjectWriter();
 }
 
-unsigned int CSKYAsmBackend::getNumFixupKinds() const { return 1; }
+const MCFixupKindInfo &
+CSKYAsmBackend::getFixupKindInfo(MCFixupKind Kind) const {
+
+  static llvm::DenseMap<unsigned, MCFixupKindInfo> Infos = {
+      {CSKY::Fixups::fixup_csky_addr32, {"fixup_csky_addr32", 0, 32, 0}},
+      {CSKY::Fixups::fixup_csky_pcrel_imm16_scale2,
+       {"fixup_csky_pcrel_imm16_scale2", 0, 32, MCFixupKindInfo::FKF_IsPCRel}},
+      {CSKY::Fixups::fixup_csky_pcrel_uimm16_scale4,
+       {"fixup_csky_pcrel_uimm16_scale4", 0, 32, MCFixupKindInfo::FKF_IsPCRel}},
+      {CSKY::Fixups::fixup_csky_pcrel_imm26_scale2,
+       {"fixup_csky_pcrel_imm26_scale2", 0, 32, MCFixupKindInfo::FKF_IsPCRel}},
+      {CSKY::Fixups::fixup_csky_pcrel_imm18_scale2,
+       {"fixup_csky_pcrel_imm18_scale2", 0, 32, MCFixupKindInfo::FKF_IsPCRel}}};
+  assert(Infos.size() == CSKY::NumTargetFixupKinds &&
+         "Not all fixup kinds added to Infos array");
+
+  assert(unsigned(Kind - FirstTargetFixupKind) < getNumFixupKinds() &&
+         "Invalid kind!");
+  if (FirstTargetFixupKind <= Kind && Kind < FirstLiteralRelocationKind)
+    return Infos[Kind];
+  else if (Kind < FirstTargetFixupKind)
+    return MCAsmBackend::getFixupKindInfo(Kind);
+  else
+    return MCAsmBackend::getFixupKindInfo(FK_NONE);
+}
+
+static uint64_t adjustFixupValue(const MCFixup &Fixup, uint64_t Value,
+                                 MCContext &Ctx) {
+  switch (Fixup.getTargetKind()) {
+  default:
+    llvm_unreachable("Unknown fixup kind!");
+  case FK_Data_1:
+  case FK_Data_2:
+  case FK_Data_4:
+  case FK_Data_8:
+    return Value;
+  case CSKY::fixup_csky_addr32:
+    return Value & 0xffffffff;
+  case CSKY::fixup_csky_pcrel_imm16_scale2:
+    if (!isIntN(17, Value))
+      Ctx.reportError(Fixup.getLoc(), "out of range pc-relative fixup value.");
+    if (Value & 0x1)
+      Ctx.reportError(Fixup.getLoc(), "fixup value must be 2-byte aligned.");
+
+    return (Value >> 1) & 0xffff;
+  case CSKY::fixup_csky_pcrel_uimm16_scale4:
+    if (!isUIntN(18, Value))
+      Ctx.reportError(Fixup.getLoc(), "out of range pc-relative fixup value.");
+    if (Value & 0x3)
+      Ctx.reportError(Fixup.getLoc(), "fixup value must be 4-byte aligned.");
+
+    return (Value >> 2) & 0xffff;
+  case CSKY::fixup_csky_pcrel_imm26_scale2:
+    if (!isIntN(27, Value))
+      Ctx.reportError(Fixup.getLoc(), "out of range pc-relative fixup value.");
+    if (Value & 0x1)
+      Ctx.reportError(Fixup.getLoc(), "fixup value must be 2-byte aligned.");
+
+    return (Value >> 1) & 0x3ffffff;
+  case CSKY::fixup_csky_pcrel_imm18_scale2:
+    if (!isIntN(19, Value))
+      Ctx.reportError(Fixup.getLoc(), "out of range pc-relative fixup value.");
+    if (Value & 0x1)
+      Ctx.reportError(Fixup.getLoc(), "fixup value must be 2-byte aligned.");
+
+    return (Value >> 1) & 0x3ffff;
+  }
+}
 
 void CSKYAsmBackend::applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
                                 const MCValue &Target,
                                 MutableArrayRef<char> Data, uint64_t Value,
                                 bool IsResolved,
                                 const MCSubtargetInfo *STI) const {
+  MCFixupKind Kind = Fixup.getKind();
+  if (Kind >= FirstLiteralRelocationKind)
     return;
+  MCContext &Ctx = Asm.getContext();
+  MCFixupKindInfo Info = getFixupKindInfo(Kind);
+  if (!Value)
+    return; // Doesn't change encoding.
+  // Apply any target-specific value adjustments.
+  Value = adjustFixupValue(Fixup, Value, Ctx);
+
+  // Shift the value into position.
+  Value <<= Info.TargetOffset;
+
+  unsigned Offset = Fixup.getOffset();
+  unsigned NumBytes = alignTo(Info.TargetSize + Info.TargetOffset, 8) / 8;
+
+  assert(Offset + NumBytes <= Data.size() && "Invalid fixup offset!");
+
+  // For each byte of the fragment that the fixup touches, mask in the
+  // bits from the fixup value.
+  bool IsLittleEndian = (Endian == support::little);
+
+  if (IsLittleEndian && (NumBytes == 4)) {
+    Data[Offset + 0] |= uint8_t((Value >> 16) & 0xff);
+    Data[Offset + 1] |= uint8_t((Value >> 24) & 0xff);
+    Data[Offset + 2] |= uint8_t(Value & 0xff);
+    Data[Offset + 3] |= uint8_t((Value >> 8) & 0xff);
+  } else {
+    for (unsigned I = 0; I != NumBytes; I++) {
+      unsigned Idx = IsLittleEndian ? I : (NumBytes - 1 - I);
+      Data[Offset + Idx] |= uint8_t((Value >> (I * 8)) & 0xff);
+    }
+  }
 }
 
 bool CSKYAsmBackend::fixupNeedsRelaxation(const MCFixup &Fixup, uint64_t Value,
                                           const MCRelaxableFragment *DF,
                                           const MCAsmLayout &Layout) const {
   return false;
 }
 

llvm/lib/Target/CSKY/MCTargetDesc/CSKYFixupKinds.h

+//===-- CSKYFixupKinds.h - CSKY Specific Fixup Entries ----------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_TARGET_CSKY_MCTARGETDESC_CSKYFIXUPKINDS_H
+#define LLVM_LIB_TARGET_CSKY_MCTARGETDESC_CSKYFIXUPKINDS_H
+
+#include "llvm/MC/MCFixup.h"
+
+namespace llvm {
+namespace CSKY {
+enum Fixups {
+  fixup_csky_addr32 = FirstTargetFixupKind,
+
+  fixup_csky_pcrel_imm16_scale2,
+
+  fixup_csky_pcrel_uimm16_scale4,
+
+  fixup_csky_pcrel_imm26_scale2,
+
+  fixup_csky_pcrel_imm18_scale2,
+
+  // Marker
+  fixup_csky_invalid,
+  NumTargetFixupKinds = fixup_csky_invalid - FirstTargetFixupKind
+};
+} // end namespace CSKY
+} // end namespace llvm
+
+#endif // LLVM_LIB_TARGET_CSKY_MCTARGETDESC_CSKYFIXUPKINDS_H

llvm/lib/Target/CSKY/MCTargetDesc/CSKYMCCodeEmitter.h

 //===-- CSKYMCCodeEmitter.cpp - CSKY Code Emitter interface ---------------===//
 //
 // 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 implements the CSKYMCCodeEmitter class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_TARGET_CSKY_MCTARGETDESC_CSKYMCCODEEMITTER_H
 #define LLVM_LIB_TARGET_CSKY_MCTARGETDESC_CSKYMCCODEEMITTER_H
 
+#include "CSKYMCExpr.h"
+#include "MCTargetDesc/CSKYFixupKinds.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 
 namespace llvm {
 
 class CSKYMCCodeEmitter : public MCCodeEmitter {
   MCContext &Ctx;
   const MCInstrInfo &MII;
public:
 
   unsigned getImmShiftOpValue(const MCInst &MI, unsigned Idx,
                               SmallVectorImpl<MCFixup> &Fixups,
                               const MCSubtargetInfo &STI) const {
     const MCOperand &MO = MI.getOperand(Idx);
     assert(MO.isImm() && "Unexpected MO type.");
     return 1 << MO.getImm();
   }
+
+  MCFixupKind getTargetFixup(const MCExpr *Expr) const;
+
+  template <llvm::CSKY::Fixups FIXUP>
+  unsigned getBranchSymbolOpValue(const MCInst &MI, unsigned Idx,
+                                  SmallVectorImpl<MCFixup> &Fixups,
+                                  const MCSubtargetInfo &STI) const {
+    const MCOperand &MO = MI.getOperand(Idx);
+
+    if (MO.isImm())
+      return MO.getImm() >> 1;
+
+    assert(MO.isExpr() && "Unexpected MO type.");
+
+    MCFixupKind Kind = MCFixupKind(FIXUP);
+    if (MO.getExpr()->getKind() == MCExpr::Target)
+      Kind = getTargetFixup(MO.getExpr());
+
+    Fixups.push_back(MCFixup::create(0, MO.getExpr(), Kind, MI.getLoc()));
+    return 0;
+  }
+
+  template <llvm::CSKY::Fixups FIXUP>
+  unsigned getConstpoolSymbolOpValue(const MCInst &MI, unsigned Idx,
+                                     SmallVectorImpl<MCFixup> &Fixups,
+                                     const MCSubtargetInfo &STI) const {
+    const MCOperand &MO = MI.getOperand(Idx);
+    assert(MO.isExpr() && "Unexpected MO type.");
+
+    MCFixupKind Kind = MCFixupKind(FIXUP);
+    if (MO.getExpr()->getKind() == MCExpr::Target)
+      Kind = getTargetFixup(MO.getExpr());
+
+    Fixups.push_back(MCFixup::create(0, MO.getExpr(), Kind, MI.getLoc()));
+    return 0;
+  }
+
+  unsigned getCallSymbolOpValue(const MCInst &MI, unsigned Idx,
+                                SmallVectorImpl<MCFixup> &Fixups,
+                                const MCSubtargetInfo &STI) const {
+    const MCOperand &MO = MI.getOperand(Idx);
+    assert(MO.isExpr() && "Unexpected MO type.");
+
+    MCFixupKind Kind = MCFixupKind(CSKY::fixup_csky_pcrel_imm26_scale2);
+    if (MO.getExpr()->getKind() == MCExpr::Target)
+      Kind = getTargetFixup(MO.getExpr());
+
+    Fixups.push_back(MCFixup::create(0, MO.getExpr(), Kind, MI.getLoc()));
+    return 0;
+  }
+
+  unsigned getBareSymbolOpValue(const MCInst &MI, unsigned Idx,
+                                SmallVectorImpl<MCFixup> &Fixups,
+                                const MCSubtargetInfo &STI) const {
+    const MCOperand &MO = MI.getOperand(Idx);
+    assert(MO.isExpr() && "Unexpected MO type.");
+
+    MCFixupKind Kind = MCFixupKind(CSKY::fixup_csky_pcrel_imm18_scale2);
+    if (MO.getExpr()->getKind() == MCExpr::Target)
+      Kind = getTargetFixup(MO.getExpr());
+
+    Fixups.push_back(MCFixup::create(0, MO.getExpr(), Kind, MI.getLoc()));
+    return 0;
+  }
 };
 
 } // namespace llvm
 
 #endif // LLVM_LIB_TARGET_CSKY_MCTARGETDESC_CSKYMCCODEEMITTER_H

llvm/lib/Target/CSKY/MCTargetDesc/CSKYMCCodeEmitter.cpp

CSKYMCCodeEmitter::getMachineOpValue(const MCInst &MI, const MCOperand &MO,
 
   if (MO.isImm())
     return static_cast<unsigned>(MO.getImm());
 
   llvm_unreachable("Unhandled expression!");
   return 0;
 }
 
+MCFixupKind CSKYMCCodeEmitter::getTargetFixup(const MCExpr *Expr) const {
+  const CSKYMCExpr *CSKYExpr = cast<CSKYMCExpr>(Expr);
+
+  switch (CSKYExpr->getKind()) {
+  default:
+    llvm_unreachable("Unhandled fixup kind!");
+  case CSKYMCExpr::VK_CSKY_ADDR:
+    return MCFixupKind(CSKY::fixup_csky_addr32);
+  }
+}
+
 MCCodeEmitter *llvm::createCSKYMCCodeEmitter(const MCInstrInfo &MCII,
                                              const MCRegisterInfo &MRI,
                                              MCContext &Ctx) {
   return new CSKYMCCodeEmitter(Ctx, MCII);
 }
 
 #include "CSKYGenMCCodeEmitter.inc"

llvm/lib/Target/CSKY/MCTargetDesc/CSKYMCExpr.h

+//===-- CSKYMCExpr.h - CSKY specific MC expression classes -*- C++ -*----===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_TARGET_LANAI_MCTARGETDESC_LANAIMCEXPR_H
+#define LLVM_LIB_TARGET_LANAI_MCTARGETDESC_LANAIMCEXPR_H
+
+#include "llvm/MC/MCExpr.h"
+#include "llvm/MC/MCValue.h"
+
+namespace llvm {
+
+class CSKYMCExpr : public MCTargetExpr {
+public:
+  enum VariantKind {
+    VK_CSKY_None,
+    VK_CSKY_ADDR,
+    VK_CSKY_PCREL,
+    VK_CSKY_GOT,
+    VK_CSKY_GOTPC,
+    VK_CSKY_GOTOFF,
+    VK_CSKY_PLT,
+    VK_CSKY_TPOFF,
+    VK_CSKY_TLSGD,
+    VK_CSKY_Invalid
+  };
+
+private:
+  const VariantKind Kind;
+  const MCExpr *Expr;
+
+  explicit CSKYMCExpr(VariantKind Kind, const MCExpr *Expr)
+      : Kind(Kind), Expr(Expr) {}
+
+public:
+  static const CSKYMCExpr *create(const MCExpr *Expr, VariantKind Kind,
+                                  MCContext &Ctx);
+
+  // Returns the kind of this expression.
+  VariantKind getKind() const { return Kind; }
+
+  // Returns the child of this expression.
+  const MCExpr *getSubExpr() const { return Expr; }
+
+  void printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const override;
+
+  bool evaluateAsRelocatableImpl(MCValue &Res, const MCAsmLayout *Layout,
+                                 const MCFixup *Fixup) const override;
+  void visitUsedExpr(MCStreamer &Streamer) const override;
+
+  MCFragment *findAssociatedFragment() const override {
+    return getSubExpr()->findAssociatedFragment();
+  }
+
+  void fixELFSymbolsInTLSFixups(MCAssembler &Asm) const override;
+
+  static bool classof(const MCExpr *E) {
+    return E->getKind() == MCExpr::Target;
+  }
+
+  static StringRef getVariantKindName(VariantKind Kind);
+};
+} // end namespace llvm
+
+#endif

llvm/lib/Target/CSKY/MCTargetDesc/CSKYMCExpr.cpp

+//===-- CSKYMCExpr.cpp - CSKY specific MC expression classes -*- C++ -*----===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "CSKYMCExpr.h"
+#include "CSKYFixupKinds.h"
+#include "llvm/MC/MCAssembler.h"
+#include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCSymbolELF.h"
+
+using namespace llvm;
+
+#define DEBUG_TYPE "csky-mc-expr"
+
+const CSKYMCExpr *CSKYMCExpr::create(const MCExpr *Expr, VariantKind Kind,
+                                     MCContext &Ctx) {
+  return new (Ctx) CSKYMCExpr(Kind, Expr);
+}
+
+StringRef CSKYMCExpr::getVariantKindName(VariantKind Kind) {
+  switch (Kind) {
+  default:
+    llvm_unreachable("Invalid ELF symbol kind");
+  case VK_CSKY_ADDR:
+    return "";
+  case VK_CSKY_PCREL:
+    return "";
+  case VK_CSKY_GOT:
+    return "@GOT";
+  case VK_CSKY_GOTPC:
+    return "@GOTPC";
+  case VK_CSKY_GOTOFF:
+    return "@GOTOFF";
+  case VK_CSKY_PLT:
+    return "@PLT";
+  case VK_CSKY_TPOFF:
+    return "@TPOFF";
+  case VK_CSKY_TLSGD:
+    return "@TLSGD";
+  }
+}
+
+void CSKYMCExpr::visitUsedExpr(MCStreamer &Streamer) const {
+  Streamer.visitUsedExpr(*getSubExpr());
+}
+
+void CSKYMCExpr::printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const {
+  Expr->print(OS, MAI);
+  OS << getVariantKindName(getKind());
+}
+
+static void fixELFSymbolsInTLSFixupsImpl(const MCExpr *Expr, MCAssembler &Asm) {
+  switch (Expr->getKind()) {
+  case MCExpr::Target:
+    llvm_unreachable("Can't handle nested target expression");
+    break;
+  case MCExpr::Constant:
+    break;
+
+  case MCExpr::Binary: {
+    const MCBinaryExpr *BE = cast<MCBinaryExpr>(Expr);
+    fixELFSymbolsInTLSFixupsImpl(BE->getLHS(), Asm);
+    fixELFSymbolsInTLSFixupsImpl(BE->getRHS(), Asm);
+    break;
+  }
+
+  case MCExpr::SymbolRef: {
+    // We're known to be under a TLS fixup, so any symbol should be
+    // modified. There should be only one.
+    const MCSymbolRefExpr &SymRef = *cast<MCSymbolRefExpr>(Expr);
+    cast<MCSymbolELF>(SymRef.getSymbol()).setType(ELF::STT_TLS);
+    break;
+  }
+
+  case MCExpr::Unary:
+    fixELFSymbolsInTLSFixupsImpl(cast<MCUnaryExpr>(Expr)->getSubExpr(), Asm);
+    break;
+  }
+}
+
+void CSKYMCExpr::fixELFSymbolsInTLSFixups(MCAssembler &Asm) const {
+  switch (getKind()) {
+  default:
+    return;
+  case VK_CSKY_TPOFF:
+  case VK_CSKY_TLSGD:
+    break;
+  }
+
+  fixELFSymbolsInTLSFixupsImpl(getSubExpr(), Asm);
+}
+
+bool CSKYMCExpr::evaluateAsRelocatableImpl(MCValue &Res,
+                                           const MCAsmLayout *Layout,
+                                           const MCFixup *Fixup) const {
+  if (!getSubExpr()->evaluateAsRelocatable(Res, Layout, Fixup))
+    return false;
+
+  // Some custom fixup types are not valid with symbol difference expressions
+  if (Res.getSymA() && Res.getSymB()) {
+    switch (getKind()) {
+    default:
+      return true;
+
+    case VK_CSKY_ADDR:
+    case VK_CSKY_PCREL:
+    case VK_CSKY_GOT:
+    case VK_CSKY_GOTPC:
+    case VK_CSKY_GOTOFF:
+    case VK_CSKY_TPOFF:
+    case VK_CSKY_TLSGD:
+      return false;
+    }
+  }
+
+  return true;
+}
 No newline at end of file

llvm/test/MC/CSKY/basic.s

 # CHECK-ASM: zext32 a3, l0, 7, 0
 # CHECK-ASM: encoding: [0x04,0xc4,0xe3,0x54]
 zext32 a3, l0, 7, 0
 
 # CHECK-ASM: sext32 a3, l0, 7, 0
 # CHECK-ASM: encoding: [0x04,0xc4,0xe3,0x58]
 sext32 a3, l0, 7, 0
 
+# CHECK-ASM: br32 .L.test
+# CHECK-ASM: encoding: [A,0xe8'A',A,A]
+# CHECK-ASM: fixup A - offset: 0, value: .L.test, kind: fixup_csky_pcrel_imm16_scale2
+.L.test:
+br32 .L.test
+
+# CHECK-ASM: bt32 .L.test2
+# CHECK-ASM: encoding: [0x60'A',0xe8'A',A,A]
+# CHECK-ASM: fixup A - offset: 0, value: .L.test2, kind: fixup_csky_pcrel_imm16_scale2
+.L.test2:
+bt32 .L.test2
+
+# CHECK-ASM: bf32 .L.test3
+# CHECK-ASM: encoding: [0x40'A',0xe8'A',A,A]
+# CHECK-ASM: fixup A - offset: 0, value: .L.test3, kind: fixup_csky_pcrel_imm16_scale2
+.L.test3:
+bf32 .L.test3
+
+# CHECK-ASM: bez32 a0, .L.test4
+# CHECK-ASM: encoding: [A,0xe9'A',A,A]
+# CHECK-ASM: fixup A - offset: 0, value: .L.test4, kind: fixup_csky_pcrel_imm16_scale2
+.L.test4:
+bez32 a0, .L.test4
+
+# CHECK-ASM: bnez32 a0, .L.test5
+# CHECK-ASM: encoding: [0x20'A',0xe9'A',A,A]
+# CHECK-ASM: fixup A - offset: 0, value: .L.test5, kind: fixup_csky_pcrel_imm16_scale2
+.L.test5:
+bnez32 a0, .L.test5
+
+# CHECK-ASM: bhz32 a0, .L.test6
+# CHECK-ASM: encoding: [0x40'A',0xe9'A',A,A]
+# CHECK-ASM: fixup A - offset: 0, value: .L.test6, kind: fixup_csky_pcrel_imm16_scale2
+.L.test6:
+bhz32 a0, .L.test6
+
+# CHECK-ASM: blsz32 a0, .L.test7
+# CHECK-ASM: encoding: [0x60'A',0xe9'A',A,A]
+# CHECK-ASM: fixup A - offset: 0, value: .L.test7, kind: fixup_csky_pcrel_imm16_scale2
+.L.test7:
+blsz32 a0, .L.test7
+
+# CHECK-ASM: blz32 a0, .L.test8
+# CHECK-ASM: encoding: [0x80'A',0xe9'A',A,A]
+# CHECK-ASM: fixup A - offset: 0, value: .L.test8, kind: fixup_csky_pcrel_imm16_scale2
+.L.test8:
+blz32 a0, .L.test8
+
+# CHECK-ASM: bhsz32 a0, .L.test9
+# CHECK-ASM: encoding: [0xa0'A',0xe9'A',A,A]
+# CHECK-ASM: fixup A - offset: 0, value: .L.test9, kind: fixup_csky_pcrel_imm16_scale2
+.L.test9:
+bhsz32 a0, .L.test9
+
+# CHECK-ASM: jmp32 a3
+# CHECK-ASM: encoding: [0xc3,0xe8,0x00,0x00]
+jmp32 a3
+
+# CHECK-ASM: jmpi32 .L.test10
+# CHECK-ASM: encoding: [0xc0'A',0xea'A',A,A]
+# CHECK-ASM: fixup A - offset: 0, value: .L.test10, kind: fixup_csky_pcrel_uimm16_scale4
+.L.test10:
+jmpi32 [.L.test10]
+
+# CHECK-ASM: bsr32 .L.test11
+# CHECK-ASM: encoding: [A,0xe0'A',A,A]
+# CHECK-ASM: fixup A - offset: 0, value: .L.test11, kind: fixup_csky_pcrel_imm26_scale2
+.L.test11:
+bsr32 .L.test11
+
+# CHECK-ASM: jsr32 a3
+# CHECK-ASM: encoding: [0xe3,0xe8,0x00,0x00]
+jsr32 a3
+
+# CHECK-ASM: jsri32 .L.test12
+# CHECK-ASM: encoding: [0xe0'A',0xea'A',A,A]
+# CHECK-ASM: fixup A - offset: 0, value: .L.test12, kind: fixup_csky_pcrel_uimm16_scale4
+.L.test12:
+jsri32 [.L.test12]
+
+# CHECK-ASM: rts32
+# CHECK-ASM: encoding: [0xcf,0xe8,0x00,0x00]
+rts32
+
+# CHECK-ASM: grs32 a0, .L.test13
+# CHECK-ASM: encoding: [0x0c'A',0xcc'A',A,A]
+# CHECK-ASM: fixup A - offset: 0, value: .L.test13, kind: fixup_csky_pcrel_imm18_scale2
+.L.test13:
+grs32 a0, .L.test13
+
+# CHECK-ASM: lrw32 a0, .L.test14
+# CHECK-ASM: encoding: [0x80'A',0xea'A',A,A]
+# CHECK-ASM: fixup A - offset: 0, value: .L.test14, kind: fixup_csky_pcrel_uimm16_scale4
+.L.test14:
+lrw32 a0, [.L.test14]
+
 # RUN: not llvm-mc -triple csky --defsym=ERR=1 < %s 2>&1 | FileCheck %s
 
 .ifdef ERR
 
 # uimm12/oimm12/nimm12
 addi32 a0, a0, 0 # CHECK: :[[#@LINE]]:16: error: immediate must be an integer in the range [1, 4096]
 subi32 a0, a0, 4097 # CHECK: :[[#@LINE]]:16: error: immediate must be an integer in the range [1, 4096]
 andi32 a0, a0, 4096 # CHECK: :[[#@LINE]]:16: error: immediate must be an integer in the range [0, 4095]

 
 # Too many operands
 subi32 t2, t3, 0x50, 0x60 # CHECK: :[[@LINE]]:22: error: invalid operand for instruction
 
 # Too few operands
 xori32 a0, a1 # CHECK: :[[#@LINE]]:1: error: too few operands for instruction
 xor32 a0, a2 # CHECK: :[[#@LINE]]:1: error: too few operands for instruction
 
+# Need label
+br32 0x100 # CHECK: :[[@LINE]]:6: error: operand must be a symbol name
+jmpi32 0x100 # CHECK: :[[@LINE]]:8: error: operand must be a constpool symbol name
+bsr32 0x100 # CHECK: :[[@LINE]]:7: error: operand must be a symbol name
+
 .endif

llvm/test/MC/CSKY/csky-error.s

+# RUN: not llvm-mc -triple=csky %s -filetype=obj -o %t.o 2>&1 | FileCheck %s
+
+# Out of PC range
+
+# br/bt/bf
+
+.L.test1:
+.space 0x10001
+br32 .L.test1 # CHECK: :[[@LINE]]:1: error: out of range pc-relative fixup value
+              # CHECK: :[[@LINE-1]]:1: error: fixup value must be 2-byte aligned
+
+br32 .L.test2 # CHECK: :[[@LINE]]:1: error: out of range pc-relative fixup value
+              # CHECK: :[[@LINE-1]]:1: error: fixup value must be 2-byte aligned
+.space 0x10001
+.L.test2:
+
+.L.test3:
+.space 0xFFFF
+br32 .L.test3 # CHECK: :[[@LINE]]:1: error: fixup value must be 2-byte aligned
+
+.L.test4:
+.space 0x10002
+br32 .L.test4 # CHECK: :[[@LINE]]:1: error: out of range pc-relative fixup value
+
+# bsr
+.L.test5:
+.space 0x4000001
+bsr32 .L.test5 # CHECK: :[[@LINE]]:1: error: out of range pc-relative fixup value
+               # CHECK: :[[@LINE-1]]:1: error: fixup value must be 2-byte aligned
+
+bsr32 .L.test6 # CHECK: :[[@LINE]]:1: error: out of range pc-relative fixup value
+               # CHECK: :[[@LINE-1]]:1: error: fixup value must be 2-byte aligned
+.space 0x4000001
+.L.test6:
+
+.L.test7:
+.space 0x3FFFFFF
+bsr32 .L.test7 # CHECK: :[[@LINE]]:1: error: fixup value must be 2-byte aligned
+
+.L.test8:
+.space 0x4000002
+bsr32 .L.test8 # CHECK: :[[@LINE]]:1: error: out of range pc-relative fixup value
+
+# grs
+.L.test9:
+.space 0x40001
+grs32 a0, .L.test9 # CHECK: :[[@LINE]]:1: error: out of range pc-relative fixup value
+                   # CHECK: :[[@LINE-1]]:1: error: fixup value must be 2-byte aligned
+
+grs32 a0, .L.test10 # CHECK: :[[@LINE]]:1: error: out of range pc-relative fixup value
+                    # CHECK: :[[@LINE-1]]:1: error: fixup value must be 2-byte aligned
+.space 0x40001
+.L.test10:
+
+.L.test11:
+.space 0x3FFFF
+grs32 a0, .L.test11 # CHECK: :[[@LINE]]:1: error: fixup value must be 2-byte aligned
+
+.L.test12:
+.space 0x40002
+grs32 a0, .L.test12 # CHECK: :[[@LINE]]:1: error: out of range pc-relative fixup value
+
+
+# TODO: Fixup
+lrw32 a0, [.L.test15] # CHECK: :[[@LINE]]:1: error: out of range pc-relative fixup value
+                    # CHECK: :[[@LINE-1]]:1: error: fixup value must be 4-byte aligned
+.space 0x40001
+.L.test15:
+
+# TODO: Fixup
+jsri32 [.L.test16]     # CHECK: :[[@LINE]]:1: error: out of range pc-relative fixup value
+                     # CHECK: :[[@LINE-1]]:1: error: fixup value must be 4-byte aligned
+.space 0x40001
+.L.test16:
+
+# TODO: Fixup
+jmpi32 [.L.test17]     # CHECK: :[[@LINE]]:1: error: out of range pc-relative fixup value
+                     # CHECK: :[[@LINE-1]]:1: error: fixup value must be 4-byte aligned
+.space 0x40001
+.L.test17: