Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "<STR_LIT>", ")" ]

[ "(", "ior", "(", "match_operand", "<NUM_LIT>" ]

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

[ "TargetPassConfig", "*", "LC3TargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "LC3PassConfig", "(", "this", "," ]

[ ")", ")" ]

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

[ "<FIXS>", "SrcReg", "=", "fastEmitZExtFromI1", "(", "MVT", "::", "i8", ",", "SrcReg", ",", "false", ")", ";", "<FIXE>", "<FIXS>", "SrcReg", "=", "fastEmit_r", "(", "SrcVT", ".", "getSimpleVT", "(", ")", ",", "DstVT", ".", "getSimpleVT", "(", ")", ",", "Op", ",", "SrcReg", ",", "false", ")", ";", "<FIXE>" ]

[ "if", "(", "SrcVT", "==", "MVT", "::", "i1", ")", "{", "if", "(", "Outs", "[", "<NUM_LIT>", "]", ".", "Flags", ".", "isSExt", "(", ")", ")", "return", "false", ";", "<BUGS>", "SrcReg", "=", "fastEmitZExtFromI1", "(", "MVT", "::", "i8", ",", "SrcReg", ",", "false", ")", ";", "<BUGE>", "SrcVT", "=", "MVT", "::", "i8", ";", "}", "unsigned", "Op", "=", "Outs", "[", "<NUM_LIT>", "]", ".", "Flags", ".", "isZExt", "(", ")", "?", "ISD", "::", "ZERO_EXTEND", ":", "ISD", "::", "SIGN_EXTEND", ";", "<BUGS>", "SrcReg", "=", "fastEmit_r", "(", "SrcVT", ".", "getSimpleVT", "(", ")", ",", "DstVT", ".", "getSimpleVT", "(", ")", ",", "Op", ",", "SrcReg", ",", "false", ")", ";", "<BUGE>", "}" ]

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

[ "class", "CmpBranchRIEa", "<", "string", "mnemonic", ",", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "RegisterOperand", "cls", ",", "ImmOpWithPattern", "imm", ">", ":", "InstRIEa", "<", "opcode", ",", "(", "outs", ")", ",", "(", "ins", "cls", ":", "$", "R1", ",", "imm", ":", "$", "I2", ",", "cond4", ":", "$", "M3", ")", "," ]

[ ")", ";" ]

[ "assert", "(", "IsStack" ]

[ "}" ]

[ "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "<STR_LIT>", "AArch64 Promote Constant", "<STR_LIT>", ";" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "inst", ";", "let", "Word1", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "arraySize", ";" ]

[ "}" ]

[ "bool", "isPCRel16", "(", ")", "const", "{", "return", "isImm16", "(", ")", ";" ]

[ "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ")", ";" ]

[ "}", "}", "const", "MCInstrDesc", "&", "Desc", "=", "TII", "->", "get", "(", "Op", "->", "getMachineOpcode", "(", ")", ")", ";", "int", "OpClassID", "=", "Desc", ".", "OpInfo", "[", "Op", ".", "getResNo", "(", ")", "]", ".", "RegClass", ";", "if", "(", "OpClassID", "!=", "-", "<NUM_LIT>", ")", "{", "return", "TRI", ".", "getRegClass", "(", "OpClassID", ")", ";", "}", "switch", "(", "Op", ".", "getMachineOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "COPY_TO_REGCLASS", ":", "OpClassID", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "OpClassID", "==", "AMDGPU", "::", "VSrc_32RegClassID", "||", "OpClassID", "==", "AMDGPU", "::", "VSrc_64RegClassID", ")", "{", "return", "getRegClassForNode", "(", "DAG", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}", "return", "TRI", ".", "getRegClass", "(", "OpClassID", ")", ";", "case", "AMDGPU", "::", "EXTRACT_SUBREG", ":", "{", "int", "SubIdx", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "const", "TargetRegisterClass", "*", "SuperClass", "=", "getRegClassForNode", "(", "DAG", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "return", "TRI", ".", "getSubClassWithSubReg", "(", "SuperClass", ",", "SubIdx", ")", ";", "}", "case", "AMDGPU", "::", "REG_SEQUENCE", ":", "return", "TRI", ".", "getRegClass", "(", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand" ]

[ "NAME", "+", "S390_BUILTIN_MAX", ",", "\\", "BUILT_IN_MD", ",", "\\", "NULL", ",", "\\", "<NUM_LIT>", ")", ";" ]

[ "tree", "returns_twice_attr", "=", "tree_cons", "(", "get_identifier", "(", "<STR_LIT>", "returns_twice", "<STR_LIT>", ")", ",", "NULL", ",", "NULL", ")", ";", "tree", "noreturn_attr", "=", "tree_cons", "(", "get_identifier", "(", "<STR_LIT>", "noreturn", "<STR_LIT>", ")", ",", "NULL", ",", "NULL", ")", ";", "tree", "c_uint64_type_node", ";", "if", "(", "TARGET_64BIT", ")", "c_uint64_type_node", "=", "long_unsigned_type_node", ";", "else", "c_uint64_type_node", "=", "long_long_unsigned_type_node", ";", "if", "(", "s390_builtin_types", "[", "INDEX", "]", "==", "NULL", ")", "\\", "s390_builtin_types", "[", "INDEX", "]", "=", "(", "!", "CONST_P", ")", "?", "\\", "(", "NODE", ")", ":", "build_type_variant", "(", "(", "NODE", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "if", "(", "s390_builtin_types", "[", "INDEX", "]", "==", "NULL", ")", "\\", "s390_builtin_types", "[", "INDEX", "]", "=", "\\", "build_pointer_type", "(", "s390_builtin_types", "[", "INDEX_BASE", "]", ")", ";", "if", "(", "s390_builtin_types", "[", "INDEX", "]", "==", "NULL", ")", "\\", "s390_builtin_types", "[", "INDEX", "]", "=", "\\", "build_distinct_type_copy", "(", "s390_builtin_types", "[", "INDEX_BASE", "]", ")", ";", "if", "(", "s390_builtin_types", "[", "INDEX", "]", "==", "NULL", ")", "\\", "s390_builtin_types", "[", "INDEX", "]", "=", "\\", "build_vector_type", "(", "s390_builtin_types", "[", "INDEX_BASE", "]", ",", "ELEMENTS", ")", ";", "if", "(", "s390_builtin_types", "[", "INDEX", "]", "==", "NULL", ")", "\\", "s390_builtin_types", "[", "INDEX", "]", "=", "\\", "build_opaque_vector_type", "(", "s390_builtin_types", "[", "INDEX_BASE", "]", ",", "ELEMENTS", ")", ";", "if", "(", "s390_builtin_fn_types", "[", "INDEX", "]", "==", "NULL", ")", "\\", "s390_builtin_fn_types", "[", "INDEX", "]", "=", "\\", "build_function_type_list", "(", "args", ",", "NULL_TREE", ")", ";", "if", "(", "s390_builtin_decls", "[", "S390_BUILTIN_", "#", "#", "NAME", "]", "==", "NULL", ")", "\\", "s390_builtin_decls", "[", "S390_BUILTIN_", "#", "#", "NAME", "]", "=", "\\", "add_builtin_function", "(", "<STR_LIT>", "__builtin_", "<STR_LIT>", "#", "NAME", ",", "\\", "s390_builtin_fn_types", "[", "FNTYPE", "]", ",", "\\", "S390_BUILTIN_", "#", "#", "NAME", ",", "\\", "BUILT_IN_MD", ",", "\\", "NULL", ",", "\\", "ATTRS", ")", ";", "if", "(", "s390_builtin_decls", "[", "S390_OVERLOADED_BUILTIN_", "#", "#", "NAME", "+", "S390_BUILTIN_MAX", "]", "\\", "==", "NULL", ")", "\\", "s390_builtin_decls", "[", "S390_OVERLOADED_BUILTIN_", "#", "#", "NAME", "+", "S390_BUILTIN_MAX", "]", "=", "\\", "add_builtin_function", "(", "<STR_LIT>", "__builtin_", "<STR_LIT>", "#", "NAME", ",", "\\", "s390_builtin_fn_types", "[", "FNTYPE", "]", ",", "\\", "S390_OVERLOADED_BUILTIN_", "#", "#" ]

[ "<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", "SrcA", "=", "src", ";", "let", "OperandType", "=", "optype", ";", "let", "Switches", "=", "sw", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";", "let", "HasImm", "=", "<NUM_LIT>", ";", "let", "immOpNum", "=" ]

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

[ "if", "(", "count", "!=", "<NUM_LIT>", ")", "return", "const0_rtx", ";", "return", "get_hard_reg_initial_val", "(", "Pmode", "," ]

[ "<FIXS>", "machine_mode", "valmode", ";", "<FIXE>" ]

[ "const_tree", "func", "ATTRIBUTE_UNUSED", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "<BUGS>", "enum", "machine_mode", "valmode", ";", "<BUGE>", "if", "(", "AGGREGATE_TYPE_P", "(", "valtype", ")", "||", "TREE_CODE", "(", "valtype", ")", "==", "COMPLEX_TYPE" ]

[ "void", "xtensa_emit_loop_end", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operands", ")", "{", "char", "done", "=", "<NUM_LIT>", ";", "for", "(", "insn", "=", "PREV_INSN", "(", "insn", ")", ";", "insn", "&&", "!", "done", ";", "insn", "=", "PREV_INSN", "(", "insn", ")", ")", "{", "switch", "(", "GET_CODE", "(", "insn", ")", ")", "{", "case", "NOTE", ":", "case", "BARRIER", ":", "break", ";", "case", "CODE_LABEL", ":", "output_asm_insn", "(", "TARGET_DENSITY", "?", "<STR_LIT>", "nop.n", "<STR_LIT>", ":", "<STR_LIT>", "nop", "<STR_LIT>", ",", "operands", ")", ";", "done", "=", "<NUM_LIT>", ";", "break", ";", "default", ":", "{", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "JUMP_P", "(", "body", ")", ")", "{", "output_asm_insn", "(", "TARGET_DENSITY", "?", "<STR_LIT>", "nop.n", "<STR_LIT>", ":", "<STR_LIT>", "nop", "<STR_LIT>", ",", "operands", ")", ";", "done", "=", "<NUM_LIT>", ";", "}", "else", "if", "(", "(", "GET_CODE", "(", "body", ")", "!=", "USE", ")", "&&", "(", "GET_CODE", "(", "body", ")", "!=", "CLOBBER", ")", ")", "done", "=", "<NUM_LIT>", ";", "}", "break", ";", "}", "}", "output_asm_insn", "(", "<STR_LIT>", "%1_LEND:", "<STR_LIT>", ",", "operands", ")", ";", "}" ]

[ "Emit", "the", "assembly", "for", "the", "end", "of", "a", "zero-cost", "loop", ".", "Normally", "we", "just", "emit", "a", "comment", "showing", "where", "the", "end", "of", "the", "loop", "is", ".", "However", ",", "if", "there", "is", "a", "label", "or", "a", "branch", "at", "the", "end", "of", "the", "loop", "then", "we", "need", "to", "place", "a", "nop", "there", ".", "If", "the", "loop", "ends", "with", "a", "label", "we", "need", "the", "nop", "so", "that", "branches", "targetting", "that", "label", "will", "target", "the", "nop", "(", "and", "thus", "remain", "in", "the", "loop", ")", ",", "instead", "of", "targetting", "the", "instruction", "after", "the", "loop", "(", "and", "thus", "exiting", "the", "loop", ")", ".", "If", "the", "loop", "ends", "with", "a", "branch", ",", "we", "need", "the", "nop", "in", "case", "the", "branch", "is", "targetting", "a", "location", "inside", "the", "loop", ".", "When", "the", "branch", "executes", "it", "will", "cause", "the", "loop", "count", "to", "be", "decremented", "even", "if", "it", "is", "taken", "(", "because", "it", "is", "the", "last", "instruction", "in", "the", "loop", ")", ",", "so", "we", "need", "to", "nop", "after", "the", "branch", "to", "prevent", "the", "loop", "count", "from", "being", "decremented", "when", "the", "branch", "is", "taken", "." ]

[ "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "static_cast", "<", "unsigned", ">", "(", "MAI", "->", "Addr", ")", ")", ")", ";" ]

[ "MCInst", "Inst", ";", "Inst", ".", "setOpcode", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

[ "PtrOff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "StackPtr", ",", "DAG", ".", "getConstant", "(", "ArgOffset", ",", "PtrVT", ")", ")", ";" ]

[ "static", "void", "LowerMemOpCallTo", "(", "SelectionDAG", "&", "DAG", ",", "MachineFunction", "&", "MF", ",", "SDValue", "Chain", ",", "SDValue", "Arg", ",", "SDValue", "PtrOff", ",", "int", "SPDiff", ",", "unsigned", "ArgOffset", ",", "bool", "isPPC64", ",", "bool", "isTailCall", ",", "bool", "isVector", ",", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "&", "MemOpChains", ",", "SmallVector", "<", "TailCallArgumentInfo", ",", "<NUM_LIT>", ">", "&", "TailCallArguments", ",", "SDLoc", "dl", ")", "{", "EVT", "PtrVT", "=", "DAG", ".", "getTargetLoweringInfo", "(", ")", ".", "getPointerTy", "(", ")", ";", "if", "(", "!", "isTailCall", ")", "{", "if", "(", "isVector", ")", "{", "SDValue", "StackPtr", ";", "if", "(", "isPPC64", ")", "StackPtr", "=", "DAG", ".", "getRegister", "(", "PPC", "::", "X1", ",", "MVT", "::", "i64", ")", ";", "else", "StackPtr", "=", "DAG", ".", "getRegister", "(", "PPC", "::", "R1", ",", "MVT", "::", "i32", ")", ";" ]

[ "if", "(", "ST", ".", "hasIEEEMode", "(", ")", ")", "Reg", "|=", "S_00B848_IEEE_MODE", "(", "IEEEMode", ")", ";" ]

[ "uint64_t", "Reg", "=", "S_00B848_VGPRS", "(", "VGPRBlocks", ")", "|", "S_00B848_SGPRS", "(", "SGPRBlocks", ")", "|", "S_00B848_PRIORITY", "(", "Priority", ")", "|", "S_00B848_FLOAT_MODE", "(", "FloatMode", ")", "|", "S_00B848_PRIV", "(", "Priv", ")", "|", "S_00B848_DEBUG_MODE", "(", "DebugMode", ")", ";", "if", "(", "ST", ".", "hasDX10ClampMode", "(", ")", ")", "Reg", "|=", "S_00B848_DX10_CLAMP", "(", "DX10Clamp", ")", ";" ]

[ "==", "Reg", "&&", "<STR_LIT>", "Misplaced operand", "<STR_LIT>", ")", ";" ]

[ "assert", "(", "MIB", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "Reg", "&&", "MIB", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")" ]

[ ")", "const", "{" ]

[ "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS" ]

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

[ "def", "abscondbrtarget", ":", "Operand", "<", "OtherVT", ">", "{", "let", "PrintMethod" ]

[ "}" ]

[ "static", "int", "mips_fp_mult_cost", "(", "machine_mode", "mode", ")", "{", "return", "mode", "==", "DFmode", "?", "mips_cost", "->", "fp_mult_df", ":", "mips_cost", "->", "fp_mult_sf", ";" ]

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

[ "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_compressdi512_mask", "(", "(", "_", "_", "v8di", ")", "_", "_", "A", ",", "(", "_", "_", "v8di", ")" ]

[ "}" ]

[ "bool", "XNCMFrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "!", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", ";" ]

[ ",", "dl", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "VT", ")", ";" ]

[ "MachineFrameInfo", "&", "MFI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFrameInfo", "(", ")", ";", "MFI", ".", "setFrameAddressIsTaken", "(", "true", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "SDLoc", "dl", "(", "Op", ")", ";", "unsigned", "Depth", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "SDValue", "FrameAddr", "=", "DAG", ".", "getCopyFromReg", "(", "DAG", ".", "getEntryNode", "(", ")" ]

[ "for", "(", "MachineInstr", "*", "Copy", ":", "CopiesToReplace", ")", "Copy", "->", "addImplicitDefUseOperands", "(", "*", "MF", ")", ";" ]

[ "MachineInstr", "*", "UseMI", "=", "Use", "->", "getParent", "(", ")", ";", "unsigned", "OpNo", "=", "Use", ".", "getOperandNo", "(", ")", ";", "if", "(", "OpToFold", ".", "isImm", "(", ")", "&&", "tryConstantFoldOp", "(", "*", "MRI", ",", "TII", ",", "UseMI", ",", "&", "OpToFold", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Constant folded ", "<STR_LIT>", "<<", "*", "UseMI", "<<", "'", "\\n", "'", ")", ";", "NextUse", "=", "MRI", "->", "use_begin", "(", "Dst", ".", "getReg", "(", ")", ")", ";", "FoldList", ".", "clear", "(", ")", ";", "continue", ";", "}", "if", "(", "isInlineConstantIfFolded", "(", "TII", ",", "*", "UseMI", ",", "OpNo", ",", "OpToFold", ")", ")", "{", "foldOperand", "(", "OpToFold", ",", "UseMI", ",", "OpNo", ",", "FoldList", ",", "CopiesToReplace", ")", ";", "}", "else", "{", "if", "(", "++", "NumLiteralUses", "==", "<NUM_LIT>", ")", "{", "NonInlineUse", "=", "&", "*", "Use", ";", "NonInlineUseOpNo", "=", "OpNo", ";", "}", "}", "}", "if", "(", "NumLiteralUses", "==", "<NUM_LIT>", ")", "{", "MachineInstr", "*", "UseMI", "=", "NonInlineUse", "->", "getParent", "(", ")", ";", "foldOperand", "(", "OpToFold", ",", "UseMI", ",", "NonInlineUseOpNo", ",", "FoldList", ",", "CopiesToReplace", ")", ";", "}", "}", "else", "{", "SmallVector", "<", "MachineRegisterInfo", "::", "use_iterator", ",", "<NUM_LIT>", ">", "UsesToProcess", ";", "for", "(", "MachineRegisterInfo", "::", "use_iterator", "Use", "=", "MRI", "->", "use_begin", "(", "Dst", ".", "getReg", "(", ")", ")", ",", "E", "=", "MRI", "->", "use_end", "(", ")", ";", "Use", "!=", "E", ";", "++", "Use", ")", "{", "UsesToProcess", ".", "push_back", "(", "Use", ")", ";", "}", "for", "(", "auto", "U", ":", "UsesToProcess", ")", "{", "MachineInstr", "*", "UseMI", "=", "U", "->", "getParent", "(", ")", ";", "foldOperand", "(", "OpToFold", ",", "UseMI", ",", "U", ".", "getOperandNo", "(", ")", ",", "FoldList", ",", "CopiesToReplace", ")", ";", "}", "}", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";" ]

[ "string", "Name", "=", "name", ";" ]

[ "let", "SearchableFields", "=", "[", "<STR_LIT>", ",", "<STR_LIT>", "]", ";", "let", "EnumValueField", "=", "<STR_LIT>", ";" ]

[ "<NUM_LIT>", ";" ]

[ "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VT", ",", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "ExtVT", ",", "InputV", ")", ")", ";", "}", "if", "(", "AnyExt", "&&", "EltBits", "==", "<NUM_LIT>", ")", "{", "int", "PSHUFDMask", "[", "<NUM_LIT>", "]", "=", "{", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "-", "<NUM_LIT>", "}", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VT", ",", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "v4i32", ",", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "v4i32", ",", "InputV", ")", ",", "getV4X86ShuffleImm8ForMask", "(", "PSHUFDMask", ",", "DAG", ")", ")", ")", ";", "}", "if", "(", "AnyExt", "&&", "EltBits", "==", "<NUM_LIT>", "&&", "Scale", ">", "<NUM_LIT>", ")", "{", "int", "PSHUFDMask", "[", "<NUM_LIT>", "]", "=", "{", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "-", "<NUM_LIT>", "}", ";", "InputV", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "v4i32", ",", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "v4i32", ",", "InputV", ")", ",", "getV4X86ShuffleImm8ForMask", "(", "PSHUFDMask", ",", "DAG", ")", ")", ";", "int", "PSHUFHWMask", "[", "<NUM_LIT>", "]", "=", "{", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ",", "-", "<NUM_LIT>", "}", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VT", ",", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "v8i16", ",", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "v8i16", ",", "InputV", ")", ",", "getV4X86ShuffleImm8ForMask", "(", "PSHUFHWMask", ",", "DAG", ")", ")", ")", ";", "}", "if", "(", "Scale", ">", "<NUM_LIT>", "&&", "EltBits", "==", "<NUM_LIT>", "&&", "Subtarget", "->", "hasSSSE3", "(", ")", ")", "{", "assert", "(", "NumElements", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Unexpected byte vector width!", "<STR_LIT>", ")", ";", "SDValue", "PSHUFBMask", "[", "<NUM_LIT>", "]", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "++", "i", ")", "PSHUFBMask", "[", "i", "]", "=", "DAG", ".", "getConstant", "(", "(", "i", "%", "Scale", "==", "<NUM_LIT>", ")", "?", "i", "/", "Scale", ":", "<NUM_LIT>", ",", "MVT", "::", "i8", ")", ";", "InputV", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "v16i8", ",", "InputV", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VT", ",", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "v16i8", ",", "InputV", ",", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_VECTOR", ",", "DL", ",", "MVT", "::", "v16i8", ",", "PSHUFBMask", ")", ")", ")", ";", "}", "do", "{", "MVT", "InputVT", "=", "MVT", "::", "getVectorVT", "(", "MVT", "::", "getIntegerVT", "(", "EltBits", ")", ",", "NumElements", ")", ";", "SDValue", "Ext", "=", "AnyExt", "?", "DAG", ".", "getUNDEF", "(", "InputVT", ")", ":", "getZeroVector", "(", "InputVT", ",", "Subtarget", ",", "DAG", ",", "DL", ")", ";", "InputV", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "InputVT", ",", "InputV", ")", ";", "InputV", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "InputVT", ",", "InputV", ",", "Ext", ")", ";", "Scale", "/", "=", "<NUM_LIT>", ";", "EltBits", "*=", "<NUM_LIT>", ";", "NumElements", "/", "=" ]

