Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "<FIXS>", "Argument", "*", "OrigArg", "=", "F", ".", "getArg", "(", "Ins", "[", "i", "]", ".", "getOrigArgIndex", "(", ")", ")", ";", "<FIXE>" ]

[ "if", "(", "Ins", "[", "i", "]", ".", "isOrigArg", "(", ")", ")", "{", "<BUGS>", "Argument", "*", "OrigArg", "=", "MF", ".", "getFunction", "(", ")", ".", "getArg", "(", "Ins", "[", "i", "]", ".", "getOrigArgIndex", "(", ")", ")", ";", "<BUGE>", "if", "(", "OrigArg", "->", "getType", "(", ")", "->", "isIntegerTy", "(", "<NUM_LIT>", ")", ")", "{", "if", "(", "!", "Ins", "[", "i", "]", ".", "Flags", ".", "isZExt", "(", ")", ")", "{", "ArgValue", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", "," ]

[ "<FIXS>", "(", "OPTIONAL_CP_INSN", "ivc2", "-", "p0s", "-", "isa", "(", "SLOTS", "P0S", ")", "(", "INTRINSIC", "<STR_LIT>", "cpsubaca0_b", "<STR_LIT>", ")", "(", "CPTYPE", "V8QI", ")", "VOLATILE", ")", "<FIXE>" ]

[ ";", "<NUM_LIT>", "qqqqq", "ppppp", "<NUM_LIT>", "cpsubaca0", ".", "b", "crqp", ",", "crpp", "(", "p0_1", ")", "(", "dni", "cpsubaca0_b_P0S", "<STR_LIT>", "cpsubaca0.b $crqp,$crpp Pn", "<STR_LIT>", "<BUGS>", "(", "OPTIONAL_CP_INSN", "ivc2", "-", "p0s", "-", "isa", "(", "SLOTS", "P0S", ")", "(", "INTRINSIC", "<STR_LIT>", "cpsubaca0_b", "<STR_LIT>", ")", "(", "CPTYPE", "V8QI", ")", ")", "<BUGE>", "<STR_LIT>", "cpsubaca0.b $crqp,$crpp", "<STR_LIT>", "(", "+", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u0", "#", "x0", ")", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u8", "#", "x18", ")", "crqp", "crpp", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u23", "#", "xd", ")", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u28", "<NUM_LIT>", ")", ")", "(", "sequence", "(", ")" ]

[ "<FIXS>", "Val_GNU_MIPS_ABI_FP_64", "=", "<NUM_LIT>", ",", "Val_GNU_MIPS_ABI_FP_64A", "=", "<NUM_LIT>", "<FIXE>" ]

[ "Val_GNU_MIPS_ABI_FP_ANY", "=", "<NUM_LIT>", ",", "Val_GNU_MIPS_ABI_FP_DOUBLE", "=", "<NUM_LIT>", ",", "Val_GNU_MIPS_ABI_FP_XX", "=", "<NUM_LIT>", ",", "<BUGS>", "Val_GNU_MIPS_ABI_FP_64", "=", "<NUM_LIT>", "<BUGE>", "}", ";", "uint16_t", "Version", ";" ]

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

[ "return", "(", "uint8x8_t", ")", "_", "_", "builtin_neon_vminuv8qi", "(", "(", "int8x8_t", ")", "_", "_", "a", ",", "(", "int8x8_t", ")" ]

[ "else", "if", "(", "CONST_OK_FOR_K", "(", "value", ")", ")", "return", "<NUM_LIT>", ";" ]

[ "static", "int", "const_costs_int", "(", "HOST_WIDE_INT", "value", ",", "int", "zero_cost", ")", "{", "if", "(", "CONST_OK_FOR_I", "(", "value", ")", ")", "return", "zero_cost", ";", "else", "if", "(", "CONST_OK_FOR_J", "(", "value", ")", ")", "return", "<NUM_LIT>", ";" ]

[ ")" ]

[ "(", "vec_merge", ":", "VF_128", "(", "fma", ":", "VF_128", "(", "neg", ":", "VF_128", "(", "match_operand", ":", "VF_128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "VF_128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "neg", ":", "VF_128", "(", "match_operand", ":", "VF_128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "match_operand", ":", "VF_128", "<NUM_LIT>", "<STR_LIT>" ]

[ "}" ]

[ "void", "XtensaInstPrinter", "::", "printOperand", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "OS", ")", "{", "OS", "<<", "<STR_LIT>", "XtensaInstPrinter::printOperand not yet implemented\\n", "<STR_LIT>", ";" ]

[ "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "<NUM_LIT>", "-", "Imm", ")", ")", ";" ]

[ "static", "DecodeStatus", "DecodeFixedPointScaleImm32", "(", "MCInst", "&", "Inst", ",", "unsigned", "Imm", ",", "uint64_t", "Addr", ",", "const", "MCDisassembler", "*", "Decoder", ")", "{", "Imm", "|=", "<NUM_LIT>", ";" ]

[ "unsigned", "ARMFastISel", "::", "fastEmitInst_rr", "(", "unsigned", "MachineInstOpcode", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Op0", ",", "unsigned", "Op1", ")", "{", "Register", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "const", "MCInstrDesc", "&", "II", "=", "TII", ".", "get", "(", "MachineInstOpcode", ")", ";", "Op0", "=", "constrainOperandRegClass", "(", "II", ",", "Op0", ",", "<NUM_LIT>", ")", ";", "Op1", "=", "constrainOperandRegClass", "(", "II", ",", "Op1", ",", "<NUM_LIT>", ")", ";", "if", "(", "II", ".", "getNumDefs", "(", ")", ">=", "<NUM_LIT>", ")", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ",", "ResultReg", ")", ".", "addReg", "(", "Op0", ")", ".", "addReg", "(", "Op1", ")", ")", ";", "}", "else", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ")", ".", "addReg", "(", "Op0", ")", ".", "addReg", "(", "Op1", ")", ")", ";", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "II", ".", "ImplicitDefs", "[", "<NUM_LIT>", "]", ")", ")", ";", "}", "return", "ResultReg", ";", "}" ]

[ "Emit", "a", "MachineInstr", "with", "two", "register", "operands", "and", "a", "result", "register", "in", "the", "given", "register", "class", "." ]

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

