Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "}" ]

[ "_", "_", "arm_vqshrnbq_m_n_s16", "(", "int8x16_t", "_", "_", "a", ",", "int16x8_t", "_", "_", "b", ",", "const", "int", "_", "_", "imm", ",", "mve_pred16_t", "_", "_", "p", ")", "{", "return", "_", "_", "builtin_mve_vqshrnbq_m_n_sv8hi", "(", "_", "_", "a", ",", "_", "_", "b", ",", "_", "_", "imm", ",", "_", "_", "p", ")", ";" ]

[ "<FIXS>", "return", "<NUM_LIT>", ";", "if", "(", "TM", ".", "getCodeModel", "(", ")", "!=", "CodeModel", "::", "Small", ")", "return", "<NUM_LIT>", ";", "<FIXE>", "<FIXS>", "default", ":", "return", "<NUM_LIT>", ";", "<FIXE>" ]

[ "unsigned", "X86FastISel", "::", "TargetMaterializeConstant", "(", "const", "Constant", "*", "C", ")", "{", "MVT", "VT", ";", "if", "(", "!", "isTypeLegal", "(", "C", "->", "getType", "(", ")", ",", "VT", ")", ")", "<BUGS>", "return", "false", ";", "<BUGE>", "unsigned", "Opc", "=", "<NUM_LIT>", ";", "const", "TargetRegisterClass", "*", "RC", "=", "NULL", ";", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "<BUGS>", "default", ":", "return", "false", ";", "<BUGE>", "case", "MVT", "::", "i8", ":", "Opc", "=", "X86", "::", "MOV8rm", ";", "RC", "=", "&", "X86", "::", "GR8RegClass", ";" ]

[ "}" ]

[ "iterator", "L", "=", "std", "::", "lower_bound", "(", "Seq", ".", "begin", "(", ")", ",", "Seq", ".", "end", "(", ")", ",", "VR", ",", "Ord", ")", ";", "if", "(", "L", "!=", "Seq", ".", "end", "(", ")", ")", "Seq", ".", "erase", "(", "L", ")", ";" ]

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

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

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

[ "let", "ResourceCycles", "=", "[", "<NUM_LIT>", ",", "<NUM_LIT>", "," ]

[ "if", "(", "F", ".", "hasSection", "(", ")", ")", "return", "false", ";" ]

[ "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "!", "OutlineFromLinkOnceODRs", "&&", "F", ".", "hasLinkOnceODRLinkage", "(", ")", ")", "return", "false", ";" ]