[ "<STR_LIT>" ]

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

[ "(", "v4i64", ")", "_", "<NUM_LIT>", ")", ";" ]

[ "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_lasx_xvpickod_d", "(", "(", "v4i64", ")", "_", "<NUM_LIT>", "," ]

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

[ "class", "BranchCond", ":", "I", "<", "(", "outs", ")", ",", "(", "ins", "ccode", ":", "$", "cond", ",", "am_brcond", ":", "$", "target", ")", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "AArch64brcond", "bb", ":", "$", "target", ",", "imm", ":", "$", "cond", ",", "NZCV", ")", "]", ">", ",", "Sched", "<", "[", "WriteBr", "]", ">", "{", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";" ]

[ "d", ";" ]

[ "long", "long", "d", ";", "_", "_", "asm__", "(", "<STR_LIT>", "fctiwz %0,%1", "<STR_LIT>", ":", "<STR_LIT>", "=d", "<STR_LIT>", "(", "d", ")", ":", "<STR_LIT>", "d", "<STR_LIT>", "(", "a", ")", ")", ";", "return", "(", "int", ")" ]

[ ";" ]

[ "static", "bool", "rs6000_expand_vec_perm_const_1", "(", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "unsigned", "char", "perm0", ",", "unsigned", "char", "perm1", ")", "{", "rtx", "x", ";", "if", "(", "(", "perm0", "&", "<NUM_LIT>", ")", "==", "(", "perm1", "&", "<NUM_LIT>", ")", ")", "{", "if", "(", "perm0", "&", "<NUM_LIT>", ")", "op0", "=", "op1", ";", "else", "op1", "=", "op0", ";", "}", "if", "(", "rtx_equal_p", "(", "op0", ",", "op1", ")", ")", "{", "perm0", "=", "perm0", "&", "<NUM_LIT>", ";", "perm1", "=", "(", "perm1", "&", "<NUM_LIT>", ")", "+", "<NUM_LIT>", ";", "}", "else", "if", "(", "perm0", "&", "<NUM_LIT>", ")", "{", "if", "(", "perm1", "&", "<NUM_LIT>", ")", "return", "false", ";", "perm0", "-=", "<NUM_LIT>", ";", "perm1", "+=", "<NUM_LIT>" ]

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

