Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "TargetRegistry", "::", "RegisterMCInstPrinter", "(", "TheARM64Target", ",", "createAArch64MCInstPrinter", ")", ";" ]

[ "void", "LLVMInitializeAArch64TargetMC", "(", ")", "{", "RegisterMCAsmInfoFn", "X", "(", "TheAArch64leTarget", ",", "createAArch64MCAsmInfo", ")", ";", "RegisterMCAsmInfoFn", "Y", "(", "TheAArch64beTarget", ",", "createAArch64MCAsmInfo", ")", ";", "RegisterMCAsmInfoFn", "Z", "(", "TheARM64Target", ",", "createAArch64MCAsmInfo", ")", ";", "TargetRegistry", "::", "RegisterMCCodeGenInfo", "(", "TheAArch64leTarget", ",", "createAArch64MCCodeGenInfo", ")", ";", "TargetRegistry", "::", "RegisterMCCodeGenInfo", "(", "TheAArch64beTarget", ",", "createAArch64MCCodeGenInfo", ")", ";", "TargetRegistry", "::", "RegisterMCCodeGenInfo", "(", "TheARM64Target", ",", "createAArch64MCCodeGenInfo", ")", ";", "TargetRegistry", "::", "RegisterMCInstrInfo", "(", "TheAArch64leTarget", ",", "createAArch64MCInstrInfo", ")", ";", "TargetRegistry", "::", "RegisterMCInstrInfo", "(", "TheAArch64beTarget", ",", "createAArch64MCInstrInfo", ")", ";", "TargetRegistry", "::", "RegisterMCInstrInfo", "(", "TheARM64Target", ",", "createAArch64MCInstrInfo", ")", ";", "TargetRegistry", "::", "RegisterMCRegInfo", "(", "TheAArch64leTarget", ",", "createAArch64MCRegisterInfo", ")", ";", "TargetRegistry", "::", "RegisterMCRegInfo", "(", "TheAArch64beTarget", ",", "createAArch64MCRegisterInfo", ")", ";", "TargetRegistry", "::", "RegisterMCRegInfo", "(", "TheARM64Target", ",", "createAArch64MCRegisterInfo", ")", ";", "TargetRegistry", "::", "RegisterMCSubtargetInfo", "(", "TheAArch64leTarget", ",", "createAArch64MCSubtargetInfo", ")", ";", "TargetRegistry", "::", "RegisterMCSubtargetInfo", "(", "TheAArch64beTarget", ",", "createAArch64MCSubtargetInfo", ")", ";", "TargetRegistry", "::", "RegisterMCSubtargetInfo", "(", "TheARM64Target", ",", "createAArch64MCSubtargetInfo", ")", ";", "TargetRegistry", "::", "RegisterMCAsmBackend", "(", "TheAArch64leTarget", ",", "createAArch64leAsmBackend", ")", ";", "TargetRegistry", "::", "RegisterMCAsmBackend", "(", "TheAArch64beTarget", ",", "createAArch64beAsmBackend", ")", ";", "TargetRegistry", "::", "RegisterMCAsmBackend", "(", "TheARM64Target", ",", "createAArch64leAsmBackend", ")", ";", "TargetRegistry", "::", "RegisterMCCodeEmitter", "(", "TheAArch64leTarget", ",", "createAArch64MCCodeEmitter", ")", ";", "TargetRegistry", "::", "RegisterMCCodeEmitter", "(", "TheAArch64beTarget", ",", "createAArch64MCCodeEmitter", ")", ";", "TargetRegistry", "::", "RegisterMCCodeEmitter", "(", "TheARM64Target", ",", "createAArch64MCCodeEmitter", ")", ";", "TargetRegistry", "::", "RegisterMCObjectStreamer", "(", "TheAArch64leTarget", ",", "createMCStreamer", ")", ";", "TargetRegistry", "::", "RegisterMCObjectStreamer", "(", "TheAArch64beTarget", ",", "createMCStreamer", ")", ";", "TargetRegistry", "::", "RegisterMCObjectStreamer", "(", "TheARM64Target", ",", "createMCStreamer", ")", ";", "TargetRegistry", "::", "RegisterMCInstPrinter", "(", "TheAArch64leTarget", ",", "createAArch64MCInstPrinter", ")", ";", "TargetRegistry", "::", "RegisterMCInstPrinter", "(", "TheAArch64beTarget", ",", "createAArch64MCInstPrinter", ")", ";" ]

[ "<FIXS>", "mmemvec", "-", "cost", "=", "Target", "RejectNegative", "Joined", "UInteger", "Var", "(", "loongarch_vector_access_cost", ")", "IntegerRange", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "mmemvec", "-", "cost", "=", "COST", "Set", "the", "cost", "of", "vector", "memory", "access", "instructions", ".", "<FIXE>" ]

[ "(", "include", "<STR_LIT>", ")", "(", "include", "<STR_LIT>", ")", "(", "define_c_enum", "<STR_LIT>", "[", "UNSPEC_ADDRESS_FIRST", "]", ")", "@", "@", "-", "<NUM_LIT>", ",", "<NUM_LIT>", "+", "<NUM_LIT>", ",", "<NUM_LIT>", "@", "@", "mbranch", "-", "cost", "=", "Target", "RejectNegative", "Joined", "UInteger", "Var", "(", "loongarch_branch_cost", ")", "<BUGS>", "mbranch", "-", "cost", "=", "COST", "\t", "Set", "the", "cost", "of", "branches", "to", "roughly", "COST", "instructions", ".", "<BUGE>", "mcheck", "-", "zero", "-", "divisionTarget", "Mask", "(", "CHECK_ZERO_DIV", ")", "Trap", "on", "integer", "divide", "by", "zero", ".", "new", "file", "mode", "<NUM_LIT>" ]

[ ",", "IsBranch", ",", "Offset", ",", "Width", ")", ";" ]

[ "static", "bool", "tryAddingSymbolicOperand", "(", "int64_t", "Value", ",", "bool", "IsBranch", ",", "uint64_t", "Address", ",", "uint64_t", "Offset", ",", "uint64_t", "Width", ",", "MCInst", "&", "MI", ",", "const", "void", "*", "Decoder", ")", "{", "const", "MCDisassembler", "*", "Dis", "=", "static_cast", "<", "const", "MCDisassembler", "*", ">", "(", "Decoder", ")", ";", "return", "Dis", "->", "tryAddingSymbolicOperand", "(", "MI", ",", "Value", ",", "Address" ]

