Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "}" ]

[ "if", "(", "!", "TARGET_ABICALLS", ")", "return", "GLOBAL_POINTER_REGNUM", ";", "if", "(", "!", "TARGET_EXPLICIT_RELOCS", ")", "return", "GLOBAL_POINTER_REGNUM", ";", "if", "(", "current_function_profile", ")", "return", "GLOBAL_POINTER_REGNUM", ";", "if", "(", "current_function_has_nonlocal_goto", ")", "return", "GLOBAL_POINTER_REGNUM", ";", "if", "(", "!", "regs_ever_live", "[", "GLOBAL_POINTER_REGNUM", "]", "&&", "!", "current_function_uses_const_pool", "&&", "!", "mips_function_has_gp_insn", "(", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "TARGET_NEWABI", "&&", "current_function_is_leaf", ")", "for", "(", "regno", "=", "GP_REG_FIRST", ";", "regno", "<=", "GP_REG_LAST", ";", "regno", "++", ")", "if", "(", "!", "regs_ever_live", "[", "regno", "]", "&&", "call_used_regs", "[", "regno", "]", "&&", "!", "fixed_regs", "[", "regno", "]", "&&", "regno", "!=", "PIC_FUNCTION_ADDR_REGNUM", ")", "return", "regno", ";", "return", "GLOBAL_POINTER_REGNUM", ";" ]

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