[ "vrev16q_u8", "(", "uint8x16_t", "_", "_", "a", ")", "{", "return", "(", "uint8x16_t", ")", "_", "_", "builtin_shuffle", "(", "_", "_", "a", ",", "(", "uint8x16_t", ")", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>" ]

[ "unsigned", "Reg", "=", "Use", ".", "getReg", "(", ")", ";" ]

[ "bool", "HardenAddressLoadedFrom", "=", "!", "HardenLoadedData", ";", "for", "(", "MachineOperand", "Op", ":", "MI", ".", "defs", "(", ")", ")", "for", "(", "MCRegAliasIterator", "AI", "(", "Op", ".", "getReg", "(", ")", ",", "TRI", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "RegsAlreadyMasked", ".", "reset", "(", "*", "AI", ")", ";", "if", "(", "HardenLoadedData", ")", "for", "(", "auto", "Def", ":", "MI", ".", "defs", "(", ")", ")", "{", "if", "(", "Def", ".", "isDead", "(", ")", ")", "continue", ";", "Modified", "|=", "makeGPRSpeculationSafe", "(", "MBB", ",", "NextMBBI", ",", "MI", ",", "Def", ".", "getReg", "(", ")", ")", ";", "}", "if", "(", "HardenAddressLoadedFrom", ")", "for", "(", "auto", "Use", ":", "MI", ".", "uses", "(", ")", ")", "{", "if", "(", "!", "Use", ".", "isReg", "(", ")", ")", "continue", ";" ]

[ ",", "LoVT", ",", "Lo", ",", "RC", ")", ";" ]

[ "std", "::", "tie", "(", "LoVT", ",", "HiVT", ")", "=", "DAG", ".", "GetSplitDestVTs", "(", "VT", ")", ";", "SDValue", "RC", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Lo", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl" ]

[ "}" ]

[ "CmpMI", "->", "eraseFromParent", "(", ")", ";", "MachineInstr", "&", "BrMI", "=", "*", "MBB", "->", "getFirstTerminator", "(", ")", ";", "BuildMI", "(", "*", "MBB", ",", "BrMI", ",", "BrMI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "Cmp", ")", ".", "addOperand", "(", "BrMI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "BrMI", ".", "eraseFromParent", "(", ")", ";", "MBB", "->", "updateTerminator", "(", ")", ";", "++", "NumConditionsAdjusted", ";" ]

[ "}" ]

[ "class", "SpuInst_Unary", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "RegisterClass", "Rdst", ",", "RegisterClass", "Rsrc", ",", "string", "asmstr", ">", ":", "ScalarInstBase", "<", "opc", ",", "asmstr", ">", "{", "let", "OutOperandList", "=", "(", "outs", "Rdst", ":", "$", "dest", ")", ";", "let", "InOperandList", "=", "(", "ins", "Rsrc", ":", "$", "op", ",", "DataType", ":", "$", "optype", ",", "SwitchSet", ":", "$", "sw", ",", "Rdst", ":", "$", "income", ",", "SPred", ":", "$", "pred", ")", ";", "let", "Itinerary", "=", "IIC_ScalarOp", ";", "let", "isNotUsedInDisasm", "=", "!", "if", "(", "!", "and", "(", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Rsrc", ")", ",", "!", "cast", "<", "string", ">", "(", "Rdst", ")", ")", ",", "!", "ne", "(", "!", "cast", "<", "string", ">", "(", "Rsrc", ")", ",", "<STR_LIT>", ")", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "op", ";", "bits", "<", "<NUM_LIT>", ">", "optype", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "op", ";", "let", "OperandType", "=", "optype", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";", "let", "Switches", "=", "{", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ",", "sw", "{", "<NUM_LIT>", "}", "}", ";", "let", "Constraints", "=", "<STR_LIT>", ";" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "bits", "<", "<NUM_LIT>", ">", "cond", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "op", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "cond", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";" ]