[ "if", "(", "!", "printAliasInstr", "(", "MI", ",", "O", ")", ")", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O" ]

[ "}" ]

[ "field", "bits", "<", "<NUM_LIT>", ">", "Word0", ";", "bits", "<", "<NUM_LIT>", ">", "ADDR", ";", "let", "Word0", "=", "ADDR", ";" ]

[ "return", "(", "CN", "&&", "(", "CN", "->", "getValueAPF", "(", ")", ".", "isZero", "(", ")", ")", ")", ";" ]

[ "static", "bool", "isFPZ", "(", "SDValue", "N", ")", "{", "ConstantFPSDNode", "*", "CN", "=", "dyn_cast", "<", "ConstantFPSDNode", ">", "(", "N", ")", ";" ]

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

[ "bool", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "llvm_unreachable", "(", "<STR_LIT>", "RelaxInstruction() unimplemented", "<STR_LIT>", ")", ";" ]

[ "<FIXS>", "return", "<STR_LIT>", "<FIXE>", "<FIXS>", "(", "define_expand", "<STR_LIT>", "[", "(", "match_operand", ":", "V16FI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V16FI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V16FI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V16FI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", ")", "]", "<STR_LIT>", "{", "int", "mask", "=", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "emit_insn", "(", "gen_avx512f_shuf_", "shuffletype", ">", "<NUM_LIT>", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "GEN_INT", "(", "(", "(", "mask", ">", ">", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", "*", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "(", "(", "mask", ">", ">", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", "*", "<NUM_LIT>", "+", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "(", "(", "mask", ">", ">", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", "*", "<NUM_LIT>", "+", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "(", "(", "mask", ">", ">", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", "*", "<NUM_LIT>", "+", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "(", "(", "mask", ">", ">", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", "*", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "(", "(", "mask", ">", ">", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", "*", "<NUM_LIT>", "+", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "(", "(", "mask", ">", ">", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", "*", "<NUM_LIT>", "+", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "(", "(", "mask", ">", ">", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", "*", "<NUM_LIT>", "+", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "(", "(", "mask", ">", ">", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", "*", "<NUM_LIT>", "+", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "(", "(", "mask", ">", ">", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", "*", "<NUM_LIT>", "+", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "(", "(", "mask", ">", ">", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", "*", "<NUM_LIT>", "+", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "(", "(", "mask", ">", ">", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", "*", "<NUM_LIT>", "+", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "(", "(", "mask", ">", ">", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", "*", "<NUM_LIT>", "+", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "(", "(", "mask", ">", ">", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", "*", "<NUM_LIT>", "+", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "(", "(", "mask", ">", ">", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", "*", "<NUM_LIT>", "+", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "(", "(", "mask", ">", ">", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", "*", "<NUM_LIT>", "+", "<NUM_LIT>", ")", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "DONE", "}", ")", "(", "define_insn", "<STR_LIT>", "<FIXE>" ]

[ "mask", "|", "=", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "-", "<NUM_LIT>", ")", "/", "<NUM_LIT>", "<NUM_LIT>", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "mask", ")", "<BUGS>", "return", "<STR_LIT>", "<BUGE>", "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGS>", "(", "define_insn", "<STR_LIT>", "<BUGE>", "[", "(", "set", "(", "match_operand", ":", "V16FI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_select", ":", "V16FI", "(", "vec_concat", ":", "ssedoublemode", ">" ]

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

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

[ "return", "Imm", ">", "=", "<NUM_LIT>", "&", "&", "Imm", "<", "<NUM_LIT>", ";", "}", "]", ",", "CCOP", ">", "{", "let", "PrintMethod" ]

[ ";" ]

[ "return", "CI", "->", "isTailCall", "(", ")" ]

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

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

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

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

[ "]", ")" ]

[ "[", "(", "set", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operator", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<STR_LIT>", ":" ]

[ "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::" ]

[ ":" ]

[ "if", "(", "!", "ST", ".", "isTrapHandlerEnabled", "(", ")", "||", "ST", ".", "getTrapHandlerAbi", "(", ")", "!=", "GCNSubtarget", "::", "TrapHandlerAbi", "::", "AMDHSA", ")", "return", "legalizeTrapEndpgm", "(", "MI", ",", "MRI", ",", "B", ")", ";", "if", "(", "Optional", "<", "uint8_t", ">", "HsaAbiVer", "=", "AMDGPU", "::", "getHsaAbiVersion", "(", "&", "ST", ")", ")", "{", "switch", "(", "*", "HsaAbiVer", ")", "{", "case", "ELF", "::", "ELFABIVERSION_AMDGPU_HSA_V2", ":", "case", "ELF", "::", "ELFABIVERSION_AMDGPU_HSA_V3" ]

[ "++", "ArgNo", ";" ]

[ "const", "DataLayout", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "const", "MipsTargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "MipsTargetLowering", ">", "(", ")", ";", "unsigned", "ArgNo", "=", "<NUM_LIT>", ";", "for", "(", "auto", "&", "Arg", ":", "Args", ")", "{", "EVT", "VT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "Arg", ".", "Ty", ")", ";", "MVT", "RegisterVT", "=", "TLI", ".", "getRegisterTypeForCallingConv", "(", "F", ".", "getContext", "(", ")", ",", "VT", ")", ";", "ISD", "::", "ArgFlagsTy", "Flags", "=", "Arg", ".", "Flags", ";", "Flags", ".", "setOrigAlign", "(", "TLI", ".", "getABIAlignmentForCallingConv", "(", "Arg", ".", "Ty", ",", "DL", ")", ")", ";", "PushBack", "(", "Flags", ",", "RegisterVT", ",", "VT", ",", "true", ",", "OrigArgIndices", "[", "ArgNo", "]", ",", "<NUM_LIT>", ")", ";" ]

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

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

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

[ "for", "(", ";", "MBBI", "!=", "E", ";", "++", "MBBI", ")", "{", "if", "(", "MBBI", "->", "getOpcode", "(", ")", "!=", "CI", ".", "I", "->", "getOpcode", "(", ")", ")", "{", "if", "(", "MBBI", "->", "hasUnmodeledSideEffects", "(", ")", ")", "return", "false", ";", "if", "(", "MBBI", "->", "mayLoadOrStore", "(", ")", "&&", "!", "memAccessesCanBeReordered", "(", "*", "CI", ".", "I", ",", "*", "MBBI", ",", "TII", ",", "AA", ")", ")", "{", "CI", ".", "InstsToMove", ".", "push_back", "(", "&", "*", "MBBI", ")", ";", "addDefsToList", "(", "*", "MBBI", ",", "DefsToMove", ")", ";", "continue", ";", "}", "addToListsIfDependent", "(", "*", "MBBI", ",", "DefsToMove", ",", "CI", ".", "InstsToMove", ")", ";", "continue", ";", "}", "if", "(", "MBBI", "->", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "if", "(", "addToListsIfDependent", "(", "*", "MBBI", ",", "DefsToMove", ",", "CI", ".", "InstsToMove", ")", ")", "continue", ";", "int", "AddrIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "CI", ".", "I", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "addr", ")", ";", "const", "MachineOperand", "&", "AddrReg0", "=", "CI", ".", "I", "->", "getOperand", "(", "AddrIdx", ")", ";", "const", "MachineOperand", "&", "AddrReg1", "=", "MBBI", "->", "getOperand", "(", "AddrIdx", ")", ";", "if", "(", "AddrReg0", ".", "getReg", "(", ")", "==", "AddrReg1", ".", "getReg", "(", ")", "&&", "AddrReg0", ".", "getSubReg", "(", ")", "==", "AddrReg1", ".", "getSubReg", "(", ")", ")", "{", "int", "OffsetIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "CI", ".", "I", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "offset", ")", ";", "CI", ".", "Offset0", "=", "CI", ".", "I", "->", "getOperand", "(", "OffsetIdx", ")", ".", "getImm", "(", ")", "&", "<NUM_LIT>", ";", "CI", ".", "Offset1", "=", "MBBI", "->", "getOperand", "(", "OffsetIdx", ")", ".", "getImm", "(", ")", "&", "<NUM_LIT>", ";", "CI", ".", "Paired", "=", "MBBI", ";", "if", "(", "offsetsCanBeCombined", "(", "CI", ")", ")", "if", "(", "canMoveInstsAcrossMemOp", "(", "*", "MBBI", ",", "CI", ".", "InstsToMove", ",", "TII", ",", "AA", ")", ")", "return", "true", ";", "}", "if", "(", "!", "memAccessesCanBeReordered", "(", "*", "CI", ".", "I", ",", "*", "MBBI", ",", "TII", ",", "AA", ")", "||", "!", "canMoveInstsAcrossMemOp", "(", "*", "MBBI", ",", "CI", ".", "InstsToMove", ",", "TII", ",", "AA" ]

[ ")", ")" ]

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

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

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_vpermt2vard128_maskz", "(", "(", "_", "_", "v4si", ")", "_", "_", "I", ",", "(", "_", "_", "v4si", ")", "_", "_", "A", ",", "(" ]

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

[ "(", "match_operand", ":", "VDF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "float_truncate", ":", "VDF", "(", "match_operand", ":", "<", "VWIDE", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

[ ")", ")", ")", "&&", "isPowerOf2_64", "(", "AndRHSVal", ")", ")", "{" ]

[ "static", "SDValue", "LowerAndToBT", "(", "SDValue", "And", ",", "ISD", "::", "CondCode", "CC", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "{", "assert", "(", "And", ".", "getOpcode", "(", ")", "==", "ISD", "::", "AND", "&&", "<STR_LIT>", "Expected AND node!", "<STR_LIT>", ")", ";", "SDValue", "Op0", "=", "And", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Op1", "=", "And", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Op0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "TRUNCATE", ")", "Op0", "=", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Op1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "TRUNCATE", ")", "Op1", "=", "Op1", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "LHS", ",", "RHS", ";", "if", "(", "Op1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SHL", ")", "std", "::", "swap", "(", "Op0", ",", "Op1", ")", ";", "if", "(", "Op0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SHL", ")", "{", "if", "(", "isOneConstant", "(", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "unsigned", "BitWidth", "=", "Op0", ".", "getValueSizeInBits", "(", ")", ";", "unsigned", "AndBitWidth", "=", "And", ".", "getValueSizeInBits", "(", ")", ";", "if", "(", "BitWidth", ">", "AndBitWidth", ")", "{", "KnownBits", "Known", ";", "DAG", ".", "computeKnownBits", "(", "Op0", ",", "Known", ")", ";", "if", "(", "Known", ".", "countMinLeadingZeros", "(", ")", "<", "BitWidth", "-", "AndBitWidth", ")", "return", "SDValue", "(", ")", ";", "}", "LHS", "=", "Op1", ";", "RHS", "=", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "}", "}", "else", "if", "(", "Op1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", ")", "{", "ConstantSDNode", "*", "AndRHS", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op1", ")", ";", "uint64_t", "AndRHSVal", "=", "AndRHS", "->", "getZExtValue", "(", ")", ";", "SDValue", "AndLHS", "=", "Op0", ";", "if", "(", "AndRHSVal", "==", "<NUM_LIT>", "&&", "AndLHS", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SRL", ")", "{", "LHS", "=", "AndLHS", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "RHS", "=", "AndLHS", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "}", "else", "{", "bool", "OptForSize", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ".", "optForSize", "(", ")", ";", "if", "(", "(", "!", "isUInt", "<", "<NUM_LIT>", ">", "(", "AndRHSVal", ")", "||", "(", "OptForSize", "&&", "!", "isUInt", "<", "<NUM_LIT>", ">", "(", "AndRHSVal" ]

[ ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ")", ";" ]

[ "SDLoc", "DL", "(", "N", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "Intrinsic", "::", "arm_mrc", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", "}", ";", "SDValue", "Cycles32", "=", "DAG", ".", "getNode", "(", "ISD", "::", "INTRINSIC_W_CHAIN", ",", "DL", ",", "DAG", ".", "getVTList", "(", "MVT", "::", "i32", ",", "MVT", "::", "Other", ")", ",", "Ops", ")", ";", "Results", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_PAIR", ",", "DL", ",", "MVT", "::", "i64", ",", "Cycles32" ]

[ "[", "SchedWriteFShuffle", ".", "XMM", ".", "Folded", "]", ">", ",", "VEX", ",", "VEX_L", ";" ]

[ "def", "VBROADCASTF128", ":", "AVX8I", "<", "<NUM_LIT>", ",", "MRMSrcMem", ",", "(", "outs", "VR256", ":", "$", "dst", ")", ",", "(", "ins", "f128mem", ":", "$", "src", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<" ]

[ ")", "]" ]

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

[ "<STR_LIT>", ")" ]

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

[ "}" ]

[ "let", "InOperandList", "=", "(", "ins", "Rsrc1", ":", "$", "op1", ",", "TPCImm", "<", "Isrc2", ">", ":", "$", "op2", ",", "DataType", ":", "$", "optype", ",", "SwitchSet", ":", "$", "sw", ",", "RhazRsOp", ":", "$", "rhaz", ",", "Rdst", ":", "$", "income", ",", "Pred", ":", "$", "pred", ")", ";", "let", "Pattern", "=", "pattern", ";", "let", "Itinerary", "=", "IIC_VectorOp", ";", "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "op1", ";", "bits", "<", "<NUM_LIT>", ">", "op2", ";", "bits", "<", "<NUM_LIT>", ">", "optype", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "rhaz", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "op1", ";", "let", "SrcB", "=", "op2", ";", "let", "OperandType", "=", "optype", ";", "let", "Switches", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sw", ";", "let", "Switches", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "VectorPred", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Pred", ")", ",", "<STR_LIT>", ")", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";", "let", "HasImm", "=", "<NUM_LIT>", ";", "let", "immOpNum", "=", "<NUM_LIT>", ";", "let", "Constraints", "=", "<STR_LIT>", ";" ]

[ "<FIXS>", "if", "(", "mask", "=", "=", "const0_rtx", ")", "<FIXE>", "<FIXS>", "if", "(", "mask", "=", "=", "constm1_rtx", ")", "<FIXE>" ]

[ "{", "rtx", "mask", "=", "alpha_expand_zap_mask", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "<BUGS>", "if", "(", "operands", "[", "<NUM_LIT>", "]", "=", "=", "const0_rtx", ")", "<BUGE>", "{", "emit_move_insn", "(", "operands", "[", "<NUM_LIT>", "]", ",", "const0_rtx", ")", "DONE", "}", "<BUGS>", "if", "(", "operands", "[", "<NUM_LIT>", "]", "=", "=", "constm1_rtx", ")", "<BUGE>", "{", "emit_move_insn", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", "DONE" ]

[ ")", ")" ]

[ "[", "(", "set", "(", "reg", ":", "CCNZ", "CC_REGNUM", ")", "(", "compare", ":", "CCNZ", "(", "ashift", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>" ]

[ "nullptr", ";" ]

[ "const", "uint32_t", "*", "getNoPreservedMask", "(", ")", "const", "override", "{", "return" ]

[ "%ld", "<STR_LIT>", ",", "INTVAL", "(", "x", ")", ")", ";" ]

[ "case", "'", "R", "'", ":", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "fprintf", "(", "file", ",", "<STR_LIT>", "%ld", "<STR_LIT>", ",", "INTVAL", "(", "x", ")", "&", "<NUM_LIT>", ")", ";", "else", "output_operand_lossage", "(", "<STR_LIT>", "invalid %%R value", "<STR_LIT>", ")", ";", "break", ";", "case", "'", "x", "'", ":", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "printx", "(", "file", ",", "INTVAL", "(", "x", ")", ")", ";", "else", "output_operand_lossage", "(", "<STR_LIT>", "invalid %%x value", "<STR_LIT>", ")", ";", "break", ";", "case", "'", "d", "'", ":", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "fprintf", "(", "file", ",", "<STR_LIT>", "%ld", "<STR_LIT>", ",", "INTVAL", "(", "x", ")", ")", ";", "else", "output_operand_lossage", "(", "<STR_LIT>", "invalid %%d value", "<STR_LIT>", ")", ";", "break", ";", "case", "'", "t", "'", ":", "case", "'", "b", "'", ":", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "{", "printx", "(", "file", ",", "INTVAL", "(", "x", ")", ")", ";", "fputs", "(", "letter", "==", "'", "t", "'", "?", "<STR_LIT>", "@h", "<STR_LIT>", ":", "<STR_LIT>", "@l", "<STR_LIT>", ",", "file", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", ")", "{", "REAL_VALUE_TYPE", "r", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "x", ")", ";", "if", "(", "GET_MODE", "(", "x", ")", "==", "SFmode", ")", "{", "long", "l", ";", "REAL_VALUE_TO_TARGET_SINGLE", "(", "r", ",", "l", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "l", ",", "letter", "==", "'", "t", "'", "?", "'", "h", "'", ":", "'", "l", "'", ")", ";", "}", "else", "output_operand_lossage", "(", "<STR_LIT>", "invalid %%t/%%b value", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "!=", "PLUS", "||", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "!=", "SYMBOL_REF", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "!=", "LABEL_REF", ")", "||", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "!=", "CONST_INT", ")", "output_operand_lossage", "(", "<STR_LIT>", "invalid %%t/%%b value", "<STR_LIT>", ")", ";", "print_operand", "(", "file", ",", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ";", "fputs", "(", "letter", "==", "'", "t", "'", "?", "<STR_LIT>", "@h", "<STR_LIT>", ":", "<STR_LIT>", "@l", "<STR_LIT>", ",", "file", ")", ";", "if", "(", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ">=", "<NUM_LIT>", ")", "fputs", "(", "<STR_LIT>", "+", "<STR_LIT>", ",", "file", ")", ";", "print_operand", "(", "file", ",", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ";", "}", "else", "{", "output_addr_const", "(", "file", ",", "x", ")", ";", "fputs", "(", "letter", "==", "'", "t", "'", "?", "<STR_LIT>", "@h", "<STR_LIT>", ":", "<STR_LIT>", "@l", "<STR_LIT>", ",", "file", ")", ";", "}", "break", ";", "default", ":", "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", "||", "GET_CODE", "(", "x", ")", "==", "SUBREG", ")", "fprintf", "(", "file", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "reg_names", "[", "xt_true_regnum", "(", "x", ")", "]", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", ")", "output_address", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "fprintf", "(", "file", ",", "<STR_LIT>" ]

[ "*", "_", "_", "base", ")", "{" ]

[ "_", "_", "arm_vld1q_s32", "(", "int32_t", "const" ]

[ "}" ]

[ "bool", "BTFDebug", "::", "IsForwardDeclCandidate", "(", "const", "DIType", "*", "Base", ")", "{", "if", "(", "const", "auto", "*", "CTy", "=", "dyn_cast", "<", "DICompositeType", ">", "(", "Base", ")", ")", "{", "auto", "CTag", "=", "CTy", "->", "getTag", "(", ")", ";", "if", "(", "(", "CTag", "==", "dwarf", "::", "DW_TAG_structure_type", "||", "CTag", "==", "dwarf", "::", "DW_TAG_union_type", ")", "&&", "!", "CTy", "->", "getName", "(", ")", ".", "empty", "(", ")", "&&", "!", "CTy", "->", "isForwardDecl", "(", ")", ")", "return", "true", ";", "}", "return", "false", ";" ]

[ "}" ]

[ "static", "inline", "bool", "MemBarrierInstr", "(", "uint32_t", "insn", ")", "{", "unsigned", "op7_4", "=", "slice", "(", "insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "if", "(", "slice", "(", "insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "&&", "(", "op7_4", ">=", "<NUM_LIT>", "&&", "op7_4", "<=", "<NUM_LIT>", ")", ")", "return", "true", ";", "return", "false", ";" ]

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

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_VMLA_LANE", ")", ")", "]", "<STR_LIT>", "{", "return", "<STR_LIT>", "}", "[", "(", "set", "(", "attr", "<STR_LIT>", ")" ]

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

[ "def", ":", "InstRW", "<", "[", "KryoWrite_1cyc_XY_63_1ln", "]", ",", "(" ]

[ "if", "(", "bitmap_bit_p", "(", "components", ",", "<NUM_LIT>", ")", ")", "cfun", "->", "machine", "->", "toc_is_wrapped_separately", "=", "true", ";" ]

[ "for", "(", "int", "i", "=", "info", "->", "first_gp_reg_save", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "if", "(", "bitmap_bit_p", "(", "components", ",", "i", ")", ")", "cfun", "->", "machine", "->", "gpr_is_wrapped_separately", "[", "i", "]", "=", "true", ";", "for", "(", "int", "i", "=", "info", "->", "first_fp_reg_save", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "if", "(", "bitmap_bit_p", "(", "components", ",", "i", ")", ")", "cfun", "->", "machine", "->", "fpr_is_wrapped_separately", "[", "i", "-", "<NUM_LIT>", "]", "=", "true", ";", "if", "(", "bitmap_bit_p", "(", "components", ",", "<NUM_LIT>", ")", ")", "cfun", "->", "machine", "->", "lr_is_wrapped_separately", "=", "true", ";" ]

[ "ValueToStore", ",", "StackSlot", ",", "MPI", ",", "Alignment", ")", ";" ]

[ "SDValue", "Chain", "=", "IsStrict", "?", "Op", "->", "getOperand", "(", "<NUM_LIT>", ")", ":", "DAG", ".", "getEntryNode", "(", ")", ";", "MVT", "SrcVT", "=", "Src", ".", "getSimpleValueType", "(", ")", ";", "MVT", "VT", "=", "Op", ".", "getSimpleValueType", "(", ")", ";", "SDLoc", "dl", "(", "Op", ")", ";", "if", "(", "isSoftF16", "(", "VT", ",", "Subtarget", ")", ")", "return", "promoteXINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "else", "if", "(", "isLegalConversion", "(", "SrcVT", ",", "true", ",", "Subtarget", ")", ")", "return", "Op", ";", "if", "(", "Subtarget", ".", "isTargetWin64", "(", ")", "&&", "SrcVT", "==", "MVT", "::", "i128", ")", "return", "LowerWin64_INT128_TO_FP", "(", "Op", ",", "DAG", ")", ";", "if", "(", "SDValue", "Extract", "=", "vectorizeExtractedCast", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ")", "return", "Extract", ";", "if", "(", "SDValue", "R", "=", "lowerFPToIntToFP", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ")", "return", "R", ";", "if", "(", "SrcVT", ".", "isVector", "(", ")", ")", "{", "if", "(", "SrcVT", "==", "MVT", "::", "v2i32", "&&", "VT", "==", "MVT", "::", "v2f64", ")", "{", "if", "(", "IsStrict", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "{", "VT", ",", "MVT", "::", "Other", "}", ",", "{", "Chain", ",", "DAG", ".", "getNode", "(", "ISD", "::", "CONCAT_VECTORS", ",", "dl", ",", "MVT", "::", "v4i32", ",", "Src", ",", "DAG", ".", "getUNDEF", "(", "SrcVT", ")", ")", "}", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "DAG", ".", "getNode", "(", "ISD", "::", "CONCAT_VECTORS", ",", "dl", ",", "MVT", "::", "v4i32", ",", "Src", ",", "DAG", ".", "getUNDEF", "(", "SrcVT", ")", ")", ")", ";", "}", "if", "(", "SrcVT", "==", "MVT", "::", "v2i64", "||", "SrcVT", "==", "MVT", "::", "v4i64", ")", "return", "lowerINT_TO_FP_vXi64", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "return", "SDValue", "(", ")", ";", "}", "assert", "(", "SrcVT", "<=", "MVT", "::", "i64", "&&", "SrcVT", ">=", "MVT", "::", "i16", "&&", "<STR_LIT>", "Unknown SINT_TO_FP to lower!", "<STR_LIT>", ")", ";", "bool", "UseSSEReg", "=", "isScalarFPTypeInSSEReg", "(", "VT", ")", ";", "if", "(", "SrcVT", "==", "MVT", "::", "i32", "&&", "UseSSEReg", ")", "return", "Op", ";", "if", "(", "SrcVT", "==", "MVT", "::", "i64", "&&", "UseSSEReg", "&&", "Subtarget", ".", "is64Bit", "(", ")", ")", "return", "Op", ";", "if", "(", "SDValue", "V", "=", "LowerI64IntToFP_AVX512DQ", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ")", "return", "V", ";", "if", "(", "SDValue", "V", "=", "LowerI64IntToFP16", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ")", "return", "V", ";", "if", "(", "SrcVT", "==", "MVT", "::", "i16", "&&", "(", "UseSSEReg", "||", "VT", "==", "MVT", "::", "f128", ")", ")", "{", "SDValue", "Ext", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "if", "(", "IsStrict", ")", "return", "DAG", ".", "getNode", "(", "ISD", "::", "STRICT_SINT_TO_FP", ",", "dl", ",", "{", "VT", ",", "MVT", "::", "Other", "}", ",", "{", "Chain", ",", "Ext", "}", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SINT_TO_FP", ",", "dl", ",", "VT", ",", "Ext", ")", ";", "}", "if", "(", "VT", "==", "MVT", "::", "f128", "||", "!", "Subtarget", ".", "hasX87", "(", ")", ")", "return", "SDValue", "(", ")", ";", "SDValue", "ValueToStore", "=", "Src", ";", "if", "(", "SrcVT", "==", "MVT", "::", "i64", "&&", "Subtarget", ".", "hasSSE2", "(", ")", "&&", "!", "Subtarget", ".", "is64Bit", "(", ")", ")", "ValueToStore", "=", "DAG", ".", "getBitcast", "(", "MVT", "::", "f64", ",", "ValueToStore", ")", ";", "unsigned", "Size", "=", "SrcVT", ".", "getStoreSize", "(", ")", ";", "Align", "Alignment", "(", "Size", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "auto", "PtrVT", "=", "getPointerTy", "(", "MF", ".", "getDataLayout", "(", ")", ")", ";", "int", "SSFI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateStackObject", "(", "Size", ",", "Alignment", ",", "false", ")", ";", "MachinePointerInfo", "MPI", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "SSFI", ")", ";", "SDValue", "StackSlot", "=", "DAG", ".", "getFrameIndex", "(", "SSFI", ",", "PtrVT", ")", ";", "Chain", "=", "DAG", ".", "getStore", "(", "Chain", ",", "dl", "," ]

[ "}" ]

[ "void", "setReg", "(", "unsigned", "Reg", ")", "{", "assert", "(", "isRegBase", "(", ")", "&&", "<STR_LIT>", "Invalid base register access!", "<STR_LIT>", ")", ";", "Base", ".", "Reg", "=", "Reg", ";" ]

[ "let", "Defs", "=", "[", "USR_OVF", "]", ";" ]

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

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

[ "void", "AVRPassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAVRShiftExpandPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses" ]

[ "break", ";" ]

[ "{", "HOST_WIDE_INT", "ival", "=", "INTVAL", "(", "pru_to_int_mode", "(", "op", ")", ")", ";", "if", "(", "letter", "!=", "<NUM_LIT>", ")", "output_operand_lossage", "(", "<STR_LIT>", "unsupported code '%c' for fixed-point:", "<STR_LIT>", ",", "letter", ")", ";", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "ival", ")", ";", "return", ";", "}", "break", ";", "case", "CONST_DOUBLE", ":", "if", "(", "letter", "==", "<NUM_LIT>", ")", "{", "long", "val", ";", "if", "(", "GET_MODE", "(", "op", ")", "!=", "SFmode", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "double constants not supported", "<STR_LIT>", ")", ";", "return", ";", "}", "REAL_VALUE_TO_TARGET_SINGLE", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "op", ")", ",", "val", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "val", ")", ";", "return", ";", "}", "else", "if", "(", "letter", "==", "'", "w", "'", "||", "letter", "==", "'", "W", "'", ")", "{", "long", "t", "[", "<NUM_LIT>", "]", ";", "REAL_VALUE_TO_TARGET_DOUBLE", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "op", ")", ",", "t", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "t", "[", "letter", "==", "'", "w", "'", "?", "<NUM_LIT>", ":", "<NUM_LIT>", "]", ")", ";", "return", ";", "}", "else", "{", "output_operand_lossage", "(", "<STR_LIT>", "invalid operand for '%%%c'", "<STR_LIT>", ",", "letter", ")", ";", "return", ";", "}", "break", ";", "case", "SUBREG", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "case", "MEM", ":", "if", "(", "letter", "==", "<NUM_LIT>", ")", "{", "output_address", "(", "VOIDmode", ",", "op", ")", ";", "return", ";", "}", "else", "if", "(", "letter", "==", "'", "B", "'", ")", "{", "rtx", "base", "=", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "{", "rtx", "op0", "=", "XEXP", "(", "base", ",", "<NUM_LIT>", ")", ";", "rtx", "op1", "=", "XEXP", "(", "base", ",", "<NUM_LIT>", ")", ";", "if", "(", "ctable_base_operand", "(", "op1", ",", "VOIDmode", ")", ")", "{", "fprintf", "(", "file", ",", "<STR_LIT>", "c", "<STR_LIT>", ")", ";", "return", ";", "}", "else", "if", "(", "REG_P", "(", "op0", ")", ")", "{", "fprintf", "(", "file", ",", "<STR_LIT>", "b", "<STR_LIT>", ")", ";", "return", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "REG_P", "(", "base", ")", ")", "{", "fprintf", "(", "file", ",", "<STR_LIT>", "b", "<STR_LIT>", ")", ";", "return", ";", "}", "else", "if", "(", "ctable_addr_operand", "(", "base", ",", "VOIDmode", ")", ")", "{", "fprintf", "(", "file", ",", "<STR_LIT>", "c", "<STR_LIT>", ")", ";", "return", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "CODE_LABEL", ":", "if", "(", "letter", "==", "<NUM_LIT>", ")", "{", "output_addr_const", "(", "file", ",", "op", ")", ";", "return", ";", "}" ]

[ ">", ";" ]

[ "def", ":", "Neon_ScalarShiftImm_fcvt_v1f64_pattern", "<", "int_arm_neon_vcvtfp2fxu", ",", "FCVTZU_Nddi" ]

[ "}" ]

[ "if", "(", "ParseIntelIdentifier", "(", "Val", ",", "Identifier", ",", "Info", ",", "false", ",", "End", ")", ")", "return", "<NUM_LIT>", ";", "InstInfo", "->", "AsmRewrites", "->", "push_back", "(", "AsmRewrite", "(", "AOK_Skip", ",", "OffsetOfLoc", ",", "<NUM_LIT>", ")", ")", ";", "unsigned", "RegNo", "=", "is64BitMode", "(", ")", "?", "X86", "::", "RBX", ":", "(", "is32BitMode", "(", ")", "?", "X86", "::", "EBX", ":", "X86", "::", "BX", ")", ";", "return", "<STR_LIT>", "::", "<STR_LIT>", "(", "RegNo", ",", "Start", ",", "End", ",", "true", ",", "OffsetOfLoc", ",", "Identifier", ",", "Info", ".", "OpDecl", ")", ";" ]

[ "<STR_LIT>", "\\t.set\\tnoat", "<STR_LIT>", ")", ")", ";" ]

[ "raw_svector_ostream", "OS", "(", "Str", ")", ";", "if", "(", "!", "IsNakedFunction", ")", "printSavedRegsBitmask", "(", "OS", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "OS", ".", "str", "(", ")", ")", ";", "if", "(", "!", "Subtarget", "->", "inMips16Mode", "(", ")", ")", "{", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "<STR_LIT>", "\\t.set\\tnoreorder", "<STR_LIT>", ")", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "<STR_LIT>", "\\t.set\\tnomacro", "<STR_LIT>", ")", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(" ]

[ "case", "ISD", "::", "SETUGE", ":", "Swap", "=", "true", ";" ]

[ "EQ", "=", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "VT", ",", "Op0", ",", "Op1", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i8", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "OR", ",", "dl", ",", "VT", ",", "UNORD", ",", "EQ", ")", ";", "}", "else", "if", "(", "SetCCOpcode", "==", "ISD", "::", "SETONE", ")", "{", "SDValue", "ORD", ",", "NEQ", ";", "ORD", "=", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "VT", ",", "Op0", ",", "Op1", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i8", ")", ")", ";", "NEQ", "=", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "VT", ",", "Op0", ",", "Op1", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i8", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "dl", ",", "VT", ",", "ORD", ",", "NEQ", ")", ";", "}", "llvm_unreachable", "(", "<STR_LIT>", "Illegal FP comparison", "<STR_LIT>", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "VT", ",", "Op0", ",", "Op1", ",", "DAG", ".", "getConstant", "(", "SSECC", ",", "MVT", "::", "i8", ")", ")", ";", "}", "unsigned", "Opc", "=", "<NUM_LIT>", ",", "EQOpc", "=", "<NUM_LIT>", ",", "GTOpc", "=", "<NUM_LIT>", ";", "bool", "Swap", "=", "false", ",", "Invert", "=", "false", ",", "FlipSigns", "=", "false", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "break", ";", "case", "MVT", "::", "v8i8", ":", "case", "MVT", "::", "v16i8", ":", "EQOpc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "GTOpc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "MVT", "::", "v4i16", ":", "case", "MVT", "::", "v8i16", ":", "EQOpc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "GTOpc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "MVT", "::", "v2i32", ":", "case", "MVT", "::", "v4i32", ":", "EQOpc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "GTOpc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "MVT", "::", "v2i64", ":", "EQOpc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "GTOpc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "}", "switch", "(", "SetCCOpcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "SETNE", ":", "Invert", "=", "true", ";", "case", "ISD", "::", "SETEQ", ":", "Opc", "=", "EQOpc", ";", "break", ";", "case", "ISD", "::", "SETLT", ":", "Swap", "=", "true", ";", "case", "ISD", "::", "SETGT", ":", "Opc", "=", "GTOpc", ";", "break", ";", "case", "ISD", "::", "SETGE", ":", "Swap", "=", "true", ";", "case", "ISD", "::", "SETLE", ":", "Opc", "=", "GTOpc", ";", "Invert", "=", "true", ";", "break", ";", "case", "ISD", "::", "SETULT", ":", "Swap", "=", "true", ";", "case", "ISD", "::", "SETUGT", ":", "Opc", "=", "GTOpc", ";", "FlipSigns", "=", "true", ";", "break", ";" ]

[ ":" ]

[ "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "FLOAT", ":", "switch", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "{", "case", "SImode", ":", "func", "=", "<STR_LIT>", "_Qp_itoq", "<STR_LIT>", ";", "break", ";", "case", "DImode", ":", "func", "=", "<STR_LIT>", "_Qp_xtoq", "<STR_LIT>", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "UNSIGNED_FLOAT", ":", "switch", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "{", "case", "SImode", ":", "func", "=", "<STR_LIT>", "_Qp_uitoq", "<STR_LIT>", ";", "break", ";", "case", "DImode", ":", "func", "=", "<STR_LIT>", "_Qp_uxtoq", "<STR_LIT>", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "FIX", ":", "switch", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "{", "case", "SImode", ":", "func", "=", "<STR_LIT>", "_Qp_qtoi", "<STR_LIT>", ";", "break", ";", "case", "DImode", ":", "func", "=", "<STR_LIT>", "_Qp_qtox", "<STR_LIT>", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "UNSIGNED_FIX" ]

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

[ "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "vec_merge", ":", "V_ALL", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_operand", ":", "V_ALL", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

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

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

[ "if", "(", "IDVal", "==", "PALMD", "::", "AssemblerDirective", ")", "return", "ParseDirectivePALMetadata", "(", ")", ";" ]

[ "if", "(", "IDVal", "==", "<STR_LIT>", ".amd_amdgpu_isa", "<STR_LIT>", ")", "return", "ParseDirectiveISAVersion", "(", ")", ";", "if", "(", "IDVal", "==", "AMDGPU", "::", "HSAMD", "::", "AssemblerDirectiveBegin", ")", "return", "ParseDirectiveHSAMetadata", "(", ")", ";", "}", "if", "(", "IDVal", "==", "<STR_LIT>", ".amdgcn_target", "<STR_LIT>", ")", "return", "ParseDirectiveAMDGCNTarget", "(", ")", ";", "if", "(", "IDVal", "==", "<STR_LIT>", ".amdgpu_lds", "<STR_LIT>", ")", "return", "ParseDirectiveAMDGPULDS", "(", ")", ";", "if", "(", "IDVal", "==", "PALMD", "::", "AssemblerDirectiveBegin", ")", "return", "ParseDirectivePALMetadataBegin", "(", ")", ";" ]

[ "}", ")" ]

[ "emit_insn", "(", "gen_andsi3", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "gen_int_mode", "(", "val", ",", "SImode", ")", ")", ")", "DONE" ]

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

[ "(", "define_predicate", "<STR_LIT>", "(", "ior", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")" ]

[ "operands", "[", "<NUM_LIT>", "]", ",", "<", "VEC_base", ">", "mode", ")" ]

[ "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", "{", "operands", "[", "<NUM_LIT>", "]", "=", "rs6000_adjust_vec_address", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", "," ]

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

[ "assert", "(", "Op", ".", "isImm", "(", ")", "&&", "<STR_LIT>", "DimMask must be an immediate", "<STR_LIT>", ")", ";", "unsigned", "Mask", "=", "Op", ".", "getImm", "(", ")", ";", "assert", "(", "Mask", "<" ]

[ ";" ]

[ "if", "(", "FramePtr", "==", "Reg", "&&", "(", "STI", ".", "isTargetDarwin", "(", ")", "||", "hasFP", "(", "MF", ")", ")", ")", "return", "true", ";", "break", ";", "case", "ARM", "::", "R9", ":", "return", "STI", ".", "isR9Reserved", "(", ")", ";", "}", "return", "false" ]

[ "<FIXS>", "tmp", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "<NUM_LIT>", "*", "i", ")", ";", "<FIXE>" ]

[ "insn", "=", "emit_insn", "(", "tmp", ")", ";", "<BUGS>", "tmp", "=", "plus_constant", "(", "stack_pointer_rtx", ",", "-", "<NUM_LIT>", "*", "i", ")", ";", "<BUGE>", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "tmp", ")", ";", "par", "[", "<NUM_LIT>", "]", "=", "tmp", ";" ]

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

[ "def", "SQRDMULHssv_2S", ":", "NeonI_ScalarXIndexedElemArith", "<", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "FPR32", ",", "FPR32", ",", "VPR64", ",", "neon_uimm1_bare", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<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", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "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>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

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

[ "vdupd_lane_s64", "(", "int64x1_t", "_", "_", "a", ",", "const", "int", "_", "_", "b", ")", "{", "_", "_", "AARCH64_LANE_CHECK", "(", "_", "_", "a", "," ]

[ ")", ",", "(", "LDRDui", "GPR64sp", ":", "$", "Rn", ",", "uimm12s8", ":", "$", "offset", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v4f16", "(", "load", "(", "am_indexed64", "GPR64sp", ":", "$", "Rn", ",", "uimm12s8", ":", "$", "offset", ")", ")" ]

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

[ "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";" ]

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

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

[ "i", "!=", "e", ";", "++", "i", ")", "{" ]

[ "OutStreamer", ".", "EmitLabel", "(", "Stub", ")", ";", "OutStreamer", ".", "EmitSymbolAttribute", "(", "RawSym", ",", "MCSA_IndirectSymbol", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "<STR_LIT>", "\\tmflr r0", "<STR_LIT>", ")", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "<STR_LIT>", "\\tbcl 20,31,", "<STR_LIT>", "+", "Twine", "(", "AnonSymbol", "->", "getName", "(", ")", ")", ")", ";", "OutStreamer", ".", "EmitLabel", "(", "AnonSymbol", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "<STR_LIT>", "\\tmflr r11", "<STR_LIT>", ")", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "<STR_LIT>", "\\taddis r11,r11,ha16(", "<STR_LIT>", "+", "Twine", "(", "LazyPtr", "->", "getName", "(", ")", ")", "+", "<STR_LIT>", "-", "<STR_LIT>", "+", "AnonSymbol", "->", "getName", "(", ")", "+", "<STR_LIT>", ")", "<STR_LIT>", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "<STR_LIT>", "\\tmtlr r0", "<STR_LIT>", ")", ")", ";", "if", "(", "isPPC64", ")", "OutStreamer", ".", "EmitRawText", "(", "<STR_LIT>", "\\tldu r12,lo16(", "<STR_LIT>", "+", "Twine", "(", "LazyPtr", "->", "getName", "(", ")", ")", "+", "<STR_LIT>", "-", "<STR_LIT>", "+", "AnonSymbol", "->", "getName", "(", ")", "+", "<STR_LIT>", ")(r11)", "<STR_LIT>", ")", ";", "else", "OutStreamer", ".", "EmitRawText", "(", "<STR_LIT>", "\\tlwzu r12,lo16(", "<STR_LIT>", "+", "Twine", "(", "LazyPtr", "->", "getName", "(", ")", ")", "+", "<STR_LIT>", "-", "<STR_LIT>", "+", "AnonSymbol", "->", "getName", "(", ")", "+", "<STR_LIT>", ")(r11)", "<STR_LIT>", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "<STR_LIT>", "\\tmtctr r12", "<STR_LIT>", ")", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "<STR_LIT>", "\\tbctr", "<STR_LIT>", ")", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "LSPSection", ")", ";", "OutStreamer", ".", "EmitLabel", "(", "LazyPtr", ")", ";", "OutStreamer", ".", "EmitSymbolAttribute", "(", "RawSym", ",", "MCSA_IndirectSymbol", ")", ";", "if", "(", "isPPC64", ")", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "<STR_LIT>", "\\t.quad dyld_stub_binding_helper", "<STR_LIT>", ")", ")", ";", "else", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "<STR_LIT>", "\\t.long dyld_stub_binding_helper", "<STR_LIT>", ")", ")", ";", "}", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "return", ";", "}", "const", "MCSection", "*", "StubSection", "=", "OutContext", ".", "getMachOSection", "(", "<STR_LIT>", "__TEXT", "<STR_LIT>", ",", "<STR_LIT>", "__symbol_stub1", "<STR_LIT>", ",", "MCSectionMachO", "::", "S_SYMBOL_STUBS", "|", "MCSectionMachO", "::", "S_ATTR_PURE_INSTRUCTIONS", ",", "<NUM_LIT>", ",", "SectionKind", "::", "getText", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "Stubs", ".", "size", "(", ")", ";" ]

[ "}" ]

[ "MCAsmParser", "&", "getParser", "(", ")", "const", "{", "return", "Parser", ";" ]

[ "IsLittle", ")", "{" ]

[ "MCII", "(", "mcii", ")", ",", "STI", "(", "sti", ")", ",", "Ctx", "(", "ctx", ")", ",", "IsLittleEndian", "(" ]

[ "static", "void", "*", "mingw32_gt_pch_get_address", "(", "size_t", "size", ",", "int", "fd", "ATTRIBUTE_UNUSED", ")", "{", "void", "*", "res", ";", "size", "=", "(", "size", "+", "va_granularity", "-", "<NUM_LIT>", ")", "&", "~", "(", "va_granularity", "-", "<NUM_LIT>", ")", ";", "if", "(", "size", ">", "pch_VA_max_size", ")", "return", "NULL", ";", "res", "=", "VirtualAlloc", "(", "NULL", ",", "pch_VA_max_size", ",", "MEM_RESERVE", "|", "MEM_TOP_DOWN", ",", "PAGE_NOACCESS", ")", ";", "if", "(", "!", "res", ")", "w32_error", "(", "_", "_", "FUNCTION__", ",", "_", "_", "FILE__", ",", "_", "_", "LINE__", ",", "<STR_LIT>", "VirtualAlloc", "<STR_LIT>", ")", ";", "else", "VirtualFree", "(", "res", ",", "<NUM_LIT>", ",", "MEM_RELEASE", ")", ";", "return", "res", ";", "}" ]

[ "Identify", "an", "address", "that", "'s", "likely", "to", "be", "free", "in", "a", "subsequent", "invocation", "of", "the", "compiler", ".", "The", "area", "should", "be", "able", "to", "hold", "SIZE", "bytes", ".", "FD", "is", "an", "open", "file", "descriptor", "if", "the", "host", "would", "like", "to", "probe", "with", "mmap", "." ]

[ "COPY_TO_REGCLASS", "(", "VMOVSDrm", "addr", ":", "$", "src", ")", ",", "VR128", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v2f64", "(", "X86vzmovl", "(", "v2f64", "(", "scalar_to_vector", "(", "loadf64", "addr", ":", "$", "src", ")", ")", ")", ")", ")", ",", "(" ]

[ "return", "SelectStore", "(", "I", ")", ";" ]

[ "if", "(", "!", "TargetSupported", ")", "return", "false", ";", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Instruction", "::", "Load", ":", "return", "SelectLoad", "(", "I", ")", ";", "case", "Instruction", "::", "Store", ":" ]

[ "}" ]

[ "static", "unsigned", "HOST_WIDE_INT", "arm_shift_truncation_mask", "(", "enum", "machine_mode", "mode", ")", "{", "return", "mode", "==", "SImode", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";" ]

[ ")", ";" ]

[ "if", "(", "Opc", "==", "ISD", "::", "TRUNCATE", "&&", "(", "Input", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "AssertSext", "||", "Input", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SIGN_EXTEND", ")", ")", "return", "addExtOrTrunc", "(", "Input", ",", "ExtOrTruncConversion", "::", "Ext", ")", ";", "LoadSDNode", "*", "InputLoad", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "Input", ")", ";", "if", "(", "InputLoad", "&&", "InputLoad", "->", "getExtensionType", "(", ")", "==", "ISD", "::", "SEXTLOAD", ")", "return", "addExtOrTrunc", "(", "Input", ",", "ExtOrTruncConversion", "::", "Ext", ")", ";", "ConstantSDNode", "*", "InputConst", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Input", ")", ";", "if", "(", "InputConst", ")", "return", "addExtOrTrunc", "(", "Input", ",", "ExtOrTruncConversion", "::", "Ext", ")", ";", "SDLoc", "dl", "(", "Input" ]

[ ")" ]

[ "(", "define_attr", "<STR_LIT>", "<STR_LIT>", "(", "const", "(", "if_then_else", "(", "symbol_ref", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>" ]

[ "A", ",", "(", "_", "_", "v8hi", ")", "_", "_", "B", ")", ";" ]

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_pmaddwd128", "(", "(", "_", "_", "v8hi", ")", "_", "_" ]

[ ")", ";" ]

[ "if", "(", "(", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "GNUEABI", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "GNUEABIHF", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "MuslEABI", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "MuslEABIHF", ")", "&&", "!", "(", "TargetTriple", ".", "isOSWindows", "(", ")", "||", "TargetTriple", ".", "isOSDarwin", "(", ")", ")", ")", "this", "->", "Options", ".", "EABIVersion", "=", "EABI", "::", "GNU", ";", "else", "this", "->", "Options", ".", "EABIVersion", "=", "EABI", "::", "EABI5", ";", "}", "if", "(", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "this", "->", "Options", ".", "NoTrapAfterNoreturn", "=", "true", ";", "}", "setSupportsDebugEntryValues", "(", "true", ")", ";", "initAsmInfo", "(", ")", ";", "setMachineOutliner", "(", "true" ]

[ "Subtarget", "->", "hasExtractInsert", "(", ")", ")", ";" ]

[ "SDValue", "MipsTargetLowering", "::", "lowerFCOPYSIGN", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "Subtarget", "->", "isGP64bit", "(", ")", ")", "return", "lowerFCOPYSIGN64", "(", "Op", ",", "DAG", ",", "Subtarget", "->", "hasExtractInsert", "(", ")", ")", ";", "return", "lowerFCOPYSIGN32", "(", "Op", ",", "DAG", "," ]

[ ";" ]

[ "unsigned", "HOST_WIDE_INT", "mask", "=", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", ";", "int", "bs0", ",", "bs1", ",", "p", ",", "len", ";", "if", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "<NUM_LIT>", ")", "return", "<STR_LIT>", "copy %1,%0", "<STR_LIT>", ";", "for", "(", "bs0", "=", "<NUM_LIT>", ";", "bs0", "<", "<NUM_LIT>", ";", "bs0", "++", ")", "if", "(", "(", "mask", "&", "(", "<NUM_LIT>", "<<", "bs0", ")", ")", "!=", "<NUM_LIT>", ")", "break", ";", "for", "(", "bs1", "=", "bs0", ";", "bs1", "<", "<NUM_LIT>", ";", "bs1", "++", ")", "if", "(", "(", "mask", "&", "(", "<NUM_LIT>", "<<", "bs1", ")", ")", "==", "<NUM_LIT>", ")", "break", ";", "gcc_assert", "(", "bs1", "==", "<NUM_LIT>", "||", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "<NUM_LIT>", "<<", "bs1", ")", ">", "mask", ")", ";", "p", "=", "<NUM_LIT>", "-", "bs0", ";", "len", "=", "bs1", "-", "bs0", ";", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "p", ")", ";", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "len", ")", ";", "return", "<STR_LIT>", "{depi|depwi} -1,%2,%3,%0", "<STR_LIT>" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_maskz_broadcastq_epi64", "(", "_", "_", "mmask8", "_", "_", "M", ",", "_", "_", "m128i", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_pbroadcastq128_mask", "(", "(", "_", "_", "v2di", ")", "_", "_", "A", ",", "(", "_", "_", "v2di", ")", "_", "mm_avx512_setzero_si128", "(", ")", ",", "_", "_", "M", ")", ";" ]

[ "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m256i", "_", "_", "A", ",", "_", "_", "m128i", "_", "_", "B", ")", "{" ]

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

[ "<FIXS>", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVgpr2gpr", ")", ",", "ARM", "::", "SP", ")", ".", "addReg", "(", "FramePtr", ")", ")", ";", "<FIXE>" ]

[ "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "MOVr", ")", ",", "ARM", "::", "SP", ")", ".", "addReg", "(", "FramePtr", ")", ".", "addImm", "(", "(", "unsigned", ")", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ";", "else", "<BUGS>", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVgpr2gpr", ")", ",", "ARM", "::", "SP", ")", ".", "addReg", "(", "FramePtr", ")", ";", "<BUGE>", "}", "}", "else", "if", "(", "NumBytes", ")", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "NumBytes", ")", ";" ]

[ "let", "accessSize", "=", "ByteAccess", ";" ]

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

[ "<FIXS>", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "getAL", "(", "CurDAG", ",", "dl", ")", ",", "<FIXE>" ]

[ "}", "else", "{", "SDValue", "Ops", "[", "]", "=", "{", "CPIdx", ",", "<BUGS>", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ",", "getAL", "(", "CurDAG", ")", ",", "<BUGE>", "CurDAG", "->", "getRegister", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ",", "CurDAG", "->", "getEntryNode", "(", ")", "}", ";" ]

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

[ "<STR_LIT>", "{", "operands", "[", "<NUM_LIT>", "]", "=", "aarch64_endian_lane_rtx", "(", "MODE", ">", "mode", ",", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "<BUGS>", "return", "<STR_LIT>", "<BUGE>", "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "::", "FP_EXTEND", ";" ]

[ "bool", "X86TargetLowering", "::", "preferScalarizeSplat", "(", "SDNode", "*", "N", ")", "const", "{", "return", "N", "->", "getOpcode", "(", ")", "!=", "ISD" ]

[ "emit_insn", "(", "gen_stack_protect_testsi", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")" ]

[ "[", "(", "set", "(", "reg", ":", "CC", "CC_REGNUM", ")", "(", "compare", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<STR_LIT>", "{", "rtx", "cc_reg", ",", "test", "#", "ifdef", "TARGET_THREAD_SSP_OFFSET", "operands", "[", "<NUM_LIT>", "]", "=", "gen_rtx_MEM", "(", "Pmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "s390_get_thread_pointer", "(", ")", ",", "GEN_INT", "(", "TARGET_THREAD_SSP_OFFSET", ")", ")", ")", "#", "endif", "if", "(", "TARGET_64BIT", ")", "emit_insn", "(", "gen_stack_protect_testdi", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "else" ]

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

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

[ "-=", "TARGET_SH4_300", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";" ]

[ "if", "(", "REG_NOTE_KIND", "(", "link", ")", "!=", "<NUM_LIT>", ")", "{", "if", "(", "REG_NOTE_KIND", "(", "link", ")", "==", "REG_DEP_ANTI", "&&", "GET_CODE", "(", "PATTERN", "(", "dep_insn", ")", ")", "==", "SET", "&&", "(", "get_attr_type", "(", "dep_insn", ")", "==", "TYPE_PT_MEDIA", "||", "get_attr_type", "(", "dep_insn", ")", "==", "TYPE_PTABS_MEDIA", ")", "&&", "get_attr_type", "(", "insn", ")", "==", "TYPE_CBRANCH_MEDIA", ")", "{", "int", "or", "ig_cost", "=", "cost", ";", "rtx", "not", "e", "=", "find_reg_note", "(", "insn", ",", "REG_BR_PROB", ",", "<NUM_LIT>", ")", ";", "rtx", "target", "=", "(", "(", "!", "not", "e", "||", "XINT", "(", "not", "e", ",", "<NUM_LIT>", ")", "*", "<NUM_LIT>", "<", "REG_BR_PROB_BASE", ")", "?", "insn", ":", "JUMP_LABEL", "(", "insn", ")", ")", ";", "cost", "--", ";", "do", "target", "=", "next_active_insn", "(", "target", ")", ";", "while", "(", "target", "&&", "!", "flow_dependent_p", "(", "target", ",", "dep_insn", ")", "&&", "--", "cost", ">", "<NUM_LIT>", ")", ";", "if", "(", "cost", ">", "or", "ig_cost", "-", "<NUM_LIT>", ")", "cost", "=", "or", "ig_cost", "-", "<NUM_LIT>", ";", "}", "else", "cost", "=", "<NUM_LIT>", ";", "}", "else", "if", "(", "get_attr_is_mac_media", "(", "insn", ")", "&&", "get_attr_is_mac_media", "(", "dep_insn", ")", ")", "cost", "=", "<NUM_LIT>", ";", "else", "if", "(", "!", "reload_completed", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ")", "==", "FLOAT", "&&", "GET_CODE", "(", "PATTERN", "(", "dep_insn", ")", ")", "==", "SET", "&&", "fp_arith_reg_operand", "(", "SET_SRC", "(", "PATTERN", "(", "dep_insn", ")", ")", ",", "VOIDmode", ")", "&&", "cost", "<", "<NUM_LIT>", ")", "cost", "=", "<NUM_LIT>", ";", "else", "if", "(", "get_attr_type", "(", "insn", ")", "==", "TYPE_JUMP_MEDIA", "&&", "!", "flow_dependent_p", "(", "insn", ",", "dep_insn", ")", ")", "cost", "--", ";", "}", "else", "if", "(", "REG_NOTE_KIND", "(", "link", ")", "==", "<NUM_LIT>", ")", "{", "enum", "attr_type", "type", ";", "rtx", "dep_set", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "<NUM_LIT>", "||", "recog_memoized", "(", "dep_insn", ")", "<", "<NUM_LIT>", ")", "return", "cost", ";", "dep_set", "=", "single_set", "(", "dep_insn", ")", ";", "if", "(", "dep_set", "&&", "MEM_P", "(", "SET_SRC", "(", "dep_set", ")", ")", "&&", "cost", ">", "<NUM_LIT>", ")", "{", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", "&&", "!", "reg_mentioned_p", "(", "SET_DEST", "(", "dep_set", ")", ",", "SET_SRC", "(", "set", ")", ")", "&&", "(", "!", "MEM_P", "(", "SET_DEST", "(", "set", ")", ")", "||", "!", "reg_mentioned_p", "(", "SET_DEST", "(", "dep_set", ")", ",", "XEXP", "(", "SET_DEST", "(", "set", ")", ",", "<NUM_LIT>", ")", ")", ")", ")", "cost", "=", "<NUM_LIT>", ";", "}", "if", "(", "CALL_P", "(", "insn", ")", ")", "{", "rtx", "call", "=", "get_call_rtx_from", "(", "insn", ")", ";", "if", "(", "call", "&&", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "call", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "UNSPEC", "||", "!", "reg_set_p", "(", "XEXP", "(", "XEXP", "(", "call", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ",", "dep_insn", ")", ")", ")", "cost", "-=", "TARGET_SH4_300", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "}", "else", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "PARALLEL", "&&", "XVECLEN", "(", "PATTERN", "(", "insn", ")", ",", "<NUM_LIT>", ")", ">=", "<NUM_LIT>", "&&", "(", "reg", "=", "sfunc_uses_reg", "(", "insn", ")", ")", ")", "{", "if", "(", "!", "reg_set_p", "(", "reg", ",", "dep_insn", ")", ")", "cost" ]

[ "let", "Pattern", "=", "pattern", ";" ]

[ "class", "VpuInstUncond", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "string", "asmstr", ",", "list", "<", "dag", ">", "pattern", "=", "[", "]", ">", ":", "VectorInstGeneric", "<", "opc", ",", "asmstr", ">", "{", "let", "OutOperandList", "=", "(", "outs", ")", ";", "let", "InOperandList", "=", "(", "ins", ")", ";" ]

[ ";" ]

[ "bool", "PTXDAGToDAGISel", "::", "SelectADDRrr", "(", "SDValue", "&", "Addr", ",", "SDValue", "&", "R1", ",", "SDValue", "&", "R2", ")", "{", "if", "(", "Addr", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "ADD", "||", "Addr", ".", "getNumOperands", "(", ")", "<", "<NUM_LIT>", "||", "isImm", "(", "Addr", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "||", "isImm", "(", "Addr", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "return", "false", ";", "assert", "(", "Addr", ".", "getValueType", "(", ")", ".", "isSimple", "(", ")", "&&", "<STR_LIT>", "Type must be simple", "<STR_LIT>", ")", ";", "R1", "=", "Addr", ";", "R2", "=", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "Addr", ".", "getValueType", "(", ")", ".", "getSimpleVT", "(", ")", ")", ";", "return", "true" ]

[ "<FIXS>", "const", "MIMetadata", "MIMD", "(", "MI", ")", ";", "<FIXE>" ]

[ "const", "TargetRegisterClass", "*", "AddrRegClass", "=", "getRegClassFor", "(", "getPointerTy", "(", "MBB", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ")", ")", ";", "const", "TargetRegisterClass", "*", "OffsetRegClass", "=", "getRegClassFor", "(", "MVT", "::", "i32", ")", ";", "<BUGS>", "const", "DebugLoc", "&", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "<BUGE>" ]

[ ";" ]

[ "d", ".", "op0", "=", "d", ".", "op1", ";", "d", ".", "one_operand_p", "=", "true", ";", "break", ";", "}", "if", "(", "d", ".", "testing_p", ")", "{", "d", ".", "target", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "<NUM_LIT>", ")", ";", "d", ".", "op1", "=", "d", ".", "op0", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "<NUM_LIT>", ")", ";", "if", "(", "!", "d", ".", "one_operand_p", ")", "d", ".", "op1", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "<NUM_LIT>", ")", ";", "start_sequence", "(", ")", ";", "bool", "ret", "=", "ia64_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "end_sequence", "(", ")", ";", "return", "ret", ";", "}", "if", "(", "ia64_expand_vec_perm_const_1", "(", "&", "d", ")", ")", "return", "true", ";", "if", "(", "which", "==", "<NUM_LIT>", "&&", "d", ".", "one_operand_p", ")", "{", "memcpy", "(", "d", ".", "perm", ",", "perm", ",", "sizeof", "(", "perm", ")", ")", ";", "d", ".", "one_operand_p", "=", "false", ";", "return", "ia64_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "}", "return", "false" ]

[ ";" ]

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

[ "<FIXS>", "VectorType", "*", "SubTp", ",", "ArrayRef", "Value", "*", ">", "=", "None", ")", ";", "<FIXE>" ]

[ "const", "Instruction", "*", "CxtI", "=", "nullptr", ")", ";", "InstructionCost", "getShuffleCost", "(", "TTI", "::", "ShuffleKind", "Kind", ",", "VectorType", "*", "Tp", ",", "ArrayRef", "int", ">", "Mask", ",", "int", "Index", ",", "<BUGS>", "VectorType", "*", "SubTp", ")", ";", "<BUGE>", "InstructionCost", "getCastInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Dst", ",", "Type", "*", "Src", ",", "TTI", "::", "CastContextHint", "CCH", ",", "TTI", "::", "TargetCostKind", "CostKind", "," ]

[ "<STR_LIT>", ")" ]

[ "(", "define_automaton" ]

[ ",", "SDValue", "&", "OffImm", ")", "{" ]

[ "bool", "SelectAddrModeIndexedU6S128", "(", "SDValue", "N", ",", "SDValue", "&", "Base" ]