[ "field", "bits", "<", "<NUM_LIT>", ">", "SoftFail", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "M1", ";", "bits", "<", "<NUM_LIT>", ">", "RI2", ";", "bits", "<", "<NUM_LIT>", ">", "BD3", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", ";" ]

[ "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

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

[ "return", "HardenedReg", ";" ]

[ "auto", "*", "DefRC", "=", "MRI", "->", "getRegClass", "(", "OldDefReg", ")", ";", "Register", "UnhardenedReg", "=", "MRI", "->", "createVirtualRegister", "(", "DefRC", ")", ";", "DefOp", ".", "setReg", "(", "UnhardenedReg", ")", ";", "unsigned", "HardenedReg", "=", "hardenValueInRegister", "(", "UnhardenedReg", ",", "MBB", ",", "std", "::", "next", "(", "MI", ".", "getIterator", "(", ")", ")", ",", "Loc", ")", ";", "MRI", "->", "replaceRegWith", "(", "OldDefReg", ",", "HardenedReg", ")", ";", "++", "NumPostLoadRegsHardened", ";" ]

[ "}" ]

[ "SDNode", "*", "User", "=", "*", "UI", ";", "unsigned", "UOpNo", "=", "UI", ".", "getOperandNo", "(", ")", ";", "if", "(", "User", "->", "getOpcode", "(", ")", "==", "ISD", "::", "TRUNCATE", "&&", "User", "->", "hasOneUse", "(", ")", ")", "{", "UOpNo", "=", "User", "->", "use_begin", "(", ")", ".", "getOperandNo", "(", ")", ";", "User", "=", "*", "User", "->", "use_begin", "(", ")", ";", "}", "if", "(", "User", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "BRCOND", "&&", "User", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "SETCC", "&&", "!", "(", "User", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SELECT", "&&", "UOpNo", "==", "<NUM_LIT>", ")", ")", "return", "true", ";" ]

[ "<FIXS>", "auto", "branch", "=", "aarch64_gen_test_and_branch", "(", "already_ok_cond", ",", "old_svcr", ",", "<NUM_LIT>", ",", "label", ")", ";", "auto", "*", "jump", "=", "emit_jump_insn", "(", "branch", ")", ";", "<FIXE>" ]

[ "gcc_assert", "(", "local_mode", "!=", "<NUM_LIT>", ")", ";", "auto", "already_ok_cond", "=", "(", "local_mode", "&", "AARCH64_FL_SM_ON", "?", "NE", ":", "EQ", ")", ";", "auto", "*", "label", "=", "gen_label_rtx", "(", ")", ";", "<BUGS>", "auto", "*", "jump", "=", "emit_jump_insn", "(", "gen_aarch64_tb", "(", "already_ok_cond", ",", "DImode", ",", "DImode", ",", "old_svcr", ",", "const0_rtx", ",", "label", ")", ")", ";", "<BUGE>", "JUMP_LABEL", "(", "jump", ")", "=", "label", ";", "return", "label", ";", "}" ]

[ "}" ]

[ "StringRef", "getToken", "(", ")", "const", "{", "assert", "(", "Kind", "==", "OpKind", "::", "Token", "&&", "<STR_LIT>", "Invalid access!", "<STR_LIT>", ")", ";", "return", "StringRef", "(", "Token", ".", "Data", ",", "Token", ".", "Length", ")", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "}" ]

[ "*", "_", "_", "a", "=", "_", "_", "builtin_mve_viwdupq_m_wb_uv8hi", "(", "_", "_", "inactive", ",", "*", "_", "_", "a", ",", "_", "_", "c", ",", "_", "_", "imm", ",", "_", "_", "p", ")", ";", "return", "_", "_", "res", ";" ]

[ ":", "I48MODE" ]

[ "[", "(", "set", "(", "match_operand", ":", "I48MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "zero_extend" ]

[ "unsigned", "Opcode", "=", "(", "N", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ "SDValue", "LHS", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "RHS", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "LHS", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "isNullConstant", "(", "LHS", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "&&", "isNullConstant", "(", "LHS", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "&&", "isOneConstant", "(", "RHS", ")", ")", "{", "return", "DCI", ".", "CombineTo", "(", "N", ",", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ",", "LHS", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}", "}", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "{", "SDValue", "RHS", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "RHS", ")", ")", "{", "int32_t", "imm", "=", "C", "->", "getSExtValue", "(", ")", ";", "if", "(", "imm", "<", "<NUM_LIT>", "&&", "imm", ">", "std", "::", "numeric_limits", "<", "int", ">", "::", "min", "(", ")", ")", "{", "SDLoc", "DL", "(", "N", ")", ";", "RHS", "=", "DAG", ".", "getConstant", "(", "-", "imm", ",", "DL", ",", "MVT", "::", "i32", ")", ";" ]

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

[ "let", "Defs", "=", "[", "PC", "]", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

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

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

[ "}", "else", "{" ]

[ "if", "(", "(", "SrcVT", "==", "MVT", "::", "f64", "||", "SrcVT", "==", "MVT", "::", "f32", "||", "(", "SrcVT", "==", "MVT", "::", "f16", "&&", "Subtarget", "->", "hasFullFP16", "(", ")", ")", ")", "&&", "DstVT", "==", "SatVT", "&&", "(", "DstVT", "==", "MVT", "::", "i64", "||", "DstVT", "==", "MVT", "::", "i32", ")", ")", "return", "DAG", ".", "getNode", "(", "Op", ".", "getOpcode", "(", ")", ",", "DL", ",", "DstVT", ",", "SrcVal", ",", "DAG", ".", "getValueType", "(", "DstVT", ")", ")", ";", "if", "(", "DstWidth", "<", "SatWidth", ")", "return", "SDValue", "(", ")", ";", "SDValue", "NativeCvt", "=", "DAG", ".", "getNode", "(", "Op", ".", "getOpcode", "(", ")", ",", "DL", ",", "DstVT", ",", "SrcVal", ",", "DAG", ".", "getValueType", "(", "DstVT", ")", ")", ";", "SDValue", "Sat", ";", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "FP_TO_SINT_SAT", ")", "{", "SDValue", "MinC", "=", "DAG", ".", "getConstant", "(", "APInt", "::", "getSignedMaxValue", "(", "SatWidth", ")", ".", "sext", "(", "DstWidth", ")", ",", "DL", ",", "DstVT", ")", ";", "SDValue", "Min", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SMIN", ",", "DL", ",", "DstVT", ",", "NativeCvt", ",", "MinC", ")", ";", "SDValue", "MaxC", "=", "DAG", ".", "getConstant", "(", "APInt", "::", "getSignedMinValue", "(", "SatWidth", ")", ".", "sext", "(", "DstWidth", ")", ",", "DL", ",", "DstVT", ")", ";", "Sat", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SMAX", ",", "DL", ",", "DstVT", ",", "Min", ",", "MaxC", ")", ";" ]

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

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

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

[ "let", "Itinerary", "=", "itin", ";", "bits", "<", "<NUM_LIT>", ">", "PPC970_First", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "PPC970_Single", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "PPC970_Cracked", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "PPC970_Unit", "=", "<NUM_LIT>", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "PPC970_First", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "PPC970_Single", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "PPC970_Cracked", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "PPC970_Unit", ";", "bits", "<", "<NUM_LIT>", ">", "UseVSXReg", "=", "<NUM_LIT>", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "UseVSXReg", ";", "bits", "<", "<NUM_LIT>", ">", "XFormMemOp", "=", "<NUM_LIT>", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "XFormMemOp", ";", "string", "BaseName", "=", "<STR_LIT>", ";" ]

[ "<FIXS>", "DAG", ".", "getTargetConstant", "(", "IdxEn", ",", "DL", ",", "MVT", "::", "i1", ")", ",", "<FIXE>" ]

[ "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getTargetConstant", "(", "Dfmt", "|", "(", "Nfmt", "<<", "<NUM_LIT>", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getTargetConstant", "(", "Glc", "|", "(", "Slc", "<<", "<NUM_LIT>", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "<BUGS>", "DAG", ".", "getTargetConstant", "(", "IdxEn", ",", "DL", ",", "MVT", "::", "i1", ")", ",", "<BUGE>", "}", ";", "unsigned", "Opc", "=", "IsD16", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_pmullq128_mask", "(", "(", "_", "_", "v2di", ")", "_", "_", "A", ",", "(", "_", "_", "v2di", ")", "_", "_", "B", ",", "(", "_", "_", "v2di", ")", "_", "mm_avx512_setzero_si128", "(", ")", "," ]

[ "bool", "FixupLEAPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Func", ")", "{", "if", "(", "skipFunction", "(", "*", "Func", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "MF", "=", "&", "Func", ";", "const", "X86Subtarget", "&", "ST", "=", "Func", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "OptIncDec", "=", "!", "ST", ".", "slowIncDec", "(", ")", "||", "Func", ".", "getFunction", "(", ")", "->", "optForMinSize", "(", ")", ";", "OptLEA", "=", "ST", ".", "LEAusesAG", "(", ")", "||", "ST", ".", "slowLEA", "(", ")", ";", "if", "(", "!", "OptLEA", "&&", "!", "OptIncDec", ")", "return", "false", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Start X86FixupLEAs\\n", "<STR_LIT>", ";", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "Func", ".", "begin", "(", ")", ",", "E", "=", "Func", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "processBasicBlock", "(", "Func", ",", "I", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "End X86FixupLEAs\\n", "<STR_LIT>", ";", ")", ";", "return", "true", ";", "}" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

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

[ "return", "(", "int16x8_t", ")", "_", "_", "builtin_aarch64_saddw2v16qi", "(", "_", "_", "a", "," ]

[ "<FIXS>", "unsigned", "Rt", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "<FIXE>", "<FIXS>", "unsigned", "Rn", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "<FIXE>" ]

[ "case", "ARM", "::", "t2PLIs", ":", "break", ";", "default", ":", "{", "<BUGS>", "unsigned", "Rt", "=", "fieldFromInstruction32", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "if", "(", "!", "Check", "(", "S", ",", "DecoderGPRRegisterClass", "(", "Inst", ",", "Rt", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "}", "}", "<BUGS>", "unsigned", "Rn", "=", "fieldFromInstruction32", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "if", "(", "Rn", "==", "<NUM_LIT>", ")", "{", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "case", "ARM", "::", "t2LDRBs", ":" ]

[ "(", "word_alignedstore", "(", "v2f64", "DPair", ":", "$", "src", ")", ",", "GPR", ":", "$", "Rn", ")", "]", ">", ";" ]

[ "def", "VSTMQIA", ":", "PseudoVFPLdStM", "<", "(", "outs", ")", ",", "(", "ins", "DPair", ":", "$", "src", ",", "GPR", ":", "$", "Rn", ")", ",", "IIC_fpStore_m", ",", "<STR_LIT>", ",", "[" ]

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

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

[ "let", "opExtentAlign", "=", "<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", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<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>", ";" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "op16", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "op5", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

[ "Consts", ";" ]

[ "TII", "->", "getOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src0_neg_X", ")", ",", "TII", "->", "getOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src0_neg_Y", ")", ",", "TII", "->", "getOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src0_neg_Z", ")", ",", "TII", "->", "getOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src0_neg_W", ")", ",", "TII", "->", "getOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src1_neg_X", ")", ",", "TII", "->", "getOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src1_neg_Y", ")", ",", "TII", "->", "getOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src1_neg_Z", ")", ",", "TII", "->", "getOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src1_neg_W", ")", "}", ";", "int", "AbsIdx", "[", "]", "=", "{", "TII", "->", "getOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src0_abs_X", ")", ",", "TII", "->", "getOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src0_abs_Y", ")", ",", "TII", "->", "getOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src0_abs_Z", ")", ",", "TII", "->", "getOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src0_abs_W", ")", ",", "TII", "->", "getOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src1_abs_X", ")", ",", "TII", "->", "getOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src1_abs_Y", ")", ",", "TII", "->", "getOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src1_abs_Z", ")", ",", "TII", "->", "getOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src1_abs_W", ")", "}", ";", "std", "::", "vector", "<", "unsigned", ">" ]

[ "}" ]

[ "bits", "<", "<NUM_LIT>", ">", "OperandType", "=", "OpType", ".", "FP32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "SrcA", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "SrcB", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Dest", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Switches", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "OperandType", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Switches", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "]", ">", ";" ]

[ "def", "X86LFence", ":", "SDNode", "<", "<STR_LIT>", ",", "SDT_X86MEMBARRIER", ",", "[", "SDNPHasChain" ]

[ ";" ]

[ "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "S_SETPC_B64", ")", "{", "return", "nullptr" ]

[ ",", "_", "_", "scale", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_mask_i32gather_ps", "(", "_", "_", "m128", "_", "_", "src", ",", "float", "const", "*", "_", "_", "base", ",", "_", "_", "m128i", "_", "_", "index", ",", "_", "_", "m128", "_", "_", "mask", ",", "const", "int", "_", "_", "scale", ")", "{", "return", "(", "_", "_", "m128", ")", "_", "_", "builtin_ia32_gathersiv4sf", "(", "(", "_", "_", "v4sf", ")", "_", "_", "src", ",", "_", "_", "base", ",", "(", "_", "_", "v4si", ")", "_", "_", "index", ",", "(", "_", "_", "v4sf", ")", "_", "_", "mask" ]

[ ")" ]

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

[ "if", "(", "(", "rs6000_isa_flags", "&", "no_flag", ")", "==", "<NUM_LIT>", "&&", "(", "rs6000_isa_flags_explicit", "&", "no_flag", ")", "!=", "<NUM_LIT>", ")", "{" ]

[ "const", "char", "*", "const", "name", ";", "}", "flags", "[", "]", "=", "{", "{", "OPTION_MASK_P9_VECTOR", ",", "OTHER_P9_VECTOR_MASKS", ",", "<STR_LIT>", "power9-vector", "<STR_LIT>", "}", ",", "{", "OPTION_MASK_P8_VECTOR", ",", "OTHER_P8_VECTOR_MASKS", ",", "<STR_LIT>", "power8-vector", "<STR_LIT>", "}", ",", "{", "OPTION_MASK_VSX", ",", "OTHER_VSX_VECTOR_MASKS", ",", "<STR_LIT>", "vsx", "<STR_LIT>", "}", ",", "{", "OPTION_MASK_ALTIVEC", ",", "OTHER_ALTIVEC_MASKS", ",", "<STR_LIT>", "altivec", "<STR_LIT>", "}", ",", "}", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "ARRAY_SIZE", "(", "flags", ")", ";", "i", "++", ")", "{", "HOST_WIDE_INT", "no_flag", "=", "flags", "[", "i", "]", ".", "no_flag", ";" ]

[ ")" ]

[ "(", "define_attr", "<STR_LIT>", "<STR_LIT>", "(", "const_int", "<NUM_LIT>", ")" ]

[ "MBB", ";" ]

[ "return", "!" ]

[ "<FIXS>", "rs6000_target_modify_macros", "(", "true", ",", "rs6000_isa_flags", ")", ";", "<FIXE>" ]

[ "rs6000_cpu_cpp_builtins", "(", "cpp_reader", "*", "pfile", ")", "{", "<BUGS>", "rs6000_target_modify_macros", "(", "true", ",", "rs6000_isa_flags", ",", "rs6000_builtin_mask_calculate", "(", ")", ")", ";", "<BUGE>", "if", "(", "TARGET_FRE", ")", "builtin_define", "(", "<STR_LIT>", "__RECIP__", "<STR_LIT>", ")", ";" ]

[ ")", ",", "<STR_LIT>", "w", "<STR_LIT>", "(", "b", ")", ",", "<STR_LIT>", "x", "<STR_LIT>", "(", "c", ")", ":", ")", ";" ]

[ "int16x4_t", "result", ";", "_", "_", "asm__", "(", "<STR_LIT>", "mla %0.4h,%2.4h,%3.h[0]", "<STR_LIT>", ":", "<STR_LIT>", "=w", "<STR_LIT>", "(", "result", ")", ":", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", "(", "a" ]

[ "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "Encoding", ")", ";" ]

[ "int", "SecondMovkIdx", "=", "NotSet", ";", "for", "(", "int", "Idx", "=", "<NUM_LIT>", ";", "Idx", "<", "<NUM_LIT>", ";", "++", "Idx", ")", "{", "const", "uint64_t", "Chunk", "=", "getChunk", "(", "UImm", ",", "Idx", ")", ";", "if", "(", "(", "Idx", "<", "StartIdx", "||", "EndIdx", "<", "Idx", ")", "&&", "Chunk", "!=", "Outside", ")", "{", "OrrImm", "=", "updateImm", "(", "OrrImm", ",", "Idx", ",", "Outside", "==", "<NUM_LIT>", ")", ";", "if", "(", "FirstMovkIdx", "==", "NotSet", ")", "FirstMovkIdx", "=", "Idx", ";", "else", "SecondMovkIdx", "=", "Idx", ";", "}", "else", "if", "(", "Idx", ">", "StartIdx", "&&", "Idx", "<", "EndIdx", "&&", "Chunk", "!=", "Inside", ")", "{", "OrrImm", "=", "updateImm", "(", "OrrImm", ",", "Idx", ",", "Inside", "!=", "Mask", ")", ";", "if", "(", "FirstMovkIdx", "==", "NotSet", ")", "FirstMovkIdx", "=", "Idx", ";", "else", "SecondMovkIdx", "=", "Idx", ";", "}", "}", "assert", "(", "FirstMovkIdx", "!=", "NotSet", "&&", "<STR_LIT>", "Constant materializable with single ORR!", "<STR_LIT>", ")", ";", "uint64_t", "Encoding", "=", "<NUM_LIT>", ";", "<STR_LIT>", "::", "<STR_LIT>", "(", "OrrImm", ",", "<NUM_LIT>", ",", "Encoding", ")", ";" ]

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

[ "bool", "isShrImm8", "(", ")", "const", "{", "return", "isShrFixedWidth", "(" ]

[ "assert", "(", "SrcBitWidth", "==", "VTBits", "&&", "<STR_LIT>", "Expected operands of same bitwidth.", "<STR_LIT>", ")", ";" ]

[ "unsigned", "RHS", "=", "DAG", ".", "ComputeNumSignBits", "(", "Op", ".", "getOperand", "(", "OpNo", "+", "<NUM_LIT>", ")", ",", "Src1DemE", ",", "Depth", "+", "<NUM_LIT>", ")", ";", "if", "(", "RHS", "==", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "unsigned", "Common", "=", "std", "::", "min", "(", "LHS", ",", "RHS", ")", ";", "unsigned", "SrcBitWidth", "=", "Op", ".", "getOperand", "(", "OpNo", ")", ".", "getScalarValueSizeInBits", "(", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "unsigned", "VTBits", "=", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "if", "(", "SrcBitWidth", ">", "VTBits", ")", "{", "unsigned", "SrcExtraBits", "=", "SrcBitWidth", "-", "VTBits", ";", "if", "(", "Common", ">", "SrcExtraBits", ")", "return", "(", "Common", "-", "SrcExtraBits", ")", ";", "return", "<NUM_LIT>", ";", "}" ]

[ "IsDefault", ",", "STI", ")", ";" ]

[ "return", "decodeCustomOperand", "(", "DepCtrInfo", ",", "DEP_CTR_SIZE", ",", "Code", ",", "Id", ",", "Name", ",", "Val", "," ]

[ "}" ]

[ "if", "(", "const", "ConstantExpr", "*", "CE", "=", "dyn_cast", "<", "ConstantExpr", ">", "(", "S", ".", "Func", ")", ")", "S", ".", "Func", "=", "CE", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "llvm", "::", "GlobalAlias", "::", "create", "(", "GlobalValue", "::", "ExternalLinkage", ",", "(", "IsCtor", "?", "llvm", "::", "Twine", "(", "<STR_LIT>", "__sinit", "<STR_LIT>", ")", ":", "llvm", "::", "Twine", "(", "<STR_LIT>", "__sterm", "<STR_LIT>", ")", ")", "+", "llvm", "::", "Twine", "(", "convertToSinitPriority", "(", "S", ".", "Priority", ")", ")", "+", "llvm", "::", "Twine", "(", "<STR_LIT>", "_", "<STR_LIT>", ",", "FormatIndicatorAndUniqueModId", ")", "+", "llvm", "::", "Twine", "(", "<STR_LIT>", "_", "<STR_LIT>", ",", "llvm", "::", "utostr", "(", "Index", "++", ")", ")", ",", "cast", "<", "Function", ">", "(", "S", ".", "Func", ")", ")", ";", "}" ]

[ "}" ]

[ "SDValue", "V2", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "ShuffleVectorSDNode", "*", "SVOp", "=", "cast", "<", "ShuffleVectorSDNode", ">", "(", "Op", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "bool", "isLittleEndian", "=", "Subtarget", ".", "isLittleEndian", "(", ")", ";", "if", "(", "Subtarget", ".", "hasVSX", "(", ")", ")", "{", "if", "(", "V2", ".", "isUndef", "(", ")", "&&", "PPC", "::", "isSplatShuffleMask", "(", "SVOp", ",", "<NUM_LIT>", ")", ")", "{", "int", "SplatIdx", "=", "PPC", "::", "getVSPLTImmediate", "(", "SVOp", ",", "<NUM_LIT>", ",", "DAG", ")", ";", "SDValue", "Conv", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "MVT", "::", "v4i32", ",", "V1", ")", ";", "SDValue", "Splat", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "v4i32", ",", "Conv", ",", "DAG", ".", "getConstant", "(", "SplatIdx", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "MVT", "::", "v16i8", ",", "Splat", ")", ";", "}", "}", "if", "(", "Subtarget", ".", "hasQPX", "(", ")", ")", "{", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "!=", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "if", "(", "V2", ".", "isUndef", "(", ")", ")", "V2", "=", "V1", ";", "int", "AlignIdx", "=", "PPC", "::", "isQVALIGNIShuffleMask", "(", "SVOp", ")", ";", "if", "(", "AlignIdx", "!=", "-", "<NUM_LIT>", ")", "{", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "V1", ",", "V2", ",", "DAG", ".", "getConstant", "(", "AlignIdx", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "}", "else", "if", "(", "SVOp", "->", "isSplat", "(", ")", ")", "{", "int", "SplatIdx", "=", "SVOp", "->", "getSplatIndex", "(", ")", ";", "if", "(", "SplatIdx", ">=", "<NUM_LIT>", ")", "{", "std", "::", "swap", "(", "V1", ",", "V2", ")", ";", "SplatIdx", "-=", "<NUM_LIT>", ";", "}", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "V1", ",", "DAG", ".", "getConstant", "(", "SplatIdx", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "}", "unsigned", "idx", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "++", "i", ")", "{", "int", "m", "=", "SVOp", "->", "getMaskElt", "(", "i", ")", ";", "unsigned", "mm", "=", "m", ">=", "<NUM_LIT>", "?", "(", "unsigned", ")", "m", ":", "i", ";", "idx", "|=", "mm", "<<", "(", "<NUM_LIT>", "-", "i", ")", "*", "<NUM_LIT>", ";", "}", "SDValue", "V3", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "v4f64", ",", "DAG", ".", "getConstant", "(", "idx", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "V1", ",", "V2", ",", "V3", ")", ";", "}", "if", "(", "V2", ".", "isUndef", "(", ")", ")", "{", "if", "(", "PPC", "::", "isSplatShuffleMask", "(", "SVOp", ",", "<NUM_LIT>", ")", "||", "PPC", "::", "isSplatShuffleMask", "(", "SVOp", ",", "<NUM_LIT>", ")", "||", "PPC", "::", "isSplatShuffleMask", "(", "SVOp", ",", "<NUM_LIT>", ")", "||", "PPC", "::", "isVPKUWUMShuffleMask", "(", "SVOp", ",", "<NUM_LIT>", ",", "DAG", ")", "||", "PPC", "::", "isVPKUHUMShuffleMask", "(", "SVOp", ",", "<NUM_LIT>", ",", "DAG", ")", "||", "PPC", "::", "isVSLDOIShuffleMask", "(", "SVOp", ",", "<NUM_LIT>", ",", "DAG", ")", "!=", "-", "<NUM_LIT>", "||", "PPC", "::", "isVMRGLShuffleMask", "(", "SVOp", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "DAG", ")", "||", "PPC", "::", "isVMRGLShuffleMask", "(", "SVOp", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "DAG", ")", "||", "PPC", "::", "isVMRGLShuffleMask", "(", "SVOp", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "DAG", ")", "||", "PPC", "::", "isVMRGHShuffleMask", "(", "SVOp", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "DAG", ")", "||", "PPC", "::", "isVMRGHShuffleMask", "(", "SVOp", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "DAG", ")", "||", "PPC", "::", "isVMRGHShuffleMask", "(", "SVOp", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "DAG", ")", "||", "(", "Subtarget", ".", "hasP8Altivec", "(", ")", "&&", "(", "PPC", "::", "isVPKUDUMShuffleMask", "(", "SVOp", ",", "<NUM_LIT>", ",", "DAG", ")", "||", "PPC", "::", "isVMRGEOShuffleMask", "(", "SVOp", ",", "true", ",", "<NUM_LIT>", ",", "DAG", ")", "||", "PPC", "::", "isVMRGEOShuffleMask", "(", "SVOp", ",", "false", ",", "<NUM_LIT>", ",", "DAG", ")", ")", ")", ")", "{", "return", "Op", ";", "}", "}", "unsigned", "int", "ShuffleKind", "=", "isLittleEndian", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "if", "(", "PPC", "::", "isVPKUWUMShuffleMask", "(", "SVOp", ",", "ShuffleKind", ",", "DAG", ")", "||", "PPC", "::", "isVPKUHUMShuffleMask", "(", "SVOp", ",", "ShuffleKind", ",", "DAG", ")", "||", "PPC", "::", "isVSLDOIShuffleMask", "(", "SVOp", ",", "ShuffleKind", ",", "DAG", ")", "!=", "-", "<NUM_LIT>", "||", "PPC", "::", "isVMRGLShuffleMask", "(", "SVOp", ",", "<NUM_LIT>", ",", "ShuffleKind", ",", "DAG", ")", "||", "PPC", "::", "isVMRGLShuffleMask", "(", "SVOp", ",", "<NUM_LIT>", ",", "ShuffleKind", ",", "DAG", ")", "||", "PPC", "::", "isVMRGLShuffleMask", "(", "SVOp", ",", "<NUM_LIT>", ",", "ShuffleKind", ",", "DAG", ")", "||", "PPC", "::", "isVMRGHShuffleMask", "(", "SVOp", ",", "<NUM_LIT>", ",", "ShuffleKind", ",", "DAG", ")", "||", "PPC", "::", "isVMRGHShuffleMask", "(", "SVOp", ",", "<NUM_LIT>", ",", "ShuffleKind", ",", "DAG", ")", "||", "PPC", "::", "isVMRGHShuffleMask", "(", "SVOp", ",", "<NUM_LIT>", ",", "ShuffleKind", ",", "DAG", ")", "||", "(", "Subtarget", ".", "hasP8Altivec", "(", ")", "&&", "(", "PPC", "::", "isVPKUDUMShuffleMask", "(", "SVOp", ",", "ShuffleKind", ",", "DAG", ")", "||", "PPC", "::", "isVMRGEOShuffleMask", "(", "SVOp", ",", "true", ",", "ShuffleKind", ",", "DAG", ")", "||", "PPC", "::", "isVMRGEOShuffleMask", "(", "SVOp", ",", "false", ",", "ShuffleKind", ",", "DAG", ")", ")", ")", ")", "return", "Op", ";", "ArrayRef", "<", "int", ">", "PermMask", "=", "SVOp", "->", "getMask", "(", ")", ";", "unsigned", "PFIndexes", "[", "<NUM_LIT>", "]", ";", "bool", "isFourElementShuffle", "=", "true", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "<NUM_LIT>", "&&", "isFourElementShuffle", ";", "++", "i", ")", "{", "unsigned", "EltNo", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "j", "=", "<NUM_LIT>", ";", "j", "!=", "<NUM_LIT>", ";", "++", "j", ")", "{", "if", "(", "PermMask", "[", "i", "*", "<NUM_LIT>", "+", "j", "]", "<", "<NUM_LIT>", ")", "continue", ";", "unsigned", "ByteSource", "=", "PermMask", "[", "i", "*", "<NUM_LIT>", "+", "j", "]", ";", "if", "(", "(", "ByteSource", "&", "<NUM_LIT>", ")", "!=", "j", ")", "{", "isFourElementShuffle", "=", "false", ";", "break", ";", "}", "if", "(", "EltNo", "==", "<NUM_LIT>", ")", "{", "EltNo", "=", "ByteSource", "/", "<NUM_LIT>", ";", "}", "else", "if", "(", "EltNo", "!=", "ByteSource", "/", "<NUM_LIT>", ")", "{", "isFourElementShuffle", "=", "false", ";", "break", ";", "}", "}", "PFIndexes", "[", "i", "]", "=", "EltNo", ";" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand" ]

[ "<FIXS>", "*", "total", "+=", "rtx_cost", "(", "op0", ",", "mode", ",", "code", ",", "<NUM_LIT>", ",", "speed", ")", ";", "<FIXE>" ]

[ "op1", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "!=", "REG", "&&", "(", "GET_CODE", "(", "op0", ")", "!=", "SUBREG", "||", "GET_CODE", "(", "SUBREG_REG", "(", "op0", ")", ")", "!=", "REG", ")", ")", "<BUGS>", "*", "total", "+=", "rtx_cost", "(", "op0", ",", "code", ",", "<NUM_LIT>", ",", "speed", ")", ";", "<BUGE>", "return", "true", ";" ]

[ "}" ]

[ "SDLoc", "dl", "(", "Op", ")", ";", "SDValue", "DBZCHK", "=", "WinDBZCheckDenominator", "(", "DAG", ",", "Op", ".", "getNode", "(", ")", ",", "DAG", ".", "getEntryNode", "(", ")", ")", ";", "SDValue", "Result", "=", "LowerWindowsDIVLibCall", "(", "Op", ",", "DAG", ",", "Signed", ",", "DBZCHK", ")", ";", "SDValue", "Lower", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "i32", ",", "Result", ")", ";", "SDValue", "Upper", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "dl", ",", "MVT", "::", "i64", ",", "Result", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "TLI", ".", "getPointerTy", "(", "DL", ")", ")", ")", ";", "Upper", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "i32", ",", "Upper", ")", ";", "Results", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_PAIR", ",", "dl", ",", "MVT", "::", "i64", ",", "Lower", ",", "Upper", ")", ")", ";" ]

[ "}" ]

[ "if", "(", "seh", "->", "cfa_reg", "==", "stack_pointer_rtx", ")", "seh", "->", "cfa_offset", "+=", "offset", ";", "seh", "->", "sp_offset", "+=", "offset", ";", "if", "(", "offset", "<", "SEH_MAX_FRAME_SIZE", ")", "fprintf", "(", "f", ",", "<STR_LIT>", "\\t.seh_stackalloc\\t", "<STR_LIT>", "HOST_WIDE_INT_PRINT_DEC", "<STR_LIT>", "\\n", "<STR_LIT>", ",", "offset", ")", ";" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "size", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "R", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opcode", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "int", "size", "ATTRIBUTE_UNUSED", ";", "<FIXE>" ]

[ "voidoutput_function_epilogue", "(", "file", ",", "size", ")", "FILE", "*", "file", ";", "<BUGS>", "int", "size", ";", "<BUGE>", "{", "rtx", "insn", "=", "get_last_insn", "(", ")", ";" ]

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

[ "(", "define_expand", "<STR_LIT>", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "intcmpcc", "(", "match_operand", ":", "VI_HW", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VI_HW", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>" ]

[ "<STR_LIT>", ";" ]

[ "let", "RenderMethod", "=", "<STR_LIT>", ";", "let", "ParserMethod", "=", "<STR_LIT>", ";", "let", "PredicateMethod", "=" ]

[ "<FIXS>", "#", "ifdef", "NDEBUG", "<FIXE>" ]

[ "}", "}", "<BUGS>", "#", "if", "<NUM_LIT>", "<BUGE>", "if", "(", "Result", ".", "getNode", "(", ")", ")", "{", "DEBUG", "(", "cerr", "<<", "<STR_LIT>", "\\nReplace.SPU: ", "<STR_LIT>", ")", ";", "DEBUG", "(", "N", "->", "dump", "(", "&", "DAG", ")", ")", ";" ]

[ "<FIXS>", "BinOpFrag", "(", "adde_dead_carry", "node", ":", "$", "LHS", ",", "node", ":", "$", "RHS", ")", ">", ",", "<NUM_LIT>", ">", ";", "<FIXE>", "<FIXS>", "BinOpFrag", "(", "sube_dead_carry", "node", ":", "$", "LHS", ",", "node", ":", "$", "RHS", ")", ">", ">", ";", "<FIXE>", "<FIXS>", "BinOpFrag", "(", "adde_live_carry", "node", ":", "$", "LHS", ",", "node", ":", "$", "RHS", ")", ">", ",", "<NUM_LIT>", ">", ";", "<FIXE>", "<FIXS>", "BinOpFrag", "(", "sube_live_carry", "node", ":", "$", "LHS", ",", "node", ":", "$", "RHS", ")", ">", ">", ";", "<FIXE>" ]

[ "BinOpFrag", "(", "subc", "node", ":", "$", "LHS", ",", "node", ":", "$", "RHS", ")", ">", ">", ";", "defm", "ADC", ":", "AI1_adde_sube_irs", "<NUM_LIT>", ",", "<STR_LIT>", ",", "<BUGS>", "BinOpFrag", "(", "adde", "node", ":", "$", "LHS", ",", "node", ":", "$", "RHS", ")", ">", ",", "<NUM_LIT>", ">", ";", "<BUGE>", "defm", "SBC", ":", "AI1_adde_sube_irs", "<NUM_LIT>", ",", "<STR_LIT>", ",", "<BUGS>", "BinOpFrag", "(", "sube", "node", ":", "$", "LHS", ",", "node", ":", "$", "RHS", ")", ">", ">", ";", "<BUGE>", "defm", "ADCS", ":", "AI1_adde_sube_s_irs", "<NUM_LIT>", ",", "<STR_LIT>", ",", "<BUGS>", "BinOpFrag", "(", "adde", "node", ":", "$", "LHS", ",", "node", ":", "$", "RHS", ")", ">", ",", "<NUM_LIT>", ">", ";", "<BUGE>", "defm", "SBCS", ":", "AI1_adde_sube_s_irs", "<NUM_LIT>", ",", "<STR_LIT>", ",", "<BUGS>", "BinOpFrag", "(", "sube", "node", ":", "$", "LHS", ",", "node", ":", "$", "RHS", ")", ">", ">", ";", "<BUGE>", "def", "RSBri", ":", "AsI1", "<NUM_LIT>", ",", "(", "outs", "GPR", ":", "$", "dst", ")", ",", "(", "ins", "GPR", ":", "$", "a", ",", "so_imm", ":", "$", "b", ")", ",", "DPFrm", "," ]

[ "Couldn't find the register class", "<STR_LIT>", ")", ";" ]

[ "const", "TargetRegisterClass", "*", "M680x0RegisterInfo", "::", "getMaximalPhysRegClass", "(", "unsigned", "reg", ",", "MVT", "VT", ")", "const", "{", "assert", "(", "isPhysicalRegister", "(", "reg", ")", "&&", "<STR_LIT>", "reg must be a physical register", "<STR_LIT>", ")", ";", "const", "TargetRegisterClass", "*", "BestRC", "=", "nullptr", ";", "for", "(", "regclass_iterator", "I", "=", "regclass_begin", "(", ")", ",", "E", "=", "regclass_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "*", "I", ";", "if", "(", "(", "VT", "==", "MVT", "::", "Other", "||", "isTypeLegalForClass", "(", "*", "RC", ",", "VT", ")", ")", "&&", "RC", "->", "contains", "(", "reg", ")", "&&", "(", "!", "BestRC", "||", "(", "BestRC", "->", "hasSubClass", "(", "RC", ")", "&&", "RC", "->", "getNumRegs", "(", ")", ">", "BestRC", "->", "getNumRegs", "(", ")", ")", ")", ")", "BestRC", "=", "RC", ";", "}", "assert", "(", "BestRC", "&&", "<STR_LIT>" ]

[ ")", ")", "_", "mm_maskz_cvtpd_epi64", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m128d", "_", "_", "A", ")", "{" ]

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

[ "BWWriteZeroLatency", "]", ">", ",", "SchedVar", "<", "NoSchedPred", ",", "[", "WriteVecLogicY", "]", ">", "]", ">", ";" ]

[ "def", "BWWriteVZeroIdiomLogicY", ":", "SchedWriteVariant", "<", "[", "SchedVar", "<", "MCSchedPredicate", "<", "ZeroIdiomPredicate", ">", ",", "[" ]

[ ")", ";" ]

[ "llvm_unreachable", "(", "<STR_LIT>", "Unimplemented", "<STR_LIT>" ]

[ "rtx_insn", "*", "insn", ")", "{" ]

[ "static", "bool", "compare_sign_p", "(" ]

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

[ "return", "useHVX", "(", ")" ]

[ "bool", "function_resolver", "::", "require_matching_vector_type", "(", "unsigned", "int", "argno", ",", "unsigned", "int", "first_argno", ",", "sve_type", "type", ")", "{", "sve_type", "new", "_", "type", "=", "infer_sve_type", "(", "argno", ")", ";", "if", "(", "!", "new", "_", "type", ")", "return", "false", ";", "if", "(", "type", ".", "num_vectors", "!=", "new", "_", "type", ".", "num_vectors", ")", "{", "report_mismatched_num_vectors", "(", "first_argno", ",", "type", ",", "argno", ",", "new", "_", "type", ")", ";", "return", "false", ";", "}", "if", "(", "type", "!=", "new", "_", "type", ")", "{", "error_at", "(", "location", ",", "<STR_LIT>", "passing %qT to argument %d of %qE, but", "<STR_LIT>", "<STR_LIT>", " argument %d had type %qT", "<STR_LIT>", ",", "get_vector_type", "(", "new", "_", "type", ")", ",", "argno", "+", "<NUM_LIT>", ",", "fndecl", ",", "first_argno", "+", "<NUM_LIT>", ",", "get_vector_type", "(", "type", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Like", "require_vector_type", ",", "but", "TYPE", "is", "inferred", "from", "previous", "arguments", "rather", "than", "being", "a", "fixed", "part", "of", "the", "function", "signature", ".", "This", "changes", "the", "nature", "of", "the", "error", "messages", "." ]

[ "<FIXS>", "TuningSlowUAMem16", ",", "TuningLEAForSP", ",", "TuningSlowDivide32", ",", "TuningSlowDivide64", ",", "TuningSlowTwoMemOps", ",", "TuningLEAUsesAG", ",", "TuningPadShortFunctions", ",", "TuningInsertVZEROUPPER", "]", ";", "<FIXE>" ]

[ "FeatureMOVBE", ",", "FeatureLAHFSAHF", "]", ";", "list", "SubtargetFeature", ">", "AtomTuning", "=", "[", "ProcIntelAtom", ",", "<BUGS>", "FeatureSlowUAMem16", ",", "FeatureLEAForSP", ",", "FeatureSlowDivide32", ",", "FeatureSlowDivide64", ",", "FeatureSlowTwoMemOps", ",", "FeatureLEAUsesAG", ",", "FeaturePadShortFunctions", ",", "FeatureInsertVZEROUPPER", "]", ";", "<BUGE>", "list", "SubtargetFeature", ">", "SLMAdditionalFeatures", "=", "[", "FeatureSSE42", "," ]

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

[ "UNSPEC_PTEST", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set", "(", "attr", "<STR_LIT>", ")", "(", "if_then_else", "(", "match_test", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>" ]

[ "}" ]

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

[ "int", "initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "int", "regs_saved", ";", "int", "regs_saved_rounding", "=", "<NUM_LIT>", ";", "int", "total_saved_regs_space", ";", "int", "total_auto_space", ";", "int", "save_flags", "=", "target_flags", ";", "int", "copy_flags", ";", "HARD_REG_SET", "live_regs_mask", ";", "shmedia_space_reserved_for_target_registers", "=", "false", ";", "regs_saved", "=", "calc_live_regs", "(", "&", "live_regs_mask", ")", ";", "regs_saved", "+=", "SHMEDIA_REGS_STACK_ADJUST", "(", ")", ";", "if", "(", "shmedia_reserve_space_for_target_registers_p", "(", "regs_saved", ",", "&", "live_regs_mask", ")", ")", "{", "shmedia_space_reserved_for_target_registers", "=", "true", ";", "regs_saved", "+=", "shmedia_target_regs_stack_adjust", "(", "&", "live_regs_mask", ")", ";", "}", "if", "(", "TARGET_SH5", "&&", "regs_saved", "%", "(", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ")", "regs_saved_rounding", "=", "(", "(", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", "-", "regs_saved", "%", "(", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ")", ";", "total_auto_space", "=", "rounded_frame_size", "(", "regs_saved", ")", "-", "regs_saved_rounding", ";", "copy_flags", "=", "target_flags", ";", "target_flags", "=", "save_flags", ";", "total_saved_regs_space", "=", "regs_saved", "+", "regs_saved_rounding", ";", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "return", "total_saved_regs_space", "+", "total_auto_space", "+", "current_function_args_info", ".", "byref_regs", "*", "<NUM_LIT>", ";", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "total_saved_regs_space", "+", "total_auto_space", "+", "current_function_args_info", ".", "byref_regs", "*", "<NUM_LIT>", ";", "if", "(", "from", "==", "HARD_FRAME_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "<NUM_LIT>", ";", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "rounded_frame_size", "(", "<NUM_LIT>", ")", ";", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", "&&", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "return", "rounded_frame_size", "(", "<NUM_LIT>", ")", ";", "gcc_assert", "(", "from", "==", "RETURN_ADDRESS_POINTER_REGNUM", "&&", "(", "to", "==", "HARD_FRAME_POINTER_REGNUM", "||", "to", "==", "STACK_POINTER_REGNUM", ")", ")", ";", "if", "(", "TARGET_SH5", ")", "{", "int", "n", "=", "total_saved_regs_space", ";", "int", "pr_reg", "=", "TARGET_SHMEDIA", "?", "PR_MEDIA_REG", ":", "PR_REG", ";", "save_schedule", "schedule", ";", "save_entry", "*", "entry", ";", "n", "+=", "total_auto_space", ";", "if", "(", "!", "TEST_HARD_REG_BIT", "(", "live_regs_mask", ",", "pr_reg", ")", ")", "return", "n", ";", "target_flags", "=", "copy_flags", ";", "sh5_schedule_saves", "(", "&", "live_regs_mask", ",", "&", "schedule", ",", "n", ")", ";", "for", "(", "entry", "=", "&", "schedule", ".", "entries", "[", "<NUM_LIT>", "]", ";", "entry", "->", "mode", "!=", "VOIDmode", ";", "entry", "++", ")", "if", "(", "entry", "->", "reg", "==", "pr_reg", ")", "{", "target_flags", "=", "save_flags", ";", "return", "entry", "->", "offset", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "else", "return", "total_auto_space", ";", "}" ]

[ "Define", "the", "offset", "between", "two", "registers", ",", "one", "to", "be", "eliminated", ",", "and", "the", "other", "its", "replacement", ",", "at", "the", "start", "of", "a", "routine", "." ]

[ "}", "]", ">", "{", "let", "ParserMatchClass", "=", "TBZImm32_63Operand", ";" ]

[ "def", "tbz_imm32_63", ":", "Operand", "<", "i64", ">", ",", "ImmLeaf", "<", "i64", ",", "[", "{", "return", "(", "(", "(", "uint32_t", ")", "Imm", ")", ">", "<NUM_LIT>", ")", "&", "&", "(", "(", "(", "uint32_t", ")", "Imm", ")", "<", "<NUM_LIT>", ")", ";" ]

[ "}" ]

[ "for", "(", "auto", "&", "MI", ":", "llvm", "::", "make_early_inc_range", "(", "MBB", ")", ")", "{", "if", "(", "MI", ".", "isDebugValue", "(", ")", "&&", "MI", ".", "getDebugOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "!", "MI", ".", "isUndefDebugValue", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Warning: dangling DBG_VALUE set to undef: ", "<STR_LIT>", "<<", "MI", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "MI", ".", "setDebugValueUndef", "(", ")", ";", "}", "}" ]

[ ")", "offset", "-=", "cfun", "->", "machine", "->", "reg_offset", ";" ]

[ "case", "ARG_POINTER_REGNUM", ":", "offset", "=", "cfun", "->", "machine", "->", "arg_offset", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "to", "==", "FRAME_POINTER_REGNUM", "||", "to", "==", "HARD_FRAME_POINTER_REGNUM" ]

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

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

[ ";" ]

[ "Impl", ".", "DL", "=", "&", "Impl", ".", "Mod", "->", "getDataLayout", "(", ")", ";", "Impl", ".", "SqrtF32", "=", "nullptr", ";", "Impl", ".", "LdexpF32", "=", "nullptr", ";", "return", "false" ]

[ "}" ]

[ "bits", "<", "<NUM_LIT>", ">", "idx2", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "idx", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "idx2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "{", "?", ",", "?", ",", "?", "}", ";" ]

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

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

[ "void", "TPCAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_4", ")", "{", "void", "*", "Ptr", "=", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "]", ";", "memcpy", "(", "Ptr", ",", "&", "Value", ",", "sizeof", "(", "uint32_t", ")", ")", ";", "}", "else", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_PCRel_4", ")", "{", "int", "RelOffset", "=", "Value", "&", "<NUM_LIT>", ";", "unsigned", "InstrSize", "=", "TPCII", "::", "InstructionSize", ";", "LLVM_DEBUG", "(", "fprintf", "(", "stderr", ",", "<STR_LIT>", "applyFixup offset=%d reloc=%d comp=%d\\n", "<STR_LIT>", ",", "Offset", ",", "RelOffset", ",", "(", "Data", "[", "Offset", "]", "&", "<NUM_LIT>", ")", ")", ";", ")", ";", "assert", "(", "InstrSize", "%", "<NUM_LIT>", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Instruction is not aligned to 64 bits anymore, fix relocations", "<STR_LIT>", ")", ";", "APInt", "Instruction", "(", "InstrSize", ",", "ArrayRef", "<", "uint64_t", ">", "(", "(", "uint64_t", "*", ")", "(", "&", "Data", "[", "Offset", "]", ")", ",", "InstrSize", "/", "<NUM_LIT>", ")", ")", ";", "APInt", "ImmSlot", "(", "TPCII", "::", "ImmSize", ",", "RelOffset", ")", ";", "Instruction", "|=", "ImmSlot", ".", "zext", "(", "InstrSize", ")", ".", "shl", "(", "TPCII", "::", "ImmStart", ")", ";", "const", "char", "*", "RawInstrucion", "=", "(", "const", "char", "*", ")", "Instruction", ".", "getRawData", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "InstrSize", "/", "<NUM_LIT>", ";", "++", "i", ")", "{", "Data", "[", "Offset", "+", "i", "]", "=", "RawInstrucion", "[", "i", "]", ";", "}", "}", "else", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "MCFixupKind", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "{", "assert", "(", "Value", "!=", "<NUM_LIT>", "&&", "<STR_LIT>", "Too short LOOP", "<STR_LIT>", ")", ";", "if", "(", "(", "Value", "&", "<NUM_LIT>", ")", "!=", "Value", ")", "{", "report_fatal_error", "(", "<STR_LIT>", "Too many instructions in the LOOP - END_PC offset does not fit in 16 bits", "<STR_LIT>", ")", ";", "}", "unsigned", "InstrSize", "=", "TPCII", "::", "InstructionSize", ";", "int", "RelOffset", "=", "(", "Value", "&", "<NUM_LIT>", ")", "-", "TPCII", "::", "InstructionSize", "/", "<NUM_LIT>", ";", "LLVM_DEBUG", "(", "fprintf", "(", "stderr", ",", "<STR_LIT>", "applyFixup LOOP offset=%d reloc=%d comp=%d\\n", "<STR_LIT>", ",", "Offset", ",", "RelOffset", ",", "(", "Data", "[", "Offset", "]", "&", "<NUM_LIT>", ")", ")", ";", ")", ";", "APInt", "Instruction", "(", "TPCII", "::", "InstructionSize", ",", "ArrayRef", "<", "uint64_t", ">", "(", "(", "uint64_t", "*", ")", "(", "&", "Data", "[", "Offset", "]", ")", ",", "TPCII", "::", "InstructionSize", "/", "<NUM_LIT>", ")", ")", ";", "APInt", "ImmSlot", "(", "TPCII", "::", "ImmSize", ",", "RelOffset", ")", ";", "Instruction", "|=", "ImmSlot", ".", "zext", "(", "TPCII", "::", "InstructionSize", ")", ".", "shl", "(", "TPCII", "::", "LoopOffsetStart", ")", ";", "const", "char", "*", "RawInstrucion", "=", "(", "const", "char", "*", ")", "Instruction", ".", "getRawData", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "InstrSize", "/", "<NUM_LIT>", ";", "++", "i", ")", "{", "Data", "[", "Offset", "+", "i", "]", "=", "RawInstrucion", "[", "i", "]", ";", "}", "}", "}" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

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

[ "rtx", "insn", ",", "next_tail", ",", "head", ",", "tail", ";", "get_block_head_tail", "(", "b", ",", "&", "head", ",", "&", "tail", ")", ";", "next_tail", "=", "NEXT_INSN", "(", "tail", ")", ";", "for", "(", "insn", "=", "head", ";", "insn", "!=", "next_tail", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "continue", ";", "if", "(", "mode", "==", "SFmode", ")", "INSN_REGMODE_WEIGHT", "(", "insn", ",", "mode", ")", "=", "find_insn_regmode_weight", "(", "insn", ",", "mode", ")", "+", "<NUM_LIT>", "*", "find_insn_regmode_weight", "(", "insn", ",", "DFmode", ")", ";", "else", "if", "(", "mode", "==", "SImode", ")", "INSN_REGMODE_WEIGHT", "(", "insn", ",", "mode", ")", "=", "find_insn_regmode_weight", "(", "insn", ",", "mode", ")", "+", "<NUM_LIT>", "*", "find_insn_regmode_weight", "(", "insn" ]

[ "PSI", ",", "BFI", ",", "AA", ")", ";" ]

[ "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "InstructionSelector", "::", "setupMF", "(", "MF", ",", "KB", ",", "CoverageInfo", "," ]

[ "{" ]

[ "<STR_LIT>", "::", "<STR_LIT>", "getExtendType", "(", ")", "const" ]

[ ";" ]

[ "SM", ".", "serializeToStackMapSection", "(", ")" ]

[ "<STR_LIT>", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "leu", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>" ]

[ "}" ]

[ "rtx", "symbol", ";", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "if", "(", "!", "MEM_P", "(", "rtl", ")", ")", "return", ";", "symbol", "=", "XEXP", "(", "rtl", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "symbol", ")", "!=", "SYMBOL_REF", ")", "return", ";", "if", "(", "flag_pic", ")", "SYMBOL_REF_FLAG", "(", "symbol", ")", "=", "(", "*", "targetm", ".", "binds_local_p", ")", "(", "decl", ")", ";" ]

[ ")", "{" ]

[ "FunctionPass", "*", "llvm", "::", "createARMLoadStoreOptimizationPass", "(" ]

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

[ "def", "lea64_32mem", ":", "Operand", "<", "i32", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";" ]

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

[ "const", "LLT", "S32", "=", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ";", "const", "LLT", "S64", "=", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ";", "const", "LLT", "S512", "=", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ";", "const", "LLT", "GlobalPtr", "=", "GetAddrSpacePtr", "(", "AMDGPUAS", "::", "GLOBAL_ADDRESS", ")", ";", "const", "LLT", "ConstantPtr", "=", "GetAddrSpacePtr", "(", "AMDGPUAS", "::", "CONSTANT_ADDRESS", ")", ";", "const", "LLT", "LocalPtr", "=", "GetAddrSpacePtr", "(", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", ";", "const", "LLT", "FlatPtr", "=", "GetAddrSpacePtr", "(", "AMDGPUAS", ".", "FLAT_ADDRESS", ")", ";", "const", "LLT", "PrivatePtr", "=", "GetAddrSpacePtr", "(", "AMDGPUAS", ".", "PRIVATE_ADDRESS", ")", ";", "const", "LLT", "AddrSpaces", "[", "]", "=", "{", "GlobalPtr", ",", "ConstantPtr", ",", "LocalPtr", ",", "FlatPtr", ",", "PrivatePtr", "}", ";", "setAction", "(", "{", "G_ADD", ",", "S32", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_ASHR", ",", "S32", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_SUB", ",", "S32", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_MUL", ",", "S32", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_AND", ",", "S32", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_OR", ",", "S32", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_XOR", ",", "S32", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_BITCAST", ",", "V2S16", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_BITCAST", ",", "<NUM_LIT>", ",", "S32", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_BITCAST", ",", "S32", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_BITCAST", ",", "<NUM_LIT>", ",", "V2S16", "}", ",", "Legal", ")", ";", "getActionDefinitionsBuilder", "(", "G_FCONSTANT", ")", ".", "legalFor", "(", "{", "S32", ",", "S64", "}", ")", ";", "getActionDefinitionsBuilder", "(", "G_IMPLICIT_DEF", ")", ".", "legalIf", "(", "[", "=", "]", "(", "const", "LegalityQuery", "&", "Query", ")", "{", "return", "Query", ".", "Types", "[", "<NUM_LIT>", "]", ".", "getSizeInBits", "(", ")", "<=", "<NUM_LIT>", ";", "}", ")", ".", "clampScalar", "(", "<NUM_LIT>", ",", "S1", ",", "S512", ")", ";", "getActionDefinitionsBuilder", "(", "G_CONSTANT", ")", ".", "legalFor", "(", "{", "S1", ",", "S32", ",", "S64", "}", ")", ";", "setAction", "(", "{", "G_CONSTANT", ",", "S1", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_FADD", ",", "S32", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_FCMP", ",", "S1", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_FCMP", ",", "<NUM_LIT>", ",", "S32", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_FCMP", ",", "<NUM_LIT>", ",", "S64", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_FMUL", ",", "S32", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_ZEXT", ",", "S64", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_ZEXT", ",", "<NUM_LIT>", ",", "S32", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_FPTOSI", ",", "S32", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_FPTOSI", ",", "<NUM_LIT>", ",", "S32", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_SITOFP", ",", "S32", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_SITOFP", ",", "<NUM_LIT>", ",", "S32", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_FPTOUI", ",", "S32", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_FPTOUI", ",", "<NUM_LIT>", ",", "S32", "}", ",", "Legal", ")", ";", "for", "(", "LLT", "PtrTy", ":", "AddrSpaces", ")", "{", "LLT", "IdxTy", "=", "LLT", "::", "scalar", "(", "PtrTy", ".", "getSizeInBits", "(", ")", ")", ";", "setAction", "(", "{", "G_GEP", ",", "PtrTy", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_GEP", ",", "<NUM_LIT>", ",", "IdxTy", "}", ",", "Legal", ")", ";", "}", "setAction", "(", "{", "G_ICMP", ",", "S1", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_ICMP", ",", "<NUM_LIT>", ",", "S32", "}", ",", "Legal", ")", ";", "getActionDefinitionsBuilder", "(", "{", "G_LOAD", ",", "G_STORE", "}", ")", ".", "legalIf", "(", "[", "=", ",", "&", "ST", "]", "(", "const", "LegalityQuery", "&", "Query", ")", "{", "const", "LLT", "&", "Ty0", "=", "Query", ".", "Types", "[", "<NUM_LIT>", "]", ";", "switch", "(", "Ty0", ".", "getSizeInBits", "(", ")", ")", "{", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "return", "true", ";", "case", "<NUM_LIT>", ":", "return", "(", "ST", ".", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SEA_ISLANDS", ")", ";", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "default", ":", "return", "false", ";", "}", "}", ")", ";", "setAction", "(", "{", "G_SELECT", ",", "S32", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_SELECT", ",", "<NUM_LIT>", ",", "S1", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_SHL", ",", "S32", "}", ",", "Legal", ")", ";", "setAction", "(", "{", "G_GEP", ",", "S64", "}", ",", "Legal", ")", ";", "for", "(", "unsigned", "Op", ":", "{", "G_EXTRACT_VECTOR_ELT", ",", "G_INSERT_VECTOR_ELT", "}", ")", "{", "getActionDefinitionsBuilder", "(", "Op", ")", ".", "legalIf", "(", "[", "=", "]", "(", "const", "LegalityQuery", "&", "Query", ")", "{", "const", "LLT", "&", "VecTy", "=", "Query", ".", "Types", "[" ]

[ "}" ]

[ "vcopyq_lane_u16", "(", "uint16x8_t", "_", "_", "a", ",", "const", "int", "_", "_", "lane1", ",", "uint16x4_t", "_", "_", "b", ",", "const", "int", "_", "_", "lane2", ")", "{", "return", "_", "_", "aarch64_vset_lane_any", "(", "_", "_", "aarch64_vget_lane_any", "(", "_", "_", "b", ",", "_", "_", "lane2", ")", ",", "_", "_", "a", ",", "_", "_", "lane1", ")", ";" ]

[ "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "FrameIndex in unexpected instruction!", "<STR_LIT>", ")", ";" ]

[ "int", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "unsigned", "DestReg", "=", "<NUM_LIT>", ";", "MachineOperand", "*", "FrameIndexOp", "=", "<NUM_LIT>", ";", "if", "(", "Opc", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "DestReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "FrameIndexOp", "=", "&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "}", "else", "if", "(", "Opc", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Opc", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "unsigned", "i", "=", "<NUM_LIT>", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "<STR_LIT>", "Instr doesn't have FrameIndex operand!", "<STR_LIT>", ")", ";", "}", "DestReg", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "FrameIndexOp", "=", "&", "MI", ".", "getOperand", "(", "i", ")", ";", "}", "int", "Offset", "=", "MF", "->", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndexOp", "->", "getIndex", "(", ")", ")", ";", "addOffset", "(", "MBB", ",", "II", ",", "DL", ",", "DestReg", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "Offset", ")", ";", "switch", "(", "Opc", ")", "{" ]

[ "(", "insn", ")", ")", "return", "<NUM_LIT>", ";" ]

[ "if", "(", "ready_index", "==", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "if", "(", "rs6000_tune", "!=", "PROCESSOR_CELL", ")", "return", "<NUM_LIT>", ";", "gcc_assert", "(", "insn", "!=", "NULL_RTX", "&&", "INSN_P", "(", "insn", ")", ")", ";", "if", "(", "!", "reload_completed", "||", "is_nonpipeline_insn", "(", "insn", ")", "||", "is_microcoded_insn" ]

[ "+", "X86", "::", "AddrIndexReg", ")", ";" ]

[ "Register", "DefReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "MachineInstr", "*", "SingleUseMI", "=", "nullptr", ";", "for", "(", "MachineInstr", "&", "UseMI", ":", "MRI", "->", "use_instructions", "(", "DefReg", ")", ")", "{", "if", "(", "HardenedInstrs", ".", "count", "(", "&", "UseMI", ")", ")", "{", "if", "(", "!", "X86InstrInfo", "::", "isDataInvariantLoad", "(", "UseMI", ")", "||", "isEFLAGSDefLive", "(", "UseMI", ")", ")", "{", "assert", "(", "X86InstrInfo", "::", "isDataInvariant", "(", "UseMI", ")", "&&", "<STR_LIT>", "Data variant instruction being hardened!", "<STR_LIT>", ")", ";", "continue", ";", "}", "const", "int", "MemRefBeginIdx", "=", "X86", "::", "getFirstAddrOperandIdx", "(", "UseMI", ")", ";", "assert", "(", "MemRefBeginIdx", ">=", "<NUM_LIT>", "&&", "<STR_LIT>", "Should always have mem references here!", "<STR_LIT>", ")", ";", "MachineOperand", "&", "BaseMO", "=", "UseMI", ".", "getOperand", "(", "MemRefBeginIdx", "+", "X86", "::", "AddrBaseReg", ")", ";", "MachineOperand", "&", "IndexMO", "=", "UseMI", ".", "getOperand", "(", "MemRefBeginIdx" ]

[ "enc", "=", "enc", ">", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "enc", ";" ]

[ "uint64_t", "enc", "=", "<NUM_LIT>", "-", "N", "-", ">", "getZExtValue", "(", ")", ";", "enc", "=", "enc", ">", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "enc", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "enc", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i64", ")", ";", "}", "]", ">", ";", "def", "i32shift_sext_i16", ":", "Operand", "<", "i64", ">", ",", "SDNodeXForm", "<", "imm", ",", "[", "{", "uint64_t", "enc", "=", "<NUM_LIT>", "-", "N", "-", ">", "getZExtValue", "(", ")", ";", "enc", "=", "enc", ">", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "enc", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "enc", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i64", ")", ";", "}", "]", ">", ";", "def", "i64shift_a", ":", "Operand", "<", "i64", ">", ",", "SDNodeXForm", "<", "imm", ",", "[", "{", "uint64_t", "enc", "=", "(", "<NUM_LIT>", "-", "N", "-", ">", "getZExtValue", "(", ")", ")", "&", "<NUM_LIT>", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "enc", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i64", ")", ";", "}", "]", ">", ";", "def", "i64shift_b", ":", "Operand", "<", "i64", ">", ",", "SDNodeXForm", "<", "imm", ",", "[", "{", "uint64_t", "enc", "=", "<NUM_LIT>", "-", "N", "-", ">", "getZExtValue", "(", ")", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "enc", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i64", ")", ";", "}", "]", ">", ";", "def", "i64shift_sext_i8", ":", "Operand", "<", "i64", ">", ",", "SDNodeXForm", "<", "imm", ",", "[", "{", "uint64_t", "enc", "=", "<NUM_LIT>", "-", "N", "-", ">", "getZExtValue", "(", ")", ";", "enc", "=", "enc", ">", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "enc", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "enc", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i64", ")", ";", "}", "]", ">", ";", "def", "i64shift_sext_i16", ":", "Operand", "<", "i64", ">", ",", "SDNodeXForm", "<", "imm", ",", "[", "{", "uint64_t", "enc", "=", "<NUM_LIT>", "-", "N", "-", ">", "getZExtValue", "(", ")", ";" ]

[ "<FIXS>", "case", "E_V2DImode", ":", "<FIXE>" ]

[ "gen_interleave_second_low", "=", "gen_vec_interleave_lowv2di", ";", "<BUGS>", "case", "V2DImode", ":", "<BUGE>", "op0", "=", "gen_reg_rtx", "(", "second_imode", ")", ";", "emit_insn", "(", "gen_interleave_second_low", "(", "op0", ",", "ops", "[", "<NUM_LIT>", "]", ",", "ops", "[", "<NUM_LIT>", "]", ")", ")", ";" ]

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

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

[ "<FIXS>", "IsTailCall", "=", "isEligibleForTailCallOptimization", "(", "CLI", ")", ";", "<FIXE>" ]

[ "if", "(", "IsTailCall", ")", "{", "<BUGS>", "IsTailCall", "=", "isEligibleForTailCallOptimization", "(", "Callee", ",", "CallConv", ",", "IsVarArg", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "DAG", ")", ";", "<BUGE>" ]

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

[ "rtx", "cc_reg", ",", "dst", ",", "cmp", ";", "cmp", "=", "operands", "[", "<NUM_LIT>", "]", ";", "if", "(", "GET_MODE", "(", "XEXP", "(", "cmp", ",", "<NUM_LIT>", ")", ")", "==", "DImode", "&&", "!", "TARGET_ARCH64", ")", "return", "false", ";", "if", "(", "GET_MODE", "(", "XEXP", "(", "cmp", ",", "<NUM_LIT>", ")", ")", "==", "TFmode", "&&", "!", "TARGET_HARD_QUAD", ")", "cmp", "=", "sparc_emit_float_lib_cmp", "(", "XEXP", "(", "cmp", ",", "<NUM_LIT>", ")", ",", "XEXP", "(", "cmp", ",", "<NUM_LIT>", ")", ",", "rc", ")", ";", "cmp_mode", "=", "GET_MODE", "(", "XEXP", "(", "cmp", ",", "<NUM_LIT>", ")", ")", ";", "rc", "=", "GET_CODE", "(", "cmp", ")", ";", "dst", "=", "operands", "[", "<NUM_LIT>", "]", ";", "if", "(", "!", "rtx_equal_p", "(", "operands", "[", "<NUM_LIT>", "]", ",", "dst", ")", "&&", "!", "rtx_equal_p", "(", "operands", "[", "<NUM_LIT>", "]", ",", "dst", ")", ")", "{", "if", "(", "reg_overlap_mentioned_p", "(", "dst", ",", "cmp", ")", ")", "dst", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_move_insn", "(", "dst", ",", "operands" ]

[ "getBlockAddress", "(", ")", ",", "Op", ".", "getValueType", "(", ")", ",", "<NUM_LIT>", ",", "TF", ")", ";" ]

[ "if", "(", "const", "GlobalAddressSDNode", "*", "GA", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Op", ")", ")", "return", "DAG", ".", "getTargetGlobalAddress", "(", "GA", "->", "getGlobal", "(", ")", ",", "SDLoc", "(", "GA", ")", ",", "GA", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "GA", "->", "getOffset", "(", ")", ",", "TF", ")", ";", "if", "(", "const", "BlockAddressSDNode", "*", "BA", "=", "dyn_cast", "<", "BlockAddressSDNode", ">", "(", "Op", ")", ")", "return", "DAG", ".", "getTargetBlockAddress", "(", "BA", "->" ]

[ "void", "visium_expand_int_cstore", "(", "rtx", "*", "operands", ",", "enum", "machine_mode", "mode", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ";", "rtx", "op0", "=", "operands", "[", "<NUM_LIT>", "]", ",", "op1", "=", "operands", "[", "<NUM_LIT>", "]", ",", "op2", "=", "operands", "[", "<NUM_LIT>", "]", ",", "sltu", ";", "bool", "reverse", "=", "false", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "NE", ":", "if", "(", "op2", "!=", "const0_rtx", ")", "op1", "=", "force_reg", "(", "mode", ",", "gen_rtx_XOR", "(", "mode", ",", "op1", ",", "op2", ")", ")", ";", "op1", "=", "gen_rtx_NOT", "(", "mode", ",", "op1", ")", ";", "op2", "=", "constm1_rtx", ";", "if", "(", "code", "==", "EQ", ")", "reverse", "=", "true", ";", "break", ";", "case", "LEU", ":", "case", "GEU", ":", "code", "=", "reverse_condition", "(", "code", ")", ";", "reverse", "=", "true", ";", "case", "LTU", ":", "case", "GTU", ":", "if", "(", "code", "==", "GTU", ")", "{", "rtx", "tmp", "=", "op1", ";", "op1", "=", "op2", ";", "op2", "=", "tmp", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "sltu", "=", "gen_rtx_LTU", "(", "SImode", ",", "op1", ",", "op2", ")", ";", "if", "(", "reverse", ")", "{", "rtx", "tmp", "=", "copy_to_mode_reg", "(", "SImode", ",", "gen_rtx_NEG", "(", "SImode", ",", "sltu", ")", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "op0", ",", "tmp", ",", "const1_rtx", ")", ")", ";", "}", "else", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "op0", ",", "sltu", ")", ")", ";", "}" ]

[ "Expand", "a", "cstore", "of", "OPERANDS", "in", "MODE", "for", "EQ/NE/LTU/GTU/GEU/LEU", ".", "We", "generate", "the", "result", "in", "the", "C", "flag", "and", "use", "the", "ADC/SUBC", "instructions", "to", "write", "it", "into", "the", "destination", "register", ".", "It", "would", "also", "be", "possible", "to", "implement", "support", "for", "LT/GT/LE/GE", "by", "means", "of", "the", "RFLAG", "instruction", "followed", "by", "some", "shifts", ",", "but", "this", "can", "pessimize", "the", "generated", "code", "." ]

[ "<FIXS>", "HasPSHUFB", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ")", "<FIXE>" ]

[ "if", "(", "Op", "->", "isOnlyUserOf", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ")", "&&", "combineX86ShufflesRecursively", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Root", ",", "Mask", ",", "Depth", "+", "<NUM_LIT>", ",", "<BUGS>", "DAG", ",", "DCI", ",", "Subtarget", ")", ")", "<BUGE>", "return", "true", ";", "break", ";", "}" ]

[ "DecodeStatus", "S", "=", "Decode3OpInstruction", "(", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "Op1", ",", "Op2", ",", "Op3", ")", ";" ]

[ "static", "DecodeStatus", "DecodeL2RUSInstruction", "(", "MCInst", "&", "Inst", ",", "unsigned", "Insn", ",", "uint64_t", "Address", ",", "const", "void", "*", "Decoder", ")", "{", "unsigned", "Op1", ",", "Op2", ",", "Op3", ";" ]

[ "getSTI", "(", ")", ")", ";" ]

[ "if", "(", "LVIInlineAsmHardening", "&&", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "FeatureLVIControlFlowIntegrity", "]", ")", "applyLVICFIMitigation", "(", "Inst", ",", "Out", ")", ";", "Out", ".", "emitInstruction", "(", "Inst", "," ]

[ ")", ";" ]

[ "virtual", "ARMTargetLowering", "*", "getTargetLowering", "(", ")", "const", "{", "return", "const_cast", "<", "ARMTargetLowering", "*", ">", "(", "&", "TLInfo" ]

[ "Printer", ".", "getFunctionNumber", "(", ")", "<<", "'", "_", "'", "<<", "MO", ".", "getIndex", "(", ")", ";" ]

[ "MCSymbol", "*", "LanaiMCInstLower", "::", "GetConstantPoolIndexSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "SmallString", "<", "<NUM_LIT>", ">", "Name", ";", "raw_svector_ostream", "(", "Name", ")", "<<", "Printer", ".", "MAI", "->", "getPrivateGlobalPrefix", "(", ")", "<<", "<STR_LIT>", "CPI", "<STR_LIT>", "<<" ]

[ "void", "AVRFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "CallingConv", "::", "ID", "CallConv", "=", "MF", ".", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ";", "DebugLoc", "DL", "=", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "AVRInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "if", "(", "CallConv", "==", "CallingConv", "::", "AVR_INTR", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "if", "(", "HasFP", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "RegState", "::", "Kill", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "if", "(", "CallConv", "==", "CallingConv", "::", "AVR_INTR", "||", "CallConv", "==", "CallingConv", "::", "AVR_SIGNAL", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "RegState", "::", "Kill", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "RegState", "::", "Kill", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "RegState", "::", "Kill", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "if", "(", "!", "HasFP", ")", "{", "return", ";", "}", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "AVRMachineFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AVRMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", "-", "AFI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "while", "(", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "&&", "MBBI", "->", "getFlag", "(", "MachineInstr", "::", "FrameSetup", ")", "&&", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "MBBI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "{", "++", "MBBI", ";", "}", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "std", "::", "next", "(", "MF", ".", "begin", "(", ")", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "I", "->", "addLiveIn", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "if", "(", "!", "FrameSize", ")", "{", "return", ";", "}", "unsigned", "Opcode", "=", "(", "isUInt", "<", "<NUM_LIT>", ">", "(", "FrameSize", ")", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "FrameSize", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setIsDead", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "addPass", "(", "createX86FixupLEAs", "(", ")", ")", ";" ]

[ "bool", "ShouldPrint", "=", "false", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getX86Subtarget", "(", ")", ".", "hasSSE2", "(", ")", ")", "{", "addPass", "(", "createExecutionDependencyFixPass", "(", "&", "X86", "::", "VR128RegClass", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "if", "(", "UseVZeroUpper", ")", "{", "addPass", "(", "createX86IssueVZeroUpperPass", "(", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createX86PadShortFunctions", "(", ")", ")", ";" ]

[ ")", ")" ]

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

[ "STI", ".", "getLegalizerInfo", "(", ")", ")", ";" ]

[ "bool", "EnableOpt", "=", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "!=", "CodeGenOptLevel", "::", "None", "&&", "!", "skipFunction", "(", "F", ")", ";", "GISelKnownBits", "*", "KB", "=", "&", "getAnalysis", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ".", "get", "(", "MF", ")", ";", "GISelCSEAnalysisWrapper", "&", "Wrapper", "=", "getAnalysis", "<", "GISelCSEAnalysisWrapperPass", ">", "(", ")", ".", "getCSEWrapper", "(", ")", ";", "auto", "*", "CSEInfo", "=", "&", "Wrapper", ".", "get", "(", "TPC", "->", "getCSEConfig", "(", ")", ")", ";", "const", "GCNSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "MachineDominatorTree", "*", "MDT", "=", "IsOptNone", "?", "nullptr", ":", "&", "getAnalysis", "<", "MachineDominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "CombinerInfo", "CInfo", "(", "true", ",", "false", ",", "nullptr", ",", "EnableOpt", ",", "F", ".", "hasOptSize", "(", ")", ",", "F", ".", "hasMinSize", "(", ")", ")", ";", "AMDGPUPreLegalizerCombinerImpl", "Impl", "(", "MF", ",", "CInfo", ",", "TPC", ",", "*", "KB", ",", "CSEInfo", ",", "RuleConfig", ",", "STI", ",", "MDT", "," ]