[ "=", "POST_INC", ")" ]

[ "if", "(", "GET_MODE", "(", "op", ")", "=", "=", "mode", "&", "&", "GET_CODE", "(", "op", ")", "=", "=", "MEM", "&", "&", "GET_CODE", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ")", "=" ]

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

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

[ "static", "int", "sh_address_cost", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "REG_P", "(", "x", ")", "&&", "REGNO", "(", "x", ")", "==", "GBR_REG", ")", "return", "<NUM_LIT>", ";", "if", "(", "REG_P", "(", "x", ")", "||", "GET_CODE", "(", "x", ")", "==", "POST_INC", "||", "GET_CODE", "(", "x", ")", "==", "PRE_DEC", ")", "return", "<NUM_LIT>", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ")", "{", "if", "(", "REGNO", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "GBR_REG", "&&", "gbr_displacement", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "mode", ")", ")", "return", "<NUM_LIT>", ";", "const", "HOST_WIDE_INT", "offset", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "offset", "==", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "if", "(", "offset", ">", "<NUM_LIT>", "&&", "offset", "<=", "sh_max_mov_insn_displacement", "(", "mode", ",", "false", ")", ")", "return", "(", "mode", "==", "HImode", "||", "mode", "==", "QImode", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "if", "(", "TARGET_SH2A", "&&", "offset", ">", "<NUM_LIT>", "&&", "offset", "<=", "sh_max_mov_insn_displacement", "(", "mode", ",", "true", ")", ")", "return", "<NUM_LIT>", ";", "return", "<NUM_LIT>", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "!", "CONSTANT_P", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ")", "return", "<NUM_LIT>", ";", "return", "<NUM_LIT>", ";", "}" ]

[ "Compute", "the", "cost", "of", "an", "address", ".", "For", "the", "SH", ",", "all", "valid", "addresses", "are", "the", "same", "cost", ".", "Use", "a", "slightly", "higher", "cost", "for", "reg", "+", "reg", "addressing", ",", "since", "it", "increases", "pressure", "on", "r0", "." ]

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

[ "def", "AArch64fmin_p", ":", "SDNode", "<" ]

[ "asm", ",", "ZPR64", ">", ";" ]

[ "def", "_D", ":", "sve_int_mlas_vvv_pred", "<", "<NUM_LIT>", ",", "opc", "," ]

[ "<FIXS>", "rs6000_constraints", "[", "RS6000_CONSTRAINT_wm", "]", "=", "VSX_REGS", ";", "<FIXE>" ]

[ "rs6000_constraints", "[", "RS6000_CONSTRAINT_wl", "]", "=", "FLOAT_REGS", ";", "if", "(", "TARGET_DIRECT_MOVE", ")", "<BUGS>", "{", "rs6000_constraints", "[", "RS6000_CONSTRAINT_wk", "]", "=", "rs6000_constraints", "[", "RS6000_CONSTRAINT_ws", "]", ";", "rs6000_constraints", "[", "RS6000_CONSTRAINT_wm", "]", "=", "VSX_REGS", ";", "}", "<BUGE>", "if", "(", "TARGET_POWERPC64", ")", "{" ]