[ "static", "void", "rs6000_split_logical_di", "(", "rtx", "operands", "[", "<NUM_LIT>", "]", ",", "enum", "rtx_code", "code", ",", "bool", "complement_final_p", ",", "bool", "complement_op1_p", ",", "bool", "complement_op2_p", ")", "{", "const", "HOST_WIDE_INT", "lower_32bits", "=", "HOST_WIDE_INT_C", "(", "<NUM_LIT>", ")", ";", "const", "HOST_WIDE_INT", "upper_32bits", "=", "~", "lower_32bits", ";", "const", "HOST_WIDE_INT", "sign_bit", "=", "HOST_WIDE_INT_C", "(", "<NUM_LIT>", ")", ";", "enum", "hi_lo", "{", "hi", "=", "<NUM_LIT>", ",", "lo", "=", "<NUM_LIT>", "}", ";", "rtx", "op0_hi_lo", "[", "<NUM_LIT>", "]", ",", "op1_hi_lo", "[", "<NUM_LIT>", "]", ",", "op2_hi_lo", "[", "<NUM_LIT>", "]", ";", "size_t", "i", ";", "op0_hi_lo", "[", "hi", "]", "=", "gen_highpart", "(", "SImode", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "op1_hi_lo", "[", "hi", "]", "=", "gen_highpart", "(", "SImode", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "op0_hi_lo", "[", "lo", "]", "=", "gen_lowpart", "(", "SImode", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "op1_hi_lo", "[", "lo", "]", "=", "gen_lowpart", "(", "SImode", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "if", "(", "code", "==", "NOT", ")", "op2_hi_lo", "[", "hi", "]", "=", "op2_hi_lo", "[", "lo", "]", "=", "NULL_RTX", ";", "else", "{", "if", "(", "!", "CONST_INT_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "{", "op2_hi_lo", "[", "hi", "]", "=", "gen_highpart_mode", "(", "SImode", ",", "DImode", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "op2_hi_lo", "[", "lo", "]", "=", "gen_lowpart", "(", "SImode", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "}", "else", "{", "HOST_WIDE_INT", "value", "=", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", ";", "HOST_WIDE_INT", "value_hi_lo", "[", "<NUM_LIT>", "]", ";", "gcc_assert", "(", "!", "complement_final_p", ")", ";", "gcc_assert", "(", "!", "complement_op1_p", ")", ";", "gcc_assert", "(", "!", "complement_op2_p", ")", ";", "value_hi_lo", "[", "hi", "]", "=", "value", ">>", "<NUM_LIT>", ";", "value_hi_lo", "[", "lo", "]", "=", "value", "&", "lower_32bits", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "{", "HOST_WIDE_INT", "sub_value", "=", "value_hi_lo", "[", "i", "]", ";", "if", "(", "sub_value", "&", "sign_bit", ")", "sub_value", "|=", "upper_32bits", ";", "op2_hi_lo", "[", "i", "]", "=", "GEN_INT", "(", "sub_value", ")", ";", "if", "(", "code", "==", "AND", "&&", "sub_value", "!=", "-", "<NUM_LIT>", "&&", "sub_value", "!=", "<NUM_LIT>", "&&", "!", "and", "_", "operand", "(", "op2_hi_lo", "[", "i", "]", ",", "SImode", ")", ")", "op2_hi_lo", "[", "i", "]", "=", "force_reg", "(", "SImode", ",", "op2_hi_lo", "[", "i", "]", ")", ";", "}", "}", "}", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "{", "if", "(", "(", "code", "==", "IOR", "||", "code", "==", "XOR", ")", "&&", "CONST_INT_P", "(", "op2_hi_lo", "[", "i", "]", ")", "&&", "!", "complement_final_p", "&&", "!", "complement_op1_p", "&&", "!", "complement_op2_p", "&&", "!", "logical_const_operand", "(", "op2_hi_lo", "[", "i", "]", ",", "SImode", ")", ")", "{", "HOST_WIDE_INT", "value", "=", "INTVAL", "(", "op2_hi_lo", "[", "i", "]", ")", ";", "HOST_WIDE_INT", "hi_16bits", "=", "value", "&", "HOST_WIDE_INT_C", "(", "<NUM_LIT>", ")", ";", "HOST_WIDE_INT", "lo_16bits", "=", "value", "&", "HOST_WIDE_INT_C", "(", "<NUM_LIT>", ")", ";", "rtx", "tmp", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "if", "(", "(", "hi_16bits", "&", "sign_bit", ")", "!=", "<NUM_LIT>", ")", "hi_16bits", "|=", "upper_32bits", ";", "rs6000_split_logical_inner", "(", "tmp", ",", "op1_hi_lo", "[", "i", "]", ",", "GEN_INT", "(", "hi_16bits", ")", ",", "code", ",", "SImode", ",", "false", ",", "false", ",", "false", ")", ";", "rs6000_split_logical_inner", "(", "op0_hi_lo", "[", "i", "]", ",", "tmp", ",", "GEN_INT", "(", "lo_16bits", ")", ",", "code", ",", "SImode", ",", "false", ",", "false", ",", "false", ")", ";", "}", "else", "rs6000_split_logical_inner", "(", "op0_hi_lo", "[", "i", "]", ",", "op1_hi_lo", "[", "i", "]", ",", "op2_hi_lo", "[", "i", "]", ",", "code", ",", "SImode", ",", "complement_final_p", ",", "complement_op1_p", ",", "complement_op2_p", ")", ";", "}", "return", ";", "}" ]

[ "Split", "a", "DImode", "AND/IOR/XOR", "with", "a", "constant", "on", "a", "32-bit", "system", ".", "These", "operations", "are", "split", "immediately", "during", "RTL", "generation", "to", "allow", "for", "more", "optimizations", "of", "the", "AND/IOR/XOR", ".", "OPERANDS", "is", "an", "array", "containing", "the", "destination", "and", "two", "input", "operands", ".", "CODE", "is", "the", "base", "operation", "(", "AND", ",", "IOR", ",", "XOR", ",", "NOT", ")", ".", "MODE", "is", "the", "machine", "mode", ".", "If", "COMPLEMENT_FINAL_P", "is", "true", ",", "wrap", "the", "whole", "operation", "with", "NOT", ".", "If", "COMPLEMENT_OP1_P", "is", "true", ",", "wrap", "operand1", "with", "NOT", ".", "If", "COMPLEMENT_OP2_P", "is", "true", ",", "wrap", "operand2", "with", "NOT", ".", "CLOBBER_REG", "is", "either", "NULL", "or", "a", "scratch", "register", "of", "type", "CC", "to", "allow", "formation", "of", "the", "AND", "instructions", "." ]

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

[ "def", "C2_mux", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "IntRegs", ":", "$", "Rs32", ",", "IntRegs", ":", "$", "Rt32", ")", ",", "<STR_LIT>", ",", "tc_4c5ba658", ",", "TypeALU32_3op", ">", ",", "Enc_ea4c54", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";" ]

[ "}", ")" ]

[ "code", "=", "m68k_output_compare_di", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "insn", ",", "code", ")", "operands", "[", "<NUM_LIT>", "]", "=", "operands", "[", "<NUM_LIT>", "]", "return", "m68k_output_branch_integer", "(", "code", ")" ]

[ ";" ]

[ "bool", "hasFlatScratchInsts", "(", ")", "const", "{", "return", "FlatScratchInsts" ]

[ "return", "sle_operand", "(", "cmp1", ",", "VOIDmode", ")", ";" ]

[ "return", "reg_or_0_operand", "(", "cmp1", ",", "VOIDmode", ")", ";", "case", "GE", ":", "case", "GEU", ":", "return", "!", "TARGET_MIPS16", "&&", "cmp1", "==", "const1_rtx", ";", "case", "LT", ":", "case", "LTU", ":", "return", "arith_operand", "(", "cmp1", ",", "VOIDmode", ")", ";", "case", "LE", ":" ]

[ "return", "true", ";" ]

[ "break", ";", "case", "TargetOpcode", "::", "COPY", ":", "{", "unsigned", "DstReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "return", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "DstReg", ")", "||", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "DstReg", ")", ")", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "assert", "(", "MI", ".", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", "==", "<NUM_LIT>", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "invalid ORRrs operands", "<STR_LIT>", ")", ";", "return", "true", ";", "}", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "{", "assert", "(", "MI", ".", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", "==", "<NUM_LIT>", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "invalid ADDXri operands", "<STR_LIT>", ")", ";" ]

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

[ "EVT", "WidenedVT", ";", "if", "(", "VT", "==", "MVT", "::", "nxv16i8", ")", "WidenedVT", "=", "MVT", "::", "nxv8i16", ";", "else", "if", "(", "VT", "==", "MVT", "::", "nxv8i16", ")", "WidenedVT", "=", "MVT", "::", "nxv4i32", ";", "else", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected Custom DIV operation", "<STR_LIT>", ")", ";", "SDLoc", "dl", "(", "Op", ")", ";", "unsigned", "UnpkLo", "=", "Signed", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "unsigned", "UnpkHi", "=", "Signed", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "SDValue", "Op0Lo", "=", "DAG", ".", "getNode", "(", "UnpkLo", ",", "dl", ",", "WidenedVT", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "Op1Lo", "=", "DAG", ".", "getNode", "(", "UnpkLo", ",", "dl", ",", "WidenedVT", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "Op0Hi", "=", "DAG", ".", "getNode", "(", "UnpkHi", ",", "dl", ",", "WidenedVT", ",", "Op", ".", "getOperand", "(" ]

[ "}" ]

[ "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

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

[ "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "{", "int", "log2", "=", "exact_log2", "(", "INTVAL", "(", "operands", "[" ]

[ "}" ]

[ "}", "Lexer", ".", "Lex", "(", ")", ";", "if", "(", "Lexer", ".", "isNot", "(", "AsmToken", "::", "Integer", ")", ")", "{", "Err", "<<", "<STR_LIT>", "integer literal expected", "<STR_LIT>", ";", "return", "false", ";", "}", "return", "true", ";" ]

[ "DONE" ]

[ "rtx", "tmp", "=", "gen_reg_rtx", "(", "V16SFmode", ")", "emit_insn", "(", "gen_avx512f_rndscalev16sf", "(", "tmp", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "emit_insn", "(", "gen_fix_truncv16sfv16si2", "(", "operands", "[", "<NUM_LIT>", "]", ",", "tmp", ")", ")" ]

[ ")", ";" ]

[ "RegListOp", "getRegList", "(", ")", "const", "{", "assert", "(", "Kind", "==", "RegisterList", "&&", "<STR_LIT>", "Invalid type access!", "<STR_LIT>" ]

[ "GEN_INT", "(", "(", "mask", ">", ">", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", "," ]

[ "(", "match_operand", ":", "V8SI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", ")", "]", "<STR_LIT>", "{", "int", "mask", "=", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "emit_insn", "(", "gen_avx2_pshufd_1_mask", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "GEN_INT", "(", "(", "mask", ">", ">", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", "," ]

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

[ "bool", "BlackfinTargetMachine", "::", "addInstSelector", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "PM", ".", "add", "(", "createBlackfinISelDag", "(", "*", "this", ",", "OptLevel", ")", ")", ";" ]

[ "MCSymbol", "*", "cfi_check_symbol", "=", "TLOF", "->", "getContext", "(", ")", ".", "getOrCreateSymbol", "(", "NameStr", ")", ";" ]

[ "if", "(", "TT", ".", "isKnownWindowsMSVCEnvironment", "(", ")", "&&", "MMI", "->", "usesVAFloatArgument", "(", ")", ")", "{", "StringRef", "SymbolName", "=", "(", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", "?", "<STR_LIT>", "_fltused", "<STR_LIT>", ":", "<STR_LIT>", "__fltused", "<STR_LIT>", ";", "MCSymbol", "*", "S", "=", "MMI", "->", "getContext", "(", ")", ".", "getOrCreateSymbol", "(", "SymbolName", ")", ";", "OutStreamer", "->", "EmitSymbolAttribute", "(", "S", ",", "MCSA_Global", ")", ";", "}", "if", "(", "TT", ".", "isOSBinFormatCOFF", "(", ")", ")", "{", "SM", ".", "serializeToStackMapSection", "(", ")", ";", "}", "if", "(", "TT", ".", "isOSBinFormatELF", "(", ")", ")", "{", "SM", ".", "serializeToStackMapSection", "(", ")", ";", "FM", ".", "serializeToFaultMapSection", "(", ")", ";", "}", "if", "(", "InstrumentSandboxingCFI", ")", "{", "const", "TargetLoweringObjectFile", "*", "TLOF", "=", "TM", ".", "getObjFileLowering", "(", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "TLOF", "->", "getMagicStringTableSection", "(", ")", ")", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "FunctionMagicLabelCount", ";", "i", "++", ")", "{", "std", "::", "string", "magic_label", ";", "magic_label", "=", "<STR_LIT>", "__magic_label_", "<STR_LIT>", "+", "std", "::", "to_string", "(", "i", ")", ";", "SmallString", "<", "<NUM_LIT>", ">", "NameStr", "(", "magic_label", ")", ";", "MCSymbol", "*", "magic_symbol", "=", "TLOF", "->", "getContext", "(", ")", ".", "getOrCreateSymbol", "(", "NameStr", ")", ";", "OutStreamer", "->", "EmitSymbolValue", "(", "magic_symbol", ",", "<NUM_LIT>", ")", ";", "}", "OutStreamer", "->", "SwitchSection", "(", "TLOF", "->", "getCFICheckTableSection", "(", ")", ")", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "CFICheckLabelCount", ";", "i", "++", ")", "{", "std", "::", "string", "cfi_check_label", ";", "cfi_check_label", "=", "<STR_LIT>", "__cfi_check_label_", "<STR_LIT>", "+", "std", "::", "to_string", "(", "i", ")", ";", "SmallString", "<", "<NUM_LIT>", ">", "NameStr", "(", "cfi_check_label", ")", ";" ]

[ ")", ";" ]

[ "int", "inner_bitsize", "=", "GET_MODE_BITSIZE", "(", "inner_mode", ")", ";", "wide_int", "mask_val", "=", "wi", "::", "set_bit_in_zero", "(", "inner_bitsize", "-", "<NUM_LIT>", ",", "inner_bitsize", ")", ";", "machine_mode", "int_mode", "=", "related_int_vector_mode", "(", "mode", ")", ".", "require", "(", ")", ";", "rtx", "mask", "=", "immed_wide_int_const", "(", "mask_val", ",", "GET_MODE_INNER", "(", "int_mode", ")", ")", ";", "mask", "=", "gen_lowpart", "(", "inner_mode", ",", "mask", ")", ";", "int", "nunits", "=", "GET_MODE_NUNITS", "(", "mode" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "rhaz", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "op1", ";", "let", "SrcB", "=", "op2", ";", "let", "OperandType", "=", "optype", ";", "let", "Switches", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sw", ";", "let", "Switches", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "VectorPred", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Pred", ")", ",", "<STR_LIT>", ")", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";", "let", "HasImm", "=", "<NUM_LIT>", ";" ]

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

[ "uint32_t", "ARMMCCodeEmitter", "::", "getUnconditionalBranchTargetOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpIdx", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "unsigned", "Val", "=", "::", "getBranchTargetOpValue", "(", "MI", ",", "OpIdx", ",", "ARM", "::", "fixup_t2_uncondbranch", ",", "Fixups", ")", ";", "bool", "I", "=", "(", "Val", "&", "<NUM_LIT>", ")", ";", "bool", "J1", "=", "(", "Val" ]

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

[ "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "MIOperandInfo", "=", "(", "ops", "GPR", ":", "$", "addr", ",", "i32imm", ")", ";" ]

[ "let", "Uses", "=", "[", "USR", "]", ";" ]

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

[ "case", "Intrinsic", "::", "ptrmask", ":" ]

[ "static", "bool", "isRemovablePointerIntrinsic", "(", "Intrinsic", "::", "ID", "IID", ")", "{", "switch", "(", "IID", ")", "{", "default", ":", "return", "false", ";" ]

[ "return", "(", "*", "It", ")", ".", "second", "->", "SccNum", ";" ]

[ "int", "R600MachineCFGStructurizer", "::", "getSCCNum", "(", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "MBBInfoMap", "::", "const_iterator", "It", "=", "BlockInfoMap", ".", "find", "(", "MBB", ")", ";", "if", "(", "It", "==", "BlockInfoMap", ".", "end", "(", ")", ")", "return", "INVALIDSCCNUM", ";" ]

[ "||", "type", "==", "TYPE_MULT_SHADOW", ")", ";" ]

[ "return", "(", "type", "==", "TYPE_SHADOW", "||", "type", "==", "TYPE_LOAD_SHADOW" ]

[ ")", ";" ]

[ "return", "(", "(", "(", "insn", ")", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>" ]

[ "(", "match_operator", ":", "GPR", "<NUM_LIT>", "<STR_LIT>" ]

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

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

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

[ "<STR_LIT>" ]

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

[ "Sched", "<", "[", "]", ">", "{" ]

[ "class", "UDFType", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "string", "asm", ">", ":", "I", "<", "(", "outs", ")", ",", "(", "ins", "uimm16", ":", "$", "imm", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", "," ]

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

[ "def", "Imm0_7Operand", ":", "AsmImmRange", "<", "<NUM_LIT>" ]

[ "virtual", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "<STR_LIT>", "Cpu0 Assembly Printer", "<STR_LIT>", ";", "}" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "static", "inline", "<STR_LIT>", "::", "<STR_LIT>", "getEmptyKey", "(", ")", "{", "return", "<STR_LIT>", "::", "<STR_LIT>", "(", "<STR_LIT>", "::", "<STR_LIT>", "::", "STK_Empty", ")", ";", "}" ]

[ "Empty", "key", ":", "no", "key", "should", "be", "generated", "that", "has", "no", "DILocalVariable", "." ]

[ "f64", "FPR64", ":", "$", "Rn", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "f64", "(", "vector_extract", "(", "v1f64", "FPR64", ":", "$", "Rn", ")", ",", "(", "i64", "<NUM_LIT>", ")", ")", ")", ",", "(" ]

[ "return", "NewSetCC", ";" ]

[ "SDValue", "X86TargetLowering", "::", "LowerSETCC", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "MVT", "VT", "=", "Op", ".", "getSimpleValueType", "(", ")", ";", "if", "(", "VT", ".", "isVector", "(", ")", ")", "return", "LowerVSETCC", "(", "Op", ",", "Subtarget", ",", "DAG", ")", ";", "assert", "(", "(", "(", "!", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "VT", "==", "MVT", "::", "i8", ")", "||", "(", "VT", "==", "MVT", "::", "i1", ")", ")", "&&", "<STR_LIT>", "SetCC type must be 8-bit or 1-bit integer", "<STR_LIT>", ")", ";", "SDValue", "Op0", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Op1", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDLoc", "dl", "(", "Op", ")", ";", "ISD", "::", "CondCode", "CC", "=", "cast", "<", "CondCodeSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "get", "(", ")", ";", "if", "(", "Op0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "AND", "&&", "Op0", ".", "hasOneUse", "(", ")", "&&", "isNullConstant", "(", "Op1", ")", "&&", "(", "CC", "==", "ISD", "::", "SETEQ", "||", "CC", "==", "ISD", "::", "SETNE", ")", ")", "{", "if", "(", "SDValue", "NewSetCC", "=", "LowerToBT", "(", "Op0", ",", "CC", ",", "dl", ",", "DAG", ")", ")", "{", "if", "(", "VT", "==", "MVT", "::", "i1", ")", "return", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "i1", ",", "NewSetCC", ")", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "and", "(", "match_code" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";" ]

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

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

[ "Mask", ";" ]

[ "uint64_t", "Mask", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "Bits", ".", "size", "(", ")", ";", "++", "i", ")", "{", "if", "(", "Bits", "[", "i", "]", ".", "hasValue", "(", ")", ")", "continue", ";", "Mask", "|=", "(", "UINT64_C", "(", "<NUM_LIT>", ")", "<<", "i", ")", ";", "}", "return", "~" ]

[ "}" ]

[ "vreinterpretq_s16_p8", "(", "poly8x16_t", "_", "_", "a", ")", "{", "return", "(", "int16x8_t", ")", "_", "_", "a", ";" ]

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

[ "let", "hasSideEffects", "=", "<NUM_LIT>", ";", "let", "isNotUsedInDisasm", "=", "<NUM_LIT>", ";", "let", "Size", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "Opcode", "=", "opc", ";", "bits", "<", "<NUM_LIT>", ">", "OType", "=", "OpType", ".", "INT32", ";", "bit", "HasImm", "=", "<NUM_LIT>", ";", "bit", "IsPredicated", "=", "<NUM_LIT>", ";", "bit", "OutOfSlotData", "=", "<NUM_LIT>", ";", "bit", "HasCompositeImm", "=", "<NUM_LIT>", ";", "SlotType", "Slot", "=", "slot", ";", "bits", "<", "<NUM_LIT>", ">", "Inst", ";", "field", "bits", "<", "<NUM_LIT>", ">", "SoftFail", "=", "<NUM_LIT>", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Slot", ".", "Value", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "HasImm", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "IsPredicated", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "OutOfSlotData", ";", "bits", "<", "<NUM_LIT>", ">", "hasImmField", "=", "<NUM_LIT>", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "hasImmField", ";", "bits", "<", "<NUM_LIT>", ">", "startBit", "=", "<NUM_LIT>", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "startBit", ";" ]

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

[ "<STR_LIT>", "{", "if", "(", "MODE", ">", "mode", "!", "=", "VEC_GATHER_SRCDI", ">", "mode", ")", "<BUGS>", "return", "<STR_LIT>", "return", "<STR_LIT>", "<BUGE>", "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "->", "isFrameAddressTaken", "(", ")", ";" ]

[ "if", "(", "MFI", "->", "hasCalls", "(", ")", "||", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "&&", "MFI", "->", "adjustsStack", "(", ")", ")", ")", "return", "true", ";", "return", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI" ]

[ "if", "(", "flag_pic", "==", "<NUM_LIT>", "&&", "mode", "==", "Pmode", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "UNSPEC", "&&", "XINT", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", "==", "UNSPEC_LOAD_GOT", "&&", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", "==", "pic_offset_table_rtx", "&&", "(", "GET_CODE", "(", "XVECEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "XVECEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "==", "LABEL_REF", ")", ")", "return", "!", "no_large_offset", ";" ]

[ "if", "(", "strict", ")", "return", "REGNO_OK_FOR_BASE_STRICT_P", "(", "REGNO", "(", "x", ")", ")", ";", "else", "return", "REGNO_OK_FOR_BASE_NONSTRICT_P", "(", "REGNO", "(", "x", ")", ")", ";", "case", "PLUS", ":", "if", "(", "!", "REG_P", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "||", "!", "c6x_legitimate_address_p_1", "(", "mode", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "strict", ",", "false", ")", ")", "return", "false", ";", "if", "(", "REG_P", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ")", "return", "false", ";", "if", "(", "mode", "==", "BLKmode", ")", "size", "=", "<NUM_LIT>", ";", "else", "if", "(", "mode", "==", "VOIDmode", ")", "size", "=", "<NUM_LIT>", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "flag_pic", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "UNSPEC", "&&", "XINT", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", "==", "UNSPEC_LOAD_SDATA", "&&", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", "==", "pic_offset_table_rtx", "&&", "sdata_symbolic_operand", "(", "XVECEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "SImode", ")", ")", "return", "!", "no_large_offset", "&&", "size", "<=", "<NUM_LIT>", ";" ]

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

[ "int64_t", "Offset", "=", "cast", "<", "GlobalAddressSDNode", ">", "(", "Op", ")", "->", "getOffset", "(", ")", ";", "SDLoc", "dl", "(", "Op", ")", ";", "Result", "=", "DAG", ".", "getTargetGlobalAddress", "(", "GV", ",", "dl", ",", "getPointerTy", "(", ")", ",", "Offset", ")", ";", "const", "HexagonTargetObjectFile", "*", "TLOF", "=", "static_cast", "<", "const", "HexagonTargetObjectFile", "*", ">", "(", "getTargetMachine", "(", ")", ".", "getObjFileLowering", "(", ")", ")", ";", "if", "(", "TLOF", "->", "IsGlobalInSmallSection", "(", "GV", ",", "getTargetMachine", "(", ")", ")", ")", "{", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "getPointerTy", "(", ")" ]

[ "ISD", "::", "ANY_EXTEND_VECTOR_INREG", ")", ";" ]

[ "SDValue", "HexagonTargetLowering", "::", "LowerHvxExtend", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "assert", "(", "Op", ".", "getOpcode", "(", ")", "==" ]

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

[ "def", "C2_tfrpr", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Ps4", ")", ",", "<STR_LIT>", ",", "tc_0ae0825c", ",", "TypeS_2op", ">", ",", "Enc_f5e933", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "FeatureLeon", ",", "ReplaceSDIV", ",", "FixCALL", ",", "IgnoreZeroFlag", ",", "InsertNOPDoublePrecision", ",", "FillDataCache", ",", "RestoreExecAddress", "<FIXE>" ]

[ "def", ":", "Processor", "<STR_LIT>", ",", "LEON2Itineraries", ",", "[", "<BUGS>", "FeatureLeon", ",", "ReplaceSDIV", ",", "FixCALL", ",", "IgnoreZeroFlag", ",", "InsertNOPDoublePrecision", "<BUGE>", "]", ">", ";" ]

[ "BuildMI", "(", "MBB", ",", "MII", ",", "DL", ",", "get", "(", "TargetOpcode", "::", "REG_SEQUENCE", ")", ",", "FullDestReg", ")", ".", "addReg", "(", "DestSub0", ")", ".", "addImm", "(", "AMDGPU", "::", "sub0", ")", ".", "addReg", "(", "DestSub1", ")", ".", "addImm", "(", "AMDGPU", "::", "sub1", ")", ";" ]

[ "MachineOperand", "SrcReg0Sub0", "=", "buildExtractSubRegOrImm", "(", "MII", ",", "MRI", ",", "Src0", ",", "Src0RC", ",", "AMDGPU", "::", "sub0", ",", "Src0SubRC", ")", ";", "MachineOperand", "SrcReg1Sub0", "=", "buildExtractSubRegOrImm", "(", "MII", ",", "MRI", ",", "Src1", ",", "Src1RC", ",", "AMDGPU", "::", "sub0", ",", "Src1SubRC", ")", ";", "const", "TargetRegisterClass", "*", "DestRC", "=", "MRI", ".", "getRegClass", "(", "Dest", ".", "getReg", "(", ")", ")", ";", "const", "TargetRegisterClass", "*", "DestSubRC", "=", "RI", ".", "getSubRegClass", "(", "DestRC", ",", "AMDGPU", "::", "sub0", ")", ";", "unsigned", "DestSub0", "=", "MRI", ".", "createVirtualRegister", "(", "DestRC", ")", ";", "MachineInstr", "*", "LoHalf", "=", "BuildMI", "(", "MBB", ",", "MII", ",", "DL", ",", "InstDesc", ",", "DestSub0", ")", ".", "addOperand", "(", "SrcReg0Sub0", ")", ".", "addOperand", "(", "SrcReg1Sub0", ")", ";", "MachineOperand", "SrcReg0Sub1", "=", "buildExtractSubRegOrImm", "(", "MII", ",", "MRI", ",", "Src0", ",", "Src0RC", ",", "AMDGPU", "::", "sub1", ",", "Src0SubRC", ")", ";", "MachineOperand", "SrcReg1Sub1", "=", "buildExtractSubRegOrImm", "(", "MII", ",", "MRI", ",", "Src1", ",", "Src1RC", ",", "AMDGPU", "::", "sub1", ",", "Src1SubRC", ")", ";", "unsigned", "DestSub1", "=", "MRI", ".", "createVirtualRegister", "(", "DestSubRC", ")", ";", "MachineInstr", "*", "HiHalf", "=", "BuildMI", "(", "MBB", ",", "MII", ",", "DL", ",", "InstDesc", ",", "DestSub1", ")", ".", "addOperand", "(", "SrcReg0Sub1", ")", ".", "addOperand", "(", "SrcReg1Sub1", ")", ";", "unsigned", "FullDestReg", "=", "MRI", ".", "createVirtualRegister", "(", "DestRC", ")", ";" ]

[ "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "LastInst", ".", "getOpcode", "(", ")", ")", ")", ";" ]

[ "static", "void", "parseCondBranch", "(", "MachineInstr", "&", "LastInst", ",", "MachineBasicBlock", "*", "&", "Target", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "{", "assert", "(", "LastInst", ".", "getDesc", "(", ")", ".", "isConditionalBranch", "(", ")", "&&", "<STR_LIT>", "Unknown conditional branch", "<STR_LIT>", ")", ";", "Target", "=", "LastInst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";" ]

[ "}" ]

[ "let", "DecoderMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "ShiftedImmAsmOperand", ";", "let", "MIOperandInfo", "=", "(", "ops", "GPR", ",", "i32imm", ")", ";" ]

[ "ADD16ri8", ":" ]

[ "FuseKind", "=", "FuseTest", ";", "break", ";", "}", "switch", "(", "First", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "X86", "::", "TEST8rr", ":", "case", "X86", "::", "TEST16rr", ":", "case", "X86", "::", "TEST32rr", ":", "case", "X86", "::", "TEST64rr", ":", "case", "X86", "::", "TEST8ri", ":", "case", "X86", "::", "TEST16ri", ":", "case", "X86", "::", "TEST32ri", ":", "case", "X86", "::", "TEST32i32", ":", "case", "X86", "::", "TEST64i32", ":", "case", "X86", "::", "TEST64ri32", ":", "case", "X86", "::", "TEST8rm", ":", "case", "X86", "::", "TEST16rm", ":", "case", "X86", "::", "TEST32rm", ":", "case", "X86", "::", "TEST64rm", ":", "case", "X86", "::", "TEST8ri_NOREX", ":", "case", "X86", "::", "AND16i16", ":", "case", "X86", "::", "AND16ri", ":", "case", "X86", "::", "AND16ri8", ":", "case", "X86", "::", "AND16rm", ":", "case", "X86", "::", "AND16rr", ":", "case", "X86", "::", "AND32i32", ":", "case", "X86", "::", "AND32ri", ":", "case", "X86", "::", "AND32ri8", ":", "case", "X86", "::", "AND32rm", ":", "case", "X86", "::", "AND32rr", ":", "case", "X86", "::", "AND64i32", ":", "case", "X86", "::", "AND64ri32", ":", "case", "X86", "::", "AND64ri8", ":", "case", "X86", "::", "AND64rm", ":", "case", "X86", "::", "AND64rr", ":", "case", "X86", "::", "AND8i8", ":", "case", "X86", "::", "AND8ri", ":", "case", "X86", "::", "AND8rm", ":", "case", "X86", "::", "AND8rr", ":", "return", "true", ";", "case", "X86", "::", "CMP16i16", ":", "case", "X86", "::", "CMP16ri", ":", "case", "X86", "::", "CMP16ri8", ":", "case", "X86", "::", "CMP16rm", ":", "case", "X86", "::", "CMP16rr", ":", "case", "X86", "::", "CMP32i32", ":", "case", "X86", "::", "CMP32ri", ":", "case", "X86", "::", "CMP32ri8", ":", "case", "X86", "::", "CMP32rm", ":", "case", "X86", "::", "CMP32rr", ":", "case", "X86", "::", "CMP64i32", ":", "case", "X86", "::", "CMP64ri32", ":", "case", "X86", "::", "CMP64ri8", ":", "case", "X86", "::", "CMP64rm", ":", "case", "X86", "::", "CMP64rr", ":", "case", "X86", "::", "CMP8i8", ":", "case", "X86", "::", "CMP8ri", ":", "case", "X86", "::", "CMP8rm", ":", "case", "X86", "::", "CMP8rr", ":", "case", "X86", "::", "ADD16i16", ":", "case", "X86", "::", "ADD16ri", ":", "case", "X86", "::" ]

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

[ "(", "compare", ":", "CC_FP", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

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

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

[ ")", ";" ]

[ "PostGenericScheduler", "::", "initialize", "(", "Dag" ]

[ "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "MipsTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "{", "switch", "(", "Constraint", "[", "<NUM_LIT>", "]", ")", "{", "case", "'", "d", "'", ":", "case", "'", "y", "'", ":", "case", "'", "r", "'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "i16", "||", "VT", "==", "MVT", "::", "i8", ")", "{", "if", "(", "Subtarget", ".", "inMips16Mode", "(", ")", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "Mips", "::", "CPU16RegsRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "Mips", "::", "GPR32RegClass", ")", ";", "}", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "!", "Subtarget", ".", "isGP64bit", "(", ")", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "Mips", "::", "GPR32RegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "Subtarget", ".", "isGP64bit", "(", ")", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "Mips", "::", "GPR64RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "nullptr", ")", ";", "case", "'", "f", "'", ":", "if", "(", "VT", "==", "MVT", "::", "v16i8", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "Mips", "::", "MSA128BRegClass", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "v8i16", "||", "VT", "==", "MVT", "::", "v8f16", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "Mips", "::", "MSA128HRegClass", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "v4i32", "||", "VT", "==", "MVT", "::", "v4f32", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "Mips", "::", "MSA128WRegClass", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "v2i64", "||", "VT", "==", "MVT", "::", "v2f64", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "Mips", "::", "MSA128DRegClass", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "Mips", "::", "FGR32RegClass", ")", ";", "else", "if", "(", "(", "VT", "==", "MVT", "::", "f64", ")", "&&", "(", "!", "Subtarget", ".", "isSingleFloat", "(", ")", ")", ")", "{", "if", "(", "Subtarget", ".", "isFP64bit", "(", ")", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "Mips", "::", "FGR64RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "Mips", "::", "AFGR64RegClass", ")", ";", "}", "break", ";", "case", "'", "c", "'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "T9", ",", "&", "Mips", "::", "GPR32RegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "T9_64", ",", "&", "Mips", "::", "GPR64RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "nullptr", ")", ";", "case", "'", "l", "'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "i16", "||", "VT", "==", "MVT", "::", "i8", ")", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "LO0", ",", "&", "Mips", "::", "LO32RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "LO0_64", ",", "&", "Mips", "::", "LO64RegClass", ")", ";", "case", "'", "x", "'", ":", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "nullptr", ")", ";", "}", "}", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "R", ";", "R", "=", "parseRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "if", "(", "R", ".", "second", ")", "return", "R", ";", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "let", "Uses", "=", "[", "CS", "]", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";" ]

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

[ "def", "J4_cmpgtui_fp1_jump_nt", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "GeneralSubRegs", ":", "$", "Rs16", ",", "u5_0Imm", ":", "$", "II", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_3d495a39", ",", "TypeCJ", ">", ",", "Enc_14d27a", ",", "PredRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";" ]

[ "a", ",", "_", "_", "b", ")", ";" ]

[ "vdup_laneq_s16", "(", "int16x8_t", "_", "_", "a", ",", "const", "int", "_", "_", "b", ")", "{", "return", "_", "_", "aarch64_vdup_laneq_s16", "(", "_", "_" ]

[ ".", "getInstrInfo", "(", ")", ";" ]

[ "bool", "X86FastTileConfig", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MFunc", ")", "{", "MF", "=", "&", "MFunc", ";", "MRI", "=", "&", "MFunc", ".", "getRegInfo", "(", ")", ";", "ST", "=", "&", "MFunc", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "TRI", "=", "ST", "->", "getRegisterInfo", "(", ")", ";", "TII", "=", "MFunc", ".", "getSubtarget", "(", ")" ]

[ ">", ";" ]

[ "def", "Wrr", ":", "BaseAddSubRegPseudo", "<", "GPR32", ",", "OpNode" ]

[ "<FIXS>", "addPass", "(", "createSIFixSGPRLiveRangesPass", "(", ")", ")", ";", "<FIXE>" ]

[ "addPass", "(", "&", "MachineCSEID", ")", ";", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ")", ";", "<BUGS>", "initializeSIFixSGPRLiveRangesPass", "(", "*", "PassRegistry", "::", "getPassRegistry", "(", ")", ")", ";", "insertPass", "(", "&", "RegisterCoalescerID", ",", "&", "SIFixSGPRLiveRangesID", ")", ";", "<BUGE>", "}", "return", "false", ";", "}" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m512i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_srli_epi16", "(", "_", "_", "m512i", "_", "_", "A", ",", "const", "int", "_", "_", "imm", ")", "{", "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_psrlwi512_mask", "(", "(", "_", "_", "v32hi", ")", "_", "_", "A", ",", "_", "_", "imm", ",", "(", "_", "_", "v32hi", ")", "_", "mm512_setzero_si512", "(", ")", ",", "(", "_", "_", "mmask32", ")", "-", "<NUM_LIT>", ")", ";" ]

[ ")", ")" ]

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

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_maskz_shldv_epi16", "(", "_", "_", "mmask8", "_", "_", "A", ",", "_", "_", "m128i", "_", "_", "B", ",", "_", "_", "m128i", "_", "_", "C", ",", "_", "_", "m128i", "_", "_", "D", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_vpshldv_v8hi_maskz", "(", "(", "_", "_", "v8hi", ")", "_", "_", "B", ",", "(", "_", "_", "v8hi", ")", "_", "_", "C", ",", "(", "_", "_", "v8hi", ")", "_", "_", "D", ",", "(", "_", "_", "mmask8", ")", "_", "_", "A", ")", ";" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "simplify_gen_subreg", "(", "V4SFmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "V2SFmode", ",", "<NUM_LIT>", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "V2SF", "<NUM_LIT>", "<STR_LIT>", ")", "(", "any_float", ":", "V2SF", "(", "match_operand", ":", "V2DI", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{" ]

[ "}", "else", "if", "(", "Op", ".", "isFPImm", "(", ")", ")", "{" ]

[ "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP32", ":", "case", "MCOI", "::", "OPERAND_IMMEDIATE", ":", "printImmediate32", "(", "Op", ".", "getImm", "(", ")", ",", "STI", ",", "O", ")", ";", "break", ";", "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT64", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP64", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT64", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP64", ":", "printImmediate64", "(", "Op", ".", "getImm", "(", ")", ",", "STI", ",", "O", ")", ";", "break", ";", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP16", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP16", ":", "printImmediate16", "(", "Op", ".", "getImm", "(", ")", ",", "STI", ",", "O", ")", ";", "break", ";", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_V2FP16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_V2INT16", ":", "printImmediateV216", "(", "Op", ".", "getImm", "(", ")", ",", "STI", ",", "O", ")", ";", "break", ";", "case", "MCOI", "::", "OPERAND_UNKNOWN", ":", "case", "MCOI", "::", "OPERAND_PCREL", ":", "O", "<<", "formatDec", "(", "Op", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MCOI", "::", "OPERAND_REGISTER", ":", "O", "<<", "<STR_LIT>", "/*invalid immediate*/", "<STR_LIT>", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "unexpected immediate operand type", "<STR_LIT>", ")", ";", "}" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m256i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_mask_cvtpd_epu64", "(", "_", "_", "m256i", "_", "_", "W", ",", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m256d", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_cvtpd2uqq256_mask", "(", "(", "_", "_", "v4df", ")", "_", "_", "A", ",", "(", "_", "_", "v4di", ")", "_", "_", "W", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "}" ]

[ "vandq_s8", "(", "int8x16_t", "_", "_", "a", ",", "int8x16_t", "_", "_", "b", ")", "{", "return", "_", "_", "a", "&", "_", "_", "b", ";" ]

[ ";" ]

[ "if", "(", "(", "type", "<", "<NUM_LIT>", "||", "type", ">", "<NUM_LIT>", ")", "&&", "(", "type", "!=", "<NUM_LIT>", ")", "&&", "(", "type", "!=", "R_AARCH64_REWRITE_INSN", ")", ")", "{", "return", "Relocator", "::", "Unknown" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "neg", ":", "V4SF", "(", "fma", ":", "V4SF", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "neg", ":", "V4SF" ]

[ "let", "SrcA", "=", "src", ";" ]

[ "let", "OutOperandList", "=", "(", "outs", "Rdst", ":", "$", "dest", ")", ";", "let", "InOperandList", "=", "(", "ins", "TPCImm", "<", "Isrc", ">", ":", "$", "src", ",", "DataType", ":", "$", "optype", ",", "SwitchSet", ":", "$", "sw", ",", "Rdst", ":", "$", "income", ",", "Pred", ":", "$", "pred", ")", ";", "let", "Itinerary", "=", "IIC_VectorOp", ";", "let", "isReMaterializable", "=", "<NUM_LIT>", ";", "let", "isAsCheapAsAMove", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "src", ";", "bits", "<", "<NUM_LIT>", ">", "optype", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";" ]

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

[ "def", "_PRE_IMM", ":", "AI2ldstidx", "<", "<NUM_LIT>", ",", "isByte", ",", "<NUM_LIT>", ",", "(", "outs", "GPR", ":", "$", "Rn_wb", ")", ",", "(", "ins", "GPR", ":", "$", "Rt", ",", "addrmode_imm12_pre", ":", "$", "addr", ")", ",", "IndexModePre", ",", "StFrm", ",", "iii", ",", "opc", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "addr", ";" ]

[ "_", "_", "idx", ")", "]", ";" ]

[ "_", "_", "arm_vgetq_lane_s8", "(", "int8x16_t", "_", "_", "a", ",", "const", "int", "_", "_", "idx", ")", "{", "_", "_", "ARM_CHECK_LANEQ", "(", "_", "_", "a", ",", "_", "_", "idx", ")", ";", "return", "_", "_", "a", "[", "_", "_", "ARM_LANEQ", "(", "_", "_", "a", "," ]

[ "return", "TargetAsmInfo", "::", "SelectSectionForGlobal", "(", "GV", ")", ";" ]

[ "}", "if", "(", "GV", "->", "hasExternalLinkage", "(", ")", "||", "GV", "->", "hasCommonLinkage", "(", ")", ")", "{", "ExternalVarDefs", "->", "Items", ".", "push_back", "(", "GV", ")", ";", "}", "const", "Constant", "*", "C", "=", "GV", "->", "getInitializer", "(", ")", ";", "if", "(", "C", "->", "isNullValue", "(", ")", ")", "return", "getBSSSectionForGlobal", "(", "GV", ")", ";", "if", "(", "GV", "->", "getType", "(", ")", "->", "getAddressSpace", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "getIDATASectionForGlobal", "(", "GV", ")", ";", "if", "(", "GV", "->", "getType", "(", ")", "->", "getAddressSpace", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "ROSection", "->", "Items", ".", "push_back", "(", "GV", ")", ";", "return", "ROSection", "->", "S_", ";", "}" ]

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

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

[ "if", "(", "nregs", "<", "NUM_ARG_REGS", ")", "*", "pretend_size", "=", "(", "NUM_ARG_REGS", "-", "nregs", ")", "*", "UNITS_PER_WORD", ";" ]

[ "int", "res", "=", "arm_needs_doubleword_align", "(", "mode", ",", "type", ")", ";", "if", "(", "res", "<", "<NUM_LIT>", "&&", "warn_psabi", ")", "inform", "(", "input_location", ",", "<STR_LIT>", "parameter passing for argument of ", "<STR_LIT>", "<STR_LIT>", "type %qT changed in GCC 7.1", "<STR_LIT>", ",", "type", ")", ";", "else", "if", "(", "res", ">", "<NUM_LIT>", ")", "nregs", "++", ";", "}", "}", "else", "nregs", "=", "pcum", "->", "nregs", ";" ]

[ "return", "Modified", ";" ]

[ "while", "(", "MBBI", "!=", "E", ")", "{", "MachineBasicBlock", "::", "iterator", "NMBBI", "=", "std", "::", "next", "(", "MBBI", ")", ";", "Modified", "|=", "expandMI", "(", "MBB", ",", "MBBI", ",", "NMBBI", ")", ";", "MBBI", "=", "NMBBI", ";", "}" ]

[ "<FIXS>", "uint64_t", "TSFlags", ",", "PrefixKind", "Kind", ",", "uint64_t", "StartByte", ",", "<FIXE>", "<FIXS>", "PrefixKind", "emitPrefixImpl", "(", "unsigned", "&", "CurOp", ",", "const", "MCInst", "&", "MI", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "const", ";", "<FIXE>", "<FIXS>", "PrefixKind", "emitVEXOpcodePrefix", "(", "int", "MemOperand", ",", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ")", "const", ";", "<FIXE>", "<FIXS>", "PrefixKind", "emitOpcodePrefix", "(", "int", "MemOperand", ",", "const", "MCInst", "&", "MI", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "const", ";", "<FIXE>", "<FIXS>", "PrefixKind", "emitREXPrefix", "(", "int", "MemOperand", ",", "const", "MCInst", "&", "MI", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "const", ";", "<FIXE>" ]

[ "raw_ostream", "&", "OS", ")", "const", ";", "void", "emitMemModRMByte", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "Op", ",", "unsigned", "RegOpcodeField", ",", "<BUGS>", "uint64_t", "TSFlags", ",", "bool", "HasREX", ",", "uint64_t", "StartByte", ",", "<BUGE>", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "bool", "ForceSIB", "=", "false", ")", "const", ";", "<BUGS>", "bool", "emitPrefixImpl", "(", "unsigned", "&", "CurOp", ",", "const", "MCInst", "&", "MI", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "const", ";", "<BUGE>", "<BUGS>", "void", "emitVEXOpcodePrefix", "(", "int", "MemOperand", ",", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ")", "const", ";", "<BUGE>", "void", "emitSegmentOverridePrefix", "(", "unsigned", "SegOperand", ",", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ")", "const", ";", "<BUGS>", "bool", "emitOpcodePrefix", "(", "int", "MemOperand", ",", "const", "MCInst", "&", "MI", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "const", ";", "<BUGE>", "<BUGS>", "bool", "emitREXPrefix", "(", "int", "MemOperand", ",", "const", "MCInst", "&", "MI", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "const", ";", "<BUGE>", "}", ";", "}" ]

[ "<STR_LIT>", ")" ]

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

[ "false", ";" ]

[ "static", "bool", "contains_core_p", "(", "unsigned", "*", "arr", ",", "unsigned", "core", ")", "{", "if", "(", "arr", "[", "<NUM_LIT>", "]", "!=", "INVALID_CORE", ")", "{", "if", "(", "arr", "[", "<NUM_LIT>", "]", "==", "core", ")", "return", "true", ";", "if", "(", "arr", "[", "<NUM_LIT>", "]", "!=", "INVALID_CORE", ")", "return", "arr", "[", "<NUM_LIT>", "]", "==", "core", ";", "}", "return" ]

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

[ "def", "msr_sysreg_op", ":", "Operand", "<", "i32", ">", "{", "let", "ParserMatchClass", "=", "MSRSystemRegisterOperand", ";" ]

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

[ "def", "MxARI", ":", "MxOpClass", "<" ]

[ "]" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "CC", "CC_REGNUM", ")", "(", "compare", ":", "CC", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")" ]

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

[ "intsystem_reg_operand", "(", "op", ",", "mode", ")", "rtx", "op", ";", "<BUGS>", "enum", "machine_mode", "mode", ";", "<BUGE>", "{", "switch", "(", "REGNO", "(", "op", ")", ")", "{" ]

[ "RR", ";" ]

[ "bool", "X86FastISel", "::", "X86FastEmitExtend", "(", "ISD", "::", "NodeType", "Opc", ",", "EVT", "DstVT", ",", "unsigned", "Src", ",", "EVT", "SrcVT", ",", "unsigned", "&", "ResultReg", ")", "{", "unsigned", "RR", "=", "FastEmit_r", "(", "SrcVT", ".", "getSimpleVT", "(", ")", ",", "DstVT", ".", "getSimpleVT", "(", ")", ",", "Opc", ",", "Src", ",", "false", ")", ";", "if", "(", "RR", "==", "<NUM_LIT>", ")", "return", "false", ";", "ResultReg", "=" ]

[ "void", "AArch64AsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", "{", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AArch64_VectorCall", "||", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AArch64_SVE_VectorCall", "||", "MF", "->", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", "->", "isSVECC", "(", ")", ")", "{", "auto", "*", "TS", "=", "static_cast", "<", "AArch64TargetStreamer", "*", ">", "(", "OutStreamer", "->", "getTargetStreamer", "(", ")", ")", ";", "TS", "->", "emitDirectiveVariantPCS", "(", "CurrentFnSym", ")", ";", "}", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "isWindowsArm64EC", "(", ")", ")", "{", "if", "(", "MDNode", "*", "Unmangled", "=", "MF", "->", "getFunction", "(", ")", ".", "getMetadata", "(", "<STR_LIT>", "arm64ec_unmangled_name", "<STR_LIT>", ")", ")", "{", "AsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", ";", "if", "(", "MDNode", "*", "ECMangled", "=", "MF", "->", "getFunction", "(", ")", ".", "getMetadata", "(", "<STR_LIT>", "arm64ec_ecmangled_name", "<STR_LIT>", ")", ")", "{", "StringRef", "UnmangledStr", "=", "cast", "<", "MDString", ">", "(", "Unmangled", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getString", "(", ")", ";", "MCSymbol", "*", "UnmangledSym", "=", "MMI", "->", "getContext", "(", ")", ".", "getOrCreateSymbol", "(", "UnmangledStr", ")", ";", "StringRef", "ECMangledStr", "=", "cast", "<", "MDString", ">", "(", "ECMangled", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getString", "(", ")", ";", "MCSymbol", "*", "ECMangledSym", "=", "MMI", "->", "getContext", "(", ")", ".", "getOrCreateSymbol", "(", "ECMangledStr", ")", ";", "OutStreamer", "->", "emitSymbolAttribute", "(", "UnmangledSym", ",", "MCSA_WeakAntiDep", ")", ";", "OutStreamer", "->", "emitAssignment", "(", "UnmangledSym", ",", "MCSymbolRefExpr", "::", "create", "(", "ECMangledSym", ",", "MCSymbolRefExpr", "::", "VK_WEAKREF", ",", "MMI", "->", "getContext", "(", ")", ")", ")", ";", "OutStreamer", "->", "emitSymbolAttribute", "(", "ECMangledSym", ",", "MCSA_WeakAntiDep", ")", ";", "OutStreamer", "->", "emitAssignment", "(", "ECMangledSym", ",", "MCSymbolRefExpr", "::", "create", "(", "CurrentFnSym", ",", "MCSymbolRefExpr", "::", "VK_WEAKREF", ",", "MMI", "->", "getContext", "(", ")", ")", ")", ";", "return", ";", "}", "else", "{", "StringRef", "UnmangledStr", "=", "cast", "<", "MDString", ">", "(", "Unmangled", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getString", "(", ")", ";", "MCSymbol", "*", "UnmangledSym", "=", "MMI", "->", "getContext", "(", ")", ".", "getOrCreateSymbol", "(", "UnmangledStr", ")", ";", "OutStreamer", "->", "emitSymbolAttribute", "(", "UnmangledSym", ",", "MCSA_WeakAntiDep", ")", ";", "OutStreamer", "->", "emitAssignment", "(", "UnmangledSym", ",", "MCSymbolRefExpr", "::", "create", "(", "CurrentFnSym", ",", "MCSymbolRefExpr", "::", "VK_WEAKREF", ",", "MMI", "->", "getContext", "(", ")", ")", ")", ";", "return", ";", "}", "}", "}", "return", "AsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", ";", "}" ]

[ "EmitFunctionEntryLabel", "-", "Emit", "the", "label", "that", "is", "the", "entrypoint", "for", "the", "function", "." ]

[ "let", "RenderMethod", "=", "<STR_LIT>", "#", "Scale", "#", "<STR_LIT>", ";" ]

[ "let", "Name", "=", "<STR_LIT>", "#", "Width", "#", "<STR_LIT>", "#", "Scale", ";", "let", "DiagnosticType", "=", "<STR_LIT>", "#", "Scale", "#", "<STR_LIT>", "#", "Width", ";" ]

[ "const", "char", "*", "output_return_instruction", "(", "rtx", "operand", ",", "bool", "really_return", ",", "bool", "reverse", ",", "bool", "simple_return", ")", "{", "char", "conditional", "[", "<NUM_LIT>", "]", ";", "char", "instr", "[", "<NUM_LIT>", "]", ";", "unsigned", "reg", ";", "unsigned", "long", "live_regs_mask", ";", "unsigned", "long", "func_type", ";", "arm_stack_offsets", "*", "offsets", ";", "func_type", "=", "arm_current_func_type", "(", ")", ";", "if", "(", "IS_NAKED", "(", "func_type", ")", ")", "return", "<STR_LIT>", "<STR_LIT>", ";", "if", "(", "IS_VOLATILE", "(", "func_type", ")", "&&", "TARGET_ABORT_NORETURN", ")", "{", "if", "(", "really_return", ")", "{", "rtx", "ops", "[", "<NUM_LIT>", "]", ";", "ops", "[", "<NUM_LIT>", "]", "=", "operand", ";", "ops", "[", "<NUM_LIT>", "]", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "NEED_PLT_RELOC", "?", "<STR_LIT>", "abort(PLT)", "<STR_LIT>", ":", "<STR_LIT>", "abort", "<STR_LIT>", ")", ";", "assemble_external_libcall", "(", "ops", "[", "<NUM_LIT>", "]", ")", ";", "output_asm_insn", "(", "reverse", "?", "<STR_LIT>", "bl%D0\\t%a1", "<STR_LIT>", ":", "<STR_LIT>", "bl%d0\\t%a1", "<STR_LIT>", ",", "ops", ")", ";", "}", "return", "<STR_LIT>", "<STR_LIT>", ";", "}", "gcc_assert", "(", "!", "cfun", "->", "calls_alloca", "||", "really_return", ")", ";", "sprintf", "(", "conditional", ",", "<STR_LIT>", "%%?%%%c0", "<STR_LIT>", ",", "reverse", "?", "'", "D", "'", ":", "'", "d", "'", ")", ";", "cfun", "->", "machine", "->", "return_used_this_function", "=", "<NUM_LIT>", ";", "offsets", "=", "arm_get_frame_offsets", "(", ")", ";", "live_regs_mask", "=", "offsets", "->", "saved_regs_mask", ";", "if", "(", "!", "simple_return", "&&", "live_regs_mask", ")", "{", "const", "char", "*", "return_reg", ";", "if", "(", "really_return", "&&", "!", "IS_CMSE_ENTRY", "(", "func_type", ")", "&&", "(", "IS_INTERRUPT", "(", "func_type", ")", "||", "!", "TARGET_INTERWORK", ")", ")", "return_reg", "=", "reg_names", "[", "PC_REGNUM", "]", ";", "else", "return_reg", "=", "reg_names", "[", "LR_REGNUM", "]", ";", "if", "(", "(", "live_regs_mask", "&", "(", "<NUM_LIT>", "<<", "IP_REGNUM", ")", ")", "==", "(", "<NUM_LIT>", "<<", "IP_REGNUM", ")", ")", "{", "if", "(", "frame_pointer_needed", ")", "{", "live_regs_mask", "&=", "~", "(", "<NUM_LIT>", "<<", "IP_REGNUM", ")", ";", "live_regs_mask", "|=", "(", "<NUM_LIT>", "<<", "SP_REGNUM", ")", ";", "}", "else", "gcc_assert", "(", "IS_INTERRUPT", "(", "func_type", ")", "||", "TARGET_REALLY_IWMMXT", ")", ";", "}", "for", "(", "reg", "=", "<NUM_LIT>", ";", "reg", "<=", "LAST_ARM_REGNUM", ";", "reg", "++", ")", "if", "(", "live_regs_mask", "==", "(", "<NUM_LIT>", "U", "<<", "reg", ")", ")", "break", ";", "if", "(", "reg", "<=", "LAST_ARM_REGNUM", "&&", "(", "reg", "!=", "LR_REGNUM", "||", "!", "really_return", "||", "!", "IS_INTERRUPT", "(", "func_type", ")", ")", ")", "{", "sprintf", "(", "instr", ",", "<STR_LIT>", "ldr%s\\t%%|%s, [%%|sp], #4", "<STR_LIT>", ",", "conditional", ",", "(", "reg", "==", "LR_REGNUM", ")", "?", "return_reg", ":", "reg_names", "[", "reg", "]", ")", ";", "}", "else", "{", "char", "*", "p", ";", "int", "first", "=", "<NUM_LIT>", ";", "if", "(", "live_regs_mask", "&", "(", "<NUM_LIT>", "<<", "SP_REGNUM", ")", ")", "{", "unsigned", "HOST_WIDE_INT", "stack_adjust", ";", "stack_adjust", "=", "offsets", "->", "outgoing_args", "-", "offsets", "->", "saved_regs", ";", "gcc_assert", "(", "stack_adjust", "==", "<NUM_LIT>", "||", "stack_adjust", "==", "<NUM_LIT>", ")", ";", "if", "(", "stack_adjust", "&&", "arm_arch5t", "&&", "TARGET_ARM", ")", "sprintf", "(", "instr", ",", "<STR_LIT>", "ldmib%s\\t%%|sp, {", "<STR_LIT>", ",", "conditional", ")", ";", "else", "{", "if", "(", "stack_adjust", ")", "live_regs_mask", "|=", "<NUM_LIT>", "<<", "<NUM_LIT>", ";", "sprintf", "(", "instr", ",", "<STR_LIT>", "ldmfd%s\\t%%|sp, {", "<STR_LIT>", ",", "conditional", ")", ";", "}", "}", "else", "if", "(", "IS_INTERRUPT", "(", "func_type", ")", ")", "sprintf", "(", "instr", ",", "<STR_LIT>", "ldmfd%s\\t%%|sp!, {", "<STR_LIT>", ",", "conditional", ")", ";", "else", "sprintf", "(", "instr", ",", "<STR_LIT>", "pop%s\\t{", "<STR_LIT>", ",", "conditional", ")", ";", "p", "=", "instr", "+", "strlen", "(", "instr", ")", ";", "for", "(", "reg", "=", "<NUM_LIT>", ";", "reg", "<=", "SP_REGNUM", ";", "reg", "++", ")", "if", "(", "live_regs_mask", "&", "(", "<NUM_LIT>", "<<", "reg", ")", ")", "{", "int", "l", "=", "strlen", "(", "reg_names", "[", "reg", "]", ")", ";", "if", "(", "first", ")", "first", "=", "<NUM_LIT>", ";", "else", "{", "memcpy", "(", "p", ",", "<STR_LIT>", ", ", "<STR_LIT>", ",", "<NUM_LIT>", ")", ";", "p", "+=", "<NUM_LIT>", ";", "}", "memcpy", "(", "p", ",", "<STR_LIT>", "%|", "<STR_LIT>", ",", "<NUM_LIT>", ")", ";", "memcpy", "(", "p", "+", "<NUM_LIT>", ",", "reg_names", "[", "reg", "]", ",", "l", ")", ";", "p", "+=", "l", "+", "<NUM_LIT>", ";", "}", "if", "(", "live_regs_mask", "&", "(", "<NUM_LIT>", "<<", "LR_REGNUM", ")", ")", "{", "sprintf", "(", "p", ",", "<STR_LIT>", "%s%%|%s}", "<STR_LIT>", ",", "first", "?", "<STR_LIT>", "<STR_LIT>", ":", "<STR_LIT>", ", ", "<STR_LIT>", ",", "return_reg", ")", ";", "if", "(", "IS_INTERRUPT", "(", "func_type", ")", ")", "strcat", "(", "p", ",", "<STR_LIT>", "^", "<STR_LIT>", ")", ";", "}", "else", "strcpy", "(", "p", ",", "<STR_LIT>", "}", "<STR_LIT>", ")", ";", "}", "output_asm_insn", "(", "instr", ",", "&", "operand", ")", ";", "if", "(", "really_return", "&&", "func_type", "!=", "ARM_FT_INTERWORKED", "&&", "(", "live_regs_mask", "&", "(", "<NUM_LIT>", "<<", "LR_REGNUM", ")", ")", "!=", "<NUM_LIT>", ")", "{", "return", "<STR_LIT>", "<STR_LIT>", ";", "}", "}", "if", "(", "really_return", ")", "{", "switch", "(", "(", "int", ")", "ARM_FUNC_TYPE", "(", "func_type", ")", ")", "{", "case", "ARM_FT_ISR", ":", "case", "ARM_FT_FIQ", ":", "sprintf", "(", "instr", ",", "<STR_LIT>", "sub%ss\\t%%|pc, %%|lr, #4", "<STR_LIT>", ",", "conditional", ")", ";", "break", ";", "case", "ARM_FT_INTERWORKED", ":", "gcc_assert", "(", "arm_arch5t", "||", "arm_arch4t", ")", ";", "sprintf", "(", "instr", ",", "<STR_LIT>", "bx%s\\t%%|lr", "<STR_LIT>", ",", "conditional", ")", ";", "break", ";", "case", "ARM_FT_EXCEPTION", ":", "sprintf", "(", "instr", ",", "<STR_LIT>", "mov%ss\\t%%|pc, %%|lr", "<STR_LIT>", ",", "conditional", ")", ";", "break", ";", "default", ":", "if", "(", "IS_CMSE_ENTRY", "(", "func_type", ")", ")", "{", "if", "(", "!", "TARGET_HAVE_FPCXT_CMSE", ")", "{", "if", "(", "TARGET_INT_SIMD", ")", "snprintf", "(", "instr", ",", "sizeof", "(", "instr", ")", ",", "<STR_LIT>", "msr%s\\tAPSR_nzcvqg, %%|lr", "<STR_LIT>", ",", "conditional", ")", ";", "else", "snprintf", "(", "instr", ",", "sizeof", "(", "instr", ")", ",", "<STR_LIT>", "msr%s\\tAPSR_nzcvq, %%|lr", "<STR_LIT>", ",", "conditional", ")", ";", "output_asm_insn", "(", "instr", ",", "&", "operand", ")", ";", "if", "(", "TARGET_HARD_FLOAT", ")", "{", "output_asm_insn", "(", "<STR_LIT>", "push\\t{%|r4}", "<STR_LIT>", ",", "&", "operand", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "vmrs\\t%|ip, fpscr", "<STR_LIT>", ",", "&", "operand", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "movw\\t%|r4, #65376", "<STR_LIT>", ",", "&", "operand", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "movt\\t%|r4, #4095", "<STR_LIT>", ",", "&", "operand", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "and\\t%|ip, %|r4", "<STR_LIT>", ",", "&", "operand", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "vmsr\\tfpscr, %|ip", "<STR_LIT>", ",", "&", "operand", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "pop\\t{%|r4}", "<STR_LIT>", ",", "&", "operand", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "mov\\t%|ip, %|lr", "<STR_LIT>", ",", "&", "operand", ")", ";", "}", "}", "snprintf", "(", "instr", ",", "sizeof", "(", "instr", ")", ",", "<STR_LIT>", "bxns\\t%%|lr", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "arm_arch5t", "||", "arm_arch4t", ")", "sprintf", "(", "instr", ",", "<STR_LIT>", "bx%s\\t%%|lr", "<STR_LIT>", ",", "conditional", ")", ";", "else", "sprintf", "(", "instr", ",", "<STR_LIT>", "mov%s\\t%%|pc, %%|lr", "<STR_LIT>", ",", "conditional", ")", ";", "break", ";", "}", "output_asm_insn", "(", "instr", ",", "&", "operand", ")", ";", "}", "return", "<STR_LIT>", "<STR_LIT>", ";", "}" ]

[ "Generate", "a", "function", "exit", "sequence", ".", "If", "REALLY_RETURN", "is", "false", ",", "then", "do", "everything", "bar", "the", "final", "return", "instruction", ".", "If", "simple_return", "is", "true", ",", "then", "do", "not", "output", "epilogue", ",", "because", "it", "has", "already", "been", "emitted", "in", "RTL", "." ]

[ "}" ]

[ "rtx_insn", "*", "insn", ",", "*", "next", ",", "*", "next_tail", ";", "if", "(", "!", "reload_completed", ")", "return", ";", "next_tail", "=", "NEXT_INSN", "(", "tail", ")", ";", "for", "(", "insn", "=", "head", ";", "insn", "!=", "next_tail", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "INSN_P", "(", "insn", ")", ")", "insn", "->", "call", "=", "<NUM_LIT>", ";", "for", "(", "insn", "=", "head", ";", "insn", "!=", "next_tail", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "INSN_P", "(", "insn", ")", "&&", "ia64_safe_itanium_class", "(", "insn", ")", "==", "ITANIUM_CLASS_IALU", ")", "{", "sd_iterator_def", "sd_it", ";", "dep_t", "dep", ";", "bool", "has_mem_op_consumer_p", "=", "false", ";", "FOR_EACH_DEP", "(", "insn", ",", "SD_LIST_FORW", ",", "sd_it", ",", "dep", ")", "{", "enum", "attr_itanium_class", "c", ";", "if", "(", "DEP_TYPE", "(", "dep", ")", "!=", "REG_DEP_TRUE", ")", "continue", ";", "next", "=", "DEP_CON", "(", "dep", ")", ";", "c", "=", "ia64_safe_itanium_class", "(", "next", ")", ";", "if", "(", "(", "c", "==", "ITANIUM_CLASS_ST", "||", "c", "==", "ITANIUM_CLASS_STF", ")", "&&", "ia64_st_address_bypass_p", "(", "insn", ",", "next", ")", ")", "{", "has_mem_op_consumer_p", "=", "true", ";", "break", ";", "}", "else", "if", "(", "(", "c", "==", "ITANIUM_CLASS_LD", "||", "c", "==", "ITANIUM_CLASS_FLD", "||", "c", "==", "ITANIUM_CLASS_FLDP", ")", "&&", "ia64_ld_address_bypass_p", "(", "insn", ",", "next", ")", ")", "{", "has_mem_op_consumer_p", "=", "true", ";", "break", ";", "}" ]

[ "void", "X86InstPrinterCommon", "::", "printPCRelImm", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ")", "{", "const", "MCOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "if", "(", "PrintBranchImmAsAddress", ")", "{", "uint64_t", "Target", "=", "Address", "+", "Op", ".", "getImm", "(", ")", ";", "if", "(", "MAI", ".", "getCodePointerSize", "(", ")", "==", "<NUM_LIT>", ")", "Target", "&=", "<NUM_LIT>", ";", "O", "<<", "formatHex", "(", "Target", ")", ";", "}", "else", "O", "<<", "formatImm", "(", "Op", ".", "getImm", "(", ")", ")", ";", "}", "else", "{", "assert", "(", "Op", ".", "isExpr", "(", ")", "&&", "<STR_LIT>", "unknown pcrel immediate operand", "<STR_LIT>", ")", ";", "const", "MCConstantExpr", "*", "BranchTarget", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getExpr", "(", ")", ")", ";", "int64_t", "Address", ";", "if", "(", "BranchTarget", "&&", "BranchTarget", "->", "evaluateAsAbsolute", "(", "Address", ")", ")", "{", "O", "<<", "formatHex", "(", "(", "uint64_t", ")", "Address", ")", ";", "}", "else", "{", "Op", ".", "getExpr", "(", ")", "->", "print", "(", "O", ",", "&", "MAI", ")", ";", "}", "}", "}" ]

[ "value", "(", "e.g", "." ]

[ "SDValue", "FrameAddr", "=", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";" ]

[ "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MFI", "->", "setReturnAddressIsTaken", "(", "true", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "SDLoc", "dl", "(", "Op", ")", ";", "unsigned", "Depth", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "Depth", ")", "{" ]

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

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

[ "_", "_", "m1", ",", "(", "_", "_", "v4hi", ")", "_", "_", "m2", ")", ";" ]

[ "return", "(", "_", "_", "m64", ")", "_", "_", "builtin_ia32_paddsw", "(", "(", "_", "_", "v4hi", ")" ]

[ "bool", "isAdd", "=", "true", ";" ]

[ "unsigned", "opc", "=", "<NUM_LIT>", ";", "if", "(", "(", "int64_t", ")", "Value", "<", "<NUM_LIT>", ")", "{", "Value", "=", "-", "Value", ";", "opc", "=", "<NUM_LIT>", ";", "}", "uint32_t", "out", "=", "(", "opc", "<<", "<NUM_LIT>", ")", ";", "out", "|=", "(", "Value", "&", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ";", "out", "|=", "(", "Value", "&", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ";", "out", "|=", "(", "Value", "&", "<NUM_LIT>", ")", ";", "return", "swapHalfWords", "(", "out", ",", "IsLittleEndian", ")", ";", "}", "case", "ARM", "::", "fixup_arm_condbranch", ":", "case", "ARM", "::", "fixup_arm_uncondbranch", ":", "case", "ARM", "::", "fixup_arm_uncondbl", ":", "case", "ARM", "::", "fixup_arm_condbl", ":", "case", "ARM", "::", "fixup_arm_blx", ":", "if", "(", "const", "MCSymbolRefExpr", "*", "SRE", "=", "dyn_cast", "<", "MCSymbolRefExpr", ">", "(", "Fixup", ".", "getValue", "(", ")", ")", ")", "if", "(", "SRE", "->", "getKind", "(", ")", "==", "MCSymbolRefExpr", "::", "VK_ARM_TLSCALL", ")", "return", "<NUM_LIT>", ";", "return", "<NUM_LIT>", "&", "(", "(", "Value", "-", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ")", ";", "case", "ARM", "::", "fixup_t2_uncondbranch", ":", "{", "Value", "=", "Value", "-", "<NUM_LIT>", ";", "Value", ">>=", "<NUM_LIT>", ";", "uint32_t", "out", "=", "<NUM_LIT>", ";", "bool", "I", "=", "Value", "&", "<NUM_LIT>", ";", "bool", "J1", "=", "Value", "&", "<NUM_LIT>", ";", "bool", "J2", "=", "Value", "&", "<NUM_LIT>", ";", "J1", "^=", "I", ";", "J2", "^=", "I", ";", "out", "|=", "I", "<<", "<NUM_LIT>", ";", "out", "|=", "!", "J1", "<<", "<NUM_LIT>", ";", "out", "|=", "!", "J2", "<<", "<NUM_LIT>", ";", "out", "|=", "(", "Value", "&", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ";", "out", "|=", "(", "Value", "&", "<NUM_LIT>", ")", ";", "return", "swapHalfWords", "(", "out", ",", "IsLittleEndian", ")", ";", "}", "case", "ARM", "::", "fixup_t2_condbranch", ":", "{", "Value", "=", "Value", "-", "<NUM_LIT>", ";", "Value", ">>=", "<NUM_LIT>", ";", "uint64_t", "out", "=", "<NUM_LIT>", ";", "out", "|=", "(", "Value", "&", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ";", "out", "|=", "(", "Value", "&", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "out", "|=", "(", "Value", "&", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "out", "|=", "(", "Value", "&", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ";", "out", "|=", "(", "Value", "&", "<NUM_LIT>", ")", ";", "return", "swapHalfWords", "(", "out", ",", "IsLittleEndian", ")", ";", "}", "case", "ARM", "::", "fixup_arm_thumb_bl", ":", "{", "uint32_t", "offset", "=", "(", "Value", "-", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "uint32_t", "signBit", "=", "(", "offset", "&", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "uint32_t", "I1Bit", "=", "(", "offset", "&", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "uint32_t", "J1Bit", "=", "(", "I1Bit", "^", "<NUM_LIT>", ")", "^", "signBit", ";", "uint32_t", "I2Bit", "=", "(", "offset", "&", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "uint32_t", "J2Bit", "=", "(", "I2Bit", "^", "<NUM_LIT>", ")", "^", "signBit", ";", "uint32_t", "imm10Bits", "=", "(", "offset", "&", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "uint32_t", "imm11Bits", "=", "(", "offset", "&", "<NUM_LIT>", ")", ";", "uint32_t", "FirstHalf", "=", "(", "(", "(", "uint16_t", ")", "signBit", "<<", "<NUM_LIT>", ")", "|", "(", "uint16_t", ")", "imm10Bits", ")", ";", "uint32_t", "SecondHalf", "=", "(", "(", "(", "uint16_t", ")", "J1Bit", "<<", "<NUM_LIT>", ")", "|", "(", "(", "uint16_t", ")", "J2Bit", "<<", "<NUM_LIT>", ")", "|", "(", "uint16_t", ")", "imm11Bits", ")", ";", "return", "joinHalfWords", "(", "FirstHalf", ",", "SecondHalf", ",", "IsLittleEndian", ")", ";", "}", "case", "ARM", "::", "fixup_arm_thumb_blx", ":", "{", "uint32_t", "offset", "=", "(", "Value", "-", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "if", "(", "const", "MCSymbolRefExpr", "*", "SRE", "=", "dyn_cast", "<", "MCSymbolRefExpr", ">", "(", "Fixup", ".", "getValue", "(", ")", ")", ")", "if", "(", "SRE", "->", "getKind", "(", ")", "==", "MCSymbolRefExpr", "::", "VK_ARM_TLSCALL", ")", "offset", "=", "<NUM_LIT>", ";", "uint32_t", "signBit", "=", "(", "offset", "&", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "uint32_t", "I1Bit", "=", "(", "offset", "&", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "uint32_t", "J1Bit", "=", "(", "I1Bit", "^", "<NUM_LIT>", ")", "^", "signBit", ";", "uint32_t", "I2Bit", "=", "(", "offset", "&", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "uint32_t", "J2Bit", "=", "(", "I2Bit", "^", "<NUM_LIT>", ")", "^", "signBit", ";", "uint32_t", "imm10HBits", "=", "(", "offset", "&", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "uint32_t", "imm10LBits", "=", "(", "offset", "&", "<NUM_LIT>", ")", ";", "uint32_t", "FirstHalf", "=", "(", "(", "(", "uint16_t", ")", "signBit", "<<", "<NUM_LIT>", ")", "|", "(", "uint16_t", ")", "imm10HBits", ")", ";", "uint32_t", "SecondHalf", "=", "(", "(", "(", "uint16_t", ")", "J1Bit", "<<", "<NUM_LIT>", ")", "|", "(", "(", "uint16_t", ")", "J2Bit", "<<", "<NUM_LIT>", ")", "|", "(", "(", "uint16_t", ")", "imm10LBits", ")", "<<", "<NUM_LIT>", ")", ";", "return", "joinHalfWords", "(", "FirstHalf", ",", "SecondHalf", ",", "IsLittleEndian", ")", ";", "}", "case", "ARM", "::", "fixup_arm_thumb_cp", ":", "return", "(", "(", "Value", "-", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ";", "case", "ARM", "::", "fixup_arm_thumb_cb", ":", "{", "uint32_t", "Binary", "=", "(", "Value", "-", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ";", "return", "(", "(", "Binary", "&", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ")", "|", "(", "(", "Binary", "&", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ")", ";", "}", "case", "ARM", "::", "fixup_arm_thumb_br", ":", "return", "(", "(", "Value", "-", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ";", "case", "ARM", "::", "fixup_arm_thumb_bcc", ":", "return", "(", "(", "Value", "-", "<NUM_LIT>", ")", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ";", "case", "ARM", "::", "fixup_arm_pcrel_10_unscaled", ":", "{", "Value", "=", "Value", "-", "<NUM_LIT>", ";" ]

[ "<FIXS>", "def", "FeatureFastPartialYMMorZMMWrite", ":", "SubtargetFeature", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ">", ";", "<FIXE>" ]

[ "def", "FeatureSoftFloat", ":", "SubtargetFeature", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ">", ";", "<BUGS>", "def", "FeatureFastPartialYMMWrite", ":", "SubtargetFeature", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ">", ";", "<BUGE>" ]