Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "<FIXS>", "default", ":", "return", "-", "<NUM_LIT>", ";", "<FIXE>" ]

[ "}", "switch", "(", "RegWidth", ")", "{", "<BUGS>", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown register width", "<STR_LIT>", ")", ";", "<BUGE>", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "SGPR_32RegClassID", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "SGPR_64RegClassID", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "SReg_128RegClassID", ";" ]

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

[ "[", "(", "set", "(", "attr", "<STR_LIT>", ")", "(", "cond", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "]" ]

[ "<FIXS>", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<FIXE>" ]

[ "if", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "=", "=", "LT", "&", "&", "operands", "[", "<NUM_LIT>", "]", "=", "=", "const0_rtx", ")", "{", "<BUGS>", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "<BUGE>", "gen_rtx_ASHIFTRT", "(", "SImode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ")" ]

[ "<FIXS>", "SelectAddrRegImm", "(", "SDValue", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Disp", ")", "{", "<FIXE>", "<FIXS>", "if", "(", "SelectAddrRegReg", "(", "N", ",", "Base", ",", "Disp", ")", ")", "<FIXE>" ]

[ "bool", "MBlazeDAGToDAGISel", "::", "<BUGS>", "SelectAddrRegImm", "(", "SDValue", "N", ",", "SDValue", "&", "Disp", ",", "SDValue", "&", "Base", ")", "{", "<BUGE>", "<BUGS>", "if", "(", "SelectAddrRegReg", "(", "N", ",", "Disp", ",", "Base", ")", ")", "<BUGE>", "return", "false", ";", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", "||", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "OR", ")", "{" ]

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

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "ByteAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";" ]

[ "const", "M88kSubtarget", "*", "M88kTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "<STR_LIT>", "target-cpu", "<STR_LIT>", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "<STR_LIT>", "target-features", "<STR_LIT>", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "std", "::", "make_unique", "<", "M88kSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "O", "<<", "Str", ";" ]

[ "void", "FISCInstPrinter", "::", "printCondCode", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNum", ",", "raw_ostream", "&", "O", ")", "{", "const", "MCOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "ISD", "::", "CondCode", "CC", "=", "(", "ISD", "::", "CondCode", ")", "Op", ".", "getImm", "(", ")", ";", "const", "char", "*", "Str", "=", "FISC_condCodeToString", "(", "CC", ")", ";" ]

[ ")", ";" ]

[ "uint64_t", "CurVal", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "(", "FullSize", "-", "<NUM_LIT>", "-", "i", ")", ";", "CurVal", "|=", "static_cast", "<", "uint64_t", ">", "(", "static_cast", "<", "uint8_t", ">", "(", "Data", "[", "Offset", "+", "Idx", "]", ")", ")", "<<", "(", "i", "*", "<NUM_LIT>", ")", ";", "}", "uint64_t", "Mask", "=", "(", "static_cast", "<", "uint64_t", ">", "(", "-", "<NUM_LIT>", ")", ">>", "(", "<NUM_LIT>", "-", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ")", ")", ";", "CurVal", "|=", "Value", "&", "Mask", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "(", "FullSize", "-", "<NUM_LIT>", "-", "i" ]

[ "MachineBasicBlock", "*", "AlphaTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ",", "DenseMap", "<", "MachineBasicBlock", "*", ",", "MachineBasicBlock", "*", ">", "*", "EM", ")", "const", "{", "const", "TargetInstrInfo", "*", "TII", "=", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "assert", "(", "(", "MI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "MI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "MI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "MI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "MI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "MI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "<STR_LIT>", "Unexpected instr type to insert", "<STR_LIT>", ")", ";", "bool", "is32", "=", "MI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "MI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "MI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "::", "iterator", "It", "=", "BB", ";", "++", "It", ";", "MachineBasicBlock", "*", "thisMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "llscMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "sinkMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "for", "(", "MachineBasicBlock", "::", "succ_iterator", "I", "=", "BB", "->", "succ_begin", "(", ")", ",", "E", "=", "BB", "->", "succ_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "EM", "->", "insert", "(", "std", "::", "make_pair", "(", "*", "I", ",", "sinkMBB", ")", ")", ";", "sinkMBB", "->", "transferSuccessors", "(", "thisMBB", ")", ";", "F", "->", "insert", "(", "It", ",", "llscMBB", ")", ";", "F", "->", "insert", "(", "It", ",", "sinkMBB", ")", ";", "BuildMI", "(", "thisMBB", ",", "dl", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addMBB", "(", "llscMBB", ")", ";", "unsigned", "reg_res", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "reg_ptr", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "reg_v2", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "reg_store", "=", "F", "->", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "BuildMI", "(", "llscMBB", ",", "dl", ",", "TII", "->", "get", "(", "is32", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "reg_res", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "reg_ptr", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "unsigned", "reg_cmp", "=", "F", "->", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "BuildMI", "(", "llscMBB", ",", "dl", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "reg_cmp", ")", ".", "addReg", "(", "reg_v2", ")", ".", "addReg", "(", "reg_res", ")", ";", "BuildMI", "(", "llscMBB", ",", "dl", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "reg_cmp", ")", ".", "addMBB", "(", "sinkMBB", ")", ";", "BuildMI", "(", "llscMBB", ",", "dl", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "reg_store", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "break", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "BuildMI", "(", "llscMBB", ",", "dl", ",", "TII", "->", "get", "(", "is32", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "reg_store", ")", ".", "addReg", "(", "reg_res", ")", ".", "addReg", "(", "reg_v2", ")", ";", "break", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "BuildMI", "(", "llscMBB", ",", "dl", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "reg_store", ")", ".", "addReg", "(", "reg_v2", ")", ".", "addReg", "(", "reg_v2", ")", ";", "break", ";", "}", "}", "BuildMI", "(", "llscMBB", ",", "dl", ",", "TII", "->", "get", "(", "is32", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "reg_store", ")", ".", "addReg", "(", "reg_store", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "reg_ptr", ")", ";", "BuildMI", "(", "llscMBB", ",", "dl", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "reg_store", ")", ".", "addMBB", "(", "llscMBB", ")", ";", "BuildMI", "(", "llscMBB", ",", "dl", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addMBB", "(", "sinkMBB", ")", ";", "thisMBB", "->", "addSuccessor", "(", "llscMBB", ")", ";", "llscMBB", "->", "addSuccessor", "(", "llscMBB", ")", ";", "llscMBB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "F", "->", "DeleteMachineInstr", "(", "MI", ")", ";", "return", "sinkMBB", ";", "}" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "int", "fr30_num_arg_regs", "(", "enum", "machine_mode", "mode", ",", "tree", "type", ")", "{", "int", "size", ";", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "type", "&&", "mode", "==", "BLKmode", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "return", "(", "size", "+", "UNITS_PER_WORD", "-", "<NUM_LIT>", ")", "/", "UNITS_PER_WORD", ";", "}" ]

[ "Compute", "the", "number", "of", "word", "sized", "registers", "needed", "to", "hold", "a", "function", "argument", "of", "mode", "INT_MODE", "and", "tree", "type", "TYPE", "." ]

[ ",", "(", "vector", "signed", "int", ")", "a3", ")", ";" ]

[ "inline", "vector", "signed", "int", "vec_msum", "(", "vector", "signed", "short", "a1", ",", "vector", "signed", "short", "a2", ",", "vector", "signed", "int", "a3", ")", "{", "return", "(", "vector", "signed", "int", ")", "_", "_", "builtin_altivec_vmsumshm", "(", "(", "vector", "signed", "short", ")", "a1", ",", "(", "vector", "signed", "short", ")", "a2" ]

[ "$", "imm", ")", "]", ">", ",", "Sched", "<", "[", "WriteFImm", "]", ">", "{" ]

[ "class", "BaseFPMoveImmediate", "<", "RegisterClass", "regtype", ",", "Operand", "fpimmtype", ",", "string", "asm", ">", ":", "I", "<", "(", "outs", "regtype", ":", "$", "Rd", ")", ",", "(", "ins", "fpimmtype", ":", "$", "imm", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "regtype", ":", "$", "Rd", ",", "fpimmtype", ":" ]

[ ")" ]

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

[ "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected value type", "<STR_LIT>", ")", ";" ]

[ "case", "MVT", "::", "i1", ":", "case", "MVT", "::", "i8", ":", "return", "fastEmitInst_extractsubreg", "(", "MVT", "::", "i8", ",", "SrcReg", ",", "X86", "::", "sub_8bit", ")", ";", "case", "MVT", "::", "i16", ":", "return", "fastEmitInst_extractsubreg", "(", "MVT", "::", "i16", ",", "SrcReg", ",", "X86", "::", "sub_16bit", ")", ";", "case", "MVT", "::", "i32", ":", "return", "SrcReg", ";", "case", "MVT", "::", "i64", ":", "{", "Register", "ResultReg", "=", "createResultReg", "(", "&", "X86", "::", "GR64RegClass", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "SUBREG_TO_REG", ")", ",", "ResultReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addImm", "(", "X86", "::", "sub_32bit", ")", ";", "return", "ResultReg", ";", "}", "}", "}", "unsigned", "Opc", "=", "<NUM_LIT>", ";", "switch", "(", "VT", ".", "SimpleTy", ")", "{" ]

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

[ "return", "(", "poly8x16_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>", ";" ]

[ "def", "L2_ploadrbt_zomap", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pt4", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_5ef37dc4", ",", "TypeMAPPING", ">", "{", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isPseudo" ]

[ "<FIXS>", "if", "(", "const", "auto", "*", "CE", "=", "dyn_cast", "MCConstantExpr", ">", "(", "Memory", ".", "OffsetImm", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "CE", "->", "getValue", "(", ")", ")", ")", ";", "elseInst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "Memory", ".", "OffsetImm", ")", ")", ";", "<FIXE>" ]

[ "void", "addMemPCRelImm12Operands", "(", "MCInst", "&", "Inst", ",", "unsigned", "N", ")", "const", "{", "assert", "(", "N", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid number of operands!", "<STR_LIT>", ")", ";", "<BUGS>", "int32_t", "Imm", "=", "Memory", ".", "OffsetImm", "->", "getValue", "(", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Imm", ")", ")", ";", "<BUGE>", "}", "void", "addAdrLabelOperands", "(", "MCInst", "&", "Inst", ",", "unsigned", "N", ")", "const", "{" ]

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

[ "if", "(", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "ByVal", ")", "||", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "InReg", ")", "||", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "StructRet", ")", "||", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "Nest", ")", ")", "return", "false", ";", "Type", "*", "ArgTy", "=", "I", "->", "getType", "(", ")", ";", "if", "(", "ArgTy", "->", "isStructTy", "(", ")", "||", "ArgTy", "->", "isArrayTy", "(", ")", "||", "ArgTy", "->", "isVectorTy", "(", ")", ")", "return", "false", ";", "EVT", "ArgVT", "=", "TLI", ".", "getValueType", "(", "ArgTy", ")", ";", "if", "(", "!", "ArgVT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "switch", "(", "ArgVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "i64", ":", "break", ";", "default", ":", "return", "false", ";", "}", "}", "static", "const", "uint16_t", "GPR32ArgRegs", "[", "]", "=", "{", "X86", "::", "EDI", ",", "X86", "::", "ESI", ",", "X86", "::", "EDX", ",", "X86", "::", "ECX", ",", "X86", "::", "R8D", ",", "X86", "::", "R9D", "}", ";", "static", "const", "uint16_t", "GPR64ArgRegs", "[", "]", "=", "{", "X86", "::", "RDI", ",", "X86", "::", "RSI", ",", "X86", "::", "RDX", ",", "X86", "::", "RCX", ",", "X86", "::", "R8", ",", "X86", "::", "R9", "}", ";", "Idx", "=", "<NUM_LIT>", ";", "const", "TargetRegisterClass", "*", "RC32", "=", "TLI", ".", "getRegClassFor", "(", "MVT", "::", "i32", ")", ";", "const", "TargetRegisterClass", "*", "RC64", "=", "TLI", ".", "getRegClassFor", "(", "MVT", "::", "i64", ")", ";", "for", "(", "Function", "::", "const_arg_iterator", "I", "=", "F", "->", "arg_begin", "(", ")", ",", "E", "=", "F", "->" ]

[ "}" ]

[ "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "offset", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Rt", ";", "let", "isAuthenticated", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "M", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "offset", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "offset", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "W", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rt", ";" ]

[ "unsigned", "Opc", "=", "SlotAlign", "<", "RegAlign", "?", "Hexagon", "::", "PS_vloadrwu_ai", ":", "Hexagon", "::", "PS_vloadrw_ai", ";" ]

[ "bool", "HasAlloca", "=", "MFI", ".", "hasVarSizedObjects", "(", ")", ";", "const", "HexagonFrameLowering", "&", "HFI", "=", "*", "Subtarget", ".", "getFrameLowering", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "SlotAlign", ")", ";", "if", "(", "Hexagon", "::", "IntRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "L2_loadri_io", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "DoubleRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "L2_loadrd_io", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "PredRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "LDriw_pred", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "ModRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "LDriw_mod", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "HvxQRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "PS_vloadrq_ai", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "HvxVRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "if", "(", "HasAlloca", ")", "SlotAlign", "=", "HFI", ".", "getStackAlignment", "(", ")", ";", "unsigned", "Opc", "=", "SlotAlign", "<", "RegAlign", "?", "Hexagon", "::", "V6_vL32Ub_ai", ":", "Hexagon", "::", "V6_vL32b_ai", ";", "MachineMemOperand", "*", "MMOA", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "SlotAlign", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMOA", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "HvxWRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "if", "(", "HasAlloca", ")", "SlotAlign", "=", "HFI", ".", "getStackAlignment", "(", ")", ";" ]

[ "return", "size", "<=", "MIPS_MAX_MOVE_BYTES_STRAIGHT", ";" ]

[ "if", "(", "op", "==", "STORE_BY_PIECES", ")", "return", "mips_store_by_pieces_p", "(", "size", ",", "align", ")", ";", "if", "(", "op", "==", "MOVE_BY_PIECES", "&&", "HAVE_movmemsi", ")", "{", "if", "(", "currently_expanding_to_rtl", ")", "return", "false", ";", "if", "(", "align", "<", "BITS_PER_WORD", ")", "return", "size", "<", "UNITS_PER_WORD", ";" ]

[ "<FIXS>", "return", "<STR_LIT>", "bne\\t%2,%.,1f%#\\n\\tbreak\\t7\\n1:", "<STR_LIT>", ";", "<FIXE>" ]

[ "if", "(", "TARGET_MIPS16", ")", "return", "<STR_LIT>", "bnez\\t%2,1f\\n\\tbreak\\t7\\n1:", "<STR_LIT>", ";", "else", "<BUGS>", "return", "<STR_LIT>", "bne\\t%2,%.,1f\\n\\t%#break\\t7\\n1:", "<STR_LIT>", ";", "<BUGE>", "}", "return", "division", ";", "}" ]

[ "_", "_", "mmask32", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_permvarhi512_mask", "(", "(", "_", "_", "v32hi", ")", "_", "_", "B", ",", "(", "_", "_", "v32hi", ")", "_", "_", "A", ",", "(", "_", "_", "v32hi", ")", "_", "mm512_setzero_hi", "(", ")", ",", "(" ]

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

[ "if", "(", "ResVT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", ")", "return", "Index", "==", "<NUM_LIT>", "||", "(", "(", "ResVT", ".", "getSizeInBits", "(", ")", "==", "SrcVT", ".", "getSizeInBits", "(", ")", "*", "<NUM_LIT>", ")", "&&", "(", "Index", "==", "ResVT", ".", "getVectorNumElements", "(", ")", ")", ")", ";", "return", "(", "Index", "%", "ResVT", ".", "getVectorNumElements", "(" ]

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

[ "unsigned", "Opcode", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", ";", "(", "void", ")", "Opcode", ";", "bool", "Strict", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", "->", "isStrictFPOpcode", "(", ")", ";", "assert", "(", "(", "Opcode", "==", "ISD", "::", "FP_TO_SINT", "||", "Opcode", "==", "ISD", "::", "FP_TO_UINT", "||", "Opcode", "==", "ISD", "::", "STRICT_FP_TO_SINT", "||", "Opcode", "==", "ISD", "::", "STRICT_FP_TO_UINT", ")", "&&", "<STR_LIT>", "Not a FP_TO_INT Instruction!", "<STR_LIT>", ")", ";", "SDValue", "Val", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOperand", "(", "Strict", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "EVT", "Op1VT", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ";", "EVT", "ResVT", "=", "Val", ".", "getValueType", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "hasVSX", "(", ")", "||", "!", "Subtarget", ".", "hasFPCVT", "(", ")", "||", "!", "isTypeLegal", "(", "ResVT", ")", ")", "return", "SDValue", "(", ")", ";", "bool", "ValidTypeForStoreFltAsInt", "=", "(", "Op1VT", "==", "MVT", "::", "i32", "||", "(", "Op1VT", "==", "MVT", "::", "i64", "&&", "Subtarget", ".", "isPPC64", "(", ")", ")", "||", "(", "Subtarget", ".", "hasP9Vector", "(", ")", "&&", "(", "Op1VT", "==", "MVT", "::", "i16", "||", "Op1VT", "==", "MVT", "::", "i8", ")", ")", ")", ";", "if", "(", "ResVT", "==", "MVT", "::", "ppcf128", "||", "(", "ResVT", "==", "MVT", "::", "f128", "&&", "!", "Subtarget", ".", "hasP9Vector", "(", ")", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "(", "Op1VT", "!=", "MVT", "::", "i64", "&&", "!", "Subtarget", ".", "hasP8Vector", "(", ")", ")", "||", "cast", "<", "StoreSDNode", ">", "(", "N", ")", "->", "isTruncatingStore", "(", ")", "||", "!", "ValidTypeForStoreFltAsInt", ")", "return", "SDValue", "(", ")", ";", "Val", "=", "convertFPToInt", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ",", "Subtarget", ")", ";", "unsigned", "ByteSize", "=", "Op1VT", ".", "getScalarSizeInBits" ]

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

[ "intpc_or_label_operand", "(", "op", ",", "mode", ")", "rtx", "op", ";", "<BUGS>", "enum", "machine_mode", "mode", ";", "<BUGE>", "{", "return", "(", "GET_CODE", "(", "op", ")", "==", "PC", "||", "GET_CODE", "(", "op", ")", "==", "LABEL_REF", ")", ";", "}" ]

[ "mode", "=", "word_mode", ";" ]

[ "cum", "->", "intoffset", "=", "-", "<NUM_LIT>", ";", "if", "(", "intoffset", "%", "BITS_PER_WORD", "!=", "<NUM_LIT>", ")", "{", "mode", "=", "mode_for_size", "(", "BITS_PER_WORD", "-", "intoffset", "%", "BITS_PER_WORD", ",", "MODE_INT", ",", "<NUM_LIT>", ")", ";", "if", "(", "mode", "==", "BLKmode", ")", "{", "intoffset", "=", "intoffset", "&", "-", "BITS_PER_WORD", ";", "mode", "=", "word_mode", ";", "}", "}", "else", "mode", "=", "word_mode", ";", "startbit", "=", "intoffset", "&", "-", "BITS_PER_WORD", ";", "endbit", "=", "(", "bitpos", "+", "BITS_PER_WORD", "-", "<NUM_LIT>", ")", "&", "-", "BITS_PER_WORD", ";", "intregs", "=", "(", "endbit", "-", "startbit", ")", "/", "BITS_PER_WORD", ";", "this_regno", "=", "cum", "->", "words", "+", "intoffset", "/", "BITS_PER_WORD", ";", "if", "(", "intregs", ">", "<NUM_LIT>", "&&", "intregs", ">", "GP_ARG_NUM_REG", "-", "this_regno", ")", "cum", "->", "use_stack", "=", "<NUM_LIT>", ";", "intregs", "=", "MIN", "(", "intregs", ",", "GP_ARG_NUM_REG", "-", "this_regno", ")", ";", "if", "(", "intregs", "<=", "<NUM_LIT>", ")", "return", ";", "intoffset", "/", "=", "BITS_PER_UNIT", ";", "do", "{", "regno", "=", "GP_ARG_MIN_REG", "+", "this_regno", ";", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "rvec", "[", "(", "*", "k", ")", "++", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg", ",", "GEN_INT", "(", "intoffset", ")", ")", ";", "this_regno", "+=", "<NUM_LIT>", ";", "intoffset", "=", "(", "intoffset", "|", "(", "UNITS_PER_WORD", "-", "<NUM_LIT>", ")", ")", "+", "<NUM_LIT>", ";" ]

[ "<FIXS>", "static", "int", "avr_operand_rtx_cost", "(", "rtx", ",", "enum", "machine_mode", ",", "enum", "rtx_code", ",", "int", ",", "bool", ")", ";", "static", "bool", "avr_rtx_costs", "(", "rtx", ",", "int", ",", "int", ",", "int", ",", "int", "*", ",", "bool", ")", ";", "<FIXE>" ]

[ "static", "void", "avr_asm_out_dtor", "(", "rtx", ",", "int", ")", ";", "static", "int", "avr_register_move_cost", "(", "enum", "machine_mode", ",", "reg_class_t", ",", "reg_class_t", ")", ";", "static", "int", "avr_memory_move_cost", "(", "enum", "machine_mode", ",", "reg_class_t", ",", "bool", ")", ";", "<BUGS>", "static", "int", "avr_operand_rtx_cost", "(", "rtx", ",", "enum", "machine_mode", ",", "enum", "rtx_code", ",", "bool", ")", ";", "static", "bool", "avr_rtx_costs", "(", "rtx", ",", "int", ",", "int", ",", "int", "*", ",", "bool", ")", ";", "<BUGE>", "static", "int", "avr_address_cost", "(", "rtx", ",", "bool", ")", ";", "static", "bool", "avr_return_in_memory", "(", "const_tree", ",", "const_tree", ")", ";", "static", "struct", "machine_function", "*", "avr_init_machine_status", "(", "void", ")", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "_", "_", "m256d", "_", "_", "A", ",", "int", "_", "_", "B", ")", "{" ]

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

[ "DAG", ".", "ComputeMaskedBits", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Mask", ",", "KnownZero2", ",", "KnownOne2", ",", "Depth", "+", "<NUM_LIT>", ")", ";" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "DAG", ".", "ComputeMaskedBits", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Mask", ",", "KnownZero", ",", "KnownOne", ",", "Depth", "+", "<NUM_LIT>", ")", ";" ]

[ "assert", "(", "Subtarget", ".", "hasSVE", "(", ")", "&&", "<STR_LIT>", "Unexpected register load without SVE", "<STR_LIT>", ")", ";" ]

[ "else", "assert", "(", "DestReg", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "loadRegPairFromStackSlot", "(", "getRegisterInfo", "(", ")", ",", "MBB", ",", "MBBI", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "FI", ",", "MMO", ")", ";", "return", ";", "}", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "assert", "(", "Subtarget", ".", "hasNEON", "(", ")", "&&", "<STR_LIT>", "Unexpected register load without NEON", "<STR_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "=", "false", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "loadRegPairFromStackSlot", "(", "getRegisterInfo", "(", ")", ",", "MBB", ",", "MBBI", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "FI", ",", "MMO", ")", ";", "return", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "assert", "(", "Subtarget", ".", "hasSVE", "(", ")", "&&", "<STR_LIT>", "Unexpected register load without SVE", "<STR_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "StackID", "=", "TargetStackID", "::", "SVEVector", ";", "}", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "assert", "(", "Subtarget", ".", "hasNEON", "(", ")", "&&", "<STR_LIT>", "Unexpected register load without NEON", "<STR_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "=", "false", ";", "}", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "assert", "(", "Subtarget", ".", "hasNEON", "(", ")", "&&", "<STR_LIT>", "Unexpected register load without NEON", "<STR_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "=", "false", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "assert", "(", "Subtarget", ".", "hasNEON", "(", ")", "&&", "<STR_LIT>", "Unexpected register load without NEON", "<STR_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "=", "false", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{" ]

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

[ "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "numArgs", ";", "++", "i", ")", "argOpers", "[", "i", "]", "=", "&", "bInstr", "->", "getOperand", "(", "i", "+", "<NUM_LIT>", ")", ";", "int", "lastAddrIndx", "=", "X86", "::", "AddrNumOperands", "-", "<NUM_LIT>", ";", "int", "valArgIndx", "=", "lastAddrIndx", "+", "<NUM_LIT>", ";", "unsigned", "t1", "=", "F", "->", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "new", "MBB", ",", "dl", ",", "TII", "->", "get", "(", "LoadOpc", ")", ",", "t1", ")", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<=", "lastAddrIndx", ";", "++", "i", ")", "(", "*", "MIB", ")", ".", "addOperand", "(", "*", "argOpers", "[", "i", "]", ")", ";", "unsigned", "t2", "=", "F", "->", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ";", "assert", "(", "(", "argOpers", "[", "valArgIndx", "]", "->", "isReg", "(", ")", "||", "argOpers", "[", "valArgIndx", "]", "->", "isImm", "(", ")", ")", "&&", "<STR_LIT>", "invalid operand", "<STR_LIT>", ")", ";", "if", "(", "argOpers", "[", "valArgIndx", "]", "->", "isReg", "(", ")", ")", "MIB", "=", "BuildMI", "(", "new", "MBB", ",", "dl", ",", "TII", "->", "get", "(", "regOpc", ")", ",", "t2", ")", ";", "else", "MIB", "=", "BuildMI", "(", "new", "MBB", ",", "dl", ",", "TII", "->", "get", "(", "immOpc", ")", ",", "t2", ")", ";", "MIB", ".", "addReg", "(", "t1", ")", ";", "(", "*", "MIB", ")", ".", "addOperand", "(", "*", "argOpers", "[", "valArgIndx", "]", ")", ";", "unsigned", "t3", "=", "F", "->", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ";", "if", "(", "Invert", ")", "{", "MIB", "=", "BuildMI", "(", "new", "MBB", ",", "dl", ",", "TII", "->", "get", "(", "not", "Opc", ")", ",", "t3", ")", ".", "addReg", "(", "t2", ")", ";", "}", "else", "t3", "=", "t2", ";", "MIB", "=", "BuildMI", "(", "new", "MBB", ",", "dl", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "EAXreg", ")", ";", "MIB", ".", "addReg", "(", "t1", ")", ";", "MIB", "=", "BuildMI", "(", "new", "MBB", ",", "dl", ",", "TII", "->", "get", "(", "CXchgOpc" ]

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

[ "case", "X86", "::", "VCMPPDrri", ":", "case", "X86", "::", "VCMPPSrri", ":", "case", "X86", "::", "VCMPPDYrri", ":", "case", "X86", "::", "VCMPPSYrri", ":", "{", "unsigned", "Imm", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "&", "<NUM_LIT>", ";", "switch", "(", "Imm", ")", "{", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "return", "fixCommutedOpIndices", "(", "SrcOpIdx1", ",", "SrcOpIdx2", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "}", "return", "false", ";", "}", "default", ":", "const", "X86InstrFMA3Group", "*", "FMA3Group", "=", "X86InstrFMA3Info", "::", "getFMA3Group", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "FMA3Group", ")", "return", "findFMA3CommutedOpIndices", "(", "MI", ",", "SrcOpIdx1", ",", "SrcOpIdx2", ",", "*", "FMA3Group", ")", ";", "return", "TargetInstrInfo", "::", "findCommutedOpIndices", "(", "MI", ",", "SrcOpIdx1", "," ]

[ "bool", "AArch64TargetLowering", "::", "isEligibleForTailCallOptimization", "(", "SDValue", "Callee", ",", "CallingConv", "::", "ID", "CalleeCC", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "!", "mayTailCallThisCC", "(", "CalleeCC", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "const", "Function", "&", "CallerF", "=", "MF", ".", "getFunction", "(", ")", ";", "CallingConv", "::", "ID", "CallerCC", "=", "CallerF", ".", "getCallingConv", "(", ")", ";", "if", "(", "CallerCC", "==", "CallingConv", "::", "C", "&&", "AArch64RegisterInfo", "::", "hasSVEArgsOrReturn", "(", "&", "MF", ")", ")", "CallerCC", "=", "CallingConv", "::", "AArch64_SVE_VectorCall", ";", "bool", "CCMatch", "=", "CallerCC", "==", "CalleeCC", ";", "if", "(", "CallerCC", "==", "CallingConv", "::", "Win64", "&&", "!", "Subtarget", "->", "isTargetWindows", "(", ")", "&&", "CalleeCC", "!=", "CallingConv", "::", "Win64", ")", "return", "false", ";", "for", "(", "Function", "::", "const_arg_iterator", "i", "=", "CallerF", ".", "arg_begin", "(", ")", ",", "e", "=", "CallerF", ".", "arg_end", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "i", "->", "hasByValAttr", "(", ")", ")", "return", "false", ";", "if", "(", "i", "->", "hasInRegAttr", "(", ")", ")", "return", "false", ";", "}", "if", "(", "canGuaranteeTCO", "(", "CalleeCC", ",", "getTargetMachine", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", ")", ")", "return", "CCMatch", ";", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "{", "const", "GlobalValue", "*", "GV", "=", "G", "->", "getGlobal", "(", ")", ";", "const", "Triple", "&", "TT", "=", "getTargetMachine", "(", ")", ".", "getTargetTriple", "(", ")", ";", "if", "(", "GV", "->", "hasExternalWeakLinkage", "(", ")", "&&", "(", "!", "TT", ".", "isOSWindows", "(", ")", "||", "TT", ".", "isOSBinFormatELF", "(", ")", "||", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", ")", "return", "false", ";", "}", "assert", "(", "(", "!", "isVarArg", "||", "CalleeCC", "==", "CallingConv", "::", "C", ")", "&&", "<STR_LIT>", "Unexpected variadic calling convention", "<STR_LIT>", ")", ";", "LLVMContext", "&", "C", "=", "*", "DAG", ".", "getContext", "(", ")", ";", "if", "(", "isVarArg", "&&", "!", "Outs", ".", "empty", "(", ")", ")", "{", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CalleeCC", ",", "isVarArg", ",", "MF", ",", "ArgLocs", ",", "C", ")", ";", "CCInfo", ".", "AnalyzeCallOperands", "(", "Outs", ",", "CCAssignFnForCall", "(", "CalleeCC", ",", "true", ")", ")", ";", "for", "(", "const", "CCValAssign", "&", "ArgLoc", ":", "ArgLocs", ")", "if", "(", "!", "ArgLoc", ".", "isRegLoc", "(", ")", ")", "return", "false", ";", "}", "if", "(", "!", "CCState", "::", "resultsCompatible", "(", "CalleeCC", ",", "CallerCC", ",", "MF", ",", "C", ",", "Ins", ",", "CCAssignFnForCall", "(", "CalleeCC", ",", "isVarArg", ")", ",", "CCAssignFnForCall", "(", "CallerCC", ",", "isVarArg", ")", ")", ")", "return", "false", ";", "const", "AArch64RegisterInfo", "*", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "const", "uint32_t", "*", "CallerPreserved", "=", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "CallerCC", ")", ";", "if", "(", "!", "CCMatch", ")", "{", "const", "uint32_t", "*", "CalleePreserved", "=", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "CalleeCC", ")", ";", "if", "(", "Subtarget", "->", "hasCustomCallingConv", "(", ")", ")", "{", "TRI", "->", "UpdateCustomCallPreservedMask", "(", "MF", ",", "&", "CallerPreserved", ")", ";", "TRI", "->", "UpdateCustomCallPreservedMask", "(", "MF", ",", "&", "CalleePreserved", ")", ";", "}", "if", "(", "!", "TRI", "->", "regmaskSubsetEqual", "(", "CallerPreserved", ",", "CalleePreserved", ")", ")", "return", "false", ";", "}", "if", "(", "Outs", ".", "empty", "(", ")", ")", "return", "true", ";", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CalleeCC", ",", "isVarArg", ",", "MF", ",", "ArgLocs", ",", "C", ")", ";", "CCInfo", ".", "AnalyzeCallOperands", "(", "Outs", ",", "CCAssignFnForCall", "(", "CalleeCC", ",", "isVarArg", ")", ")", ";", "const", "AArch64FunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "if", "(", "llvm", "::", "any_of", "(", "ArgLocs", ",", "[", "]", "(", "CCValAssign", "&", "A", ")", "{", "assert", "(", "(", "A", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "Indirect", "||", "A", ".", "getValVT", "(", ")", ".", "isScalableVector", "(", ")", ")", "&&", "<STR_LIT>", "Expected value to be scalable", "<STR_LIT>", ")", ";", "return", "A", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "Indirect", ";", "}", ")", ")", "return", "false", ";", "if", "(", "CCInfo", ".", "getNextStackOffset", "(", ")", ">", "FuncInfo", "->", "getBytesInStackArgArea", "(", ")", ")", "return", "false", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "!", "parametersInCSRMatch", "(", "MRI", ",", "CallerPreserved", ",", "ArgLocs", ",", "OutVals", ")", ")", "return", "false", ";", "return", "true", ";", "}" ]

[ "Returns", "true", "if", "the", "call", "can", "be", "lowered", "as", "a", "tail", "call", "." ]

[ "for", "(", "auto", "IT", "=", "po_begin", "(", "&", "CG", ")", ";", "IT", "!=", "End", ";", "++", "IT", ")", "{" ]

[ "const", "TargetMachine", "&", "TM", "=", "TPC", "->", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "const", "MCSubtargetInfo", "&", "STI", "=", "*", "TM", ".", "getMCSubtargetInfo", "(", ")", ";", "bool", "HasIndirectCall", "=", "false", ";", "CallGraph", "CG", "=", "CallGraph", "(", "M", ")", ";", "auto", "End", "=", "po_end", "(", "&", "CG", ")", ";", "if", "(", "AMDGPU", "::", "getAMDHSACodeObjectVersion", "(", "M", ")", ">=", "AMDGPU", "::", "AMDHSA_COV5", "||", "STI", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDPAL", ")", "{", "if", "(", "!", "AssumedStackSizeForDynamicSizeObjects", ".", "getNumOccurrences", "(", ")", ")", "AssumedStackSizeForDynamicSizeObjects", "=", "<NUM_LIT>", ";", "if", "(", "!", "AssumedStackSizeForExternalCall", ".", "getNumOccurrences", "(", ")", ")", "AssumedStackSizeForExternalCall", "=", "<NUM_LIT>", ";", "}" ]

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

[ "(", "define_split", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "bswap", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "rotate", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")" ]

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

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

[ ";" ]

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

[ "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "ashiftrt", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]" ]

[ "[", "(", "parallel", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "sign_extend", ":", "SI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", ")", "]", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "ashift", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")" ]

[ ";" ]

[ "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "extra", "->", "Imm", ")", ")", ";", "}", "unsigned", "Register", "=", "PredicateTable", "[", "extra", "->", "Predicate", "]", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "Register", ")", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "extra", "->", "Polarity", ")", ")", ";", "return", "MCDisassembler", "::", "Success" ]

[ "DEBUG_FUNCTION", "void", "debug_ready_dispatch", "(", "void", ")", "{", "int", "i", ";", "int", "no_ready", "=", "number_in_ready", "(", ")", ";", "fprintf", "(", "stdout", ",", "<STR_LIT>", "Number of ready: %d\\n", "<STR_LIT>", ",", "no_ready", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "no_ready", ";", "i", "++", ")", "debug_insn_dispatch_info_file", "(", "stdout", ",", "get_ready_element", "(", "i", ")", ")", ";", "}" ]

[ "Print", "to", "STDERR", "the", "status", "of", "the", "ready", "list", "with", "respect", "to", "dispatch", "windows", "." ]

[ "<NUM_LIT>", ";" ]

[ "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "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", "=" ]

[ "<STR_LIT>", ";" ]

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

[ "&&", "X86EarlyIfConv", ";" ]

[ "return", "canUseCMOV", "(", ")" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseLongOffset", ";", "let", "accessSize", "=", "WordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isExtended", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "DecoderNamespace", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

[ ")", "_", "mm512_undefined_epi32", "(", ")", ",", "(", "_", "_", "mmask16", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_pmovzxbd512_mask", "(", "(", "_", "_", "v16qi", ")", "_", "_", "A", ",", "(", "_", "_", "v16si" ]

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

[ "return", "Error", "(", "Loc" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "gen_rtx_REG", "(", "V2DImode", ",", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "operand_subword", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "TImode", ")", "operands", "[", "<NUM_LIT>", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")" ]

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

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

[ "def", "Imm0_1AsmOperand", ":", "ImmAsmOperand", "{", "let", "Name", "=", "<STR_LIT>", ";", "}", "def", "imm0_1", ":", "Operand", "<", "i32", ">", "{", "let", "ParserMatchClass", "=", "Imm0_1AsmOperand", ";", "}", "def", "Imm0_3AsmOperand", ":", "ImmAsmOperand", "{", "let", "Name", "=", "<STR_LIT>", ";", "}", "def", "imm0_3", ":", "Operand", "<", "i32", ">", "{", "let", "ParserMatchClass", "=", "Imm0_3AsmOperand", ";", "}", "def", "Imm0_7AsmOperand", ":", "ImmAsmOperand", "{", "let", "Name", "=", "<STR_LIT>", ";", "}", "def", "imm0_7", ":", "Operand", "<", "i32", ">", ",", "ImmLeaf", "<", "i32", ",", "[", "{" ]

[ "def", "arm_i32imm", ":", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "if", "(", "Subtarget", "-", ">", "useMovt", "(", "*", "MF", ")", ")", "return", "true", ";", "return", "ARM_AM", ":", ":", "isSOImmTwoPartVal", "(", "(", "unsigned", ")", "N", "-", ">", "getZExtValue", "(", ")", ")", ";", "}", "]", ">", ";" ]

[ ";" ]

[ "if", "(", "!", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isXRegisterReserved", "(", "<NUM_LIT>", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "Must reserve x18 to use shadow call stack", "<STR_LIT>", ")", ";", "return", "true" ]

[ "machine_mode", "opmode", "=", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ";" ]

[ "rtx", "tag", ";", "if", "(", "cfun", "->", "machine", "->", "doloop_tags", "==", "<NUM_LIT>", "||", "cfun", "->", "machine", "->", "doloop_tag_from_end", "==", "is_end", ")", "{", "cfun", "->", "machine", "->", "doloop_tags", "++", ";", "cfun", "->", "machine", "->", "doloop_tag_from_end", "=", "is_end", ";", "}", "tag", "=", "GEN_INT", "(", "cfun", "->", "machine", "->", "doloop_tags", "-", "<NUM_LIT>", ")", ";" ]

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

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

[ "<FIXS>", "emit_library_call", "(", "long_int_memset_libfunc", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "<FIXE>" ]

[ "unsigned", "int", "rem", "=", "bytes", "%", "<NUM_LIT>", ";", "value_rtx", "=", "convert_to_mode", "(", "Pmode", ",", "value_rtx", ",", "<NUM_LIT>", ")", ";", "<BUGS>", "emit_library_call", "(", "long_int_memset_libfunc", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "<NUM_LIT>", ",", "<BUGE>", "dst_reg", ",", "Pmode", ",", "value_rtx", ",", "Pmode", ",", "convert_to_mode", "(", "TYPE_MODE", "(", "sizetype", ")", "," ]

[ "bool", "OR1KAsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "if", "(", "(", "Count", "%", "<NUM_LIT>", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";", "for", "(", "uint64_t", "i", "=", "<NUM_LIT>", ";", "i", "<", "Count", ";", "i", "+=", "<NUM_LIT>", ")", "OW", "->", "Write32", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

[ "<NUM_LIT>", ";" ]

[ "static", "int", "matchShuffleAsByteRotate", "(", "MVT", "VT", ",", "SDValue", "&", "V1", ",", "SDValue", "&", "V2", ",", "ArrayRef", "<", "int", ">", "Mask", ")", "{", "if", "(", "isAnyZero", "(", "Mask", ")", ")", "return", "-", "<NUM_LIT>", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "RepeatedMask", ";", "if", "(", "!", "is128BitLaneRepeatedShuffleMask", "(", "VT", ",", "Mask", ",", "RepeatedMask", ")", ")", "return", "-", "<NUM_LIT>", ";", "int", "Rotation", "=", "matchShuffleAsElementRotate", "(", "V1", ",", "V2", ",", "RepeatedMask", ")", ";", "if", "(", "Rotation", "<=", "<NUM_LIT>", ")", "return", "-" ]

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

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

[ "bool", "HasAlVars", "=", "MFI", ".", "hasVarSizedObjects", "(", ")", "&&", "MFI", ".", "getMaxAlign", "(", ")", ">", "getStackAlign", "(", ")", ";" ]

[ "unsigned", "StackSize", "=", "determineFrameLayout", "(", "MF", ",", "true", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "spillsCR", "(", "MF", ")", "||", "hasNonRISpills", "(", "MF", ")", "||", "(", "hasSpills", "(", "MF", ")", "&&", "!", "isInt", "<", "<NUM_LIT>", ">", "(", "StackSize", ")", ")", ")", "{", "const", "TargetRegisterClass", "&", "GPRC", "=", "PPC", "::", "GPRCRegClass", ";", "const", "TargetRegisterClass", "&", "G8RC", "=", "PPC", "::", "G8RCRegClass", ";", "const", "TargetRegisterClass", "&", "RC", "=", "Subtarget", ".", "isPPC64", "(", ")", "?", "G8RC", ":", "GPRC", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "Size", "=", "TRI", ".", "getSpillSize", "(", "RC", ")", ";", "Align", "Alignment", "=", "TRI", ".", "getSpillAlign", "(", "RC", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "MFI", ".", "CreateStackObject", "(", "Size", ",", "Alignment", ",", "false", ")", ")", ";" ]

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

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

[ "<STR_LIT>", ")" ]

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

[ "}" ]

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

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

[ "(", "vec_merge", ":", "VF_128", "(", "unspec", ":", "VF_128", "[", "(", "match_operand", ":", "VF_128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_RSQRT14", ")", "(", "match_operand", ":", "VF_128" ]

[ "SVEPredicateVector", ")", "return", "DiagnosticPredicateTy", "::", "NoMatch", ";" ]

[ "if", "(", "Kind", "!=", "k_Register", "||", "Reg", ".", "Kind", "!=", "RegKind", "::" ]

[ "static", "void", "xtensa_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "rtx", "this_rtx", ";", "rtx", "funexp", ";", "rtx_insn", "*", "insn", ";", "int", "this_reg_no", ";", "rtx", "temp0", "=", "gen_rtx_REG", "(", "Pmode", ",", "A9_REG", ")", ";", "const", "char", "*", "fnname", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "thunk", ")", ")", ";", "reload_completed", "=", "<NUM_LIT>", ";", "if", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", ")", "this_reg_no", "=", "<NUM_LIT>", ";", "else", "this_reg_no", "=", "<NUM_LIT>", ";", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "A0_REG", "+", "this_reg_no", ")", ";", "if", "(", "delta", ")", "xtensa_emit_add_imm", "(", "this_rtx", ",", "this_rtx", ",", "delta", ",", "temp0", ",", "false", ")", ";", "if", "(", "vcall_offset", ")", "{", "rtx", "temp1", "=", "gen_rtx_REG", "(", "Pmode", ",", "A0_REG", "+", "<NUM_LIT>", ")", ";", "rtx", "addr", "=", "temp1", ";", "emit_move_insn", "(", "temp0", ",", "gen_rtx_MEM", "(", "Pmode", ",", "this_rtx", ")", ")", ";", "if", "(", "xtensa_uimm8x4", "(", "vcall_offset", ")", ")", "addr", "=", "plus_constant", "(", "Pmode", ",", "temp0", ",", "vcall_offset", ")", ";", "else", "xtensa_emit_add_imm", "(", "temp1", ",", "temp0", ",", "vcall_offset", ",", "temp1", ",", "false", ")", ";", "emit_move_insn", "(", "temp1", ",", "gen_rtx_MEM", "(", "Pmode", ",", "addr", ")", ")", ";", "emit_insn", "(", "gen_add2_insn", "(", "this_rtx", ",", "temp1", ")", ")", ";", "}", "if", "(", "!", "TREE_USED", "(", "function", ")", ")", "{", "assemble_external", "(", "function", ")", ";", "TREE_USED", "(", "function", ")", "=", "<NUM_LIT>", ";", "}", "funexp", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "<NUM_LIT>", ")", ";", "funexp", "=", "gen_rtx_MEM", "(", "FUNCTION_MODE", ",", "funexp", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_sibcall", "(", "funexp", ",", "const0_rtx", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "insn", "=", "get_insns", "(", ")", ";", "shorten_branches", "(", "insn", ")", ";", "assemble_start_function", "(", "thunk", ",", "fnname", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "<NUM_LIT>", ")", ";", "final", "(", "insn", ",", "file", ",", "<NUM_LIT>", ")", ";", "final_end_function", "(", ")", ";", "assemble_end_function", "(", "thunk", ",", "fnname", ")", ";", "reload_completed", "=", "<NUM_LIT>", ";", "}" ]

[ "Output", "code", "to", "add", "DELTA", "to", "the", "first", "argument", ",", "and", "then", "jump", "to", "FUNCTION", ".", "Used", "for", "C++", "multiple", "inheritance", "." ]

[ "static", "rtx", "ix86_expand_sse_cmp", "(", "rtx", "dest", ",", "enum", "rtx_code", "code", ",", "rtx", "cmp_op0", ",", "rtx", "cmp_op1", ",", "rtx", "op_true", ",", "rtx", "op_false", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "machine_mode", "cmp_ops_mode", "=", "GET_MODE", "(", "cmp_op0", ")", ";", "machine_mode", "cmp_mode", ";", "bool", "maskcmp", "=", "false", ";", "rtx", "x", ";", "if", "(", "GET_MODE_SIZE", "(", "cmp_ops_mode", ")", "==", "<NUM_LIT>", ")", "{", "cmp_mode", "=", "mode_for_size", "(", "GET_MODE_NUNITS", "(", "cmp_ops_mode", ")", ",", "MODE_INT", ",", "<NUM_LIT>", ")", ";", "gcc_assert", "(", "cmp_mode", "!=", "BLKmode", ")", ";", "maskcmp", "=", "true", ";", "}", "else", "cmp_mode", "=", "cmp_ops_mode", ";", "cmp_op0", "=", "force_reg", "(", "cmp_ops_mode", ",", "cmp_op0", ")", ";", "if", "(", "!", "nonimmediate_operand", "(", "cmp_op1", ",", "cmp_ops_mode", ")", ")", "cmp_op1", "=", "force_reg", "(", "cmp_ops_mode", ",", "cmp_op1", ")", ";", "if", "(", "optimize", "||", "(", "maskcmp", "&&", "cmp_mode", "!=", "mode", ")", "||", "(", "op_true", "&&", "reg_overlap_mentioned_p", "(", "dest", ",", "op_true", ")", ")", "||", "(", "op_false", "&&", "reg_overlap_mentioned_p", "(", "dest", ",", "op_false", ")", ")", ")", "dest", "=", "gen_reg_rtx", "(", "maskcmp", "?", "cmp_mode", ":", "mode", ")", ";", "if", "(", "maskcmp", "&&", "(", "code", "==", "GT", "||", "code", "==", "EQ", ")", ")", "{", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "switch", "(", "cmp_ops_mode", ")", "{", "case", "V64QImode", ":", "gcc_assert", "(", "TARGET_AVX512BW", ")", ";", "gen", "=", "code", "==", "GT", "?", "gen_avx512bw_gtv64qi3", ":", "gen_avx512bw_eqv64qi3_1", ";", "break", ";", "case", "V32HImode", ":", "gcc_assert", "(", "TARGET_AVX512BW", ")", ";", "gen", "=", "code", "==", "GT", "?", "gen_avx512bw_gtv32hi3", ":", "gen_avx512bw_eqv32hi3_1", ";", "break", ";", "case", "V16SImode", ":", "gen", "=", "code", "==", "GT", "?", "gen_avx512f_gtv16si3", ":", "gen_avx512f_eqv16si3_1", ";", "break", ";", "case", "V8DImode", ":", "gen", "=", "code", "==", "GT", "?", "gen_avx512f_gtv8di3", ":", "gen_avx512f_eqv8di3_1", ";", "break", ";", "default", ":", "gen", "=", "NULL", ";", "}", "if", "(", "gen", ")", "{", "emit_insn", "(", "gen", "(", "dest", ",", "cmp_op0", ",", "cmp_op1", ")", ")", ";", "return", "dest", ";", "}", "}", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "cmp_mode", ",", "cmp_op0", ",", "cmp_op1", ")", ";", "if", "(", "cmp_mode", "!=", "mode", "&&", "!", "maskcmp", ")", "{", "x", "=", "force_reg", "(", "cmp_ops_mode", ",", "x", ")", ";", "convert_move", "(", "dest", ",", "x", ",", "false", ")", ";", "}", "else", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "x", ")", ")", ";", "return", "dest", ";", "}" ]

[ "Expand", "an", "sse", "vector", "comparison", ".", "Return", "the", "register", "with", "the", "result", "." ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m512d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_maskz_max_round_pd", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m512d", "_", "_", "A", ",", "_", "_", "m512d", "_", "_", "B", ",", "const", "int", "_", "_", "R", ")", "{", "return", "(", "_", "_", "m512d", ")", "_", "_", "builtin_ia32_maxpd512_mask", "(", "(", "_", "_", "v8df", ")", "_", "_", "A", ",", "(", "_", "_", "v8df", ")", "_", "_", "B", ",", "(", "_", "_", "v8df", ")", "_", "mm512_setzero_pd", "(", ")", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ",", "_", "_", "R", ")", ";" ]

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

[ "assert", "(", "needsPromotionToI32", "(", "I", ".", "getType", "(", ")", ")", "&&", "<STR_LIT>", "I does not need promotion to i32", "<STR_LIT>", ")", ";", "IRBuilder", "<", ">", "Builder", "(", "&", "I", ")", ";", "Builder", ".", "SetCurrentDebugLocation", "(", "I", ".", "getDebugLoc", "(", ")", ")", ";", "Type", "*", "I32Ty", "=", "getI32Ty", "(", "Builder", ",", "I", ".", "getType", "(", ")", ")", ";", "Value", "*", "ExtOp1", "=", "nullptr", ";", "Value", "*", "ExtOp2", "=", "nullptr", ";", "Value", "*", "ExtRes", "=", "nullptr", ";", "Value", "*", "TruncRes", "=", "nullptr", ";", "if", "(", "isSigned", "(", "I", ")", ")", "{", "ExtOp1", "=", "Builder", ".", "CreateSExt", "(", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "I32Ty", ")", ";", "ExtOp2", "=", "Builder", ".", "CreateSExt", "(", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "I32Ty", ")", ";", "}", "else", "{", "ExtOp1", "=", "Builder", ".", "CreateZExt", "(", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "I32Ty", ")", ";", "ExtOp2", "=", "Builder", ".", "CreateZExt", "(", "I", ".", "getOperand", "(", "<NUM_LIT>", ")" ]

[ "<FIXS>", "if", "(", "TREE_CODE", "(", "arg2", ")", "==", "INTEGER_CST", ")", "<FIXE>" ]

[ "arg2", "=", "fold_for_warn", "(", "arg2", ")", ";", "<BUGS>", "if", "(", "TREE_CODE", "(", "arg2", ")", "==", "INTEGER_CST", "&&", "wi", "::", "ltu_p", "(", "wi", "::", "to_wide", "(", "arg2", ")", ",", "nunits", ")", ")", "<BUGE>", "{", "switch", "(", "mode", ")", "{", "default", ":" ]

[ "void", "SIFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "MFI", ".", "hasStackObjects", "(", ")", ")", "return", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "const", "SIRegisterInfo", "&", "TRI", "=", "TII", "->", "getRegisterInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "bool", "AllSGPRSpilledToVGPRs", "=", "false", ";", "if", "(", "TRI", ".", "spillSGPRToVGPR", "(", ")", "&&", "FuncInfo", "->", "hasSpilledSGPRs", "(", ")", ")", "{", "AllSGPRSpilledToVGPRs", "=", "true", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "MachineBasicBlock", "::", "iterator", "Next", ";", "for", "(", "auto", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "Next", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "if", "(", "TII", "->", "isSGPRSpill", "(", "MI", ")", ")", "{", "int", "FI", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "addr", ")", "->", "getIndex", "(", ")", ";", "assert", "(", "MFI", ".", "getStackID", "(", "FI", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "if", "(", "FuncInfo", "->", "allocateSGPRSpillToVGPR", "(", "MF", ",", "FI", ")", ")", "{", "bool", "Spilled", "=", "TRI", ".", "eliminateSGPRToVGPRSpillFrameIndex", "(", "MI", ",", "FI", ",", "RS", ")", ";", "(", "void", ")", "Spilled", ";", "assert", "(", "Spilled", "&&", "<STR_LIT>", "failed to spill SGPR to VGPR when allocated", "<STR_LIT>", ")", ";", "}", "else", "AllSGPRSpilledToVGPRs", "=", "false", ";", "}", "}", "}", "}", "FuncInfo", "->", "removeSGPRToVGPRFrameIndices", "(", "MFI", ")", ";", "if", "(", "FuncInfo", "->", "hasNonSpillStackObjects", "(", ")", "||", "FuncInfo", "->", "hasSpilledVGPRs", "(", ")", "||", "!", "AllSGPRSpilledToVGPRs", "||", "!", "allStackObjectsAreDead", "(", "MFI", ")", ")", "{", "assert", "(", "RS", "&&", "<STR_LIT>", "RegScavenger required if spilling", "<STR_LIT>", ")", ";", "if", "(", "FuncInfo", "->", "isEntryFunction", "(", ")", ")", "{", "int", "ScavengeFI", "=", "MFI", ".", "CreateFixedObject", "(", "TRI", ".", "getSpillSize", "(", "AMDGPU", "::", "SGPR_32RegClass", ")", ",", "<NUM_LIT>", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "ScavengeFI", ")", ";", "}", "else", "{", "int", "ScavengeFI", "=", "MFI", ".", "CreateStackObject", "(", "TRI", ".", "getSpillSize", "(", "AMDGPU", "::", "SGPR_32RegClass", ")", ",", "TRI", ".", "getSpillAlignment", "(", "AMDGPU", "::", "SGPR_32RegClass", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "ScavengeFI", ")", ";", "}", "}", "}" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "}" ]

[ "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "tzcnt_u32", "(", "unsigned", "int", "_", "_", "X", ")", "{", "return", "_", "_", "builtin_ia32_tzcnt_u32", "(", "_", "_", "X", ")", ";" ]

[ "void", "sparc_emit_membar_for_model", "(", "enum", "memmodel", "model", ",", "int", "load_store", ",", "int", "before_after", ")", "{", "const", "int", "LoadLoad", "=", "<NUM_LIT>", ";", "const", "int", "StoreLoad", "=", "<NUM_LIT>", ";", "const", "int", "LoadStore", "=", "<NUM_LIT>", ";", "const", "int", "StoreStore", "=", "<NUM_LIT>", ";", "int", "mm", "=", "<NUM_LIT>", ",", "implied", "=", "<NUM_LIT>", ";", "switch", "(", "sparc_memory_model", ")", "{", "case", "SMM_SC", ":", "implied", "=", "LoadLoad", "|", "StoreLoad", "|", "LoadStore", "|", "StoreStore", ";", "break", ";", "case", "SMM_TSO", ":", "implied", "|=", "StoreStore", ";", "if", "(", "load_store", "==", "<NUM_LIT>", "&&", "before_after", "==", "<NUM_LIT>", ")", "implied", "|=", "StoreLoad", ";", "case", "SMM_PSO", ":", "implied", "|=", "LoadLoad", "|", "LoadStore", ";", "if", "(", "load_store", "==", "<NUM_LIT>", "&&", "before_after", "==", "<NUM_LIT>", ")", "implied", "|=", "StoreLoad", "|", "StoreStore", ";", "case", "SMM_RMO", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "before_after", "&", "<NUM_LIT>", ")", "{", "if", "(", "is_mm_release", "(", "model", ")", "||", "is_mm_acq_rel", "(", "model", ")", "||", "is_mm_seq_cst", "(", "model", ")", ")", "{", "if", "(", "load_store", "&", "<NUM_LIT>", ")", "mm", "|=", "LoadLoad", "|", "StoreLoad", ";", "if", "(", "load_store", "&", "<NUM_LIT>", ")", "mm", "|=", "LoadStore", "|", "StoreStore", ";", "}", "}", "if", "(", "before_after", "&", "<NUM_LIT>", ")", "{", "if", "(", "is_mm_acquire", "(", "model", ")", "||", "is_mm_acq_rel", "(", "model", ")", "||", "is_mm_seq_cst", "(", "model", ")", ")", "{", "if", "(", "load_store", "&", "<NUM_LIT>", ")", "mm", "|=", "LoadLoad", "|", "LoadStore", ";", "if", "(", "load_store", "&", "<NUM_LIT>", ")", "mm", "|=", "StoreLoad", "|", "StoreStore", ";", "}", "}", "mm", "&=", "~", "implied", ";", "if", "(", "mm", "||", "before_after", "==", "<NUM_LIT>", ")", "emit_insn", "(", "gen_membar", "(", "GEN_INT", "(", "mm", ")", ")", ")", ";", "}" ]

[ "Expand", "a", "membar", "instruction", "for", "various", "use", "cases", ".", "Both", "the", "LOAD_STORE", "and", "BEFORE_AFTER", "arguments", "of", "the", "form", "X_Y", ".", "They", "are", "two-bit", "masks", "where", "bit", "0", "indicates", "that", "X", "is", "true", ",", "and", "bit", "1", "indicates", "Y", "is", "true", "." ]

[ "void", "AMDGPUCallLowering", "::", "splitToValueTypes", "(", "MachineIRBuilder", "&", "B", ",", "const", "ArgInfo", "&", "OrigArg", ",", "SmallVectorImpl", "<", "ArgInfo", ">", "&", "SplitArgs", ",", "const", "DataLayout", "&", "DL", ",", "CallingConv", "::", "ID", "CallConv", ")", "const", "{", "const", "SITargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "SITargetLowering", ">", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "OrigArg", ".", "Ty", "->", "getContext", "(", ")", ";", "SmallVector", "<", "EVT", ",", "<NUM_LIT>", ">", "SplitVTs", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "OrigArg", ".", "Ty", ",", "SplitVTs", ")", ";", "assert", "(", "OrigArg", ".", "Regs", ".", "size", "(", ")", "==", "SplitVTs", ".", "size", "(", ")", ")", ";", "if", "(", "SplitVTs", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "return", ";", "if", "(", "SplitVTs", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "{", "SplitArgs", ".", "emplace_back", "(", "OrigArg", ".", "Regs", "[", "<NUM_LIT>", "]", ",", "SplitVTs", "[", "<NUM_LIT>", "]", ".", "getTypeForEVT", "(", "Ctx", ")", ",", "OrigArg", ".", "Flags", "[", "<NUM_LIT>", "]", ",", "OrigArg", ".", "IsFixed", ")", ";", "return", ";", "}", "assert", "(", "OrigArg", ".", "Regs", ".", "size", "(", ")", "==", "SplitVTs", ".", "size", "(", ")", "&&", "<STR_LIT>", "Regs / types mismatch", "<STR_LIT>", ")", ";", "bool", "NeedsRegBlock", "=", "TLI", ".", "functionArgumentNeedsConsecutiveRegisters", "(", "OrigArg", ".", "Ty", ",", "CallConv", ",", "false", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "SplitVTs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "Type", "*", "SplitTy", "=", "SplitVTs", "[", "i", "]", ".", "getTypeForEVT", "(", "Ctx", ")", ";", "SplitArgs", ".", "emplace_back", "(", "OrigArg", ".", "Regs", "[", "i", "]", ",", "SplitTy", ",", "OrigArg", ".", "Flags", "[", "<NUM_LIT>", "]", ",", "OrigArg", ".", "IsFixed", ")", ";", "if", "(", "NeedsRegBlock", ")", "SplitArgs", ".", "back", "(", ")", ".", "Flags", "[", "<NUM_LIT>", "]", ".", "setInConsecutiveRegs", "(", ")", ";", "}", "SplitArgs", ".", "back", "(", ")", ".", "Flags", "[", "<NUM_LIT>", "]", ".", "setInConsecutiveRegsLast", "(", ")", ";", "}" ]

[ "Break", "OrigArgInfo", "into", "one", "or", "more", "pieces", "the", "calling", "convention", "can", "process", ",", "returned", "in", "SplitArgs", "." ]

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

[ "class", "T_MType_mpy_ri", "<", "bit", "isNeg", ",", "Operand", "ImmOp", ",", "list", "<", "dag", ">", "pattern", ">", ":", "MInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs", ",", "ImmOp", ":", "$", "u8", ")", ",", "<STR_LIT>", "#", "!", "if", "(", "isNeg", ",", "<STR_LIT>", ",", "<STR_LIT>", ")", "#", "<STR_LIT>", ",", "pattern", ",", "<STR_LIT>", ",", "M_tc_3x_SLOT23", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rs", ";" ]

[ "Hexagon Constant Propagation", "<STR_LIT>", ";" ]

[ "return", "<STR_LIT>" ]

[ "else", "{" ]

[ "case", "ISD", "::", "SETUNE", ":", "case", "ISD", "::", "SETNE", ":", "case", "ISD", "::", "SETULE", ":", "case", "ISD", "::", "SETULT", ":", "case", "ISD", "::", "SETOLE", ":", "case", "ISD", "::", "SETOLT", ":", "case", "ISD", "::", "SETLE", ":", "case", "ISD", "::", "SETLT", ":", "CCOpcode", "=", "ISD", "::", "getSetCCInverse", "(", "CCOpcode", ",", "CompareVT", "==", "MVT", "::", "i32", ")", ";", "Temp", "=", "True", ";", "True", "=", "False", ";", "False", "=", "Temp", ";", "break", ";", "default", ":", "break", ";", "}", "SDValue", "SelectNode", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SELECT_CC", ",", "DL", ",", "CompareVT", ",", "Cond", ",", "Zero", ",", "True", ",", "False", ",", "DAG", ".", "getCondCode", "(", "CCOpcode", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VT", ",", "SelectNode", ")", ";", "}", "SDValue", "MinMax", "=", "LowerMinMax", "(", "Op", ",", "DAG", ")", ";", "if", "(", "MinMax", ".", "getNode", "(", ")", ")", "{", "return", "MinMax", ";", "}", "SDValue", "HWTrue", ",", "HWFalse", ";", "if", "(", "CompareVT", "==", "MVT", "::", "f32", ")", "{", "HWTrue", "=", "DAG", ".", "getConstantFP", "(", "<NUM_LIT>", ",", "CompareVT", ")", ";", "HWFalse", "=", "DAG", ".", "getConstantFP", "(", "<NUM_LIT>", ",", "CompareVT", ")", ";", "}", "else", "if", "(", "CompareVT", "==", "MVT", "::", "i32", ")", "{", "HWTrue", "=", "DAG", ".", "getConstant", "(", "-", "<NUM_LIT>", ",", "CompareVT", ")", ";", "HWFalse", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "CompareVT", ")", ";", "}" ]

[ "let", "Itinerary", "=", "IIC_LoadScalGlobalMask", ";" ]

[ "class", "LoadInst_LD_GI", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "RegisterClass", "Rdst", ",", "string", "asmstr", ",", "bit", "MaskInReg", ",", "list", "<", "dag", ">", "pattern", "=", "[", "]", ">", ":", "LoadInstGenericSrcB", "<", "opc", ",", "asmstr", ">", "{", "let", "OutOperandList", "=", "(", "outs", "Rdst", ":", "$", "dest", ")", ";", "let", "InOperandList", "=", "(", "ins", "ADRF", ":", "$", "addr", ",", "DimMask", ":", "$", "dimmask", ",", "SwitchSet", ":", "$", "sw", ",", "Rdst", ":", "$", "income", ",", "SPred", ":", "$", "pred", ")", ";" ]

[ "}" ]

[ "if", "(", "isBaseRegConflictPossible", "(", "DAG", ",", "ClobberSet", ")", ")", "return", "SDValue", "(", ")", ";", "const", "X86Subtarget", "&", "Subtarget", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "UseFSRMForMemcpy", "&&", "Subtarget", ".", "hasFSRM", "(", ")", ")", "return", "emitRepmovs", "(", "Subtarget", ",", "DAG", ",", "dl", ",", "Chain", ",", "Dst", ",", "Src", ",", "Size", ",", "MVT", "::", "i8", ")", ";", "if", "(", "ConstantSDNode", "*", "ConstantSize", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ")", "return", "emitConstantSizeRepmov", "(", "DAG", ",", "Subtarget", ",", "dl", ",", "Chain", ",", "Dst", ",", "Src", ",", "ConstantSize", "->", "getZExtValue", "(", ")", ",", "Size", ".", "getValueType", "(", ")", ",", "Alignment", ".", "value", "(", ")", ",", "isVolatile", ",", "AlwaysInline", ",", "DstPtrInfo", ",", "SrcPtrInfo", ")", ";", "return", "SDValue", "(", ")", ";" ]

[ ",", "OOL", ",", "IOL", ",", "asmstr", ">", "{" ]

[ "class", "BForm_1", "<", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "bits", "<", "<NUM_LIT>", ">", "bo", ",", "bit", "aa", ",", "bit", "lk", ",", "dag", "OOL", ",", "dag", "IOL", ",", "string", "asmstr", ">", ":", "BForm", "<", "opcode", ",", "aa", ",", "lk" ]

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

[ "[", "(", "parallel", "[", "(", "set", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "call", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "(", "return", ")" ]

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

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

[ ";" ]

[ "StringRef", "condString", "=", "token", ".", "getString", "(", ")", ";", "for", "(", "int", "i", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "i", "<=", "<STR_LIT>", "::", "<STR_LIT>", ";", "i", "++", ")", "{", "if", "(", "condString", ".", "equals", "(", "TeakCCondCodeToString", "(", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "i", ")", ")", ")", "{", "condition", "=", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "i", ";", "return", "false", ";", "}", "}", "return", "true" ]

[ "}" ]

[ "OperandMatchResultTy", "NyuziAsmParser", "::", "ParseSImm14Value", "(", "OperandVector", "&", "Operands", ")", "{", "return", "ParseImmediate", "(", "Operands", ",", "<NUM_LIT>", ",", "true", ")", ";" ]

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

[ "def", "Xrr", ":", "BaseLogicalRegPseudo", "<", "GPR64", "," ]

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

[ "(", "label_ref", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_expand", "<STR_LIT>", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

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

[ "(", "and", ":", "TF", "(", "not", ":", "TF", "(", "match_operand", ":", "TF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "TF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ ";" ]

[ "X86FrameLowering", "::", "emitStackProbeCall", "(", "*", "BB", "->", "getParent", "(", ")", ",", "*", "BB", ",", "MI", ",", "DL", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "BB" ]

[ "return", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

[ "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown condition code!", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ "}" ]

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

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

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

[ "Cost", ";" ]

[ "int", "SystemZTTIImpl", "::", "getIntrinsicInstrCost", "(", "Intrinsic", "::", "ID", "ID", ",", "Type", "*", "RetTy", ",", "ArrayRef", "<", "Type", "*", ">", "Tys", ",", "FastMathFlags", "FMF", ",", "unsigned", "ScalarizationCostPassed", ",", "const", "Instruction", "*", "I", ")", "{", "int", "Cost", "=", "getVectorIntrinsicInstrCost", "(", "ID", ",", "RetTy", ")", ";", "if", "(", "Cost", "!=", "-", "<NUM_LIT>", ")", "return" ]

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

[ "def", ":", "InstAlias", "<", "<STR_LIT>", ",", "(", "ORRv8i8", "V64", ":", "$", "dst", ",", "V64", ":", "$", "src", ",", "V64", ":", "$", "src", ")" ]

[ "<STR_LIT>", ";" ]

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

[ "void", "thumb_expand_prologue", "(", ")", "{", "HOST_WIDE_INT", "amount", "=", "(", "get_frame_size", "(", ")", "+", "current_function_outgoing_args_size", ")", ";", "unsigned", "long", "func_type", ";", "func_type", "=", "arm_current_func_type", "(", ")", ";", "if", "(", "IS_NAKED", "(", "func_type", ")", ")", "return", ";", "if", "(", "IS_INTERRUPT", "(", "func_type", ")", ")", "{", "error", "(", "<STR_LIT>", "interrupt Service Routines cannot be coded in Thumb mode", "<STR_LIT>", ")", ";", "return", ";", "}", "if", "(", "frame_pointer_needed", ")", "emit_insn", "(", "gen_movsi", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ")", ";", "if", "(", "amount", ")", "{", "amount", "=", "ROUND_UP", "(", "amount", ")", ";", "if", "(", "amount", "<", "<NUM_LIT>", ")", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "amount", ")", ")", ")", ";", "else", "{", "int", "regno", ";", "rtx", "reg", ";", "for", "(", "regno", "=", "LAST_ARG_REGNUM", "+", "<NUM_LIT>", ";", "regno", "<=", "LAST_LO_REGNUM", ";", "regno", "++", ")", "if", "(", "regs_ever_live", "[", "regno", "]", "&&", "!", "call_used_regs", "[", "regno", "]", "&&", "!", "(", "TARGET_SINGLE_PIC_BASE", "&&", "(", "regno", "==", "arm_pic_register", ")", ")", "&&", "!", "(", "frame_pointer_needed", "&&", "(", "regno", "==", "THUMB_HARD_FRAME_POINTER_REGNUM", ")", ")", ")", "break", ";", "if", "(", "regno", ">", "LAST_LO_REGNUM", ")", "{", "rtx", "spare", "=", "gen_rtx", "(", "REG", ",", "SImode", ",", "IP_REGNUM", ")", ";", "reg", "=", "gen_rtx", "(", "REG", ",", "SImode", ",", "LAST_LO_REGNUM", ")", ";", "emit_insn", "(", "gen_movsi", "(", "spare", ",", "reg", ")", ")", ";", "emit_insn", "(", "gen_prologue_use", "(", "spare", ")", ")", ";", "emit_insn", "(", "gen_movsi", "(", "reg", ",", "GEN_INT", "(", "-", "amount", ")", ")", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "reg", ")", ")", ";", "emit_insn", "(", "gen_movsi", "(", "reg", ",", "spare", ")", ")", ";", "emit_insn", "(", "gen_prologue_use", "(", "reg", ")", ")", ";", "}", "else", "{", "reg", "=", "gen_rtx", "(", "REG", ",", "SImode", ",", "regno", ")", ";", "emit_insn", "(", "gen_movsi", "(", "reg", ",", "GEN_INT", "(", "-", "amount", ")", ")", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "reg", ")", ")", ";", "}", "}", "}", "if", "(", "current_function_profile", "||", "TARGET_NO_SCHED_PRO", ")", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}" ]

[ "Generate", "the", "rest", "of", "a", "function", "'s", "prologue", "." ]

[ ")", ";" ]

[ "return", "X86SelectTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "FPExt", ":", "return", "X86SelectFPExt", "(", "I", ")", ";", "case", "Instruction", "::", "FPTrunc", ":", "return", "X86SelectFPTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "SIToFP", ":", "return", "X86SelectSIToFP", "(", "I", ")", ";", "case", "Instruction", "::", "UIToFP", ":", "return", "X86SelectUIToFP", "(", "I", ")", ";", "case", "Instruction", "::", "IntToPtr", ":", "case", "Instruction", "::", "PtrToInt", ":", "{", "EVT", "SrcVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", "->", "getType", "(", ")", ")", ";", "EVT", "DstVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "I", "->", "getType", "(", ")", ")", ";", "if", "(", "DstVT", ".", "bitsGT", "(", "SrcVT", ")", ")", "return", "X86SelectZExt", "(", "I", ")", ";", "if", "(", "DstVT", ".", "bitsLT", "(", "SrcVT", ")", ")", "return", "X86SelectTrunc", "(", "I", ")", ";", "unsigned", "Reg", "=", "getRegForValue", "(", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "Reg", "==", "<NUM_LIT>", ")", "return", "false", ";", "updateValueMap", "(", "I", ",", "Reg" ]

[ "<FIXS>", "SET_INSN_DELETED", "(", "insn", ")", ";", "<FIXE>" ]

[ "if", "(", "GET_CODE", "(", "body", ")", "==", "SET", "&&", "rtx_equal_p", "(", "SET_SRC", "(", "body", ")", ",", "SET_DEST", "(", "body", ")", ")", ")", "{", "<BUGS>", "PUT_CODE", "(", "insn", ",", "NOTE", ")", ";", "NOTE_LINE_NUMBER", "(", "insn", ")", "=", "NOTE_INSN_DELETED", ";", "NOTE_SOURCE_FILE", "(", "insn", ")", "=", "<NUM_LIT>", ";", "<BUGE>", "continue", ";", "}", "}" ]

[ "<STR_LIT>", ")" ]

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

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

[ "const", "int", "sz", "=", "GET_MODE_SIZE", "(", "GET_MODE" ]

[ "EVT", "CCVT", "=", "EVT", "::", "getIntegerVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "WavefrontSize", ")", ";" ]

[ "const", "auto", "*", "CD", "=", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "int", "CondCode", "=", "CD", "->", "getSExtValue", "(", ")", ";", "if", "(", "CondCode", "<", "FCmpInst", "::", "Predicate", "::", "FIRST_FCMP_PREDICATE", "||", "CondCode", ">", "FCmpInst", "::", "Predicate", "::", "LAST_FCMP_PREDICATE", ")", "{", "return", "DAG", ".", "getUNDEF", "(", "VT", ")", ";", "}", "SDValue", "Src0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Src1", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "CmpVT", "=", "Src0", ".", "getValueType", "(", ")", ";", "SDLoc", "SL", "(", "N", ")", ";", "if", "(", "CmpVT", "==", "MVT", "::", "f16", "&&", "!", "TLI", ".", "isTypeLegal", "(", "CmpVT", ")", ")", "{", "Src0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "SL", ",", "MVT", "::", "f32", ",", "Src0", ")", ";", "Src1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "SL", ",", "MVT", "::", "f32", ",", "Src1", ")", ";", "}", "FCmpInst", "::", "Predicate", "IcInput", "=", "static_cast", "<", "FCmpInst", "::", "Predicate", ">", "(", "CondCode", ")", ";", "ISD", "::", "CondCode", "CCOpcode", "=", "getFCmpCondCode", "(", "IcInput", ")", ";", "unsigned", "WavefrontSize", "=", "TLI", ".", "getSubtarget", "(", ")", "->", "getWavefrontSize", "(", ")", ";" ]