[ "static", "void", "cris_conditional_register_usage", "(", "void", ")", "{", "if", "(", "TARGET_HAS_MUL_INSNS", ")", "fixed_regs", "[", "CRIS_MOF_REGNUM", "]", "=", "<NUM_LIT>", ";", "if", "(", "cris_cpu_version", "<", "<NUM_LIT>", ")", "reg_names", "[", "CRIS_CC0_REGNUM", "]", "=", "<STR_LIT>", "ccr", "<STR_LIT>", ";", "}" ]

[ "The", "CONDITIONAL_REGISTER_USAGE", "worker", "." ]

[ "<STR_LIT>", ")" ]

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

[ "}" ]

[ "static", "inline", "bool", "isAdvSIMDModImmType7", "(", "uint64_t", "Imm", ")", "{", "return", "(", "(", "Imm", ">>", "<NUM_LIT>", ")", "==", "(", "Imm", "&", "<NUM_LIT>", "ULL", ")", ")", "&&", "(", "(", "Imm", "&", "<NUM_LIT>", "ULL", ")", "==", "<NUM_LIT>", "ULL", ")", ";" ]

[ ":" ]

[ "case", "TargetOpcode", "::", "G_ADD", ":", "case", "TargetOpcode", "::", "G_SUB", ":", "if", "(", "selectG_ADD_SUB", "(", "I", ")", ")", "return", "true", ";", "LLVM_FALLTHROUGH", ";", "default", ":", "return", "selectImpl", "(", "I", ",", "CoverageInfo", ")", ";", "case", "TargetOpcode", "::", "G_INTTOPTR", ":", "case", "TargetOpcode", "::", "G_BITCAST", ":", "return", "selectCOPY", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_CONSTANT", ":", "case", "TargetOpcode", "::", "G_FCONSTANT", ":", "return", "selectG_CONSTANT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_EXTRACT", ":", "return", "selectG_EXTRACT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_MERGE_VALUES", ":", "case", "TargetOpcode", "::", "G_BUILD_VECTOR", ":", "case", "TargetOpcode", "::", "G_CONCAT_VECTORS", ":", "return", "selectG_MERGE_VALUES", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_UNMERGE_VALUES", ":", "return", "selectG_UNMERGE_VALUES", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_GEP", ":", "return", "selectG_GEP", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_IMPLICIT_DEF", ":", "return", "selectG_IMPLICIT_DEF", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_INSERT", ":", "return", "selectG_INSERT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_INTRINSIC", ":", "return", "selectG_INTRINSIC", "(", "I", ",", "CoverageInfo", ")", ";", "case", "TargetOpcode", "::", "G_INTRINSIC_W_SIDE_EFFECTS", ":", "return", "selectG_INTRINSIC_W_SIDE_EFFECTS", "(", "I", ",", "CoverageInfo", ")", ";", "case", "TargetOpcode", "::", "G_ICMP", ":", "if", "(", "selectG_ICMP", "(", "I", ")", ")", "return", "true", ";", "return", "selectImpl", "(", "I", ",", "CoverageInfo", ")", ";", "case", "TargetOpcode", "::", "G_LOAD", ":", "return", "selectImpl", "(", "I", ",", "CoverageInfo", ")", ";", "case", "TargetOpcode", "::", "G_SELECT", ":", "return", "selectG_SELECT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_STORE", ":", "if", "(", "selectImpl", "(", "I", ",", "CoverageInfo", ")", ")", "return", "true", ";", "return", "selectG_STORE", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_TRUNC" ]

[ "}" ]

[ "SDValue", "Lo", "=", "DAG", ".", "getBlockAddress", "(", "BA", ",", "MVT", "::", "i32", ",", "true", ",", "OpFlagLo", ")", ";", "Hi", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "i32", ",", "Hi", ")", ";", "Lo", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "i32", ",", "Lo", ")", ";", "SDValue", "Result", "=", "DAG", ".", "getNode", "(", "ISD", "::", "OR", ",", "DL", ",", "MVT", "::", "i32", ",", "Hi", ",", "Lo", ")", ";", "return", "Result", ";" ]

[ "<FIXS>", "[", "(", "set", "(", "match_operand", ":", "V64DI", "<NUM_LIT>", "<STR_LIT>", "\t", "\t", "<STR_LIT>", ")", "<FIXE>", "<FIXS>", "(", "match_operand", ":", "V64DI", "<NUM_LIT>", "<STR_LIT>", "\t", "\t", "<STR_LIT>", ")", "(", "match_operand", ":", "V64DI", "<NUM_LIT>", "<STR_LIT>", "\t", "\t", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "V64DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "\t", "\t", "<STR_LIT>", ")", ")", ")", "<FIXE>" ]