[ "<STR_LIT>", ")", ";" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "Size", "=", "<NUM_LIT>", ";", "Pad", "=", "<NUM_LIT>", ";", "FixOffset", "=", "ThisByte", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "Size", "=", "<NUM_LIT>", ";", "Pad", "=", "<NUM_LIT>", ";", "FixOffset", "=", "ThisByte", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "Size", "=", "<NUM_LIT>", ";", "Pad", "=", "<NUM_LIT>", ";", "FixOffset", "=", "ThisByte", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "Size", "=", "<NUM_LIT>", ";", "Pad", "=", "<NUM_LIT>", ";", "NoExpr", "=", "true", ";", "break", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "\\tEncodeImm", "<STR_LIT>", "<<", "<STR_LIT>", " Op: ", "<STR_LIT>", "<<", "Op", "<<", "<STR_LIT>", ", Size: ", "<STR_LIT>", "<<", "Size", "<<", "<STR_LIT>", ", Alt: ", "<STR_LIT>", "<<", "Alt", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "MCOperand", "MCO", ";", "if", "(", "MIO", ".", "isTargetType", "(", ")", ")", "{", "if", "(", "isPCRel", ")", "{", "assert", "(", "!", "Alt", "&&", "<STR_LIT>", "You cannot use ALT operand with PCRel", "<STR_LIT>", ")", ";", "MCO", "=", "MI", ".", "getOperand", "(", "MIO", ".", "MINo", "+", "M680x0", "::", "PCRelDisp", ")", ";", "}", "else", "{", "MCO", "=", "MI", ".", "getOperand", "(", "MIO", ".", "MINo", "+", "(", "Alt", "?", "M680x0", "::", "MemOuter", ":", "M680x0", "::", "MemDisp", ")", ")", ";", "}", "if", "(", "MCO", ".", "isExpr", "(", ")", ")", "{", "assert", "(", "!", "NoExpr", "&&", "<STR_LIT>", "Cannot use expression here", "<STR_LIT>", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MCO", ".", "getExpr", "(", ")", ";", "if", "(", "isPCRel", "&&", "Addendum", "!=", "<NUM_LIT>", ")", "{", "Expr", "=", "MCBinaryExpr", "::", "createAdd", "(", "Expr", ",", "MCConstantExpr", "::", "create", "(", "Addendum", ",", "Ctx", ")", ",", "Ctx", ")", ";", "}", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "FixOffset", ",", "Expr", ",", "getFixupForSize", "(", "Size", ",", "isPCRel", ")", ",", "MI", ".", "getLoc", "(", ")", ")", ")", ";", "return", "EmitConstant", "(", "<NUM_LIT>", ",", "Size", ",", "Pad", ",", "Buffer", ",", "Offset", ")", ";", "}", "}", "else", "{", "MCO", "=", "MI", ".", "getOperand", "(", "MIO", ".", "MINo", ")", ";", "if", "(", "MCO", ".", "isExpr", "(", ")", ")", "{", "assert", "(", "!", "NoExpr", "&&", "<STR_LIT>", "Cannot use expression here", "<STR_LIT>", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MCO", ".", "getExpr", "(", ")", ";", "if", "(", "Addendum", "!=", "<NUM_LIT>", ")", "{", "Expr", "=", "MCBinaryExpr", "::", "createAdd", "(", "Expr", ",", "MCConstantExpr", "::", "create", "(", "Addendum", ",", "Ctx", ")", ",", "Ctx", ")", ";", "}", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "FixOffset", ",", "Expr", ",", "getFixupForSize", "(", "Size", ",", "isPCRel", ")", ",", "MI", ".", "getLoc", "(", ")", ")", ")", ";", "return", "EmitConstant", "(", "<NUM_LIT>", ",", "Size", ",", "Pad", ",", "Buffer", ",", "Offset", ")", ";", "}", "}", "int64_t", "I", "=", "MCO", ".", "getImm", "(", ")", ";", "if", "(", "Type", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "Alt", ")", "{", "assert", "(", "I", "&&", "<STR_LIT>", "Cannot encode Alt Imm3 zero value" ]

[ "if", "(", "ResultReg", "==", "<NUM_LIT>", ")", "return", "false", ";" ]

[ "bool", "X86FastISel", "::", "X86SelectZExt", "(", "const", "Instruction", "*", "I", ")", "{", "if", "(", "I", "->", "getType", "(", ")", "->", "isIntegerTy", "(", "<NUM_LIT>", ")", "&&", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", "->", "getType", "(", ")", "->", "isIntegerTy", "(", "<NUM_LIT>", ")", ")", "{", "unsigned", "ResultReg", "=", "getRegForValue", "(", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "ResultReg", "==", "<NUM_LIT>", ")", "return", "false", ";", "ResultReg", "=", "FastEmitZExtFromI1", "(", "MVT", "::", "i8", ",", "ResultReg", ")", ";" ]

[ "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "return", "<STR_LIT>", "case", "<NUM_LIT>", ":", "{", "rtx", "elt0", "=", "CONST_VECTOR_ELT", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", "unsigned", "HOST_WIDE_INT", "val", "=", "~", "UINTVAL", "(", "elt0", ")", "operands", "[", "<NUM_LIT>", "]", "=", "mips_gen_const_int_vector", "(", "<", "MODE", ">", "mode", ",", "val", "&", "(", "-", "val", ")", ")", "return", "<STR_LIT>", "}", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "default", ":", "gcc_unreachable", "(", ")", "}", "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", ")" ]

[ "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "[", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "INT", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>" ]

[ "void", "print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "rtx", "breg", ";", "rtx", "offset", ";", "int", "again", "=", "<NUM_LIT>", ";", "retry", ":", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "MEM", ":", "if", "(", "TARGET_UNIX_ASM", ")", "fprintf", "(", "file", ",", "<STR_LIT>", "*", "<STR_LIT>", ")", ";", "else", "fprintf", "(", "file", ",", "<STR_LIT>", "@", "<STR_LIT>", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "again", "=", "<NUM_LIT>", ";", "goto", "retry", ";", "case", "REG", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "(%s)", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "addr", ")", "]", ")", ";", "break", ";", "case", "PRE_MODIFY", ":", "case", "PRE_DEC", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "-(%s)", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "]", ")", ";", "break", ";", "case", "POST_MODIFY", ":", "case", "POST_INC", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "(%s)+", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "]", ")", ";", "break", ";", "case", "PLUS", ":", "breg", "=", "<NUM_LIT>", ";", "offset", "=", "<NUM_LIT>", ";", "if", "(", "CONSTANT_ADDRESS_P", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "||", "GET_CODE", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "==", "MEM", ")", "{", "offset", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "}", "else", "if", "(", "CONSTANT_ADDRESS_P", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "||", "GET_CODE", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "==", "MEM", ")", "{", "offset", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "}", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "PLUS", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "==", "REG", ")", "{", "breg", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "==", "REG", ")", "{", "breg", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "}", "if", "(", "GET_CODE", "(", "addr", ")", "==", "REG", ")", "{", "gcc_assert", "(", "breg", "==", "<NUM_LIT>", ")", ";", "breg", "=", "addr", ";", "addr", "=", "<NUM_LIT>", ";", "}", "if", "(", "offset", "!=", "<NUM_LIT>", ")", "{", "gcc_assert", "(", "addr", "==", "<NUM_LIT>", ")", ";", "addr", "=", "offset", ";", "}", "if", "(", "addr", "!=", "<NUM_LIT>", ")", "output_addr_const_pdp11", "(", "file", ",", "addr", ")", ";", "if", "(", "breg", "!=", "<NUM_LIT>", ")", "{", "gcc_assert", "(", "GET_CODE", "(", "breg", ")", "==", "REG", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "(%s)", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "breg", ")", "]", ")", ";", "}", "break", ";", "default", ":", "if", "(", "!", "again", "&&", "GET_CODE", "(", "addr", ")", "==", "CONST_INT", ")", "{", "if", "(", "TARGET_DEC_ASM", ")", "fprintf", "(", "file", ",", "<STR_LIT>", "@#", "<STR_LIT>", ")", ";", "else", "if", "(", "!", "TARGET_UNIX_ASM", ")", "fprintf", "(", "file", ",", "<STR_LIT>", "@$", "<STR_LIT>", ")", ";", "}", "output_addr_const_pdp11", "(", "file", ",", "addr", ")", ";", "}", "}" ]

[ "Print", "the", "operand", "address", "represented", "by", "the", "rtx", "addr" ]

[ ")", ")", ")", "]" ]

[ "[", "(", "set", "(", "match_operand", ":", "V_INT_1REG", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mult", ":", "V_INT_1REG", "(", "match_operand", ":", "V_INT_1REG", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V_INT_1REG", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>" ]

[ ")" ]

[ "(", "define_automaton", "<STR_LIT>" ]

[ "off4", ";" ]

[ "class", "SLRO", "<", "bits", "<", "<NUM_LIT>", ">", "op1", ",", "dag", "outs", ",", "dag", "ins", ",", "string", "asmstr", ",", "list", "<", "dag", ">", "pattern", ">", ":", "T16", "<", "outs", ",", "ins", ",", "asmstr", ",", "pattern", ">", "{", "bits", "<", "<NUM_LIT>", ">" ]

[ "am_unscaled64", ":", "$", "addr", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "store", "(", "v4i16", "FPR64", ":", "$", "Rn", ")", ",", "am_unscaled64", ":", "$", "addr", ")", ",", "(", "STURDi", "FPR64", ":", "$", "Rn", "," ]

[ ";" ]

[ "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "{", "return", "&", "DL" ]

[ "<NUM_LIT>", "<STR_LIT>", ")", ")" ]

[ "(", "define_peephole2", "[", "(", "set", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DF" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "offsetBits", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "src4", ";", "bits", "<", "<NUM_LIT>", ">", "offsetBits", ";", "let", "isPredicatedNew", "=", "isPredNew", ";", "let", "isPredicatedFalse", "=", "PredNot", ";", "string", "ImmOpStr", "=", "!", "cast", "<", "string", ">", "(", "ImmOp", ")", ";", "let", "opExtentBits", "=", "!", "if", "(", "!", "eq", "(", "ImmOpStr", ",", "<STR_LIT>", ")", ",", "<NUM_LIT>", ",", "!", "if", "(", "!", "eq", "(", "ImmOpStr", ",", "<STR_LIT>", ")", ",", "<NUM_LIT>", ",", "!", "if", "(", "!", "eq", "(", "ImmOpStr", ",", "<STR_LIT>", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", ";", "let", "offsetBits", "=", "!", "if", "(", "!", "eq", "(", "ImmOpStr", ",", "<STR_LIT>", ")", ",", "src3", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "!", "if", "(", "!", "eq", "(", "ImmOpStr", ",", "<STR_LIT>", ")", ",", "src3", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "!", "if", "(", "!", "eq", "(", "ImmOpStr", ",", "<STR_LIT>", ")", ",", "src3", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "src3", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ")", ")", ")", ";", "let", "isNVStorable", "=", "!", "if", "(", "!", "eq", "(", "mnemonic", ",", "<STR_LIT>", ")", ",", "<NUM_LIT>", ",", "!", "if", "(", "isH", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ";", "let", "IClass", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "PredNot", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "isPredNew", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "MajOp", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "src2", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "offsetBits", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "src4", ";" ]

[ "const", "SDValue", "Ops", "[", "]", "=", "{", "RegClass", ",", "V0", ",", "SubReg0", ",", "V1", ",", "SubReg1", ",", "V2", ",", "SubReg2", ",", "V3", ",", "SubReg3", "}", ";" ]

[ "SDValue", "SubReg1", "=", "CurDAG", "->", "getTargetConstant", "(", "ARM", "::", "ssub_1", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "SDValue", "SubReg2", "=", "CurDAG", "->", "getTargetConstant", "(", "ARM", "::", "ssub_2", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "SDValue", "SubReg3", "=", "CurDAG", "->", "getTargetConstant", "(", "ARM", "::", "ssub_3", ",", "dl", ",", "MVT", "::", "i32", ")", ";" ]

[ "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue" ]

[ "}" ]

[ "FunctionPass", "*", "llvm", "::", "createSparcCodePrinterPass", "(", "raw_ostream", "&", "o", ",", "TargetMachine", "&", "tm", ",", "bool", "fast", ")", "{", "return", "new", "SparcAsmPrinter", "(", "o", ",", "tm", ",", "tm", ".", "getTargetAsmInfo", "(", ")", ",", "fast", ")", ";" ]

[ ",", "IIC_VTBX1", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "DPR", ":", "$", "Vd", ",", "(", "v8i8", "(", "int_arm_neon_vtbx1", "DPR", ":", "$", "orig", ",", "VecListOneD", ":", "$", "Vn", ",", "DPR", ":", "$", "Vm", ")", ")", ")", "]", ">", ";" ]

[ "def", "VTBX1", ":", "N3V", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "DPR", ":", "$", "Vd", ")", ",", "(", "ins", "DPR", ":", "$", "orig", ",", "VecListOneD", ":", "$", "Vn", ",", "DPR", ":", "$", "Vm", ")", ",", "NVTBLFrm" ]

[ "UNSPEC_VCMLA90", "UNSPEC_VCMLA180", "UNSPEC_VCMLA270", "]", ")" ]

[ "(", "define_int_iterator", "VCADD", "[", "UNSPEC_VCADD90", "UNSPEC_VCADD270", "]", ")", "(", "define_int_iterator", "VCMLA", "[", "UNSPEC_VCMLA" ]

[ "HasSM4", ";" ]

[ "bool", "hasSM4", "(", ")", "const", "{", "return" ]

[ "v2i32", "(", "Neon_High4S", "node", ":", "$", "Rn", ")", ")", ")", ")", ">", ";" ]

[ "def", "_v2i32", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "Rn", ")", ",", "(", "v2i64", "(", "ext", "(" ]

[ ")", ",", "DL", ",", "IntVT", ")", ";" ]

[ "SrcElementWidth", "=", "<NUM_LIT>", ";", "}", "else", "if", "(", "SrcElementVT", "!=", "MVT", "::", "f64", "&&", "SrcElementVT", "!=", "MVT", "::", "f32", "&&", "SrcElementVT", "!=", "MVT", "::", "f16", "&&", "SrcElementVT", "!=", "MVT", "::", "bf16", ")", "return", "SDValue", "(", ")", ";", "SDLoc", "DL", "(", "Op", ")", ";", "if", "(", "SatWidth", "==", "<NUM_LIT>", "&&", "SrcElementWidth", "<", "<NUM_LIT>", ")", "{", "MVT", "F64VT", "=", "MVT", "::", "getVectorVT", "(", "MVT", "::", "f64", ",", "SrcVT", ".", "getVectorNumElements", "(", ")", ")", ";", "SrcVal", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "DL", ",", "F64VT", ",", "SrcVal", ")", ";", "SrcVT", "=", "F64VT", ";", "SrcElementVT", "=", "MVT", "::", "f64", ";", "SrcElementWidth", "=", "<NUM_LIT>", ";", "}", "if", "(", "SrcElementWidth", "==", "DstElementWidth", "&&", "SrcElementWidth", "==", "SatWidth", ")", "return", "DAG", ".", "getNode", "(", "Op", ".", "getOpcode", "(", ")", ",", "DL", ",", "DstVT", ",", "SrcVal", ",", "DAG", ".", "getValueType", "(", "DstVT", ".", "getScalarType", "(", ")", ")", ")", ";", "if", "(", "SrcElementWidth", "<", "SatWidth", "||", "SrcElementVT", "==", "MVT", "::", "f64", ")", "return", "SDValue", "(", ")", ";", "EVT", "IntVT", "=", "SrcVT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "SDValue", "NativeCvt", "=", "DAG", ".", "getNode", "(", "Op", ".", "getOpcode", "(", ")", ",", "DL", ",", "IntVT", ",", "SrcVal", ",", "DAG", ".", "getValueType", "(", "IntVT", ".", "getScalarType", "(", ")", ")", ")", ";", "SDValue", "Sat", ";", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "FP_TO_SINT_SAT", ")", "{", "SDValue", "MinC", "=", "DAG", ".", "getConstant", "(", "APInt", "::", "getSignedMaxValue", "(", "SatWidth", ")", ".", "sext", "(", "SrcElementWidth" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_maskz_srlv_epi64", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m128i", "_", "_", "X", ",", "_", "_", "m128i", "_", "_", "Y", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_psrlv2di_mask", "(", "(", "_", "_", "v2di", ")", "_", "_", "X", ",", "(", "_", "_", "v2di", ")", "_", "_", "Y", ",", "(", "_", "_", "v2di", ")", "_", "mm_setzero_si128", "(", ")", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ ".", "set", "(", "getBaseRegister", "(", ")", ")", ";" ]

[ "Reserved", ".", "set", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Reserved", ".", "set", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Reserved", ".", "set", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Reserved", ".", "set", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Reserved", ".", "set", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Reserved", ".", "set", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Reserved", ".", "set", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "Reserved" ]

[ "<STR_LIT>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_CLIPS", ")", ")", "]", "<STR_LIT>" ]

[ "-", "<NUM_LIT>", ")", "return", "-", "<NUM_LIT>", ";" ]

[ "if", "(", "MCOp", "==", "-", "<NUM_LIT>", ")", "return", "Opcode", ";", "if", "(", "MCOp", "==", "(", "uint16_t", ")" ]

[ ")", ")" ]

[ "<STR_LIT>", "(", "and", "(", "match_code", "<STR_LIT>", ")", "(", "match_test", "<STR_LIT>", ")" ]

[ ")", ")", ";" ]

[ "return", "D", "(", "<STR_LIT>", "pusha", "<STR_LIT>", ",", "R", "(", "a" ]

[ ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";" ]

[ "setOperationAction", "(", "ISD", "::", "FLOG10", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FEXP", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FMA", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FMA", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FREM", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FREM", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FP16_TO_FP", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_FP16", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FP16_TO_FP", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_FP16", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "EH_RETURN", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "VASTART", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "VAARG", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "VACOPY", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "VAEND", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "STACKSAVE", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "STACKRESTORE", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "if", "(", "!", "Subtarget", ".", "isGP64bit", "(", ")", ")", "{", "setOperationAction", "(", "ISD", "::", "ATOMIC_LOAD", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ATOMIC_STORE", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "}", "if", "(", "!", "Subtarget", ".", "hasMips32r2", "(", ")", ")", "{", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "i8", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "i16", ",", "Expand", ")", ";", "}", "if", "(", "!", "Subtarget", ".", "hasMips32", "(", ")", "||", "Subtarget", ".", "inMips16Mode", "(", ")", ")", "setOperationAction", "(", "ISD", "::", "CTLZ", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "if", "(", "!", "Subtarget", ".", "hasMips64", "(", ")", ")", "setOperationAction", "(", "ISD", "::", "CTLZ", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "if", "(", "!", "Subtarget", ".", "hasMips32r2", "(", ")", ")", "setOperationAction", "(", "ISD", "::", "BSWAP", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "if", "(", "!", "Subtarget", ".", "hasMips64r2", "(", ")", ")", "setOperationAction", "(", "ISD", "::", "BSWAP", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "if", "(", "Subtarget", ".", "isGP64bit", "(", ")", ")", "{", "setLoadExtAction", "(", "ISD", "::", "SEXTLOAD", ",", "MVT", "::", "i64", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "setLoadExtAction", "(", "ISD", "::", "ZEXTLOAD", ",", "MVT", "::", "i64", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "setLoadExtAction", "(", "ISD", "::", "EXTLOAD", ",", "MVT", "::", "i64", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "i64", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "}", "setOperationAction", "(", "ISD", "::", "TRAP", ",", "MVT", "::", "Other", ",", "Legal", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "SDIVREM", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "UDIVREM", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "SELECT", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "AND", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "OR", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "ADD", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "AssertZext", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "SHL", ")", ";", "if", "(", "ABI", ".", "IsO32", "(", ")", ")", "{", "setLibcallName", "(", "RTLIB", "::", "SHL_I128", ",", "nullptr", ")", ";", "setLibcallName", "(", "RTLIB", "::", "SRL_I128", ",", "nullptr", ")", ";", "setLibcallName", "(", "RTLIB", "::", "SRA_I128", ",", "nullptr", ")", ";", "}", "setMinFunctionAlignment", "(", "Subtarget", ".", "isGP64bit", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "setMinStackArgumentAlignment", "(", "(", "ABI", ".", "IsN32", "(", ")", "||", "ABI", ".", "IsN64", "(", ")" ]

[ "mm512_maskz_movehdup_ps", "(", "_", "_", "mmask16", "_", "_", "U", ",", "_", "_", "m512", "_", "_", "A", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m512", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_" ]

[ "]", ")" ]

[ "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", "{", "int", "val", "=", "INTVAL", "(", "operands", "[", "<NUM_LIT>" ]

[ "dag", "BE_VARIABLE_HALF", "=", "(", "EXTRACT_SUBREG", "(", "SRD", "BE_MV_VHALF", ",", "BE_VHALF_SHIFT", ")", ",", "sub_32", ")", ";" ]

[ "dag", "LE_VBYTE_PERM_VEC", "=", "(", "v16i8", "(", "LVSL", "ZERO8", ",", "(", "ANDC8", "(", "LI8", "<NUM_LIT>", ")", ",", "$", "Idx", ")", ")", ")", ";", "dag", "LE_VBYTE_PERMUTE", "=", "(", "v16i8", "(", "VPERM", "$", "S", ",", "$", "S", ",", "LE_VBYTE_PERM_VEC", ")", ")", ";", "dag", "LE_MV_VBYTE", "=", "(", "MFVSRD", "(", "EXTRACT_SUBREG", "(", "v2i64", "(", "COPY_TO_REGCLASS", "LE_VBYTE_PERMUTE", ",", "VSRC", ")", ")", ",", "sub_64", ")", ")", ";", "dag", "LE_VBYTE_SHIFT", "=", "(", "EXTRACT_SUBREG", "(", "RLDICR", "(", "AND8", "(", "LI8", "<NUM_LIT>", ")", ",", "$", "Idx", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "sub_32", ")", ";", "dag", "LE_VARIABLE_BYTE", "=", "(", "EXTRACT_SUBREG", "(", "SRD", "LE_MV_VBYTE", ",", "LE_VBYTE_SHIFT", ")", ",", "sub_32", ")", ";", "dag", "LE_VHALF_PERM_VEC", "=", "(", "v16i8", "(", "LVSL", "ZERO8", ",", "(", "RLDICR", "(", "ANDC8", "(", "LI8", "<NUM_LIT>", ")", ",", "$", "Idx", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", ";", "dag", "LE_VHALF_PERMUTE", "=", "(", "v16i8", "(", "VPERM", "$", "S", ",", "$", "S", ",", "LE_VHALF_PERM_VEC", ")", ")", ";", "dag", "LE_MV_VHALF", "=", "(", "MFVSRD", "(", "EXTRACT_SUBREG", "(", "v2i64", "(", "COPY_TO_REGCLASS", "LE_VHALF_PERMUTE", ",", "VSRC", ")", ")", ",", "sub_64", ")", ")", ";", "dag", "LE_VHALF_SHIFT", "=", "(", "EXTRACT_SUBREG", "(", "RLDICR", "(", "AND8", "(", "LI8", "<NUM_LIT>", ")", ",", "$", "Idx", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "sub_32", ")", ";", "dag", "LE_VARIABLE_HALF", "=", "(", "EXTRACT_SUBREG", "(", "SRD", "LE_MV_VHALF", ",", "LE_VHALF_SHIFT", ")", ",", "sub_32", ")", ";", "dag", "LE_VWORD_PERM_VEC", "=", "(", "v16i8", "(", "LVSL", "ZERO8", ",", "(", "RLDICR", "(", "ANDC8", "(", "LI8", "<NUM_LIT>", ")", ",", "$", "Idx", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", ";", "dag", "LE_VWORD_PERMUTE", "=", "(", "v16i8", "(", "VPERM", "$", "S", ",", "$", "S", ",", "LE_VWORD_PERM_VEC", ")", ")", ";", "dag", "LE_MV_VWORD", "=", "(", "MFVSRD", "(", "EXTRACT_SUBREG", "(", "v2i64", "(", "COPY_TO_REGCLASS", "LE_VWORD_PERMUTE", ",", "VSRC", ")", ")", ",", "sub_64", ")", ")", ";", "dag", "LE_VWORD_SHIFT", "=", "(", "EXTRACT_SUBREG", "(", "RLDICR", "(", "AND8", "(", "LI8", "<NUM_LIT>", ")", ",", "$", "Idx", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "sub_32", ")", ";", "dag", "LE_VARIABLE_WORD", "=", "(", "EXTRACT_SUBREG", "(", "SRD", "LE_MV_VWORD", ",", "LE_VWORD_SHIFT", ")", ",", "sub_32", ")", ";", "dag", "LE_VDWORD_PERM_VEC", "=", "(", "v16i8", "(", "LVSL", "ZERO8", ",", "(", "RLDICR", "(", "ANDC8", "(", "LI8", "<NUM_LIT>", ")", ",", "$", "Idx", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", ";", "dag", "LE_VDWORD_PERMUTE", "=", "(", "v16i8", "(", "VPERM", "$", "S", ",", "$", "S", ",", "LE_VDWORD_PERM_VEC", ")", ")", ";", "dag", "LE_VARIABLE_DWORD", "=", "(", "MFVSRD", "(", "EXTRACT_SUBREG", "(", "v2i64", "(", "COPY_TO_REGCLASS", "LE_VDWORD_PERMUTE", ",", "VSRC", ")", ")", ",", "sub_64", ")", ")", ";", "dag", "LE_VFLOAT_PERM_VEC", "=", "(", "v16i8", "(", "LVSL", "ZERO8", ",", "(", "RLDICR", "(", "XOR8", "(", "LI8", "<NUM_LIT>", ")", ",", "$", "Idx", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", ";", "dag", "LE_VFLOAT_PERMUTE", "=", "(", "VPERM", "$", "S", ",", "$", "S", ",", "LE_VFLOAT_PERM_VEC", ")", ";", "dag", "LE_VARIABLE_FLOAT", "=", "(", "XSCVSPDPN", "LE_VFLOAT_PERMUTE", ")", ";", "dag", "LE_VDOUBLE_PERMUTE", "=", "(", "v16i8", "(", "VPERM", "(", "v16i8", "(", "COPY_TO_REGCLASS", "$", "S", ",", "VRRC", ")", ")", ",", "(", "v16i8", "(", "COPY_TO_REGCLASS", "$", "S", ",", "VRRC", ")", ")", ",", "LE_VDWORD_PERM_VEC", ")", ")", ";", "dag", "LE_VARIABLE_DOUBLE", "=", "(", "COPY_TO_REGCLASS", "LE_VDOUBLE_PERMUTE", ",", "VSRC", ")", ";", "dag", "BE_VBYTE_PERM_VEC", "=", "(", "v16i8", "(", "LVSL", "ZERO8", ",", "(", "ANDIo8", "$", "Idx", ",", "<NUM_LIT>", ")", ")", ")", ";", "dag", "BE_VBYTE_PERMUTE", "=", "(", "v16i8", "(", "VPERM", "$", "S", ",", "$", "S", ",", "BE_VBYTE_PERM_VEC", ")", ")", ";", "dag", "BE_MV_VBYTE", "=", "(", "MFVSRD", "(", "EXTRACT_SUBREG", "(", "v2i64", "(", "COPY_TO_REGCLASS", "BE_VBYTE_PERMUTE", ",", "VSRC", ")", ")", ",", "sub_64", ")", ")", ";", "dag", "BE_VBYTE_SHIFT", "=", "(", "EXTRACT_SUBREG", "(", "RLDICR", "(", "ANDC8", "(", "LI8", "<NUM_LIT>", ")", ",", "$", "Idx", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "sub_32", ")", ";", "dag", "BE_VARIABLE_BYTE", "=", "(", "EXTRACT_SUBREG", "(", "SRD", "BE_MV_VBYTE", ",", "BE_VBYTE_SHIFT", ")", ",", "sub_32", ")", ";", "dag", "BE_VHALF_PERM_VEC", "=", "(", "v16i8", "(", "LVSL", "ZERO8", ",", "(", "RLDICR", "(", "ANDIo8", "$", "Idx", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", ";", "dag", "BE_VHALF_PERMUTE", "=", "(", "v16i8", "(", "VPERM", "$", "S", ",", "$", "S", ",", "BE_VHALF_PERM_VEC", ")", ")", ";", "dag", "BE_MV_VHALF", "=", "(", "MFVSRD", "(", "EXTRACT_SUBREG", "(", "v2i64", "(", "COPY_TO_REGCLASS", "BE_VHALF_PERMUTE", ",", "VSRC", ")", ")", ",", "sub_64", ")", ")", ";", "dag", "BE_VHALF_SHIFT", "=", "(", "EXTRACT_SUBREG", "(", "RLDICR", "(", "ANDC8", "(", "LI8", "<NUM_LIT>", ")", ",", "$", "Idx", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "sub_32", ")", ";" ]

[ "Addr", ",", "Decoder", ")", ";" ]

[ "return", "DecodeGPRSeqPairsClassRegisterClass", "(", "Inst", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "RegNo", "," ]

[ "<FIXS>", "case", "ARM", "::", "tADDhirr", ":", "Offset", "=", "-", "AFI", "->", "EHPrologueOffsetInRegs", ".", "lookup", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "<FIXE>", "<FIXS>", "<FIXE>" ]

[ "case", "ARM", "::", "tADDrSPi", ":", "Offset", "=", "-", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "*", "<NUM_LIT>", ";", "break", ";", "<BUGS>", "case", "ARM", "::", "tLDRpci", ":", "{", "unsigned", "CPI", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "const", "MachineConstantPool", "*", "MCP", "=", "MF", ".", "getConstantPool", "(", ")", ";", "if", "(", "CPI", ">=", "MCP", "->", "getConstants", "(", ")", ".", "size", "(", ")", ")", "CPI", "=", "AFI", "->", "getOriginalCPIdx", "(", "CPI", ")", ";", "assert", "(", "CPI", "!=", "-", "<NUM_LIT>", "U", "&&", "<STR_LIT>", "Invalid constpool index", "<STR_LIT>", ")", ";", "const", "MachineConstantPoolEntry", "&", "CPE", "=", "MCP", "->", "getConstants", "(", ")", "[", "CPI", "]", ";", "assert", "(", "!", "CPE", ".", "isMachineConstantPoolEntry", "(", ")", "&&", "<STR_LIT>", "Invalid constpool entry", "<STR_LIT>", ")", ";", "Offset", "=", "-", "cast", "ConstantInt", ">", "(", "CPE", ".", "Val", ".", "ConstVal", ")", "->", "getSExtValue", "(", ")", ";", "<BUGE>", "break", ";", "}", "<BUGS>", "}", "<BUGE>", "if", "(", "MAI", "->", "getExceptionHandlingType", "(", ")", "==", "ExceptionHandling", "::", "ARM", ")", "{", "if", "(", "DstReg", "==", "FramePtr", "&&", "FramePtr", "!=", "ARM", "::", "SP", ")" ]

[ "MCInst", "&", "MI", ")", "const", "{" ]

[ "int", "TPCMCCodeEmitter", "::", "isLoopInst", "(", "const" ]

[ "<FIXS>", "def", "tLDR", ":", "T1pI4", "(", "outs", "tGPR", ":", "$", "dst", ")", ",", "(", "ins", "t_addrmode_s4", ":", "$", "addr", ")", ",", "IIC_iLoad_r", ",", "<FIXE>", "<FIXS>", "def", "tLDRi", ":", "T1pI4", "(", "outs", "tGPR", ":", "$", "dst", ")", ",", "(", "ins", "t_addrmode_s4", ":", "$", "addr", ")", ",", "IIC_iLoad_r", ",", "<FIXE>", "<FIXS>", "def", "tLDRB", ":", "T1pI1", "(", "outs", "tGPR", ":", "$", "dst", ")", ",", "(", "ins", "t_addrmode_s1", ":", "$", "addr", ")", ",", "IIC_iLoad_bh_r", ",", "<FIXE>", "<FIXS>", "def", "tLDRBi", ":", "T1pI1", "(", "outs", "tGPR", ":", "$", "dst", ")", ",", "(", "ins", "t_addrmode_s1", ":", "$", "addr", ")", ",", "IIC_iLoad_bh_r", ",", "<FIXE>", "<FIXS>", "def", "tLDRH", ":", "T1pI2", "(", "outs", "tGPR", ":", "$", "dst", ")", ",", "(", "ins", "t_addrmode_s2", ":", "$", "addr", ")", ",", "IIC_iLoad_bh_r", ",", "<FIXE>", "<FIXS>", "def", "tLDRHi", ":", "T1pI2", "(", "outs", "tGPR", ":", "$", "dst", ")", ",", "(", "ins", "t_addrmode_s2", ":", "$", "addr", ")", ",", "IIC_iLoad_bh_r", ",", "<FIXE>", "<FIXS>", "def", "tLDRSB", ":", "T1pI1", "(", "outs", "tGPR", ":", "$", "dst", ")", ",", "(", "ins", "t_addrmode_rr", ":", "$", "addr", ")", ",", "IIC_iLoad_bh_r", ",", "<FIXE>", "<FIXS>", "def", "tLDRSH", ":", "T1pI2", "(", "outs", "tGPR", ":", "$", "dst", ")", ",", "(", "ins", "t_addrmode_rr", ":", "$", "addr", ")", ",", "IIC_iLoad_bh_r", ",", "<FIXE>", "<FIXS>", "def", "tLDRspi", ":", "T1pIs", "(", "outs", "tGPR", ":", "$", "dst", ")", ",", "(", "ins", "t_addrmode_sp", ":", "$", "addr", ")", ",", "IIC_iLoad_i", ",", "<FIXE>" ]

[ "let", "canFoldAsLoad", "=", "<NUM_LIT>", ",", "isReMaterializable", "=", "<NUM_LIT>", "in", "<BUGS>", "def", "tLDR", ":", "T1pI4", "(", "outs", "tGPR", ":", "$", "dst", ")", ",", "(", "ins", "t_addrmode_s4", ":", "$", "addr", ")", ",", "IIC_iLoadr", ",", "<BUGE>", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "tGPR", ":", "$", "dst", ",", "(", "load", "t_addrmode_s4", ":", "$", "addr", ")", ")", "]", ">", ",", "T1LdSt", "<NUM_LIT>", ">", ";", "<BUGS>", "def", "tLDRi", ":", "T1pI4", "(", "outs", "tGPR", ":", "$", "dst", ")", ",", "(", "ins", "t_addrmode_s4", ":", "$", "addr", ")", ",", "IIC_iLoadr", ",", "<BUGE>", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "T1LdSt4Imm", "{", "<NUM_LIT>", ",", "?", ",", "?", "}", ">", ";", "<BUGS>", "def", "tLDRB", ":", "T1pI1", "(", "outs", "tGPR", ":", "$", "dst", ")", ",", "(", "ins", "t_addrmode_s1", ":", "$", "addr", ")", ",", "IIC_iLoadr", ",", "<BUGE>", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "tGPR", ":", "$", "dst", ",", "(", "zextloadi8", "t_addrmode_s1", ":", "$", "addr", ")", ")", "]", ">", ",", "T1LdSt", "<NUM_LIT>", ">", ";", "<BUGS>", "def", "tLDRBi", ":", "T1pI1", "(", "outs", "tGPR", ":", "$", "dst", ")", ",", "(", "ins", "t_addrmode_s1", ":", "$", "addr", ")", ",", "IIC_iLoadr", ",", "<BUGE>", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "T1LdSt1Imm", "{", "<NUM_LIT>", ",", "?", ",", "?", "}", ">", ";", "<BUGS>", "def", "tLDRH", ":", "T1pI2", "(", "outs", "tGPR", ":", "$", "dst", ")", ",", "(", "ins", "t_addrmode_s2", ":", "$", "addr", ")", ",", "IIC_iLoadr", ",", "<BUGE>", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "tGPR", ":", "$", "dst", ",", "(", "zextloadi16", "t_addrmode_s2", ":", "$", "addr", ")", ")", "]", ">", ",", "T1LdSt", "<NUM_LIT>", ">", ";", "<BUGS>", "def", "tLDRHi", ":", "T1pI2", "(", "outs", "tGPR", ":", "$", "dst", ")", ",", "(", "ins", "t_addrmode_s2", ":", "$", "addr", ")", ",", "IIC_iLoadr", ",", "<BUGE>", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "T1LdSt2Imm", "{", "<NUM_LIT>", ",", "?", ",", "?", "}", ">", ";", "let", "AddedComplexity", "=", "<NUM_LIT>", "in", "<BUGS>", "def", "tLDRSB", ":", "T1pI1", "(", "outs", "tGPR", ":", "$", "dst", ")", ",", "(", "ins", "t_addrmode_rr", ":", "$", "addr", ")", ",", "IIC_iLoadr", ",", "<BUGE>", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "tGPR", ":", "$", "dst", ",", "(", "sextloadi8", "t_addrmode_rr", ":", "$", "addr", ")", ")", "]", ">", ",", "T1LdSt", "<NUM_LIT>", ">", ";", "let", "AddedComplexity", "=", "<NUM_LIT>", "in", "<BUGS>", "def", "tLDRSH", ":", "T1pI2", "(", "outs", "tGPR", ":", "$", "dst", ")", ",", "(", "ins", "t_addrmode_rr", ":", "$", "addr", ")", ",", "IIC_iLoadr", ",", "<BUGE>", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "tGPR", ":", "$", "dst", ",", "(", "sextloadi16", "t_addrmode_rr", ":", "$", "addr", ")", ")", "]", ">", ",", "T1LdSt", "<NUM_LIT>", ">", ";", "let", "canFoldAsLoad", "=", "<NUM_LIT>", "in", "<BUGS>", "def", "tLDRspi", ":", "T1pIs", "(", "outs", "tGPR", ":", "$", "dst", ")", ",", "(", "ins", "t_addrmode_sp", ":", "$", "addr", ")", ",", "IIC_iLoadi", ",", "<BUGE>", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "tGPR", ":", "$", "dst", ",", "(", "load", "t_addrmode_sp", ":", "$", "addr", ")", ")", "]", ">", ",", "T1LdStSP", "{", "<NUM_LIT>", ",", "?", ",", "?", "}", ">", ";" ]

[ "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "define_cpu_unit" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rdd32", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rs32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rs32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "<FIXS>", "FeatureBF16", ",", "FeatureDotProd", ",", "FeatureMatMulInt8", ",", "FeatureSSBS", "]", ";", "<FIXE>" ]

[ "FeatureComplxNum", ",", "FeatureCRC", ",", "FeatureJS", ",", "FeatureLSE", ",", "FeaturePAuth", ",", "FeatureFPAC", ",", "FeatureRAS", ",", "FeatureRCPC", ",", "FeatureRDM", ",", "<BUGS>", "FeatureBF16", ",", "FeatureDotProd", ",", "FeatureMatMulInt8", "]", ";", "<BUGE>", "list", "SubtargetFeature", ">", "AppleA17", "=", "[", "HasV8_6aOps", ",", "FeatureSHA2", ",", "FeatureAES", ",", "FeatureFPARMv8", ",", "FeatureNEON", ",", "FeaturePerfMon", ",", "FeatureSHA3", ",", "FeatureFullFP16", ",", "FeatureFP16FML", "," ]

[ "Extract", ")", "{" ]

[ "unsigned", "getScalarizationOverhead", "(", "Type", "*", "Ty", ",", "bool", "Insert", ",", "bool" ]

[ "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "WordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";" ]

[ "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

[ "let", "accessSize", "=", "ByteAccess", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "<STR_LIT>", "<FIXE>" ]

[ "(", "neg", ":", "SF", "(", "minus", ":", "SF", "(", "mult", ":", "SF", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "}" ]

[ "void", "setGlobalBaseReg", "(", "Register", "Reg", ")", "{", "GlobalBaseReg", "=", "Reg", ";" ]

[ "else", "return", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";" ]

[ "if", "(", "to", ">=", "S_REGS", ")", "return", "m68hc11_memory_move_cost", "(", "mode", ",", "S_REGS", ",", "<NUM_LIT>", ")", ";", "else", "if", "(", "from", "<=", "S_REGS", ")", "return", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", "+", "(", "reload_completed", "|", "reload_in_progress", ")", ";" ]

[ ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "op1", ";", "bits", "<", "<NUM_LIT>", ">", "op2", ";", "bits", "<", "<NUM_LIT>", ">", "optype", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "op1", ";", "let", "SrcB", "=", "op2", ";", "let", "OperandType", "=", "optype", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";", "let", "Switches", "=", "sw", ";", "let", "HasImm", "=", "<NUM_LIT>" ]

[ "<STR_LIT>", ")" ]

[ "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "minus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_op_dup", "<NUM_LIT>", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

[ ")", ")", ")", "]" ]

[ "[", "(", "set", "(", "match_operand", ":", "DF", "\t", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "float", ":", "DF", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>" ]

[ "(", "rotate", ":", "VI", "(", "match_operand", ":", "VI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "VI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ ")", ")" ]

[ "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "rtx", "dest", ",", "base", ",", "off", ",", "pic", ",", "tp", ";", "<FIXE>", "<FIXS>", "tp", "=", "TARGET_GNU2_TLS", "?", "get_thread_pointer", "(", "<NUM_LIT>", ")", ":", "<NUM_LIT>", ";", "if", "(", "TARGET_64BIT", "&&", "!", "TARGET_GNU2_TLS", ")", "<FIXE>" ]

[ "static", "rtxlegitimize_tls_address", "(", "rtx", "x", ",", "enum", "tls_model", "model", ",", "int", "for_mov", ")", "{", "<BUGS>", "rtx", "dest", ",", "base", ",", "off", ",", "pic", ";", "<BUGE>", "int", "type", ";", "switch", "(", "model", ")", "{", "case", "TLS_MODEL_GLOBAL_DYNAMIC", ":", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "<BUGS>", "if", "(", "TARGET_64BIT", ")", "<BUGE>", "{", "rtx", "rax", "=", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")", ",", "insns", ";" ]

[ "}" ]

[ "bool", "CPChange", "=", "false", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "CPUsers", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "CPChange", "|=", "handleConstantPoolUser", "(", "i", ")", ";", "if", "(", "CPChange", "&&", "++", "NoCPIters", ">", "<NUM_LIT>", ")", "report_fatal_error", "(", "<STR_LIT>", "Constant Island pass failed to converge!", "<STR_LIT>", ")", ";", "DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "NewWaterList", ".", "clear", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Beginning BR iteration #", "<STR_LIT>", "<<", "NoBRIters", "<<", "'", "\\n", "'", ")", ";", "bool", "BRChange", "=", "false", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "ImmBranches", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "BRChange", "|=", "fixupImmediateBr", "(", "ImmBranches", "[", "i", "]", ")", ";", "if", "(", "BRChange", "&&", "++", "NoBRIters", ">", "<NUM_LIT>", ")", "report_fatal_error", "(", "<STR_LIT>", "Branch Fix Up pass failed to converge!", "<STR_LIT>", ")", ";", "DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "if", "(", "!", "CPChange", "&&", "!", "BRChange", ")", "break", ";", "MadeChange", "=", "true", ";", "}", "if", "(", "isThumb2", "&&", "!", "STI", "->", "prefers32BitThumb", "(", ")", ")", "MadeChange", "|=", "optimizeThumb2Instructions", "(", ")", ";", "if", "(", "isThumb", "&&", "STI", "->", "hasV8MBaselineOps", "(", ")", ")", "MadeChange", "|=", "optimizeThumb2Branches", "(", ")", ";", "if", "(", "isThumb2", ")", "MadeChange", "|=", "optimizeThumb2JumpTables", "(", ")", ";", "verify", "(", ")", ";", "if", "(", "isThumb", "&&", "!", "HasFarJump", "&&", "AFI", "->", "isLRSpilledForFarJump", "(", ")", ")", "MadeChange", "|=", "undoLRSpillRestore", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "CPEntries", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "for", "(", "unsigned", "j", "=", "<NUM_LIT>", ",", "je", "=", "CPEntries", "[", "i", "]", ".", "size", "(", ")", ";", "j", "!=", "je", ";", "++", "j", ")", "{", "const", "CPEntry", "&", "CPE", "=", "CPEntries", "[", "i", "]", "[", "j", "]", ";", "if", "(", "CPE", ".", "CPEMI", "&&", "CPE", ".", "CPEMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isCPI", "(", ")", ")", "AFI", "->", "recordCPEClone", "(", "i", ",", "CPE", ".", "CPI", ")", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "def", "DBG", ":", "AI", "<", "(", "outs", ")", ",", "(", "ins", "imm0_15", ":", "$", "opt", ")", ",", "MiscFrm", ",", "NoItinerary", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "int_arm_dbg", "imm0_15", ":", "$", "opt", ")", "]", ">", ",", "Requires", "<", "[", "IsARM", ",", "HasV7", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "opt", ";" ]

[ "<FIXS>", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ";", "<FIXE>" ]

[ "intdivmod_operator", "(", "op", ",", "mode", ")", "register", "rtx", "op", ";", "<BUGS>", "enum", "machine_mode", "mode", ";", "<BUGE>", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{" ]

[ "}" ]

[ "PPCHazardRecognizer970", "::", "PPCHazardRecognizer970", "(", "const", "ScheduleDAG", "&", "DAG", ")", ":", "DAG", "(", "DAG", ")", "{", "EndDispatchGroup", "(", ")", ";" ]

[ "static", "bool", "ix86_expand_vec_one_operand_perm_avx512", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "d", "->", "op0", ")", ";", "machine_mode", "maskmode", "=", "mode", ";", "unsigned", "inner_size", "=", "GET_MODE_SIZE", "(", "GET_MODE_INNER", "(", "mode", ")", ")", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", "=", "NULL", ";", "rtx", "target", ",", "op0", ",", "mask", ";", "rtx", "vec", "[", "<NUM_LIT>", "]", ";", "if", "(", "!", "rtx_equal_p", "(", "d", "->", "op0", ",", "d", "->", "op1", ")", ")", "return", "false", ";", "if", "(", "!", "TARGET_AVX512F", ")", "return", "false", ";", "if", "(", "!", "TARGET_AVX512VL", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "!", "TARGET_AVX512BW", "&&", "inner_size", "==", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "!", "TARGET_AVX512VBMI", "&&", "inner_size", "==", "<NUM_LIT>", ")", "return", "false", ";", "switch", "(", "mode", ")", "{", "case", "E_V16SImode", ":", "gen", "=", "gen_avx512f_permvarv16si", ";", "break", ";", "case", "E_V16SFmode", ":", "gen", "=", "gen_avx512f_permvarv16sf", ";", "maskmode", "=", "V16SImode", ";", "break", ";", "case", "E_V8DImode", ":", "gen", "=", "gen_avx512f_permvarv8di", ";", "break", ";", "case", "E_V8DFmode", ":", "gen", "=", "gen_avx512f_permvarv8df", ";", "maskmode", "=", "V8DImode", ";", "break", ";", "case", "E_V32HImode", ":", "gen", "=", "gen_avx512bw_permvarv32hi", ";", "break", ";", "case", "E_V16HImode", ":", "gen", "=", "gen_avx512vl_permvarv16hi", ";", "break", ";", "case", "E_V8HImode", ":", "gen", "=", "gen_avx512vl_permvarv8hi", ";", "break", ";", "case", "E_V64QImode", ":", "gen", "=", "gen_avx512bw_permvarv64qi", ";", "break", ";", "case", "E_V32QImode", ":", "gen", "=", "gen_avx512vl_permvarv32qi", ";", "break", ";", "case", "E_V16QImode", ":", "gen", "=", "gen_avx512vl_permvarv16qi", ";", "break", ";", "default", ":", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "target", "=", "d", "->", "target", ";", "op0", "=", "d", "->", "op0", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "d", "->", "nelt", ";", "++", "i", ")", "vec", "[", "i", "]", "=", "GEN_INT", "(", "d", "->", "perm", "[", "i", "]", ")", ";", "mask", "=", "gen_rtx_CONST_VECTOR", "(", "maskmode", ",", "gen_rtvec_v", "(", "d", "->", "nelt", ",", "vec", ")", ")", ";", "emit_insn", "(", "gen", "(", "target", ",", "op0", ",", "force_reg", "(", "maskmode", ",", "mask", ")", ")", ")", ";", "return", "true", ";", "}" ]

[ "Try", "to", "expand", "one-operand", "permutation", "with", "constant", "mask", "." ]

[ "GEN_INT", "(", "v", ")" ]

[ "(", "zero_extend", ":", "DI", "(", "udiv", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "umod", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "FLAGS_REG", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "zero_extend", ":", "DI", "(", "lshiftrt", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "FLAGS_REG", ")", ")", "]", ")", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "and", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "FLAGS_REG", ")", ")", "]", ")", "]", "{", "int", "v", "=", "exact_log2", "(", "UINTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "operands", "[", "<NUM_LIT>", "]", "=" ]

[ ",", "<NUM_LIT>", ">", ";" ]

[ "class", "SUBV_B_ENC", ":", "MSA_3R_FMT", "<", "<NUM_LIT>", ",", "<NUM_LIT>" ]

[ "bool", "AMDGPUPromoteAllocaImpl", "::", "run", "(", "Function", "&", "F", ",", "bool", "PromoteToLDS", ")", "{", "Mod", "=", "F", ".", "getParent", "(", ")", ";", "DL", "=", "&", "Mod", "->", "getDataLayout", "(", ")", ";", "const", "AMDGPUSubtarget", "&", "ST", "=", "AMDGPUSubtarget", "::", "get", "(", "TM", ",", "F", ")", ";", "if", "(", "!", "ST", ".", "isPromoteAllocaEnabled", "(", ")", ")", "return", "false", ";", "MaxVGPRs", "=", "getMaxVGPRs", "(", "TM", ",", "F", ")", ";", "bool", "SufficientLDS", "=", "PromoteToLDS", "?", "hasSufficientLocalMem", "(", "F", ")", ":", "false", ";", "unsigned", "VectorizationBudget", "=", "(", "PromoteAllocaToVectorLimit", "?", "PromoteAllocaToVectorLimit", "*", "<NUM_LIT>", ":", "(", "MaxVGPRs", "*", "<NUM_LIT>", ")", ")", "/", "<NUM_LIT>", ";", "SmallVector", "<", "AllocaInst", "*", ",", "<NUM_LIT>", ">", "Allocas", ";", "for", "(", "Instruction", "&", "I", ":", "F", ".", "getEntryBlock", "(", ")", ")", "{", "if", "(", "AllocaInst", "*", "AI", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "&", "I", ")", ")", "{", "if", "(", "!", "AI", "->", "isStaticAlloca", "(", ")", "||", "AI", "->", "isArrayAllocation", "(", ")", ")", "continue", ";", "Allocas", ".", "push_back", "(", "AI", ")", ";", "}", "}", "sortAllocasToPromote", "(", "Allocas", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "AllocaInst", "*", "AI", ":", "Allocas", ")", "{", "const", "unsigned", "AllocaCost", "=", "DL", "->", "getTypeSizeInBits", "(", "AI", "->", "getAllocatedType", "(", ")", ")", ";", "if", "(", "AllocaCost", "<=", "VectorizationBudget", ")", "{", "if", "(", "tryPromoteAllocaToVector", "(", "*", "AI", ")", ")", "{", "Changed", "=", "true", ";", "assert", "(", "(", "VectorizationBudget", "-", "AllocaCost", ")", "<", "VectorizationBudget", "&&", "<STR_LIT>", "Underflow!", "<STR_LIT>", ")", ";", "VectorizationBudget", "-=", "AllocaCost", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " Remaining vectorization budget:", "<STR_LIT>", "<<", "VectorizationBudget", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "continue", ";", "}", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Alloca too big for vectorization (size:", "<STR_LIT>", "<<", "AllocaCost", "<<", "<STR_LIT>", ", budget:", "<STR_LIT>", "<<", "VectorizationBudget", "<<", "<STR_LIT>", "): ", "<STR_LIT>", "<<", "*", "AI", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "}", "if", "(", "PromoteToLDS", "&&", "tryPromoteAllocaToLDS", "(", "*", "AI", ",", "SufficientLDS", ")", ")", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

[ "getLO32DSPReg", "(", ")", ")", ")", ";" ]

[ "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(" ]

[ "let", "DiagnosticType", "=", "<STR_LIT>", ";" ]

[ "let", "Name", "=", "<STR_LIT>", ";", "let", "ParserMethod", "=", "<STR_LIT>", ";" ]

[ "::", "prev", "(", "MBBI", ")", ";" ]

[ "bool", "Filler", "::", "tryCombineRestoreWithPrevInst", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ")", "{", "if", "(", "MBBI", "==", "MBB", ".", "begin", "(", ")", ")", "return", "false", ";", "assert", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "MBBI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "MBBI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "MBBI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "MachineBasicBlock", "::", "iterator", "PrevInst", "=", "std" ]

[ ",", "_", "_", "R", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m512i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_cvt_roundps_epi32", "(", "_", "_", "m512", "_", "_", "A", ",", "const", "int", "_", "_", "R", ")", "{", "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_cvtps2dq512_mask", "(", "(", "_", "_", "v16sf", ")", "_", "_", "A", ",", "(", "_", "_", "v16si", ")", "_", "mm512_undefined_si512", "(", ")", ",", "(", "_", "_", "mmask16", ")", "-", "<NUM_LIT>" ]

[ "true", ";" ]

[ "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "setReg", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "Reg", ")", ")", ";", "return", "true", ";", "}", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "Imm", ")", ")", "{", "MI", ".", "setDesc", "(", "TII", "->", "get", "(", "LLIxH", ")", ")", ";", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "setReg", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "Reg", ")", ")", ";", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "setImm", "(", "Imm", ">>", "<NUM_LIT>", ")", ";", "return" ]

[ "static", "rtx", "iq2000_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "ignore", "ATTRIBUTE_UNUSED", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "<NUM_LIT>", ")", ";", "int", "fcode", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "enum", "rtx_code", "code", "[", "<NUM_LIT>", "]", ";", "code", "[", "<NUM_LIT>", "]", "=", "REG", ";", "code", "[", "<NUM_LIT>", "]", "=", "REG", ";", "code", "[", "<NUM_LIT>", "]", "=", "REG", ";", "code", "[", "<NUM_LIT>", "]", "=", "REG", ";", "code", "[", "<NUM_LIT>", "]", "=", "REG", ";", "switch", "(", "fcode", ")", "{", "default", ":", "break", ";", "case", "IQ2000_BUILTIN_ADO16", ":", "return", "expand_one_builtin", "(", "CODE_FOR_ado16", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_RAM", ":", "code", "[", "<NUM_LIT>", "]", "=", "CONST_INT", ";", "code", "[", "<NUM_LIT>", "]", "=", "CONST_INT", ";", "code", "[", "<NUM_LIT>", "]", "=", "CONST_INT", ";", "return", "expand_one_builtin", "(", "CODE_FOR_ram", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_CHKHDR", ":", "return", "expand_one_builtin", "(", "CODE_FOR_chkhdr", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_PKRL", ":", "return", "expand_one_builtin", "(", "CODE_FOR_pkrl", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_CFC0", ":", "code", "[", "<NUM_LIT>", "]", "=", "CONST_INT", ";", "return", "expand_one_builtin", "(", "CODE_FOR_cfc0", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_CFC1", ":", "code", "[", "<NUM_LIT>", "]", "=", "CONST_INT", ";", "return", "expand_one_builtin", "(", "CODE_FOR_cfc1", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_CFC2", ":", "code", "[", "<NUM_LIT>", "]", "=", "CONST_INT", ";", "return", "expand_one_builtin", "(", "CODE_FOR_cfc2", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_CFC3", ":", "code", "[", "<NUM_LIT>", "]", "=", "CONST_INT", ";", "return", "expand_one_builtin", "(", "CODE_FOR_cfc3", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_CTC0", ":", "code", "[", "<NUM_LIT>", "]", "=", "CONST_INT", ";", "return", "expand_one_builtin", "(", "CODE_FOR_ctc0", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_CTC1", ":", "code", "[", "<NUM_LIT>", "]", "=", "CONST_INT", ";", "return", "expand_one_builtin", "(", "CODE_FOR_ctc1", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_CTC2", ":", "code", "[", "<NUM_LIT>", "]", "=", "CONST_INT", ";", "return", "expand_one_builtin", "(", "CODE_FOR_ctc2", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_CTC3", ":", "code", "[", "<NUM_LIT>", "]", "=", "CONST_INT", ";", "return", "expand_one_builtin", "(", "CODE_FOR_ctc3", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_MFC0", ":", "code", "[", "<NUM_LIT>", "]", "=", "CONST_INT", ";", "return", "expand_one_builtin", "(", "CODE_FOR_mfc0", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_MFC1", ":", "code", "[", "<NUM_LIT>", "]", "=", "CONST_INT", ";", "return", "expand_one_builtin", "(", "CODE_FOR_mfc1", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_MFC2", ":", "code", "[", "<NUM_LIT>", "]", "=", "CONST_INT", ";", "return", "expand_one_builtin", "(", "CODE_FOR_mfc2", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_MFC3", ":", "code", "[", "<NUM_LIT>", "]", "=", "CONST_INT", ";", "return", "expand_one_builtin", "(", "CODE_FOR_mfc3", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_MTC0", ":", "code", "[", "<NUM_LIT>", "]", "=", "CONST_INT", ";", "return", "expand_one_builtin", "(", "CODE_FOR_mtc0", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_MTC1", ":", "code", "[", "<NUM_LIT>", "]", "=", "CONST_INT", ";", "return", "expand_one_builtin", "(", "CODE_FOR_mtc1", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_MTC2", ":", "code", "[", "<NUM_LIT>", "]", "=", "CONST_INT", ";", "return", "expand_one_builtin", "(", "CODE_FOR_mtc2", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_MTC3", ":", "code", "[", "<NUM_LIT>", "]", "=", "CONST_INT", ";", "return", "expand_one_builtin", "(", "CODE_FOR_mtc3", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_LUR", ":", "return", "expand_one_builtin", "(", "CODE_FOR_lur", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_RB", ":", "return", "expand_one_builtin", "(", "CODE_FOR_rb", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_RX", ":", "return", "expand_one_builtin", "(", "CODE_FOR_rx", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_SRRD", ":", "return", "expand_one_builtin", "(", "CODE_FOR_srrd", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_SRWR", ":", "return", "expand_one_builtin", "(", "CODE_FOR_srwr", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_WB", ":", "return", "expand_one_builtin", "(", "CODE_FOR_wb", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_WX", ":", "return", "expand_one_builtin", "(", "CODE_FOR_wx", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_LUC32L", ":", "return", "expand_one_builtin", "(", "CODE_FOR_luc32l", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_LUC64", ":", "return", "expand_one_builtin", "(", "CODE_FOR_luc64", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_LUC64L", ":", "return", "expand_one_builtin", "(", "CODE_FOR_luc64l", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_LUK", ":", "return", "expand_one_builtin", "(", "CODE_FOR_luk", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_LULCK", ":", "return", "expand_one_builtin", "(", "CODE_FOR_lulck", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_LUM32", ":", "return", "expand_one_builtin", "(", "CODE_FOR_lum32", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_LUM32L", ":", "return", "expand_one_builtin", "(", "CODE_FOR_lum32l", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_LUM64", ":", "return", "expand_one_builtin", "(", "CODE_FOR_lum64", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_LUM64L", ":", "return", "expand_one_builtin", "(", "CODE_FOR_lum64l", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_LURL", ":", "return", "expand_one_builtin", "(", "CODE_FOR_lurl", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_MRGB", ":", "code", "[", "<NUM_LIT>", "]", "=", "CONST_INT", ";", "return", "expand_one_builtin", "(", "CODE_FOR_mrgb", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_SRRDL", ":", "return", "expand_one_builtin", "(", "CODE_FOR_srrdl", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_SRULCK", ":", "return", "expand_one_builtin", "(", "CODE_FOR_srulck", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_SRWRU", ":", "return", "expand_one_builtin", "(", "CODE_FOR_srwru", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_TRAPQFL", ":", "return", "expand_one_builtin", "(", "CODE_FOR_trapqfl", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_TRAPQNE", ":", "return", "expand_one_builtin", "(", "CODE_FOR_trapqne", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_TRAPREL", ":", "return", "expand_one_builtin", "(", "CODE_FOR_traprel", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_WBU", ":", "return", "expand_one_builtin", "(", "CODE_FOR_wbu", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "case", "IQ2000_BUILTIN_SYSCALL", ":", "return", "expand_one_builtin", "(", "CODE_FOR_syscall", ",", "target", ",", "exp", ",", "code", ",", "<NUM_LIT>", ")", ";", "}", "return", "NULL_RTX", ";", "}" ]

[ "Expand", "an", "expression", "EXP", "that", "calls", "a", "built-in", "function", ",", "with", "result", "going", "to", "TARGET", "if", "that", "'s", "convenient", "(", "and", "in", "mode", "MODE", "if", "that", "'s", "convenient", ")", ".", "SUBTARGET", "may", "be", "used", "as", "the", "target", "for", "computing", "one", "of", "EXP", "'s", "operands", ".", "IGNORE", "is", "nonzero", "if", "the", "value", "is", "to", "be", "ignored", "." ]

[ "<STR_LIT>", ")" ]

[ "(", "unspec", ":", "MVE_0", "[", "(", "match_operand", ":", "MVE_0", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "MVE_0", "<NUM_LIT>", "<STR_LIT>" ]

[ "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

[ "=", "t", ";" ]

[ "class", "SlotType", "<", "bits", "<", "<NUM_LIT>", ">", "t", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Value" ]

[ "char", "*", "emit_cond_move", "(", "rtx", "*", "operands", ",", "rtx", "insn", "ATTRIBUTE_UNUSED", ")", "{", "static", "char", "buffer", "[", "<NUM_LIT>", "]", ";", "const", "char", "*", "dest", "=", "reg_names", "[", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", "]", ";", "buffer", "[", "<NUM_LIT>", "]", "=", "<NUM_LIT>", ";", "gcc_assert", "(", "REG_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", ";", "gcc_assert", "(", "conditional_move_operand", "(", "operands", "[", "<NUM_LIT>", "]", ",", "SImode", ")", ")", ";", "gcc_assert", "(", "conditional_move_operand", "(", "operands", "[", "<NUM_LIT>", "]", ",", "SImode", ")", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "NE", ")", "{", "rtx", "tmp", "=", "operands", "[", "<NUM_LIT>", "]", ";", "operands", "[", "<NUM_LIT>", "]", "=", "operands", "[", "<NUM_LIT>", "]", ";", "operands", "[", "<NUM_LIT>", "]", "=", "tmp", ";", "}", "sprintf", "(", "buffer", ",", "<STR_LIT>", "mvfc %s, cbr", "<STR_LIT>", ",", "dest", ")", ";", "if", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "<NUM_LIT>", ")", "sprintf", "(", "buffer", "+", "strlen", "(", "buffer", ")", ",", "<STR_LIT>", "\\n\\txor3 %s, %s, #1", "<STR_LIT>", ",", "dest", ",", "dest", ")", ";", "return", "buffer", ";", "}" ]

[ "Generate", "the", "correct", "assembler", "code", "to", "handle", "the", "conditional", "loading", "of", "a", "value", "into", "a", "register", ".", "It", "is", "known", "that", "the", "operands", "satisfy", "the", "conditional_move_operand", "(", ")", "function", "above", ".", "The", "destination", "is", "operand", "[", "0", "]", ".", "The", "condition", "is", "operand", "[", "1", "]", ".", "The", "'true", "'", "value", "is", "operand", "[", "2", "]", "and", "the", "'false", "'", "value", "is", "operand", "[", "3", "]", "." ]

[ "void", "PPCRegisterInfo", "::", "adjustStackMapLiveOutMask", "(", "uint32_t", "*", "Mask", ")", "const", "{", "for", "(", "unsigned", "PseudoReg", ":", "{", "PPC", "::", "ZERO", ",", "PPC", "::", "ZERO8", ",", "PPC", "::", "RM", "}", ")", "Mask", "[", "PseudoReg", "/", "<NUM_LIT>", "]", "&=", "~", "(", "<NUM_LIT>", "u", "<<", "(", "PseudoReg", "%", "<NUM_LIT>", ")", ")", ";", "}" ]

[ "Prior", "to", "adding", "the", "live-out", "mask", "to", "a", "stackmap", "or", "patchpoint", "instruction", ",", "provide", "the", "target", "the", "opportunity", "to", "adjust", "it", "(", "mainly", "to", "remove", "pseudo-registers", "that", "should", "be", "ignored", ")", "." ]

[ "<FIXS>", "unsigned", "short", "NumOps", ",", "unsigned", "&", "NumOpsAdded", ",", "BO", "B", ")", "{", "<FIXE>" ]

[ "static", "bool", "DisassembleThumb1Special", "(", "MCInst", "&", "MI", ",", "unsigned", "Opcode", ",", "uint32_t", "insn", ",", "<BUGS>", "unsigned", "short", "NumOps", ",", "unsigned", "&", "NumOpsAdded", ")", "{", "<BUGE>", "if", "(", "NumOps", "==", "<NUM_LIT>", ")" ]

[ "bool", "AArch64FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "SmallVector", "<", "RegPairInfo", ",", "<NUM_LIT>", ">", "RegPairs", ";", "bool", "NeedShadowCallStackProlog", "=", "false", ";", "computeCalleeSaveRegisterPairs", "(", "MF", ",", "CSI", ",", "TRI", ",", "RegPairs", ",", "NeedShadowCallStackProlog", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "NeedShadowCallStackProlog", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "MBB", ".", "addLiveIn", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "for", "(", "auto", "RPII", "=", "RegPairs", ".", "rbegin", "(", ")", ",", "RPIE", "=", "RegPairs", ".", "rend", "(", ")", ";", "RPII", "!=", "RPIE", ";", "++", "RPII", ")", "{", "RegPairInfo", "RPI", "=", "*", "RPII", ";", "unsigned", "Reg1", "=", "RPI", ".", "Reg1", ";", "unsigned", "Reg2", "=", "RPI", ".", "Reg2", ";", "unsigned", "StrOpc", ";", "if", "(", "RPI", ".", "IsGPR", ")", "StrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "StrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "CSR spill: (", "<STR_LIT>", "<<", "printReg", "(", "Reg1", ",", "TRI", ")", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "dbgs", "(", ")", "<<", "<STR_LIT>", ", ", "<STR_LIT>", "<<", "printReg", "(", "Reg2", ",", "TRI", ")", ";", "dbgs", "(", ")", "<<", "<STR_LIT>", ") -> fi#(", "<STR_LIT>", "<<", "RPI", ".", "FrameIdx", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "dbgs", "(", ")", "<<", "<STR_LIT>", ", ", "<STR_LIT>", "<<", "RPI", ".", "FrameIdx", "+", "<NUM_LIT>", ";", "dbgs", "(", ")", "<<", "<STR_LIT>", ")\\n", "<STR_LIT>", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "StrOpc", ")", ")", ";", "if", "(", "!", "MRI", ".", "isReserved", "(", "Reg1", ")", ")", "MBB", ".", "addLiveIn", "(", "Reg1", ")", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "{", "if", "(", "!", "MRI", ".", "isReserved", "(", "Reg2", ")", ")", "MBB", ".", "addLiveIn", "(", "Reg2", ")", ";", "MIB", ".", "addReg", "(", "Reg2", ",", "getPrologueDeath", "(", "MF", ",", "Reg2", ")", ")", ";", "MIB", ".", "addMemOperand", "(", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "RPI", ".", "FrameIdx", "+", "<NUM_LIT>", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ";", "}", "MIB", ".", "addReg", "(", "Reg1", ",", "getPrologueDeath", "(", "MF", ",", "Reg1", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "RPI", ".", "Offset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "MIB", ".", "addMemOperand", "(", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "RPI", ".", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ";", "}", "return", "true", ";", "}" ]

[ "spillCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "spill", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "store", "instructions", "via", "storeRegToStackSlot", "(", ")", "." ]

[ "<STR_LIT>", ")" ]

[ "(", "plus", ":", "P", "(", "match_operand", ":", "P", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "P", "[", "(", "match_operand", ":", "P", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_TLSLDM", ")", ")", ")", "]", "<STR_LIT>" ]

[ ",", "SDValue", "&", "Disp", ")", "const", "{" ]

[ "bool", "selectBDAddr20Only", "(", "SDValue", "Addr", ",", "SDValue", "&", "Base" ]

[ "<<", "<STR_LIT>", "nul\\n", "<STR_LIT>", ";" ]

[ "else", "dbgs", "(", ")", "<<", "<STR_LIT>", "nul\\n", "<STR_LIT>", ";", "if", "(", "BaseType", "==", "FrameIndexBase", ")", "dbgs", "(", ")", "<<", "<STR_LIT>", " Base.FrameIndex ", "<STR_LIT>", "<<", "Base_FrameIndex", "<<", "'", "\\n", "'", ";", "dbgs", "(", ")", "<<", "<STR_LIT>", " Scale ", "<STR_LIT>", "<<", "Scale", "<<", "'", "\\n", "'", "<<", "<STR_LIT>", "IndexReg ", "<STR_LIT>", ";", "if", "(", "NegateIndex", ")", "dbgs", "(", ")", "<<", "<STR_LIT>", "negate ", "<STR_LIT>", ";", "if", "(", "IndexReg", ".", "getNode", "(", ")", ")", "IndexReg", ".", "getNode", "(", ")", "->", "dump", "(", "DAG", ")", ";", "else", "dbgs", "(", ")" ]

[ "let", "isExtendable", "=", "<NUM_LIT>", ";" ]

[ "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isPredicable", "=", "<NUM_LIT>", ";" ]

[ "RIPRel", ";" ]

[ "return", "PICStyle", "==", "PICStyles", "::" ]

[ "i64", ")", "{", "uint64_t", "Imm", "=", "N", "-", ">", "getZExtValue", "(", ")", ";" ]

[ "if", "(", "N", "-", ">", "getValueType", "(", "<NUM_LIT>", ")", "=", "=", "MVT", ":", ":" ]

[ "return", "false", ";" ]

[ "int", "Val", ";", "if", "(", "isScaledConstantInRange", "(", "N", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "Val", ")", ")", "{", "Offset", "=", "CurDAG", "->", "getRegister", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ";", "Opc", "=", "CurDAG", "->", "getTargetConstant", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "AddSub", ",", "Val", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "SDLoc", "(", "Op", ")", ",", "MVT", "::", "i32", ")", ";", "return", "true", ";", "}" ]

[ "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "(", "plus", ":", "SI", "(", "mult", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "return", "DecoderTable32", ";" ]

[ "static", "const", "uint8_t", "*", "getDecoderTable", "(", "uint64_t", "Size", ")", "{", "switch", "(", "Size", ")", "{", "case", "<NUM_LIT>", ":", "return", "DecoderTable16", ";", "case", "<NUM_LIT>", ":" ]

[ "xop", "[", "<NUM_LIT>", "]", "=", "xoperands", "[", "<NUM_LIT>", "]", ";" ]

[ "nbytes", "+=", "<NUM_LIT>", ";", "}", "}", "else", "if", "(", "TARGET_PORTABLE_RUNTIME", ")", "{", "output_asm_insn", "(", "<STR_LIT>", "ldil L'%0,%%r1", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "ldo R'%0(%%r1),%%r22", "<STR_LIT>", ",", "xoperands", ")", ";", "if", "(", "!", "val_14", ")", "output_asm_insn", "(", "<STR_LIT>", "ldil L'%2,%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "bv %%r0(%%r22)", "<STR_LIT>", ",", "xoperands", ")", ";", "if", "(", "val_14", ")", "{", "output_asm_insn", "(", "<STR_LIT>", "ldo %2(%%r26),%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "nbytes", "+=", "<NUM_LIT>", ";", "}", "else", "{", "output_asm_insn", "(", "<STR_LIT>", "ldo R'%2(%%r26),%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "nbytes", "+=", "<NUM_LIT>", ";", "}", "}", "else", "if", "(", "TARGET_SOM", "&&", "flag_pic", "&&", "TREE_PUBLIC", "(", "function", ")", ")", "{", "ASM_GENERATE_INTERNAL_LABEL", "(", "label", ",", "<STR_LIT>", "LTHN", "<STR_LIT>", ",", "current_thunk_number", ")", ";", "xoperands", "[", "<NUM_LIT>", "]", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "label", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "addil LT'%3,%%r19", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "ldw RT'%3(%%r1),%%r22", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "ldw 0(%%sr0,%%r22),%%r22", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "bb,>=,n %%r22,30,.+16", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "depi 0,31,2,%%r22", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "ldw 4(%%sr0,%%r22),%%r19", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "ldw 0(%%sr0,%%r22),%%r22", "<STR_LIT>", ",", "xoperands", ")", ";", "if", "(", "!", "val_14", ")", "{", "output_asm_insn", "(", "<STR_LIT>", "addil L'%2,%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "nbytes", "+=", "<NUM_LIT>", ";", "}", "if", "(", "TARGET_PA_20", ")", "{", "output_asm_insn", "(", "<STR_LIT>", "bve (%%r22)", "<STR_LIT>", ",", "xoperands", ")", ";", "nbytes", "+=", "<NUM_LIT>", ";", "}", "else", "if", "(", "TARGET_NO_SPACE_REGS", ")", "{", "output_asm_insn", "(", "<STR_LIT>", "be 0(%%sr4,%%r22)", "<STR_LIT>", ",", "xoperands", ")", ";", "nbytes", "+=", "<NUM_LIT>", ";", "}", "else", "{", "output_asm_insn", "(", "<STR_LIT>", "ldsid (%%sr0,%%r22),%%r21", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "mtsp %%r21,%%sr0", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "be 0(%%sr0,%%r22)", "<STR_LIT>", ",", "xoperands", ")", ";", "nbytes", "+=", "<NUM_LIT>", ";", "}", "if", "(", "val_14", ")", "output_asm_insn", "(", "<STR_LIT>", "ldo %2(%%r26),%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "else", "output_asm_insn", "(", "<STR_LIT>", "ldo R'%2(%%r1),%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "}", "else", "if", "(", "flag_pic", ")", "{", "rtx", "xop", "[", "<NUM_LIT>", "]", ";" ]

[ ";" ]

[ "const", "MCExpr", "*", "getSubExpr", "(", ")", "const", "{", "return", "SubExpr" ]

[ "bool", "X86FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "if", "(", "isFuncletReturnInstr", "(", "*", "MI", ")", "&&", "STI", ".", "isOSWindows", "(", ")", ")", "{", "if", "(", "STI", ".", "is32Bit", "(", ")", ")", "return", "true", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "X86", "::", "CATCHRET", ")", "{", "const", "Function", "*", "Func", "=", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", ";", "bool", "IsSEH", "=", "isAsynchronousEHPersonality", "(", "classifyEHPersonality", "(", "Func", "->", "getPersonalityFn", "(", ")", ")", ")", ";", "if", "(", "IsSEH", ")", "return", "true", ";", "}", "}", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "unsigned", "Opc", "=", "STI", ".", "is64Bit", "(", ")", "?", "X86", "::", "POP64r", ":", "X86", "::", "POP32r", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "Reg", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "return", "true", ";", "}" ]

[ "restoreCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "restore", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "load", "instructions", "via", "loadRegToStackSlot", "(", ")", "." ]

[ "TheMipselTarget", ";" ]

[ "static", "Target", "TheMipselTarget", ";", "return" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "immr", ";", "bits", "<", "<NUM_LIT>", ">", "imms", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "immr", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imms", ";" ]

[ "Changed", "|=", "enableGLCBit", "(", "MI", ")", ";" ]

[ "if", "(", "MOI", ".", "getOrdering", "(", ")", "==", "AtomicOrdering", "::", "Acquire", "||", "MOI", ".", "getOrdering", "(", ")", "==", "AtomicOrdering", "::", "SequentiallyConsistent", ")", "{", "Changed", "|=", "insertWaitcntVmcnt0", "(", "MI", ",", "false", ")", ";", "Changed", "|=", "insertVmemSIMDCacheInvalidate", "(", "MI", ",", "false", ")", ";", "}", "return", "Changed", ";", "}", "if", "(", "MOI", ".", "getSSID", "(", ")", "==", "SyncScope", "::", "SingleThread", "||", "MOI", ".", "getSSID", "(", ")", "==", "MMI", "->", "getWorkgroupSSID", "(", ")", "||", "MOI", ".", "getSSID", "(", ")", "==", "MMI", "->", "getWavefrontSSID", "(", ")", ")", "{", "return", "Changed", ";", "}", "llvm_unreachable", "(", "<STR_LIT>", "Unsupported synchronization scope", "<STR_LIT>", ")", ";", "}", "if", "(", "MOI", ".", "isNonTemporal", "(", ")", ")", "{" ]

[ "<STR_LIT>", ")" ]

[ "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "unspec", ":", "QI", "[", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>" ]

[ "a", ";" ]

[ "return", "(", "poly64x2_t", ")", "_", "_" ]

[ "MachineInstr", "*", "Copy1", "=", "BuildMI", "(", "*", "MBB", ",", "CI", ".", "Paired", ",", "DL", ",", "CopyDesc", ")", ".", "add", "(", "*", "Dest1", ")", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Kill", ",", "SubRegIdx1", ")", ";" ]

[ "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "SubRegIdx", "=", "getSubRegIdxs", "(", "CI", ")", ";", "const", "unsigned", "SubRegIdx0", "=", "std", "::", "get", "<", "<NUM_LIT>", ">", "(", "SubRegIdx", ")", ";", "const", "unsigned", "SubRegIdx1", "=", "std", "::", "get", "<", "<NUM_LIT>", ">", "(", "SubRegIdx", ")", ";", "const", "MCInstrDesc", "&", "CopyDesc", "=", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ";", "const", "auto", "*", "Dest0", "=", "TII", "->", "getNamedOperand", "(", "*", "CI", ".", "I", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";", "const", "auto", "*", "Dest1", "=", "TII", "->", "getNamedOperand", "(", "*", "CI", ".", "Paired", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";", "BuildMI", "(", "*", "MBB", ",", "CI", ".", "Paired", ",", "DL", ",", "CopyDesc", ")", ".", "add", "(", "*", "Dest0", ")", ".", "addReg", "(", "DestReg", ",", "<NUM_LIT>", ",", "SubRegIdx0", ")", ";" ]

[ "::", "EndOfStatement", ")", ")", "{" ]

[ "unsigned", "VPTPredicationCode", ";", "unsigned", "ProcessorIMod", ";", "bool", "CarrySetting", ";", "StringRef", "ITMask", ";", "Mnemonic", "=", "splitMnemonic", "(", "Mnemonic", ",", "ExtraToken", ",", "PredicationCode", ",", "VPTPredicationCode", ",", "CarrySetting", ",", "ProcessorIMod", ",", "ITMask", ")", ";", "if", "(", "isThumbOne", "(", ")", "&&", "PredicationCode", "!=", "<STR_LIT>", "::", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "b", "<STR_LIT>", ")", "{", "return", "Error", "(", "NameLoc", ",", "<STR_LIT>", "conditional execution not supported in Thumb1", "<STR_LIT>", ")", ";", "}", "Operands", ".", "push_back", "(", "ARMOperand", "::", "CreateToken", "(", "Mnemonic", ",", "NameLoc", ")", ")", ";", "if", "(", "Mnemonic", "==", "<STR_LIT>", "it", "<STR_LIT>", "||", "Mnemonic", ".", "startswith", "(", "<STR_LIT>", "vpt", "<STR_LIT>", ")", "||", "Mnemonic", ".", "startswith", "(", "<STR_LIT>", "vpst", "<STR_LIT>", ")", ")", "{", "SMLoc", "Loc", "=", "Mnemonic", "==", "<STR_LIT>", "it", "<STR_LIT>", "?", "SMLoc", "::", "getFromPointer", "(", "NameLoc", ".", "getPointer", "(", ")", "+", "<NUM_LIT>", ")", ":", "Mnemonic", "==", "<STR_LIT>", "vpt", "<STR_LIT>", "?", "SMLoc", "::", "getFromPointer", "(", "NameLoc", ".", "getPointer", "(", ")", "+", "<NUM_LIT>", ")", ":", "SMLoc", "::", "getFromPointer", "(", "NameLoc", ".", "getPointer", "(", ")", "+", "<NUM_LIT>", ")", ";", "if", "(", "ITMask", ".", "size", "(", ")", ">", "<NUM_LIT>", ")", "{", "if", "(", "Mnemonic", "==", "<STR_LIT>", "it", "<STR_LIT>", ")", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "too many conditions on IT instruction", "<STR_LIT>", ")", ";", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "too many conditions on VPT instruction", "<STR_LIT>", ")", ";", "}", "unsigned", "Mask", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "i", "=", "ITMask", ".", "size", "(", ")", ";", "i", "!=", "<NUM_LIT>", ";", "--", "i", ")", "{", "char", "pos", "=", "ITMask", "[", "i", "-", "<NUM_LIT>", "]", ";", "if", "(", "pos", "!=", "'", "t", "'", "&&", "pos", "!=", "'", "e", "'", ")", "{", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "illegal IT block condition mask '", "<STR_LIT>", "+", "ITMask", "+", "<STR_LIT>", "'", "<STR_LIT>", ")", ";", "}", "Mask", ">>=", "<NUM_LIT>", ";", "if", "(", "ITMask", "[", "i", "-", "<NUM_LIT>", "]", "==", "'", "e", "'", ")", "Mask", "|=", "<NUM_LIT>", ";", "}", "Operands", ".", "push_back", "(", "ARMOperand", "::", "CreateITMask", "(", "Mask", ",", "Loc", ")", ")", ";", "}", "bool", "CanAcceptCarrySet", ",", "CanAcceptPredicationCode", ",", "CanAcceptVPTPredicationCode", ";", "getMnemonicAcceptInfo", "(", "Mnemonic", ",", "ExtraToken", ",", "Name", ",", "CanAcceptCarrySet", ",", "CanAcceptPredicationCode", ",", "CanAcceptVPTPredicationCode", ")", ";", "if", "(", "!", "CanAcceptCarrySet", "&&", "CarrySetting", ")", "{", "return", "Error", "(", "NameLoc", ",", "<STR_LIT>", "instruction '", "<STR_LIT>", "+", "Mnemonic", "+", "<STR_LIT>", "' can not set flags, but 's' suffix specified", "<STR_LIT>", ")", ";", "}", "if", "(", "!", "CanAcceptPredicationCode", "&&", "PredicationCode", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "return", "Error", "(", "NameLoc", ",", "<STR_LIT>", "instruction '", "<STR_LIT>", "+", "Mnemonic", "+", "<STR_LIT>", "' is not predicable, but condition code specified", "<STR_LIT>", ")", ";", "}", "if", "(", "!", "CanAcceptVPTPredicationCode", "&&", "VPTPredicationCode", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "return", "Error", "(", "NameLoc", ",", "<STR_LIT>", "instruction '", "<STR_LIT>", "+", "Mnemonic", "+", "<STR_LIT>", "' is not VPT predicable, but VPT code T/E is specified", "<STR_LIT>", ")", ";", "}", "if", "(", "CanAcceptCarrySet", ")", "{", "SMLoc", "Loc", "=", "SMLoc", "::", "getFromPointer", "(", "NameLoc", ".", "getPointer", "(", ")", "+", "Mnemonic", ".", "size", "(", ")", ")", ";", "Operands", ".", "push_back", "(", "ARMOperand", "::", "CreateCCOut", "(", "CarrySetting", "?", "ARM", "::", "CPSR", ":", "<NUM_LIT>", ",", "Loc", ")", ")", ";", "}", "if", "(", "CanAcceptPredicationCode", ")", "{", "SMLoc", "Loc", "=", "SMLoc", "::", "getFromPointer", "(", "NameLoc", ".", "getPointer", "(", ")", "+", "Mnemonic", ".", "size", "(", ")", "+", "CarrySetting", ")", ";", "Operands", ".", "push_back", "(", "ARMOperand", "::", "CreateCondCode", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "PredicationCode", ")", ",", "Loc", ")", ")", ";", "}", "if", "(", "CanAcceptVPTPredicationCode", "&&", "Mnemonic", "!=", "<STR_LIT>", "vmov", "<STR_LIT>", "&&", "!", "Mnemonic", ".", "startswith", "(", "<STR_LIT>", "vcmp", "<STR_LIT>", ")", "&&", "!", "(", "Mnemonic", ".", "startswith", "(", "<STR_LIT>", "vcvt", "<STR_LIT>", ")", "&&", "Mnemonic", "!=", "<STR_LIT>", "vcvta", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "vcvtn", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "vcvtp", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "vcvtm", "<STR_LIT>", ")", ")", "{", "SMLoc", "Loc", "=", "SMLoc", "::", "getFromPointer", "(", "NameLoc", ".", "getPointer", "(", ")", "+", "Mnemonic", ".", "size", "(", ")", "+", "CarrySetting", ")", ";", "Operands", ".", "push_back", "(", "ARMOperand", "::", "CreateVPTPred", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "VPTPredicationCode", ")", ",", "Loc", ")", ")", ";", "}", "if", "(", "ProcessorIMod", ")", "{", "Operands", ".", "push_back", "(", "ARMOperand", "::", "CreateImm", "(", "MCConstantExpr", "::", "create", "(", "ProcessorIMod", ",", "getContext", "(", ")", ")", ",", "NameLoc", ",", "NameLoc", ")", ")", ";", "}", "else", "if", "(", "Mnemonic", "==", "<STR_LIT>", "cps", "<STR_LIT>", "&&", "isMClass", "(", ")", ")", "{", "return", "Error", "(", "NameLoc", ",", "<STR_LIT>", "instruction 'cps' requires effect for M-class", "<STR_LIT>", ")", ";", "}", "while", "(", "Next", "!=", "StringRef", "::", "npos", ")", "{", "Start", "=", "Next", ";", "Next", "=", "Name", ".", "find", "(", "'", ".", "'", ",", "Start", "+", "<NUM_LIT>", ")", ";", "ExtraToken", "=", "Name", ".", "slice", "(", "Start", ",", "Next", ")", ";", "if", "(", "isDataTypeToken", "(", "ExtraToken", ")", "&&", "doesIgnoreDataTypeSuffix", "(", "Mnemonic", ",", "ExtraToken", ")", ")", "continue", ";", "if", "(", "ExtraToken", "==", "<STR_LIT>", ".n", "<STR_LIT>", "&&", "!", "isThumb", "(", ")", ")", "{", "SMLoc", "Loc", "=", "SMLoc", "::", "getFromPointer", "(", "NameLoc", ".", "getPointer", "(", ")", "+", "Start", ")", ";", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "instruction with .n (narrow) qualifier not allowed in ", "<STR_LIT>", "<STR_LIT>", "arm mode", "<STR_LIT>", ")", ";", "}", "if", "(", "ExtraToken", "!=", "<STR_LIT>", ".n", "<STR_LIT>", "&&", "(", "isThumb", "(", ")", "||", "ExtraToken", "!=", "<STR_LIT>", ".w", "<STR_LIT>", ")", ")", "{", "SMLoc", "Loc", "=", "SMLoc", "::", "getFromPointer", "(", "NameLoc", ".", "getPointer", "(", ")", "+", "Start", ")", ";", "Operands", ".", "push_back", "(", "ARMOperand", "::", "CreateToken", "(", "ExtraToken", ",", "Loc", ")", ")", ";", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken" ]

[ "=", "CCIfNoSignedWrap", ";" ]

[ "let", "Pattern", "=", "pattern", ";", "let", "AsmString", "=", "asmstr", ";", "let", "hasSideEffects", "=", "<NUM_LIT>", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "mayStore", "=", "<NUM_LIT>", ";", "string", "DispKey", "=", "<STR_LIT>", ";", "string", "DispSize", "=", "<STR_LIT>", ";", "string", "OpKey", "=", "<STR_LIT>", ";", "string", "OpType", "=", "<STR_LIT>", ";", "string", "MemKey", "=", "<STR_LIT>", ";", "string", "MemType", "=", "<STR_LIT>", ";", "string", "NumOpsKey", "=", "<STR_LIT>", ";", "string", "NumOpsValue", "=", "<STR_LIT>", ";", "bit", "SimpleBDXLoad", "=", "<NUM_LIT>", ";", "bit", "SimpleBDXStore", "=", "<NUM_LIT>", ";", "bit", "Has20BitOffset", "=", "<NUM_LIT>", ";", "bit", "HasIndex", "=", "<NUM_LIT>", ";", "bit", "Is128Bit", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "AccessBytes", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "CCValues", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "CompareZeroCCMask", "=", "<NUM_LIT>", ";", "bit", "CCMaskFirst", "=", "<NUM_LIT>", ";", "bit", "CCMaskLast", "=", "<NUM_LIT>", ";", "bit", "IsLogical", "=", "<NUM_LIT>", ";", "bit", "CCIfNoSignedWrap", "=", "<NUM_LIT>", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "SimpleBDXLoad", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "SimpleBDXStore", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "Has20BitOffset", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "HasIndex", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "Is128Bit", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "AccessBytes", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "CCValues", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "CompareZeroCCMask", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "CCMaskFirst", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "CCMaskLast", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "IsLogical", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}" ]

[ ";" ]

[ "HOST_WIDE_INT", "unsorted_offsets", "[", "MAX_LDM_STM_OPS", "]", ";", "int", "or", "der", "[", "MAX_LDM_STM_OPS", "]", ";", "int", "base_reg", "=", "-", "<NUM_LIT>", ";", "int", "i", ",", "ldm_case", ";", "gcc_assert", "(", "nops", ">=", "<NUM_LIT>", "&&", "nops", "<=", "MAX_LDM_STM_OPS", ")", ";", "memset", "(", "or", "der", ",", "<NUM_LIT>", ",", "MAX_LDM_STM_OPS", "*", "sizeof", "(", "int", ")", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "nops", ";", "i", "++", ")", "{", "rtx", "reg", ";", "rtx", "offset", ";", "if", "(", "GET_CODE", "(", "operands", "[", "nops", "+", "i", "]", ")", "==", "SUBREG", ")", "operands", "[", "nops", "+", "i", "]", "=", "alter_subreg", "(", "operands", "+", "(", "nops", "+", "i", ")", ",", "true", ")", ";", "gcc_assert", "(", "MEM_P", "(", "operands", "[", "nops", "+", "i", "]", ")", ")", ";", "if", "(", "MEM_VOLATILE_P", "(", "operands", "[", "nops", "+", "i", "]", ")", ")", "return", "<NUM_LIT>", ";", "offset", "=", "const0_rtx", ";", "if", "(", "(", "REG_P", "(", "reg", "=", "XEXP", "(", "operands", "[", "nops", "+", "i", "]", ",", "<NUM_LIT>", ")", ")", "||", "(", "SUBREG_P", "(", "reg", ")", "&&", "REG_P", "(", "reg", "=", "SUBREG_REG", "(", "reg", ")", ")", ")", ")", "||", "(", "GET_CODE", "(", "XEXP", "(", "operands", "[", "nops", "+", "i", "]", ",", "<NUM_LIT>", ")", ")", "==", "PLUS", "&&", "(", "(", "REG_P", "(", "reg", "=", "XEXP", "(", "XEXP", "(", "operands", "[", "nops", "+", "i", "]", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ")", "||", "(", "SUBREG_P", "(", "reg", ")", "&&", "REG_P", "(", "reg", "=", "SUBREG_REG", "(", "reg", ")", ")", ")", ")", "&&", "(", "CONST_INT_P", "(", "offset", "=", "XEXP", "(", "XEXP", "(", "operands", "[", "nops", "+", "i", "]", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ")", ")", ")", "{", "if", "(", "i", "==", "<NUM_LIT>", ")", "{", "base_reg", "=", "REGNO", "(", "reg", ")", ";", "if", "(", "TARGET_THUMB1", "&&", "base_reg", ">", "LAST_LO_REGNUM", ")", "return", "<NUM_LIT>", ";", "}", "else", "if", "(", "base_reg", "!=", "(", "int", ")", "REGNO", "(", "reg", ")", ")", "return", "<NUM_LIT>", ";", "unsorted_regs", "[", "i", "]", "=", "(", "REG_P", "(", "operands", "[", "i", "]", ")", "?", "REGNO", "(", "operands", "[", "i", "]", ")", ":", "REGNO", "(", "SUBREG_REG", "(", "operands", "[", "i", "]", ")", ")", ")", ";", "if", "(", "unsorted_regs", "[", "i", "]", "<", "<NUM_LIT>", "||", "(", "TARGET_THUMB1", "&&", "unsorted_regs", "[", "i", "]", ">", "LAST_LO_REGNUM", ")", "||", "unsorted_regs", "[", "i", "]", ">", "<NUM_LIT>", "||", "(", "i", "!=", "nops", "-", "<NUM_LIT>", "&&", "unsorted_regs", "[", "i", "]", "==", "base_reg", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "unsorted_regs", "[", "i", "]", "==", "SP_REGNUM", "&&", "base_reg", "!=", "SP_REGNUM", ")", "return", "<NUM_LIT>", ";", "unsorted_offsets", "[", "i", "]", "=", "INTVAL", "(", "offset", ")", ";", "if", "(", "i", "==", "<NUM_LIT>", "||", "unsorted_offsets", "[", "i", "]", "<", "unsorted_offsets", "[", "or", "der", "[", "<NUM_LIT>", "]", "]", ")", "or", "der", "[", "<NUM_LIT>", "]", "=", "i", ";", "}", "else", "return", "<NUM_LIT>" ]

[ ";" ]

[ "if", "(", "Value", ".", "isAbsolute", "(", ")", ")", "{", "Result", "=", "evaluateAsInt64", "(", "Value", ".", "getConstant", "(", ")", ")", ";", "return", "true" ]

[ "int16_t", "Imm", ",", "SMLoc", "IDLoc", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "{" ]

[ "void", "MipsTargetStreamer", "::", "emitRRI", "(", "unsigned", "Opcode", ",", "unsigned", "Reg0", ",", "unsigned", "Reg1", "," ]

[ "}" ]

[ "for", "(", "opno", "=", "<NUM_LIT>", ";", "opno", "<", "recog_data", ".", "n_operands", ";", "opno", "++", ")", "{", "if", "(", "recog_data", ".", "operand_type", "[", "opno", "]", "!=", "OP_IN", ")", "continue", ";", "if", "(", "op_alt", "[", "opno", "]", ".", "memory_ok", ")", "{", "rtx", "op", "=", "recog_data", ".", "operand", "[", "opno", "]", ";", "if", "(", "CONSTANT_P", "(", "op", ")", ")", "{", "if", "(", "do_pushes", ")", "push_csky_minipool_fix", "(", "insn", ",", "address", ",", "recog_data", ".", "operand_loc", "[", "opno", "]", ",", "recog_data", ".", "operand_mode", "[", "opno", "]", ",", "op", ")", ";", "result", "=", "true", ";" ]

[ ",", "DAG", ")", ";" ]

[ "if", "(", "VT", ".", "isVector", "(", ")", ")", "{", "VecVT", "=", "IntVT", ";", "SetVecVal", "(", ")", ";", "}", "else", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "{", "VecVT", "=", "MVT", "::", "v2i64", ";", "SetVecVal", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "{", "VecVT", "=", "MVT", "::", "v4i32", ";", "SetVecVal", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "VT", "==", "MVT", "::", "f16", ")", "{", "VecVT", "=", "MVT", "::", "v8i16", ";", "SetVecVal", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "<STR_LIT>", "Invalid type for copysign!", "<STR_LIT>", ")", ";", "}", "unsigned", "BitWidth", "=", "In1", ".", "getScalarValueSizeInBits", "(", ")", ";", "SDValue", "SignMaskV", "=", "DAG", ".", "getConstant", "(", "~", "APInt", "::", "getSignMask", "(", "BitWidth", ")", ",", "DL", ",", "VecVT", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", "||", "VT", "==", "MVT", "::", "v2f64", ")", "{", "SignMaskV", "=", "DAG", ".", "getConstant", "(", "APInt", "::", "getAllOnes", "(", "BitWidth", ")", ",", "DL", ",", "VecVT", ")", ";", "SignMaskV", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "v2f64", ",", "SignMaskV", ")", ";", "SignMaskV", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FNEG", ",", "DL", ",", "MVT", "::", "v2f64", ",", "SignMaskV", ")", ";", "SignMaskV", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "v2i64", ",", "SignMaskV", ")", ";", "}", "SDValue", "BSP", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VecVT", ",", "SignMaskV", ",", "VecVal1", ",", "VecVal2", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f16", ")", "return", "DAG", ".", "getTargetExtractSubreg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "BSP", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "DAG", ".", "getTargetExtractSubreg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "BSP", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "return", "DAG", ".", "getTargetExtractSubreg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "BSP", ")", ";", "return", "BitCast", "(", "VT", ",", "BSP" ]

[ "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "let", "isReMaterializable", "=", "<NUM_LIT>", ";", "let", "isAsCheapAsAMove", "=", "<NUM_LIT>", ";", "let", "isMoveImm", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]