[ "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn_and_split", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "V64DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "vec_merge", ":", "V64DI", "(", "minus", ":", "V64DI", "<BUGS>", "(", "match_operand", ":", "V64DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V64DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "V64DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<BUGE>", "(", "clobber", "(", "reg", ":", "DI", "VCC_REG", ")", ")", "]", "<STR_LIT>" ]

[ "<FIXS>", "int_x86_sse_cvtsi642ss", ",", "i64mem", ",", "loadi64", ",", "<STR_LIT>", ",", "<FIXE>", "<FIXS>", "int_x86_sse2_cvtsi642sd", ",", "i64mem", ",", "loadi64", ",", "<STR_LIT>", ",", "<FIXE>" ]

[ "int_x86_sse_cvtsi2ss", ",", "i32mem", ",", "loadi32", ",", "<STR_LIT>", ",", "SSE_CVT_Scalar", ",", "<NUM_LIT>", ">", ",", "XS", ",", "VEX_4V", ";", "defm", "Int_VCVTSI2SS64", ":", "sse12_cvt_sint_3addr", "<NUM_LIT>", ",", "GR64", ",", "VR128", ",", "<BUGS>", "int_x86_sse_cvtsi642ss", ",", "i64mem", ",", "loadi64", ",", "<STR_LIT>", ",", "<BUGE>", "SSE_CVT_Scalar", ",", "<NUM_LIT>", ">", ",", "XS", ",", "VEX_4V", ",", "VEX_W", ";", "defm", "Int_VCVTSI2SD", ":", "sse12_cvt_sint_3addr", "<NUM_LIT>", ",", "GR32", ",", "VR128", ",", "int_x86_sse2_cvtsi2sd", ",", "i32mem", ",", "loadi32", ",", "<STR_LIT>", ",", "SSE_CVT_Scalar", ",", "<NUM_LIT>", ">", ",", "XD", ",", "VEX_4V", ";", "defm", "Int_VCVTSI2SD64", ":", "sse12_cvt_sint_3addr", "<NUM_LIT>", ",", "GR64", ",", "VR128", ",", "<BUGS>", "int_x86_sse2_cvtsi642sd", ",", "i64mem", ",", "loadi64", ",", "<STR_LIT>", ",", "<BUGE>", "SSE_CVT_Scalar", ",", "<NUM_LIT>", ">", ",", "XD", ",", "VEX_4V", ",", "VEX_W", ";" ]

[ ";" ]

[ "bool", "addRegAssignAndRewriteFast", "(", ")", "override", "{", "return", "false" ]

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

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

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

[ "static", "void", "arm_print_value", "(", "FILE", "*", "f", ",", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST_INT", ":", "fprintf", "(", "f", ",", "HOST_WIDE_INT_PRINT_HEX", ",", "INTVAL", "(", "x", ")", ")", ";", "return", ";", "case", "CONST_DOUBLE", ":", "{", "char", "fpstr", "[", "<NUM_LIT>", "]", ";", "real_to_decimal", "(", "fpstr", ",", "CONST_DOUBLE_REAL_VALUE", "(", "x", ")", ",", "sizeof", "(", "fpstr", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "fputs", "(", "fpstr", ",", "f", ")", ";", "}", "return", ";", "case", "CONST_VECTOR", ":", "{", "int", "i", ";", "fprintf", "(", "f", ",", "<STR_LIT>", "<", "<STR_LIT>", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "CONST_VECTOR_NUNITS", "(", "x", ")", ";", "i", "++", ")", "{", "fprintf", "(", "f", ",", "HOST_WIDE_INT_PRINT_HEX", ",", "INTVAL", "(", "CONST_VECTOR_ELT", "(", "x", ",", "i", ")", ")", ")", ";", "if", "(", "i", "<", "(", "CONST_VECTOR_NUNITS", "(", "x", ")", "-", "<NUM_LIT>", ")", ")", "fputc", "(", "'", ",", "'", ",", "f", ")", ";", "}", "fprintf", "(", "f", ",", "<STR_LIT>", ">", "<STR_LIT>", ")", ";", "}", "return", ";", "case", "CONST_STRING", ":", "fprintf", "(", "f", ",", "<STR_LIT>", "\\\"%s\\\"", "<STR_LIT>", ",", "XSTR", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "return", ";", "case", "SYMBOL_REF", ":", "fprintf", "(", "f", ",", "<STR_LIT>", "`%s'", "<STR_LIT>", ",", "XSTR", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "return", ";", "case", "LABEL_REF", ":", "fprintf", "(", "f", ",", "<STR_LIT>", "L%d", "<STR_LIT>", ",", "INSN_UID", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ")", ";", "return", ";", "case", "CONST", ":", "arm_print_value", "(", "f", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "return", ";", "case", "PLUS", ":", "arm_print_value", "(", "f", ",", "XEXP", "(", "x" ]

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

[ "(", "match_operand", "<NUM_LIT>", ")", ")", "(", "unspec", "[", "(", "reg", ":", "DI", "<NUM_LIT>", ")", "]", "UNSPEC_SIBCALL", ")" ]

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

[ "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

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

[ "return", "new", "MipsAsmBackend", "(", "T", ",", "Triple", "(", "TT", ")", ".", "getOS", "(", ")", ",", "true", "," ]

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

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

[ ")" ]

[ "(", "vec_concat", ":", "V8SI", "(", "match_operand", ":", "V4SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V4SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "}" ]

[ "static", "int", "fr30_arg_partial_bytes", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "named", "==", "<NUM_LIT>", "||", "*", "cum", ">=", "FR30_NUM_ARG_REGS", ")", "return", "<NUM_LIT>", ";", "if", "(", "*", "cum", "+", "fr30_num_arg_regs", "(", "mode", ",", "type", ")", "<=", "FR30_NUM_ARG_REGS", ")", "return", "<NUM_LIT>", ";", "return", "(", "FR30_NUM_ARG_REGS", "-", "*", "cum", ")", "*", "UNITS_PER_WORD", ";" ]

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

[ "(", "define_mode_attr", "doublemodesuffix", "[", "(", "SI", "<STR_LIT>", ")", "(", "DI", "<STR_LIT>" ]

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

[ "def", "MVE_VSHLL_immu8th", ":", "MVE_VSHLL_imm8", "<", "<STR_LIT>", "," ]

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

[ "bits", "<", "<NUM_LIT>", ">", "op1", ";", "bits", "<", "<NUM_LIT>", ">", "Cn", ";", "bits", "<", "<NUM_LIT>", ">", "Cm", ";", "bits", "<", "<NUM_LIT>", ">", "op2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op1", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Cn", ";" ]

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

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

[ "sdst", ",", "(", "AMDGPUffbl_b32", "i64", ":", "$", "src0", ")", ")", "]", ">", ";" ]

[ "def", "S_FF1_I32_B64", ":", "SOP1_32_64", "<", "<STR_LIT>", ",", "[", "(", "set", "i32", ":", "$" ]

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

[ "def", "SLG", ":", "BinaryRXY", "<", "<STR_LIT>", ",", "<NUM_LIT>", ",", "subc", ",", "GR64", "," ]

[ "<FIXS>", "const", "MipsSubtarget", "*", "STI", "=", "nullptr", ";", "<FIXE>", "<FIXS>", "MachineFunction", "*", "MF", "=", "nullptr", ";", "MachineConstantPool", "*", "MCP", "=", "nullptr", ";", "<FIXE>", "<FIXS>", "bool", "PrescannedForConstants", "=", "false", ";", "<FIXE>", "<FIXS>", "MipsConstantIslands", "(", ")", ":", "MachineFunctionPass", "(", "ID", ")", "{", "}", "<FIXE>" ]

[ "bool", "HasFarJump", ";", "<BUGS>", "const", "MipsSubtarget", "*", "STI", ";", "<BUGE>", "const", "Mips16InstrInfo", "*", "TII", ";", "MipsFunctionInfo", "*", "MFI", ";", "<BUGS>", "MachineFunction", "*", "MF", ";", "MachineConstantPool", "*", "MCP", ";", "<BUGE>", "unsigned", "PICLabelUId", ";", "<BUGS>", "bool", "PrescannedForConstants", ";", "<BUGE>", "void", "initPICLabelUId", "(", "unsigned", "UId", ")", "{", "PICLabelUId", "=", "UId", ";", "}", "unsigned", "createPICLabelUId", "(", ")", "{", "return", "PICLabelUId", "++", ";", "}", "public", ":", "static", "char", "ID", ";", "<BUGS>", "MipsConstantIslands", "(", ")", ":", "MachineFunctionPass", "(", "ID", ")", ",", "STI", "(", "nullptr", ")", ",", "MF", "(", "nullptr", ")", ",", "MCP", "(", "nullptr", ")", ",", "PrescannedForConstants", "(", "false", ")", "{", "}", "<BUGE>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "<STR_LIT>", "Mips Constant Islands", "<STR_LIT>", ";", "}" ]

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

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

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

[ "def", "J4_cmpgtui_fp1_jump_t", ":", "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>", ";" ]

[ "}", "=", "Rd", ";" ]

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

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

[ "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isBarrier", "=", "<NUM_LIT>", ";", "let", "isPredicable", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "]", ")", "<FIXE>", "<FIXS>", "(", "define_insn_and_split", "<STR_LIT>", "<FIXE>" ]

[ "(", "const_int", "<NUM_LIT>", ")", "(", "if_then_else", "(", "match_test", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "<BUGS>", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "<BUGS>", "(", "define_insn", "<STR_LIT>", "<BUGE>", "[", "(", "set", "(", "pc", ")", "(", "if_then_else", "(", "match_operator", "<NUM_LIT>", "<STR_LIT>" ]

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

[ "else", "if", "(", "Rs", "==", "<NUM_LIT>", ")", "MI", ".", "setOpcode", "(", "Mips", "::", "BLEZC", ")", ";", "else", "if", "(", "Rs", "==", "Rt", ")", "MI", ".", "setOpcode", "(", "Mips", "::", "BGEZC", ")", ";", "else", "return", "MCDisassembler", "::", "Fail", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "getReg", "(", "Decoder", ",", "Mips", "::", "GPR32RegClassID", ",", "Rt", ")", ")", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "Imm" ]

[ ";" ]

[ "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "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>" ]

[ "<STR_LIT>" ]

[ "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "FLAGS_REG", ")", ")", "]" ]

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

[ "bool", "MipsInstructionSelector", "::", "materialize32BitImm", "(", "Register", "DestReg", ",", "APInt", "Imm", ",", "MachineIRBuilder", "&", "B", ")", "const", "{", "assert", "(", "Imm", ".", "getBitWidth", "(", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Unsupported immediate size.", "<STR_LIT>", ")", ";", "if", "(", "Imm", ".", "getHiBits", "(", "<NUM_LIT>", ")", ".", "isNullValue", "(", ")", ")", "{", "MachineInstr", "*", "Inst", "=", "B", ".", "buildInstr", "(", "Mips", "::", "ORi", ",", "{", "DestReg", "}", ",", "{", "Register", "(", "Mips", "::", "ZERO", ")", "}", ")", ".", "addImm", "(", "Imm", ".", "getLoBits", "(", "<NUM_LIT>", ")", ".", "getLimitedValue", "(", ")", ")", ";", "return", "constrainSelectedInstRegOperands", "(", "*", "Inst", ",", "TII", ",", "TRI", ",", "RBI", ")", ";", "}", "if", "(", "Imm", ".", "getLoBits", "(", "<NUM_LIT>", ")", ".", "isNullValue", "(", ")", ")", "{", "MachineInstr", "*", "Inst", "=", "B", ".", "buildInstr", "(", "Mips", "::", "LUi", ",", "{", "DestReg", "}", ",", "{", "}", ")", ".", "addImm", "(", "Imm", ".", "getHiBits", "(", "<NUM_LIT>", ")", ".", "getLimitedValue", "(", ")", ")", ";", "return", "constrainSelectedInstRegOperands", "(", "*", "Inst", ",", "TII", ",", "TRI", ",", "RBI", ")", ";", "}", "if", "(", "Imm", ".", "isSignedIntN", "(", "<NUM_LIT>", ")", ")", "{", "MachineInstr", "*", "Inst", "=", "B", ".", "buildInstr", "(", "Mips", "::", "ADDiu", ",", "{", "DestReg", "}", ",", "{", "Register", "(", "Mips", "::", "ZERO", ")", "}", ")", ".", "addImm", "(", "Imm", ".", "getLoBits", "(", "<NUM_LIT>", ")", ".", "getLimitedValue", "(", ")", ")", ";", "return", "constrainSelectedInstRegOperands", "(", "*", "Inst", ",", "TII", ",", "TRI", ",", "RBI", ")", ";", "}", "Register", "LUiReg", "=", "B", ".", "getMRI", "(", ")", "->", "createVirtualRegister", "(", "&", "Mips", "::", "GPR32RegClass", ")", ";", "MachineInstr", "*", "LUi", "=", "B", ".", "buildInstr", "(", "Mips", "::", "LUi", ",", "{", "LUiReg", "}", ",", "{", "}", ")", ".", "addImm", "(", "Imm", ".", "getHiBits", "(", "<NUM_LIT>", ")", ".", "getLimitedValue", "(", ")", ")", ";", "MachineInstr", "*", "ORi", "=", "B", ".", "buildInstr", "(", "Mips", "::", "ORi", ",", "{", "DestReg", "}", ",", "{", "LUiReg", "}", ")", ".", "addImm", "(", "Imm", ".", "getLoBits", "(", "<NUM_LIT>", ")", ".", "getLimitedValue" ]

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

[ "int", "ARMBaseInstrInfo", "::", "getVSTMUseCycle", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "const", "MCInstrDesc", "&", "UseMCID", ",", "unsigned", "UseClass", ",", "unsigned", "UseIdx", ",", "unsigned", "UseAlign", ")", "const", "{", "int", "RegNo", "=", "(", "int", ")", "(", "UseIdx", "+", "<NUM_LIT>", ")", "-", "UseMCID", ".", "getNumOperands", "(", ")", "+", "<NUM_LIT>", ";", "if", "(", "RegNo", "<=", "<NUM_LIT>", ")", "return", "ItinData", "->", "getOperandCycle", "(", "UseClass", ",", "UseIdx", ")", ";", "int", "UseCycle", ";", "if", "(", "Subtarget", ".", "isCortexA8", "(", ")", ")", "{", "UseCycle", "=", "RegNo", "/", "<NUM_LIT>", "+", "<NUM_LIT>", ";", "if", "(", "RegNo", "%", "<NUM_LIT>", ")", "++", "UseCycle", ";", "}", "else", "if", "(", "Subtarget", ".", "isCortexA9", "(", ")", ")", "{", "UseCycle", "=", "RegNo", ";", "bool", "isSStore", "=", "false", ";", "switch", "(", "UseMCID", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "VSTMSIA", ":", "case", "ARM", "::", "VSTMSIA_UPD", ":", "case", "ARM", "::", "VSTMSDB_UPD", ":", "isSStore", "=", "true", ";", "break", ";", "}", "if", "(", "(", "isSStore", "&&", "(", "RegNo", "%", "<NUM_LIT>", ")", ")", "||", "UseAlign" ]

[ "}" ]

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

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

[ "extern", "_", "_", "inline", "_", "_", "m256i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_maskz_rorv_epi64", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m256i", "_", "_", "A", ",", "_", "_", "m256i", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_prorvq256_mask", "(", "(", "_", "_", "v4di", ")", "_", "_", "A", ",", "(", "_", "_", "v4di", ")", "_", "_", "B" ]

[ "<FIXS>", "if", "(", "!", "TARGET_AVX512DQ", "&", "&", "!", "TARGET_AVX10_1", ")", "<FIXE>" ]

[ "ops", "=", "<STR_LIT>", "breakcase", "<NUM_LIT>", ":", "<BUGS>", "if", "(", "!", "TARGET_AVX512DQ", ")", "<BUGE>", "{", "suffix", "=", "MODE", ">", "mode", "=", "=", "DFmode", "?", "<STR_LIT>", ":", "<STR_LIT>", "ops", "=", "<STR_LIT>" ]

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

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

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

[ "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "SL", ",", "VT", ",", "RHS", ")", ";", "}", "if", "(", "CLHS", "->", "isExactlyValue", "(", "-", "<NUM_LIT>", ")", ")", "{", "SDValue", "FNegRHS", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FNEG", ",", "SL", ",", "VT", ",", "RHS", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "SL", ",", "VT", ",", "FNegRHS", ")", ";", "}", "}", "}", "const", "SDNodeFlags", "*", "Flags", "=", "Op", "->", "getFlags", "(", ")", ";", "if", "(", "Unsafe", "||", "Flags", "->", "hasAllowReciprocal", "(", ")", ")", "{", "SDNodeFlags", "Flags", ";", "Flags", ".", "setUnsafeAlgebra", "(", "true", ")", ";", "SDValue", "Recip", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "SL", ",", "VT", "," ]

[ "}", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "XF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "fix", ":", "XF", "(", "match_operand", ":", "XF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "if", "(", "FP_REG_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "return", "<STR_LIT>", "return", "<STR_LIT>" ]

[ ";" ]

[ "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "LastInst", "->", "getOpcode", "(", ")", ")", ")", ";", "Cond", ".", "push_back", "(", "LastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "return", "false", ";", "}", "if", "(", "LastOpcodeHasJMP_c", ")", "{", "TBB", "=", "LastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "LastInst", "->", "getOpcode", "(", ")", ")", ")", ";", "Cond", ".", "push_back", "(", "LastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "return", "false", ";", "}", "if", "(", "LastOpcodeHasNVJump", "&&", "(", "LastInst", "->", "getNumExplicitOperands", "(", ")", "==", "<NUM_LIT>", ")", ")", "{", "TBB", "=", "LastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "LastInst", "->", "getOpcode", "(", ")", ")", ")", ";", "Cond", ".", "push_back", "(", "LastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Cond", ".", "push_back", "(", "LastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "return", "false", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "\\nCant analyze BB#", "<STR_LIT>", "<<", "MBB", ".", "getNumber", "(", ")", "<<", "<STR_LIT>", " with one jump\\n", "<STR_LIT>", ";", ")", ";", "return", "true", ";", "}", "bool", "SecLastOpcodeHasJMP_c", "=", "PredOpcodeHasJMP_c", "(", "SecLastOpcode", ")", ";", "bool", "SecLastOpcodeHasNVJump", "=", "isNewValueJump", "(", "SecondLastInst", ")", ";", "if", "(", "SecLastOpcodeHasJMP_c", "&&", "(", "LastOpcode", "==", "Hexagon", "::", "J2_jump", ")", ")", "{", "if", "(", "!", "SecondLastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isMBB", "(", ")", ")", "return", "true", ";", "TBB", "=", "SecondLastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "SecondLastInst", "->", "getOpcode", "(", ")", ")", ")", ";", "Cond", ".", "push_back", "(", "SecondLastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "FBB", "=", "LastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "if", "(", "SecLastOpcodeHasNVJump", "&&", "(", "SecondLastInst", "->", "getNumExplicitOperands", "(", ")", "==", "<NUM_LIT>", ")", "&&", "(", "LastOpcode", "==", "Hexagon", "::", "J2_jump", ")", ")", "{", "TBB", "=", "SecondLastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "SecondLastInst", "->", "getOpcode", "(", ")", ")", ")", ";", "Cond", ".", "push_back", "(", "SecondLastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Cond", ".", "push_back", "(", "SecondLastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "FBB", "=", "LastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "if", "(", "SecLastOpcode", "==", "Hexagon", "::", "J2_jump", "&&", "LastOpcode", "==", "Hexagon", "::", "J2_jump", ")", "{", "TBB", "=", "SecondLastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "I", "=", "LastInst", "->", "getIterator", "(", ")", ";", "if", "(", "AllowModify", ")", "I", "->", "eraseFromParent", "(", ")", ";", "return", "false", ";", "}", "if", "(", "isEndLoopN", "(", "SecLastOpcode", ")", "&&", "LastOpcode", "==", "Hexagon", "::", "J2_jump", ")", "{", "TBB", "=", "SecondLastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "SecondLastInst", "->", "getOpcode", "(", ")", ")", ")", ";", "Cond", ".", "push_back", "(", "SecondLastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "FBB", "=", "LastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "return", "false" ]

[ "let", "SuperClasses", "=", "[", "X86Mem64AsmOperand", "]", ";" ]

[ "def", "X86DstIdx64Operand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";" ]

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

[ ":", "N3V", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "op21_20", ",", "op11_8", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "QPR", ":", "$", "dst", ")", ",", "(", "ins", "QPR", ":", "$", "src1", ",", "QPR", ":", "$", "src2", ",", "DPR_8", ":", "$", "src3", ",", "nohash_imm", ":", "$", "lane", ")", ",", "itin", ",", "<BUGS>", "!", "strconcat", "(", "OpcodeStr", ",", "<STR_LIT>", ")", ",", "<STR_LIT>", ",", "<BUGE>", "[", "(", "set", "(", "ResTy", "QPR", ":", "$", "dst", ")", ",", "(", "ResTy", "(", "ShOp", "(", "ResTy", "QPR", ":", "$", "src1", ")", ",", "(", "ResTy", "(", "MulOp", "QPR", ":", "$", "src2", "," ]

[ ".", "nentry", ")", "{" ]

[ "for", "(", "CD_map_entry_t", "::", "iterator", "EI", "=", "map_entry", ".", "begin", "(", ")", ",", "EE", "=", "map_entry", ".", "end", "(", ")", ";", "EI", "!=", "EE", ";", "++", "EI", ")", "{", "Node", "*", "n", "=", "EI", "->", "first", ";", "Edge", "e", "=", "EI", "->", "second", ";", "if", "(", "n", "==", "&", "fcfg" ]

[ "<FIXS>", "return", "use_ndd", "?", "<STR_LIT>", ":", "<STR_LIT>", "<FIXE>", "<FIXS>", "return", "use_ndd", "?", "<STR_LIT>", ":", "<STR_LIT>", "<FIXE>" ]

[ "std", ":", ":", "swap", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", "if", "(", "x86_maybe_negate_const_int", "(", "&", "operands", "[", "<NUM_LIT>", "]", ",", "HImode", ")", ")", "<BUGS>", "return", "use_ndd", "?", "<STR_LIT>", ":", "<STR_LIT>", "<BUGE>", "<BUGS>", "return", "use_ndd", "?", "<STR_LIT>", ":", "<STR_LIT>", "<BUGE>", "}", "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

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

[ "class", "sve_int_bin_cons_misc_0_c", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "string", "asm", ",", "ZPRRegOp", "zprty", ">", ":", "I", "<", "(", "outs", "zprty", ":", "$", "Zd", ")", ",", "(", "ins", "zprty", ":", "$", "Zn", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Zd", ";", "bits", "<", "<NUM_LIT>", ">", "Zn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "<FIXS>", "xstormy16_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "<FIXE>" ]

[ "}", "static", "rtx", "<BUGS>", "xstormy16_function_arg", "(", "cumulative_args_t", "cum_v", ",", "enum", "machine_mode", "mode", ",", "<BUGE>", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";" ]

[ "<FIXS>", "Register", "&", "SrcReg2", ",", "int64_t", "&", "CmpMask", ",", "int64_t", "&", "CmpValue", ")", "const", "{", "<FIXE>" ]

[ "}", "bool", "LanaiInstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "Register", "&", "SrcReg", ",", "<BUGS>", "Register", "&", "SrcReg2", ",", "int", "&", "CmpMask", ",", "int", "&", "CmpValue", ")", "const", "{", "<BUGE>", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "pstatefield", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";", "let", "hasCompleteDecoder", "=", "<NUM_LIT>", ";" ]

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

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

[ ";" ]

[ "if", "(", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "OptimizeForSize", ")", "||", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "MinSize", ")", ")", "{", "return", "false", ";", "}", "TM", "=", "&", "MF", ".", "getTarget", "(", ")", ";", "if", "(", "!", "TM", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "padShortFunctions", "(", ")", ")", "return", "false", ";", "TII", "=", "TM", "->", "getInstrInfo", "(", ")", ";", "ReturnBBs", ".", "clear", "(", ")", ";", "VisitedBBs", ".", "clear", "(", ")", ";", "findReturns", "(", "MF", ".", "begin", "(", ")", ")", ";", "bool", "MadeChange", "=", "false", ";", "MachineBasicBlock", "*", "MBB", ";", "unsigned", "int", "Cycles", "=", "<NUM_LIT>", ";", "for", "(", "DenseMap", "<", "MachineBasicBlock", "*", ",", "unsigned", "int", ">", "::", "iterator", "I", "=", "ReturnBBs", ".", "begin", "(", ")", ";", "I", "!=", "ReturnBBs", ".", "end", "(", ")", ";", "++", "I", ")", "{", "MBB", "=", "I", "->", "first", ";", "Cycles", "=", "I", "->", "second", ";", "if", "(", "Cycles", "<", "Threshold", ")", "{", "assert", "(", "MBB", "->", "size", "(", ")", ">", "<NUM_LIT>", "&&", "<STR_LIT>", "Basic block should contain at least a RET but is empty", "<STR_LIT>", ")", ";", "MachineBasicBlock", "::", "iterator", "ReturnLoc", "=", "--", "MBB", "->", "end", "(", ")", ";", "while", "(", "ReturnLoc", "->", "isDebugValue", "(", ")", ")", "--", "ReturnLoc", ";", "assert", "(", "ReturnLoc", "->", "isReturn", "(", ")", "&&", "!", "ReturnLoc", "->", "isCall", "(", ")", "&&", "<STR_LIT>", "Basic block does not end with RET", "<STR_LIT>", ")", ";", "addPadding", "(", "MBB", ",", "ReturnLoc", ",", "Threshold", "-", "Cycles", ")", ";", "NumBBsPadded", "++" ]

[ ".", "clock", ";" ]

[ "static", "int", "insn_uid_get_clock", "(", "int", "uid", ")", "{", "return", "INSN_INFO_ENTRY", "(", "uid", ")" ]

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

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

[ "}" ]

[ "let", "Pattern", "=", "pattern", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "A", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "B", ";" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_maskz_expand_epi16", "(", "_", "_", "mmask8", "_", "_", "A", ",", "_", "_", "m128i", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_expandhi128_maskz", "(", "(", "_", "_", "v8hi", ")", "_", "_", "B", ",", "(", "_", "_", "v8hi", ")", "_", "mm_avx512_setzero_si128", "(", ")", ",", "(", "_", "_", "mmask8", ")", "_", "_", "A", ")", ";" ]

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

[ "def", "PPCstore_scal_int_from_vsr", ":", "SDNode", "<", "<STR_LIT>", ",", "SDT_PPCstore_scal_int_from_vsr", ",", "[", "SDNPHasChain", ",", "SDNPMayStore" ]