Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

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

[ "void", "pattern3_ppp", "(", "StackFixup", "&", "Rv", ",", "unsigned", "i", ",", "unsigned", "j", ",", "unsigned", "k", ")", "{", "Rv", "(", "StackFixup", "::", "push3", "(", "i", ",", "j", ",", "k" ]

[ "return", "Op", ";" ]

[ "static", "std", "::", "unique_ptr", "<", "SystemZOperand", ">", "createMem", "(", "MemoryKind", "MemKind", ",", "RegisterKind", "RegKind", ",", "unsigned", "Base", ",", "const", "MCExpr", "*", "Disp", ",", "unsigned", "Index", ",", "const", "MCExpr", "*", "LengthImm", ",", "unsigned", "LengthReg", ",", "SMLoc", "StartLoc", ",", "SMLoc", "EndLoc", ")", "{", "auto", "Op", "=", "make_unique", "<", "SystemZOperand", ">", "(", "KindMem", ",", "StartLoc", ",", "EndLoc", ")", ";", "Op", "->", "Mem", ".", "MemKind", "=", "MemKind", ";", "Op", "->", "Mem", ".", "RegKind", "=", "RegKind", ";", "Op", "->", "Mem", ".", "Base", "=", "Base", ";", "Op", "->", "Mem", ".", "Index", "=", "Index", ";", "Op", "->", "Mem", ".", "Disp", "=", "Disp", ";", "if", "(", "MemKind", "==", "BDLMem", ")", "Op", "->", "Mem", ".", "Length", ".", "Imm", "=", "LengthImm", ";", "if", "(", "MemKind", "==", "BDRMem", ")", "Op", "->", "Mem", ".", "Length", ".", "Reg", "=", "LengthReg", ";" ]

[ "<FIXS>", "MachineInstr", "&", "SecondLastInst", "=", "*", "I", ";", "unsigned", "SecondLastOpc", "=", "SecondLastInst", ".", "getOpcode", "(", ")", ";", "<FIXE>", "<FIXS>", "auto", "predSet", "=", "--", "I", ";", "<FIXE>", "<FIXS>", "TBB", "=", "SecondLastInst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "FBB", "=", "LastInst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "<FIXE>" ]

[ "}", "<BUGS>", "MachineInstr", "*", "SecondLastInst", "=", "I", ";", "unsigned", "SecondLastOpc", "=", "SecondLastInst", "->", "getOpcode", "(", ")", ";", "<BUGE>", "if", "(", "SecondLastOpc", "==", "AMDGPU", "::", "JUMP_COND", "&&", "LastOpc", "==", "AMDGPU", "::", "JUMP", ")", "{", "<BUGS>", "MachineInstr", "*", "predSet", "=", "--", "I", ";", "<BUGE>", "while", "(", "!", "isPredicateSetter", "(", "predSet", "->", "getOpcode", "(", ")", ")", ")", "{", "predSet", "=", "--", "I", ";", "}", "<BUGS>", "TBB", "=", "SecondLastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "FBB", "=", "LastInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "<BUGE>", "Cond", ".", "push_back", "(", "predSet", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Cond", ".", "push_back", "(", "predSet", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateReg", "(", "AMDGPU", "::", "PRED_SEL_ONE", ",", "false", ")", ")", ";" ]

[ "if", "(", "State", ".", "isVarArg", "(", ")", ")", "{" ]

[ "const", "unsigned", "Offset", "=", "State", ".", "AllocateStack", "(", "PtrByteSize", ",", "PtrByteSize", ")", ";", "const", "MVT", "RegVT", "=", "IsPPC64", "?", "MVT", "::", "i64", ":", "MVT", "::", "i32", ";", "if", "(", "unsigned", "Reg", "=", "State", ".", "AllocateReg", "(", "IsPPC64", "?", "GPR_64", ":", "GPR_32", ")", ")", "{", "if", "(", "ValVT", ".", "getSizeInBits", "(", ")", "<", "RegVT", ".", "getSizeInBits", "(", ")", ")", "LocInfo", "=", "ArgFlags", ".", "isSExt", "(", ")", "?", "CCValAssign", "::", "LocInfo", "::", "SExt", ":", "CCValAssign", "::", "LocInfo", "::", "ZExt", ";", "State", ".", "addLoc", "(", "CCValAssign", "::", "getReg", "(", "ValNo", ",", "ValVT", ",", "Reg", ",", "RegVT", ",", "LocInfo", ")", ")", ";", "}", "else", "State", ".", "addLoc", "(", "CCValAssign", "::", "getMem", "(", "ValNo", ",", "ValVT", ",", "Offset", ",", "RegVT", ",", "LocInfo", ")", ")", ";", "return", "false", ";", "}", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "{", "const", "unsigned", "StoreSize", "=", "LocVT", ".", "getStoreSize", "(", ")", ";", "const", "unsigned", "Offset", "=", "State", ".", "AllocateStack", "(", "IsPPC64", "?", "<NUM_LIT>", ":", "StoreSize", ",", "<NUM_LIT>", ")", ";", "unsigned", "FReg", "=", "State", ".", "AllocateReg", "(", "FPR", ")", ";", "if", "(", "FReg", ")", "State", ".", "addLoc", "(", "CCValAssign", "::", "getReg", "(", "ValNo", ",", "ValVT", ",", "FReg", ",", "LocVT", ",", "LocInfo", ")", ")", ";", "const", "MVT", "RegVT", "=", "IsPPC64", "?", "MVT", "::", "i64", ":", "MVT", "::", "i32", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ";", "I", "<", "StoreSize", ";", "I", "+=", "PtrByteSize", ")", "{", "if", "(", "unsigned", "Reg", "=", "State", ".", "AllocateReg", "(", "IsPPC64", "?", "GPR_64", ":", "GPR_32", ")", ")", "{", "assert", "(", "FReg", "&&", "<STR_LIT>", "An FPR should be available when a GPR is reserved.", "<STR_LIT>", ")", ";" ]

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

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

[ "bool", "ok", ";" ]

[ "int", "i", ";", "if", "(", "GET_CODE", "(", "c", ")", "!=", "CONST_DOUBLE", ")", "return", "<NUM_LIT>", ";", "mode", "=", "GET_MODE", "(", "c", ")", ";", "if", "(", "c", "==", "const_tiny_rtx", "[", "(", "int", ")", "mode", "]", "[", "<NUM_LIT>", "]", "||", "c", "==", "const_tiny_rtx", "[", "(", "int", ")", "mode", "]", "[", "<NUM_LIT>", "]", "||", "c", "==", "const_tiny_rtx", "[", "(", "int", ")", "mode", "]", "[", "<NUM_LIT>", "]", ")", "return", "<NUM_LIT>", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "c", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "{", "int", "x", "=", "<NUM_LIT>", "<<", "i", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "IRBuilder", "<", ">", "Builder", "(", "CS", ".", "getInstruction", "(", ")", ")", ";" ]

[ "FinalState", "=", "State", ";", "}", "if", "(", "InitialState", "==", "OverdefinedState", ")", "{", "Worklist", ".", "push_back", "(", "BB", ")", ";", "continue", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "X86WinEHState: ", "<STR_LIT>", "<<", "BB", "->", "getName", "(", ")", "<<", "<STR_LIT>", " InitialState=", "<STR_LIT>", "<<", "InitialState", "<<", "'", "\\n", "'", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "X86WinEHState: ", "<STR_LIT>", "<<", "BB", "->", "getName", "(", ")", "<<", "<STR_LIT>", " FinalState=", "<STR_LIT>", "<<", "FinalState", "<<", "'", "\\n", "'", ")", ";", "InitialStates", ".", "insert", "(", "{", "BB", ",", "InitialState", "}", ")", ";", "FinalStates", ".", "insert", "(", "{", "BB", ",", "FinalState", "}", ")", ";", "}", "while", "(", "!", "Worklist", ".", "empty", "(", ")", ")", "{", "BasicBlock", "*", "BB", "=", "Worklist", ".", "front", "(", ")", ";", "Worklist", ".", "pop_front", "(", ")", ";", "if", "(", "InitialStates", ".", "count", "(", "BB", ")", "!=", "<NUM_LIT>", ")", "continue", ";", "int", "PredState", "=", "getPredState", "(", "FinalStates", ",", "F", ",", "ParentBaseState", ",", "BB", ")", ";", "if", "(", "PredState", "==", "OverdefinedState", ")", "continue", ";", "InitialStates", ".", "insert", "(", "{", "BB", ",", "PredState", "}", ")", ";", "FinalStates", ".", "insert", "(", "{", "BB", ",", "PredState", "}", ")", ";", "for", "(", "BasicBlock", "*", "SuccBB", ":", "successors", "(", "BB", ")", ")", "Worklist", ".", "push_back", "(", "SuccBB", ")", ";", "}", "for", "(", "BasicBlock", "*", "BB", ":", "RPOT", ")", "{", "int", "SuccState", "=", "getSuccState", "(", "InitialStates", ",", "F", ",", "ParentBaseState", ",", "BB", ")", ";", "if", "(", "SuccState", "==", "OverdefinedState", ")", "continue", ";", "FinalStates", ".", "insert", "(", "{", "BB", ",", "SuccState", "}", ")", ";", "}", "for", "(", "BasicBlock", "*", "BB", ":", "RPOT", ")", "{", "auto", "&", "BBColors", "=", "BlockColors", "[", "BB", "]", ";", "BasicBlock", "*", "FuncletEntryBB", "=", "BBColors", ".", "front", "(", ")", ";", "if", "(", "isa", "<", "CleanupPadInst", ">", "(", "FuncletEntryBB", "->", "getFirstNonPHI", "(", ")", ")", ")", "continue", ";", "int", "PrevState", "=", "getPredState", "(", "FinalStates", ",", "F", ",", "ParentBaseState", ",", "BB", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "X86WinEHState: ", "<STR_LIT>", "<<", "BB", "->", "getName", "(", ")", "<<", "<STR_LIT>", " PrevState=", "<STR_LIT>", "<<", "PrevState", "<<", "'", "\\n", "'", ")", ";", "for", "(", "Instruction", "&", "I", ":", "*", "BB", ")", "{", "CallSite", "CS", "(", "&", "I", ")", ";", "if", "(", "!", "isStateStoreNeeded", "(", "Personality", ",", "CS", ")", ")", "continue", ";", "int", "State", "=", "getStateForCallSite", "(", "BlockColors", ",", "FuncInfo", ",", "CS", ")", ";", "if", "(", "State", "!=", "PrevState", ")", "insertStateNumberStore", "(", "&", "I", ",", "State", ")", ";", "PrevState", "=", "State", ";", "}", "auto", "EndState", "=", "FinalStates", ".", "find", "(", "BB", ")", ";", "if", "(", "EndState", "!=", "FinalStates", ".", "end", "(", ")", ")", "if", "(", "EndState", "->", "second", "!=", "PrevState", ")", "insertStateNumberStore", "(", "BB", "->", "getTerminator", "(", ")", ",", "EndState", "->", "second", ")", ";", "}", "SmallVector", "<", "CallSite", ",", "<NUM_LIT>", ">", "SetJmp3CallSites", ";", "for", "(", "BasicBlock", "*", "BB", ":", "RPOT", ")", "{", "for", "(", "Instruction", "&", "I", ":", "*", "BB", ")", "{", "CallSite", "CS", "(", "&", "I", ")", ";", "if", "(", "!", "CS", ")", "continue", ";", "if", "(", "CS", ".", "getCalledValue", "(", ")", "->", "stripPointerCasts", "(", ")", "!=", "SetJmp3", "->", "stripPointerCasts", "(", ")", ")", "continue", ";", "SetJmp3CallSites", ".", "push_back", "(", "CS", ")", ";", "}", "}", "for", "(", "CallSite", "CS", ":", "SetJmp3CallSites", ")", "{", "auto", "&", "BBColors", "=", "BlockColors", "[", "CS", "->", "getParent", "(", ")", "]", ";", "BasicBlock", "*", "FuncletEntryBB", "=", "BBColors", ".", "front", "(", ")", ";", "bool", "InCleanup", "=", "isa", "<", "CleanupPadInst", ">", "(", "FuncletEntryBB", "->", "getFirstNonPHI", "(", ")", ")", ";" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mult", ":", "SI", "(", "sign_extend", ":", "SI", "(", "vec_select", ":", "HI", "(", "match_operand", ":", "V2HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "(", "sign_extend", ":", "SI", "(", "vec_select", ":", "HI", "(", "match_operand", ":", "V2HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", ")" ]

[ "}" ]

[ "def", "GPR32", ":", "RegisterClass", "<", "<STR_LIT>", ",", "[", "i32", "]", ",", "<NUM_LIT>", ",", "(", "add", "GPR32common", ",", "WZR", ")", ">", "{", "let", "AltOrders", "=", "[", "(", "rotl", "GPR32", ",", "<NUM_LIT>", ")", "]", ";", "let", "AltOrderSelect", "=", "[", "{", "return", "<NUM_LIT>", ";", "}", "]", ";" ]

[ "}" ]

[ "iterator_range", "<", "MCInst", "::", "const_iterator", ">", "HexagonMCInstrInfo", "::", "bundleInstructions", "(", "MCInst", "const", "&", "MCI", ")", "{", "assert", "(", "isBundle", "(", "MCI", ")", ")", ";", "return", "drop_begin", "(", "MCI", ",", "bundleInstructionsOffset", ")", ";" ]

[ "SDValue", "Arg", "=", "SplitVals", "[", "realRVLocIdx", "]", ";" ]

[ "NewOut", ".", "Flags", ".", "setSplit", "(", ")", ";", "NewOut", ".", "VT", "=", "VT", ";", "unsigned", "NumElements", "=", "Out", ".", "ArgVT", ".", "getVectorNumElements", "(", ")", ";", "for", "(", "unsigned", "j", "=", "<NUM_LIT>", ";", "j", "!=", "NumElements", ";", "++", "j", ")", "{", "SDValue", "Elem", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "DL", ",", "VT", ",", "OutVals", "[", "i", "]", ",", "DAG", ".", "getConstant", "(", "j", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "SplitVals", ".", "push_back", "(", "Elem", ")", ";", "Splits", ".", "push_back", "(", "NewOut", ")", ";", "NewOut", ".", "PartOffset", "+=", "NewOut", ".", "VT", ".", "getStoreSize", "(", ")", ";", "}", "}", "else", "{", "SplitVals", ".", "push_back", "(", "OutVals", "[", "i", "]", ")", ";", "Splits", ".", "push_back", "(", "Out", ")", ";", "}", "}", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "AnalyzeReturn", "(", "CCInfo", ",", "Splits", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "RetOps", ";", "RetOps", ".", "push_back", "(", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "realRVLocIdx", "=", "<NUM_LIT>", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ",", "++", "realRVLocIdx", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "<STR_LIT>", "Can only return in registers!", "<STR_LIT>", ")", ";" ]

[ "(", "_", "_", "mmask16", ")", "_", "_", "U", ",", "_", "_", "R", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "mmask16", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_mask_cmp_round_ps_mask", "(", "_", "_", "mmask16", "_", "_", "U", ",", "_", "_", "m512", "_", "_", "X", ",", "_", "_", "m512", "_", "_", "Y", ",", "const", "int", "_", "_", "P", ",", "const", "int", "_", "_", "R", ")", "{", "return", "(", "_", "_", "mmask16", ")", "_", "_", "builtin_ia32_cmpps512_mask", "(", "(", "_", "_", "v16sf", ")", "_", "_", "X", ",", "(", "_", "_", "v16sf", ")", "_", "_", "Y", ",", "_", "_", "P", "," ]

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

[ "let", "isPredicatedFalse", "=", "<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", "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>", ";", "let", "opNewValue" ]

[ "SrcOp", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", ")", ";" ]

[ "if", "(", "(", "ExtVT", "!=", "MVT", "::", "i64", "||", "Subtarget", "->", "is64Bit", "(", ")", ")", "&&", "SrcOp", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SCALAR_TO_VECTOR", "&&", "SrcOp", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BITCAST", "&&", "SrcOp", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", "==", "ExtVT", ")", "{", "OpVT", "=", "(", "OpVT", "==", "MVT", "::", "v2f64", ")", "?", "MVT", "::", "v2i64", ":", "MVT", "::", "v4i32", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "VT", ",", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "OpVT", ",", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "dl", ",", "OpVT", "," ]

[ "let", "isAsCheapAsAMove", "=", "<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>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isPredicable", "=", "<NUM_LIT>", ";", "let", "isReMaterializable", "=", "<NUM_LIT>", ";" ]

[ ";" ]

[ "initializeAArch64DeadRegisterDefinitionsPass", "(", "*", "PR", ")", ";", "initializeAArch64ExpandPseudoPass", "(", "*", "PR", ")", ";", "initializeAArch64LoadStoreOptPass", "(", "*", "PR", ")", ";", "initializeAArch64SIMDInstrOptPass", "(", "*", "PR", ")", ";", "initializeAArch64PreLegalizerCombinerPass", "(", "*", "PR", ")", ";", "initializeAArch64PromoteConstantPass", "(", "*", "PR", ")", ";", "initializeAArch64RedundantCopyEliminationPass", "(", "*", "PR", ")", ";", "initializeAArch64StorePairSuppressPass", "(", "*", "PR", ")", ";", "initializeFalkorHWPFFixPass", "(", "*", "PR", ")", ";", "initializeFalkorMarkStridedAccessesLegacyPass", "(", "*", "PR", ")", ";", "initializeLDTLSCleanupPass", "(", "*", "PR", ")" ]

[ "ARM", "::", "t2LDRi12", ")", ",", "NewDestReg", ")", ".", "addReg", "(", "DestReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";" ]

[ "const", "TargetRegisterClass", "*", "RC", "=", "isThumb2", "?", "&", "ARM", "::", "rGPRRegClass", ":", "&", "ARM", "::", "GPRRegClass", ";", "unsigned", "DestReg", "=", "createResultReg", "(", "RC", ")", ";", "const", "GlobalVariable", "*", "GVar", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GV", ")", ";", "bool", "IsThreadLocal", "=", "GVar", "&&", "GVar", "->", "isThreadLocal", "(", ")", ";", "if", "(", "!", "Subtarget", "->", "isTargetMachO", "(", ")", "&&", "IsThreadLocal", ")", "return", "<NUM_LIT>", ";", "bool", "IsPositionIndependent", "=", "isPositionIndependent", "(", ")", ";", "if", "(", "Subtarget", "->", "useMovt", "(", "*", "FuncInfo", ".", "MF", ")", "&&", "(", "Subtarget", "->", "isTargetMachO", "(", ")", "||", "!", "IsPositionIndependent", ")", ")", "{", "unsigned", "Opc", ";", "unsigned", "char", "TF", "=", "<NUM_LIT>", ";", "if", "(", "Subtarget", "->", "isTargetMachO", "(", ")", ")", "TF", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "IsPositionIndependent", ")", "Opc", "=", "isThumb2", "?", "ARM", "::", "t2MOV_ga_pcrel", ":", "ARM", "::", "MOV_ga_pcrel", ";", "else", "Opc", "=", "isThumb2", "?", "ARM", "::", "t2MOVi32imm", ":", "ARM", "::", "MOVi32imm", ";", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addGlobalAddress", "(", "GV", ",", "<NUM_LIT>", ",", "TF", ")", ")", ";", "}", "else", "{", "unsigned", "Align", "=", "DL", ".", "getPrefTypeAlignment", "(", "GV", "->", "getType", "(", ")", ")", ";", "if", "(", "Align", "==", "<NUM_LIT>", ")", "{", "Align", "=", "DL", ".", "getTypeAllocSize", "(", "GV", "->", "getType", "(", ")", ")", ";", "}", "if", "(", "Subtarget", "->", "isTargetELF", "(", ")", "&&", "IsPositionIndependent", ")", "return", "ARMLowerPICELF", "(", "GV", ",", "Align", ",", "VT", ")", ";", "unsigned", "PCAdj", "=", "IsPositionIndependent", "?", "(", "Subtarget", "->", "isThumb", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ":", "<NUM_LIT>", ";", "unsigned", "Id", "=", "AFI", "->", "createPICLabelUId", "(", ")", ";", "ARMConstantPoolValue", "*", "CPV", "=", "ARMConstantPoolConstant", "::", "Create", "(", "GV", ",", "Id", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "PCAdj", ")", ";", "unsigned", "Idx", "=", "MCP", ".", "getConstantPoolIndex", "(", "CPV", ",", "Align", ")", ";", "MachineInstrBuilder", "MIB", ";", "if", "(", "isThumb2", ")", "{", "unsigned", "Opc", "=", "IsPositionIndependent", "?", "ARM", "::", "t2LDRpci_pic", ":", "ARM", "::", "t2LDRpci", ";", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ";", "if", "(", "IsPositionIndependent", ")", "MIB", ".", "addImm", "(", "Id", ")", ";", "AddOptionalDefs", "(", "MIB", ")", ";", "}", "else", "{", "DestReg", "=", "constrainOperandRegClass", "(", "TII", ".", "get", "(", "ARM", "::", "LDRcp", ")", ",", "DestReg", ",", "<NUM_LIT>", ")", ";", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "ARM", "::", "LDRcp", ")", ",", "DestReg", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "AddOptionalDefs", "(", "MIB", ")", ";", "if", "(", "IsPositionIndependent", ")", "{", "unsigned", "Opc", "=", "IsIndirect", "?", "ARM", "::", "PICLDR", ":", "ARM", "::", "PICADD", ";", "unsigned", "NewDestReg", "=", "createResultReg", "(", "TLI", ".", "getRegClassFor", "(", "VT", ")", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "NewDestReg", ")", ".", "addReg", "(", "DestReg", ")", ".", "addImm", "(", "Id", ")", ";", "AddOptionalDefs", "(", "MIB", ")", ";", "return", "NewDestReg", ";", "}", "}", "}", "if", "(", "IsIndirect", ")", "{", "MachineInstrBuilder", "MIB", ";", "unsigned", "NewDestReg", "=", "createResultReg", "(", "TLI", ".", "getRegClassFor", "(", "VT", ")", ")", ";", "if", "(", "isThumb2", ")", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(" ]

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

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

[ "SmallVector", "<", "MachineInstr", "*", ",", "<NUM_LIT>", ">", "&", "Lds", "=", "Base2LdsMap", "[", "Base", "]", ";" ]

[ "if", "(", "isLd", ")", "{", "DenseMap", "<", "unsigned", ",", "SmallVector", "<", "MachineInstr", "*", ",", "<NUM_LIT>", ">", ">", "::", "iterator", "BI", "=", "Base2LdsMap", ".", "find", "(", "Base", ")", ";", "if", "(", "BI", "!=", "Base2LdsMap", ".", "end", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "BI", "->", "second", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "Offset", "==", "getMemoryOpOffset", "(", "BI", "->", "second", "[", "i", "]", ")", ")", "{", "StopHere", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "StopHere", ")", "BI", "->", "second", ".", "push_back", "(", "MI", ")", ";", "}", "else", "{", "SmallVector", "<", "MachineInstr", "*", ",", "<NUM_LIT>", ">", "MIs", ";", "MIs", ".", "push_back", "(", "MI", ")", ";", "Base2LdsMap", "[", "Base", "]", "=", "MIs", ";", "LdBases", ".", "push_back", "(", "Base", ")", ";", "}", "}", "else", "{", "DenseMap", "<", "unsigned", ",", "SmallVector", "<", "MachineInstr", "*", ",", "<NUM_LIT>", ">", ">", "::", "iterator", "BI", "=", "Base2StsMap", ".", "find", "(", "Base", ")", ";", "if", "(", "BI", "!=", "Base2StsMap", ".", "end", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "BI", "->", "second", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "Offset", "==", "getMemoryOpOffset", "(", "BI", "->", "second", "[", "i", "]", ")", ")", "{", "StopHere", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "StopHere", ")", "BI", "->", "second", ".", "push_back", "(", "MI", ")", ";", "}", "else", "{", "SmallVector", "<", "MachineInstr", "*", ",", "<NUM_LIT>", ">", "MIs", ";", "MIs", ".", "push_back", "(", "MI", ")", ";", "Base2StsMap", "[", "Base", "]", "=", "MIs", ";", "StBases", ".", "push_back", "(", "Base", ")", ";", "}", "}", "if", "(", "StopHere", ")", "{", "--", "Loc", ";", "break", ";", "}", "}", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "LdBases", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Base", "=", "LdBases", "[", "i", "]", ";" ]

[ "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";" ]

[ "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "get", "(", "Opcode", ")", ".", "getSize", "(", ")", ";", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", "<NUM_LIT>", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "{" ]

[ "Hexagon", "::", "V6_vL32b_ai_128B", ";" ]

[ "unsigned", "DstR", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "DstHi", "=", "HRI", ".", "getSubReg", "(", "DstR", ",", "Hexagon", "::", "subreg_hireg", ")", ";", "unsigned", "DstLo", "=", "HRI", ".", "getSubReg", "(", "DstR", ",", "Hexagon", "::", "subreg_loreg", ")", ";", "int", "FI", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "bool", "Is128B", "=", "HST", ".", "useHVXDblOps", "(", ")", ";", "auto", "*", "RC", "=", "!", "Is128B", "?", "&", "Hexagon", "::", "VectorRegsRegClass", ":", "&", "Hexagon", "::", "VectorRegs128BRegClass", ";", "unsigned", "Size", "=", "RC", "->", "getSize", "(", ")", ";", "unsigned", "NeedAlign", "=", "RC", "->", "getAlignment", "(", ")", ";", "unsigned", "HasAlign", "=", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ";", "unsigned", "LoadOpc", ";", "if", "(", "NeedAlign", "<=", "HasAlign", ")", "LoadOpc", "=", "!", "Is128B", "?", "Hexagon", "::", "V6_vL32b_ai", ":", "Hexagon", "::", "V6_vL32b_ai_128B", ";", "else", "LoadOpc", "=", "!", "Is128B", "?", "Hexagon", "::", "V6_vL32Ub_ai", ":", "Hexagon", "::", "V6_vL32Ub_ai_128B", ";", "BuildMI", "(", "B", ",", "It", ",", "DL", ",", "HII", ".", "get", "(", "LoadOpc", ")", ",", "DstLo", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "setMemRefs", "(", "MI", "->", "memoperands_begin", "(", ")", ",", "MI", "->", "memoperands_end", "(", ")", ")", ";", "if", "(", "NeedAlign", "<=", "MinAlign", "(", "HasAlign", ",", "Size", ")", ")", "LoadOpc", "=", "!", "Is128B", "?", "Hexagon", "::", "V6_vL32b_ai", ":" ]

[ "def", "z_storebswap64", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "src", ",", "node", ":", "$", "addr", ")", ",", "(", "z_storebswap", "node", ":", "$", "src", ",", "node", ":", "$", "addr", ")", ",", "[", "{" ]

[ "return", "cast", "<", "MemIntrinsicSDNode", ">", "(", "N", ")", "-", ">", "getMemoryVT", "(", ")", "=", "=", "MVT", ":", ":", "i64", ";", "}", "]", ">", ";", "def", "z_storebswap16", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "src", ",", "node", ":", "$", "addr", ")", ",", "(", "z_storebswap", "node", ":", "$", "src", ",", "node", ":", "$", "addr", ")", ",", "[", "{", "return", "cast", "<", "MemIntrinsicSDNode", ">", "(", "N", ")", "-", ">", "getMemoryVT", "(", ")", "=", "=", "MVT", ":", ":", "i16", ";", "}", "]", ">", ";", "def", "z_storebswap32", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "src", ",", "node", ":", "$", "addr", ")", ",", "(", "z_storebswap", "node", ":", "$", "src", ",", "node", ":", "$", "addr", ")", ",", "[", "{", "return", "cast", "<", "MemIntrinsicSDNode", ">", "(", "N", ")", "-", ">", "getMemoryVT", "(", ")", "=", "=", "MVT", ":", ":", "i32", ";", "}", "]", ">", ";" ]

[ "setOperationAction", "(", "ISD", "::", "CTPOP", ",", "MVT", "::", "i64", ",", "Custom", ")", ";" ]

[ "setOperationAction", "(", "ISD", "::", "SREM", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UREM", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SDIV", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UDIV", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SDIVREM", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UDIVREM", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SREM", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UREM", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SDIV", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UDIV", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SDIVREM", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UDIVREM", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SREM", ",", "MVT", "::", "i128", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UREM", ",", "MVT", "::", "i128", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SDIV", ",", "MVT", "::", "i128", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UDIV", ",", "MVT", "::", "i128", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SDIVREM", ",", "MVT", "::", "i128", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UDIVREM", ",", "MVT", "::", "i128", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FSIN", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FCOS", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FREM", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FSIN", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FCOS", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FREM", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FSQRT", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FSQRT", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FMA", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FMA", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FCOPYSIGN", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FCOPYSIGN", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ROTR", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ROTR", ",", "MVT", "::", "i16", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ROTR", ",", "MVT", "::", "i8", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ROTL", ",", "MVT", "::", "i32", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "ROTL", ",", "MVT", "::", "i16", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "ROTL", ",", "MVT", "::", "i8", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SHL", ",", "MVT", "::", "i8", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SRL", ",", "MVT", "::", "i8", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SRA", ",", "MVT", "::", "i8", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SHL", ",", "MVT", "::", "i64", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SRL", ",", "MVT", "::", "i64", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SRA", ",", "MVT", "::", "i64", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "MUL", ",", "MVT", "::", "i8", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "MUL", ",", "MVT", "::", "i32", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "MUL", ",", "MVT", "::", "i64", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "UMUL_LOHI", ",", "MVT", "::", "i8", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SMUL_LOHI", ",", "MVT", "::", "i8", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "MULHU", ",", "MVT", "::", "i8", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "MULHS", ",", "MVT", "::", "i8", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UMUL_LOHI", ",", "MVT", "::", "i16", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SMUL_LOHI", ",", "MVT", "::", "i16", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "MULHU", ",", "MVT", "::", "i16", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "MULHS", ",", "MVT", "::", "i16", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UMUL_LOHI", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SMUL_LOHI", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "MULHU", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "MULHS", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UMUL_LOHI", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SMUL_LOHI", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "MULHU", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "MULHS", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ADD", ",", "MVT", "::", "i8", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "ADD", ",", "MVT", "::", "i64", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SUB", ",", "MVT", "::", "i8", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SUB", ",", "MVT", "::", "i64", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "BSWAP", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "BSWAP", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "CTPOP", ",", "MVT", "::", "i8", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "CTPOP", ",", "MVT", "::", "i16", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "CTPOP", ",", "MVT", "::", "i32", ",", "Custom", ")", ";" ]

[ "::", "UNKNOWN", ")", "{" ]

[ "size_t", "Next", "=", "Name", ".", "find", "(", "'", ".", "'", ")", ";", "StringRef", "Mnemonic", "=", "Name", ";", "bool", "IsBRR", "=", "false", ";", "if", "(", "Name", ".", "endswith", "(", "<STR_LIT>", ".r", "<STR_LIT>", ")", ")", "{", "Mnemonic", "=", "Name", ".", "substr", "(", "<NUM_LIT>", ",", "Name", ".", "size", "(", ")", "-", "<NUM_LIT>", ")", ";", "IsBRR", "=", "true", ";", "}", "if", "(", "Mnemonic", "[", "<NUM_LIT>", "]", "==", "'", "b", "'", "||", "(", "Mnemonic", "[", "<NUM_LIT>", "]", "==", "'", "s", "'", "&&", "!", "Mnemonic", ".", "startswith", "(", "<STR_LIT>", "sel", "<STR_LIT>", ")", "&&", "!", "Mnemonic", ".", "startswith", "(", "<STR_LIT>", "st", "<STR_LIT>", ")", ")", ")", "{", "LPCC", "::", "CondCode", "CondCode", "=", "LPCC", "::", "suffixToLanaiCondCode", "(", "Mnemonic", ".", "substr", "(", "<NUM_LIT>", ",", "Next", ")", ")", ";", "if", "(", "CondCode", "!=", "LPCC" ]

[ "<FIXS>", "&", "has_cxx_zero_width_bf", ",", "&", "has_cxx17_empty_base", ")", ";", "<FIXE>" ]

[ "mode", "=", "promote_function_mode", "(", "valtype", ",", "mode", ",", "&", "unsigned_p", ",", "func", ",", "<NUM_LIT>", ")", ";", "bool", "has_cxx_zero_width_bf", "=", "false", ";", "int", "use_fpr", "=", "mips_fpr_return_fields", "(", "valtype", ",", "fields", ",", "<BUGS>", "&", "has_cxx_zero_width_bf", ")", ";", "<BUGE>", "if", "(", "TARGET_HARD_FLOAT", "&&", "warn_psabi", "&&", "has_cxx_zero_width_bf", "&&", "use_fpr", "!=", "<NUM_LIT>", ")", "{", "static", "unsigned", "last_reported_type_uid", ";" ]

[ "=", "L_bit", ";" ]

[ "def", "SDB_UPD", ":", "AXSI4", "<", "(", "outs", "GPR", ":", "$", "wb", ")", ",", "(", "ins", "GPR", ":", "$", "Rn", ",", "pred", ":", "$", "p", ",", "spr_reglist", ":", "$", "regs", ",", "variable_ops", ")", ",", "IndexModeUpd", ",", "itin_upd", ",", "!", "strconcat", "(", "asm", ",", "<STR_LIT>", ")", ",", "<STR_LIT>", ",", "[", "]", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}" ]

[ "<FIXS>", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "<FIXE>", "<FIXS>", "switch", "(", "ConstraintID", ")", "{", "case", "InlineAsm", "::", "Constraint_o", ":", "case", "InlineAsm", "::", "Constraint_v", ":", "<FIXE>", "<FIXS>", "case", "InlineAsm", "::", "Constraint_m", ":", "<FIXE>" ]

[ "bool", "HexagonDAGToDAGISel", "::", "<BUGS>", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "<BUGE>", "std", "::", "vector", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Inp", "=", "Op", ",", "Res", ";", "<BUGS>", "switch", "(", "ConstraintCode", ")", "{", "case", "'", "o", "'", ":", "case", "'", "v", "'", ":", "<BUGE>", "default", ":", "return", "true", ";", "<BUGS>", "case", "'", "m", "'", ":", "<BUGE>", "if", "(", "SelectAddrFI", "(", "Inp", ",", "Res", ")", ")", "OutOps", ".", "push_back", "(", "Res", ")", ";", "else" ]

[ "static", "void", "mips_avoid_hazard", "(", "rtx_insn", "*", "after", ",", "rtx_insn", "*", "insn", ",", "int", "*", "hilo_delay", ",", "rtx", "*", "delayed_reg", ",", "rtx", "lo_reg", ")", "{", "rtx", "pattern", ",", "set", ";", "int", "nops", ",", "ninsns", ";", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "ASM_INPUT", "||", "asm_noperands", "(", "pattern", ")", ">=", "<NUM_LIT>", ")", "cfun", "->", "machine", "->", "all_noreorder_p", "=", "false", ";", "ninsns", "=", "get_attr_length", "(", "insn", ")", "/", "<NUM_LIT>", ";", "if", "(", "ninsns", "==", "<NUM_LIT>", ")", "return", ";", "if", "(", "*", "hilo_delay", "<", "<NUM_LIT>", "&&", "reg_set_p", "(", "lo_reg", ",", "pattern", ")", ")", "nops", "=", "<NUM_LIT>", "-", "*", "hilo_delay", ";", "else", "if", "(", "*", "delayed_reg", "!=", "<NUM_LIT>", "&&", "reg_referenced_p", "(", "*", "delayed_reg", ",", "pattern", ")", ")", "nops", "=", "<NUM_LIT>", ";", "else", "nops", "=", "<NUM_LIT>", ";", "*", "hilo_delay", "+=", "nops", ";", "while", "(", "nops", "--", ">", "<NUM_LIT>", ")", "emit_insn_after", "(", "gen_hazard_nop", "(", ")", ",", "after", ")", ";", "*", "hilo_delay", "+=", "ninsns", ";", "*", "delayed_reg", "=", "<NUM_LIT>", ";", "if", "(", "INSN_CODE", "(", "insn", ")", ">=", "<NUM_LIT>", ")", "switch", "(", "get_attr_hazard", "(", "insn", ")", ")", "{", "case", "HAZARD_NONE", ":", "break", ";", "case", "HAZARD_HILO", ":", "*", "hilo_delay", "=", "<NUM_LIT>", ";", "break", ";", "case", "HAZARD_DELAY", ":", "set", "=", "single_set", "(", "insn", ")", ";", "gcc_assert", "(", "set", ")", ";", "*", "delayed_reg", "=", "SET_DEST", "(", "set", ")", ";", "break", ";", "}", "}" ]

[ "Subroutine", "of", "mips_reorg", ".", "If", "there", "is", "a", "hazard", "between", "INSN", "and", "a", "previous", "instruction", ",", "avoid", "it", "by", "inserting", "nops", "after", "instruction", "AFTER", ".", "*", "DELAYED_REG", "and", "*", "HILO_DELAY", "describe", "the", "hazards", "that", "apply", "at", "this", "point", ".", "If", "*", "DELAYED_REG", "is", "non-null", ",", "INSN", "must", "wait", "a", "cycle", "before", "using", "the", "value", "of", "that", "register", ".", "*", "HILO_DELAY", "counts", "the", "number", "of", "instructions", "since", "the", "last", "hilo", "hazard", "(", "that", "is", ",", "the", "number", "of", "instructions", "since", "the", "last", "mflo", "or", "mfhi", ")", ".", "After", "inserting", "nops", "for", "INSN", ",", "update", "*", "DELAYED_REG", "and", "*", "HILO_DELAY", "for", "the", "next", "instruction", ".", "LO_REG", "is", "an", "rtx", "for", "the", "LO", "register", ",", "used", "in", "dependence", "checking", "." ]

[ "Rn", ";" ]

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

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

[ "if", "(", "!", "Cur", "->", "isArray", "(", ")", ")", "{", "StringRef", "StringValue", "=", "String", ".", "substr", "(", "Cur", "->", "offset", ",", "Cur", "->", "elementSize", ")", ";", "if", "(", "StringRef", "(", "Cur", "->", "fieldName", ")", ".", "compare_lower", "(", "TPCSpecialFunctionUsedName", ")", "==", "<NUM_LIT>", ")", "StringValue", ".", "getAsInteger", "(", "<NUM_LIT>", ",", "Header", ".", "specialFunctionUsed", ")", ";", "else", "if", "(", "StringRef", "(", "Cur", "->", "fieldName", ")", ".", "compare_lower", "(", "TPCPrintfUsedName", ")", "==", "<NUM_LIT>", ")", "StringValue", ".", "getAsInteger", "(", "<NUM_LIT>", ",", "Header", ".", "printfUsed", ")", ";", "else", "if", "(", "StringRef", "(", "Cur", "->", "fieldName", ")", ".", "compare_lower", "(", "TPCLockUnLockName", ")", "==", "<NUM_LIT>", ")", "StringValue", ".", "getAsInteger", "(", "<NUM_LIT>", ",", "Header", ".", "lockUnLock", ")", ";", "else", "if", "(", "StringRef", "(", "Cur", "->", "fieldName", ")", ".", "compare_lower", "(", "TPCMarchName", ")", "==", "<NUM_LIT>", ")", "StringValue", ".", "getAsInteger", "(", "<NUM_LIT>", ",", "Header", ".", "march", ")", ";", "else", "if", "(", "StringRef", "(", "Cur", "->", "fieldName", ")", ".", "compare_lower", "(", "TPCMMIOName", ")", "==", "<NUM_LIT>", ")", "StringValue", ".", "getAsInteger", "(", "<NUM_LIT>", ",", "Header", ".", "mmioUsed", ")", ";", "else", "llvm_unreachable", "(", "TPCUnhandledMetadataField", ")", ";", "}", "else", "{", "if", "(", "StringRef", "(", "Cur", "->", "fieldName", ")", ".", "compare_lower", "(", "TPCScalarLdName", ")", "==", "<NUM_LIT>", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "Cur", "->", "length", ";", "++", "i", ")", "{", "StringRef", "StringValue", "=", "String", ".", "substr", "(", "Cur", "->", "offset", "+", "i", ",", "Cur", "->" ]

[ ";" ]

[ "SourceRange", "=", "RegName", ".", "SourceRange", ";", "return", "true", ";", "}", "return", "false", ";", "}", ";", "auto", "diagnoseRegisterClass", "=", "[", "&", "]", "(", "const", "yaml", "::", "StringValue", "&", "RegName", ")", "{", "const", "MemoryBuffer", "&", "Buffer", "=", "*", "PFS", ".", "SM", "->", "getMemoryBuffer", "(", "PFS", ".", "SM", "->", "getMainFileID", "(", ")", ")", ";", "Error", "=", "SMDiagnostic", "(", "*", "PFS", ".", "SM", ",", "SMLoc", "(", ")", ",", "Buffer", ".", "getBufferIdentifier", "(", ")", ",", "<NUM_LIT>", ",", "RegName", ".", "Value", ".", "size", "(", ")", ",", "SourceMgr", "::", "DK_Error", ",", "<STR_LIT>", "incorrect register class for field", "<STR_LIT>", ",", "RegName", ".", "Value", ",", "None", ",", "None", ")", ";", "SourceRange", "=", "RegName", ".", "SourceRange", ";", "return", "true", ";", "}", ";", "if", "(", "parseRegister", "(", "YamlMFI", ".", "ScratchRSrcReg", ",", "MFI", "->", "ScratchRSrcReg", ")", "||", "parseRegister", "(", "YamlMFI", ".", "ScratchWaveOffsetReg", ",", "MFI", "->", "ScratchWaveOffsetReg", ")", "||", "parseRegister", "(", "YamlMFI", ".", "FrameOffsetReg", ",", "MFI", "->", "FrameOffsetReg", ")", "||", "parseRegister", "(", "YamlMFI", ".", "StackPtrOffsetReg", ",", "MFI", "->", "StackPtrOffsetReg", ")", ")", "return", "true", ";", "if", "(", "MFI", "->", "ScratchRSrcReg", "!=", "AMDGPU", "::", "PRIVATE_RSRC_REG", "&&", "!", "AMDGPU", "::", "SReg_128RegClass", ".", "contains", "(", "MFI", "->", "ScratchRSrcReg", ")", ")", "{", "return", "diagnoseRegisterClass", "(", "YamlMFI", ".", "ScratchRSrcReg", ")", ";", "}", "if", "(", "MFI", "->", "ScratchWaveOffsetReg", "!=", "AMDGPU", "::", "SCRATCH_WAVE_OFFSET_REG", "&&", "!", "AMDGPU", "::", "SGPR_32RegClass", ".", "contains", "(", "MFI", "->", "ScratchWaveOffsetReg", ")", ")", "{", "return", "diagnoseRegisterClass", "(", "YamlMFI", ".", "ScratchWaveOffsetReg", ")", ";", "}", "if", "(", "MFI", "->", "FrameOffsetReg", "!=", "AMDGPU", "::", "FP_REG", "&&", "!", "AMDGPU", "::", "SGPR_32RegClass", ".", "contains", "(", "MFI", "->", "FrameOffsetReg", ")", ")", "{", "return", "diagnoseRegisterClass", "(", "YamlMFI", ".", "FrameOffsetReg", ")", ";", "}", "if", "(", "MFI", "->", "StackPtrOffsetReg", "!=", "AMDGPU", "::", "SP_REG", "&&", "!", "AMDGPU", "::", "SGPR_32RegClass", ".", "contains", "(", "MFI", "->", "StackPtrOffsetReg", ")", ")", "{", "return", "diagnoseRegisterClass", "(", "YamlMFI", ".", "StackPtrOffsetReg", ")", ";", "}", "auto", "parseAndCheckArgument", "=", "[", "&", "]", "(", "const", "Optional", "<", "yaml", "::", "SIArgument", ">", "&", "A", ",", "const", "TargetRegisterClass", "&", "RC", ",", "ArgDescriptor", "&", "Arg", ")", "{", "if", "(", "!", "A", ")", "return", "false", ";", "if", "(", "A", "->", "IsRegister", ")", "{", "unsigned", "Reg", ";", "if", "(", "parseNamedRegisterReference", "(", "PFS", ",", "Reg", ",", "A", "->", "RegisterName", ".", "Value", ",", "Error", ")", ")", "{", "SourceRange", "=", "A", "->", "RegisterName", ".", "SourceRange", ";", "return", "true" ]

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

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

[ "}" ]

[ "vorrq_s64", "(", "int64x2_t", "_", "_", "a", ",", "int64x2_t", "_", "_", "b", ")", "{", "return", "_", "_", "a", "|", "_", "_", "b", ";" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "if", "(", "!", "MaybeParseRegister", "(", "Op", ",", "true", ")", ")", "<FIXE>" ]

[ "return", "true", ";", "}", "<BUGS>", "<BUGE>", "bool", "ARMAsmParser", "::", "ParseOperand", "(", "ARMOperand", "&", "Op", ")", "{", "switch", "(", "getLexer", "(", ")", ".", "getKind", "(", ")", ")", "{", "case", "AsmToken", "::", "Identifier", ":", "<BUGS>", "if", "(", "!", "ParseRegister", "(", "Op", ")", ")", "<BUGE>", "return", "false", ";" ]

[ "_", "_", "asm__", "_", "_", "volatile__", "(", "<STR_LIT>", "getcfg\t%1, %2, %0", "<STR_LIT>", ":", "<STR_LIT>", "=r", "<STR_LIT>", "(", "res", ")", ":", "<STR_LIT>", "r", "<STR_LIT>", "(", "mm", ")", ",", "<STR_LIT>", "n", "<STR_LIT>", "(", "s", ")", ")", ";" ]

[ "_", "_", "inline__", "static", "unsigned", "long", "long", "sh_media_GETCFG", "(", "unsigned", "long", "long", "mm", ",", "int", "s", ")", "{", "unsigned", "long", "long", "res", ";" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "Pg", ";", "bits", "<", "<NUM_LIT>", ">", "Zdn", ";", "bits", "<", "<NUM_LIT>", ">", "Za", ";", "bits", "<", "<NUM_LIT>", ">", "Zm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz8_64", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pg", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Za", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zdn", ";" ]

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

[ "emit_note", "(", "NOTE_INSN_DELETED", ")", "DONE", "}", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

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

[ "extern", "_", "_", "inline", "_", "_", "m256i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_insert_epi8", "(", "_", "_", "m256i", "_", "_", "X", ",", "int", "_", "_", "D", ",", "int", "const", "_", "_", "N", ")", "{", "_", "_", "m128i", "_", "_", "Y", "=", "_", "mm256_extractf128_si256", "(", "_", "_", "X", ",", "_", "_", "N", ">>", "<NUM_LIT>", ")", ";", "_", "_", "Y", "=", "_", "mm_insert_epi8", "(", "_", "_", "Y", ",", "_", "_", "D", ",", "_", "_", "N", "%" ]

[ "Rd", ",", "(", "v16i8", "MQPR", ":", "$", "val1", ")", ",", "(", "v16i8", "MQPR", ":", "$", "val2", ")", ")", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "i32", "(", "add", "(", "ARMVMLAVs", "(", "v16i8", "MQPR", ":", "$", "val1", ")", ",", "(", "v16i8", "MQPR", ":", "$", "val2", ")", ")", ",", "tGPREven", ":", "$", "Rd", ")", ")", ",", "(", "i32", "(", "MVE_VMLADAVas8", "tGPREven", ":", "$" ]

[ "}" ]

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

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

[ "def", "AArch64smaxv", ":", "SDNode", "<", "<STR_LIT>" ]

[ "setLibcallName", "(", "RTLIB", "::", "SRL_I128", ",", "nullptr", ")", ";" ]

[ "setOperationAction", "(", "ISD", "::", "UINT_TO_FP", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UINT_TO_FP", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_UINT", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_UINT", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "i1", ",", "Expand", ")", ";", "if", "(", "Subtarget", ".", "hasCnMips", "(", ")", ")", "{", "setOperationAction", "(", "ISD", "::", "CTPOP", ",", "MVT", "::", "i32", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "CTPOP", ",", "MVT", "::", "i64", ",", "Legal", ")", ";", "}", "else", "{", "setOperationAction", "(", "ISD", "::", "CTPOP", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "CTPOP", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "}", "setOperationAction", "(", "ISD", "::", "CTTZ", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "CTTZ", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ROTL", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ROTL", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "DYNAMIC_STACKALLOC", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "DYNAMIC_STACKALLOC", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "if", "(", "!", "Subtarget", ".", "hasMips32r2", "(", ")", ")", "setOperationAction", "(", "ISD", "::", "ROTR", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "if", "(", "!", "Subtarget", ".", "hasMips64r2", "(", ")", ")", "setOperationAction", "(", "ISD", "::", "ROTR", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FSIN", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FSIN", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FCOS", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FCOS", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FSINCOS", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FSINCOS", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FPOW", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FPOW", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FLOG", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FLOG2", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FLOG10", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FEXP", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FMA", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FMA", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FREM", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FREM", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FP16_TO_FP", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_FP16", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FP16_TO_FP", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_FP16", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "EH_RETURN", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "VASTART", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "VAARG", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "VACOPY", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "VAEND", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "STACKSAVE", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "STACKRESTORE", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "if", "(", "!", "Subtarget", ".", "isGP64bit", "(", ")", ")", "{", "setOperationAction", "(", "ISD", "::", "ATOMIC_LOAD", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ATOMIC_STORE", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "}", "if", "(", "!", "Subtarget", ".", "hasMips32r2", "(", ")", ")", "{", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "i8", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "i16", ",", "Expand", ")", ";", "}", "if", "(", "!", "Subtarget", ".", "hasMips32", "(", ")", "||", "Subtarget", ".", "inMips16Mode", "(", ")", ")", "setOperationAction", "(", "ISD", "::", "CTLZ", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "if", "(", "!", "Subtarget", ".", "hasMips64", "(", ")", ")", "setOperationAction", "(", "ISD", "::", "CTLZ", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "if", "(", "!", "Subtarget", ".", "hasMips32r2", "(", ")", ")", "setOperationAction", "(", "ISD", "::", "BSWAP", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "if", "(", "!", "Subtarget", ".", "hasMips64r2", "(", ")", ")", "setOperationAction", "(", "ISD", "::", "BSWAP", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "if", "(", "Subtarget", ".", "isGP64bit", "(", ")", ")", "{", "setLoadExtAction", "(", "ISD", "::", "SEXTLOAD", ",", "MVT", "::", "i64", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "setLoadExtAction", "(", "ISD", "::", "ZEXTLOAD", ",", "MVT", "::", "i64", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "setLoadExtAction", "(", "ISD", "::", "EXTLOAD", ",", "MVT", "::", "i64", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "i64", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "}", "setOperationAction", "(", "ISD", "::", "TRAP", ",", "MVT", "::", "Other", ",", "Legal", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "SDIVREM", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "UDIVREM", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "SELECT", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "AND", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "OR", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "ADD", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "AssertZext", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "SHL", ")", ";", "if", "(", "ABI", ".", "IsO32", "(", ")", ")", "{", "setLibcallName", "(", "RTLIB", "::", "SHL_I128", ",", "nullptr", ")", ";" ]

[ "getValueType", "(", ")", "!=", "MVT", "::", "f128", ")", "{" ]

[ "SDValue", "AArch64TargetLowering", "::", "LowerFP_TO_INT", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ".", "isVector", "(", ")", ")", "return", "LowerVectorFP_TO_INT", "(", "Op", ",", "DAG", ")", ";", "if", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", "." ]

[ "}" ]

[ "void", "microblaze_eh_return", "(", "rtx", "op0", ")", "{", "emit_insn", "(", "gen_movsi", "(", "gen_rtx_MEM", "(", "Pmode", ",", "stack_pointer_rtx", ")", ",", "op0", ")", ")", ";" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "PredNot", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "isTak", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "isPredNew", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "src", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "dst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "dst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "dst", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "dst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "_", "_", "m2", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m64", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_or_si64", "(", "_", "_", "m64", "_", "_", "m1", ",", "_", "_", "m64", "_", "_", "m2", ")", "{", "return", "(", "_", "_", "m1", "|" ]

[ "}" ]

[ "static", "inline", "int", "getQuarterRateInstrCost", "(", ")", "{", "return", "<NUM_LIT>", "*", "TargetTransformInfo", "::", "TCC_Basic", ";" ]

[ "bool", "ARMPassConfig", "::", "addPreSched2", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "!", "getARMSubtarget", "(", ")", ".", "isThumb1Only", "(", ")", ")", "{", "PM", ".", "add", "(", "createARMLoadStoreOptimizationPass", "(", ")", ")", ";", "printAndVerify", "(", "<STR_LIT>", "After ARM load / store optimizer", "<STR_LIT>", ")", ";", "}", "if", "(", "getARMSubtarget", "(", ")", ".", "hasNEON", "(", ")", ")", "PM", ".", "add", "(", "createExecutionDependencyFixPass", "(", "&", "ARM", "::", "DPRRegClass", ")", ")", ";", "}", "PM", ".", "add", "(", "createARMExpandPseudoPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "!", "getARMSubtarget", "(", ")", ".", "isThumb1Only", "(", ")", ")", "addPass", "(", "IfConverterID", ")", ";", "}", "if", "(", "getARMSubtarget", "(", ")", ".", "isThumb2", "(", ")", ")", "PM", ".", "add", "(", "createThumb2ITBlockPass", "(", ")", ")", ";", "return", "true", ";", "}" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

[ "}" ]

[ "MVT", "VT", ";", "if", "(", "!", "isTypeLegal", "(", "Val", "->", "getType", "(", ")", ",", "VT", ")", "&&", "!", "(", "VT", "==", "MVT", "::", "i1", "||", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i16", ")", ")", "return", "false", ";", "if", "(", "VT", ".", "isVector", "(", ")", "||", "VT", ".", "getSizeInBits", "(", ")", ">", "<NUM_LIT>", ")", "return", "false", ";", "OutVTs", ".", "push_back", "(", "VT", ")", ";", "}", "Address", "Addr", ";", "if", "(", "!", "computeCallAddress", "(", "Callee", ",", "Addr", ")", ")", "return", "false", ";", "unsigned", "NumBytes", ";", "if", "(", "!", "processCallArgs", "(", "CLI", ",", "OutVTs", ",", "NumBytes", ")", ")", "return", "false", ";", "if", "(", "!", "Addr", ".", "getGlobalValue", "(", ")", ")", "return", "false", ";", "unsigned", "DestAddress", ";", "if", "(", "Symbol", ")", "DestAddress", "=", "materializeExternalCallSym", "(", "Symbol", ")", ";", "else", "DestAddress", "=", "materializeGV", "(", "Addr", ".", "getGlobalValue", "(", ")", ",", "MVT", "::", "i32", ")", ";", "emitInst", "(", "TargetOpcode", "::", "COPY", ",", "Mips", "::", "T9", ")", ".", "addReg", "(", "DestAddress", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "MIMD", ",", "TII", ".", "get", "(", "Mips", "::", "JALR", ")", ",", "Mips", "::", "RA", ")", ".", "addReg", "(", "Mips", "::", "T9", ")", ";", "for", "(", "auto", "Reg", ":", "CLI", ".", "OutRegs", ")", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Implicit", ")", ";", "MIB", ".", "addRegMask", "(", "TRI", ".", "getCallPreservedMask", "(", "*", "FuncInfo", ".", "MF", ",", "CC", ")", ")", ";", "CLI", ".", "Call", "=", "MIB", ";", "if", "(", "EmitJalrReloc", "&&", "!", "Subtarget", "->", "inMips16Mode", "(", ")", ")", "{", "if", "(", "Symbol", ")", "MIB", ".", "addSym", "(", "Symbol", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "else", "MIB", ".", "addSym", "(", "FuncInfo", ".", "MF", "->", "getContext", "(", ")", ".", "getOrCreateSymbol", "(", "Addr", ".", "getGlobalValue", "(", ")", "->", "getName", "(", ")", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "return", "finishCall", "(", "CLI", ",", "RetVT", ",", "NumBytes", ")", ";" ]

[ "}" ]

[ "def", "PPCS17ImmAsmOperand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";", "let", "PredicateMethod", "=", "<STR_LIT>", ";", "let", "RenderMethod", "=", "<STR_LIT>", ";" ]

[ "<STR_LIT>", ";" ]

[ "class", "MemRegRQOffsetAsmOperand", "<", "int", "shift", ">", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", "#", "shift", "#", "<STR_LIT>", ";", "let", "PredicateMethod", "=", "<STR_LIT>", "#", "shift", "#" ]

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

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

[ "<FIXS>", "(", "define_mode_attr", "VWIDE", "[", "(", "V8QI", "<STR_LIT>", ")", "(", "V4HI", "<STR_LIT>", ")", "(", "V2SI", "<STR_LIT>", ")", "(", "V16QI", "<STR_LIT>", ")", "(", "V8HI", "<STR_LIT>", ")", "(", "V4SI", "<STR_LIT>", ")", "(", "HI", "<STR_LIT>", ")", "(", "SI", "<STR_LIT>", ")", "(", "V8HF", "<STR_LIT>", ")", "(", "V4SF", "<STR_LIT>", ")", "(", "V4HF", "<STR_LIT>", ")", "(", "V2SF", "<STR_LIT>", ")", "(", "VNx8HF", "<STR_LIT>", ")", "(", "VNx4SF", "<STR_LIT>", ")", "(", "VNx16QI", "<STR_LIT>", ")", "(", "VNx8HI", "<STR_LIT>", ")", "(", "VNx4SI", "<STR_LIT>", ")", "(", "VNx16BI", "<STR_LIT>", ")", "(", "VNx8BI", "<STR_LIT>", ")", "(", "VNx4BI", "<STR_LIT>", ")", "]", ")", "(", "define_mode_attr", "VWIDE_PRED", "[", "(", "VNx8HF", "<STR_LIT>", ")", "(", "VNx4SF", "<STR_LIT>", ")", "]", ")", "<FIXE>", "<FIXS>", "(", "define_mode_attr", "Vwide", "[", "(", "V2SF", "<STR_LIT>", ")", "(", "V4HF", "<STR_LIT>", ")", "(", "VNx16QI", "<STR_LIT>", ")", "(", "VNx8HI", "<STR_LIT>", ")", "(", "VNx4SI", "<STR_LIT>", ")", "(", "VNx8HF", "<STR_LIT>", ")", "(", "VNx4SF", "<STR_LIT>", ")", "(", "VNx16BI", "<STR_LIT>", ")", "(", "VNx8BI", "<STR_LIT>", ")", "(", "VNx4BI", "<STR_LIT>", ")", "]", ")", "<FIXE>" ]

[ "(", "V2DI", "<STR_LIT>", ")", "]", ")", "<BUGS>", "(", "define_mode_attr", "VWIDE", "[", "(", "V8QI", "<STR_LIT>", ")", "(", "V4HI", "<STR_LIT>", ")", "(", "V2SI", "<STR_LIT>", ")", "(", "V16QI", "<STR_LIT>", ")", "(", "V8HI", "<STR_LIT>", ")", "(", "V4SI", "<STR_LIT>", ")", "(", "HI", "<STR_LIT>", ")", "(", "SI", "<STR_LIT>", ")", "(", "V8HF", "<STR_LIT>", ")", "(", "V4SF", "<STR_LIT>", ")", "(", "V4HF", "<STR_LIT>", ")", "(", "V2SF", "<STR_LIT>", ")", "]", ")", "<BUGE>", "<BUGS>", "(", "define_mode_attr", "Vwide", "[", "(", "V2SF", "<STR_LIT>", ")", "(", "V4HF", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_mode_attr", "Vwtype", "[", "(", "V8QI", "<STR_LIT>", ")", "(", "V4HI", "<STR_LIT>", ")" ]

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

[ "return", "_", "_", "builtin_ia32_sqrtsh_mask_round", "(", "_", "_", "B", ",", "_", "_", "A", ",", "_", "mm_setzero_ph", "(", ")", ",", "(", "_", "_", "mmask8" ]

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

[ "void", "fma_forest", "::", "merge_forest", "(", "fma_forest", "*", "other_forest", ")", "{", "std", "::", "list", "<", "fma_root_node", "*", ">", "*", "other_roots", ";", "std", "::", "list", "<", "fma_root_node", "*", ">", "::", "iterator", "other_root_iter", ";", "if", "(", "this", "==", "other_forest", ")", "return", ";", "other_roots", "=", "other_forest", "->", "m_roots", ";", "for", "(", "other_root_iter", "=", "other_roots", "->", "begin" ]

[ "}", ";" ]

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

[ "return", "<STR_LIT>" ]

[ "(", "mod", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "CC_REGNUM", ")", ")", "]", "<STR_LIT>", "{", "if", "(", "TARGET_V850E2_UP", ")", "return", "<STR_LIT>", "else" ]

[ "SDValue", "REM_sub", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", ",", "DL", ",", "VT", ",", "REM", ",", "RHS", ")", ";" ]

[ "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "halfBitWidth", ";", "++", "i", ")", "{", "const", "unsigned", "bitPos", "=", "halfBitWidth", "-", "i", "-", "<NUM_LIT>", ";", "SDValue", "POS", "=", "DAG", ".", "getConstant", "(", "bitPos", ",", "DL", ",", "HalfVT", ")", ";", "SDValue", "HBit", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "HalfVT", ",", "LHS_Lo", ",", "POS", ")", ";", "HBit", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "HalfVT", ",", "HBit", ",", "one", ")", ";", "HBit", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "DL", ",", "VT", ",", "HBit", ")", ";", "REM", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "DL", ",", "VT", ",", "REM", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "VT", ")", ")", ";", "REM", "=", "DAG", ".", "getNode", "(", "ISD", "::", "OR", ",", "DL", ",", "VT", ",", "REM", ",", "HBit", ")", ";", "SDValue", "BIT", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", "<<", "bitPos", ",", "DL", ",", "HalfVT", ")", ";", "SDValue", "realBIT", "=", "DAG", ".", "getSelectCC", "(", "DL", ",", "REM", ",", "RHS", ",", "BIT", ",", "zero", ",", "ISD", "::", "SETUGE", ")", ";", "DIV_Lo", "=", "DAG", ".", "getNode", "(", "ISD", "::", "OR", ",", "DL", ",", "HalfVT", ",", "DIV_Lo", ",", "realBIT", ")", ";" ]

[ "unsigned", "getNumFixupKinds", "(", ")", "const", "override", "{", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "}" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "}" ]

[ "if", "(", "mode", "==", "CPSImode", ")", "return", "<NUM_LIT>", ";", "return", "msp430_hard_regno_nregs", "(", "regno", ",", "mode", ")", ";" ]

[ "case", "R_FRV_TLSMOFFHI", ":", "return", "<STR_LIT>", "tlsmoffhi", "<STR_LIT>", ";" ]

[ "case", "R_FRV_GOTLO", ":", "return", "<STR_LIT>", "gotlo", "<STR_LIT>", ";", "case", "R_FRV_FUNCDESC", ":", "return", "<STR_LIT>", "funcdesc", "<STR_LIT>", ";", "case", "R_FRV_FUNCDESC_GOT12", ":", "return", "<STR_LIT>", "gotfuncdesc12", "<STR_LIT>", ";", "case", "R_FRV_FUNCDESC_GOTHI", ":", "return", "<STR_LIT>", "gotfuncdeschi", "<STR_LIT>", ";", "case", "R_FRV_FUNCDESC_GOTLO", ":", "return", "<STR_LIT>", "gotfuncdesclo", "<STR_LIT>", ";", "case", "R_FRV_FUNCDESC_VALUE", ":", "return", "<STR_LIT>", "funcdescvalue", "<STR_LIT>", ";", "case", "R_FRV_FUNCDESC_GOTOFF12", ":", "return", "<STR_LIT>", "gotofffuncdesc12", "<STR_LIT>", ";", "case", "R_FRV_FUNCDESC_GOTOFFHI", ":", "return", "<STR_LIT>", "gotofffuncdeschi", "<STR_LIT>", ";", "case", "R_FRV_FUNCDESC_GOTOFFLO", ":", "return", "<STR_LIT>", "gotofffuncdesclo", "<STR_LIT>", ";", "case", "R_FRV_GOTOFF12", ":", "return", "<STR_LIT>", "gotoff12", "<STR_LIT>", ";", "case", "R_FRV_GOTOFFHI", ":", "return", "<STR_LIT>", "gotoffhi", "<STR_LIT>", ";", "case", "R_FRV_GOTOFFLO", ":", "return", "<STR_LIT>", "gotofflo", "<STR_LIT>", ";", "case", "R_FRV_GPREL12", ":", "return", "<STR_LIT>", "gprel12", "<STR_LIT>", ";", "case", "R_FRV_GPRELHI", ":", "return", "<STR_LIT>", "gprelhi", "<STR_LIT>", ";", "case", "R_FRV_GPRELLO", ":", "return", "<STR_LIT>", "gprello", "<STR_LIT>", ";", "case", "R_FRV_GOTTLSOFF_HI", ":", "return", "<STR_LIT>", "gottlsoffhi", "<STR_LIT>", ";", "case", "R_FRV_GOTTLSOFF_LO", ":", "return", "<STR_LIT>", "gottlsofflo", "<STR_LIT>", ";" ]

[ "static", "void", "ix86_emit_save_regs", "(", "void", ")", "{", "unsigned", "int", "regno", ";", "rtx_insn", "*", "insn", ";", "for", "(", "regno", "=", "FIRST_PSEUDO_REGISTER", "-", "<NUM_LIT>", ";", "regno", "--", ">", "<NUM_LIT>", ";", ")", "if", "(", "GENERAL_REGNO_P", "(", "regno", ")", "&&", "ix86_save_reg", "(", "regno", ",", "true", ",", "true", ")", ")", "{", "insn", "=", "emit_insn", "(", "gen_push", "(", "gen_rtx_REG", "(", "word_mode", ",", "regno", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "}", "}" ]

[ "Emit", "code", "to", "save", "registers", "in", "the", "prologue", "." ]

[ "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

[ "return", "std", "::", "make_pair", "(", "TF", "&", "~", "<STR_LIT>", "::", "<STR_LIT>", ",", "TF" ]

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

[ "ValueType", "ResTy", ",", "ValueType", "OpTy", ",", "Intrinsic", "IntOp", ">", ":", "N2V", "op24_23", ",", "op21_20", ",", "op19_18", ",", "op17_16", ",", "op11_7", ",", "<NUM_LIT>", ",", "op4", ",", "(", "outs", "DPR_VFP2", ":", "$", "dst", ")", ",", "(", "ins", "DPR_VFP2", ":", "$", "src", ")", ",", "itin", ",", "<BUGS>", "!", "strconcat", "(", "OpcodeStr", ",", "<STR_LIT>", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ";", "<BUGE>", "class", "N2VDIntsPat", "SDNode", "OpNode", ",", "NeonI", "Inst", ">", ":", "NEONFPPat", "(", "f32", "(", "OpNode", "SPR", ":", "$", "a", ")", ")", "," ]

[ "<FIXS>", "unsigned", "ARMBaseInstrInfo", "::", "isLoadFromStackSlotPostFE", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "<FIXE>", "<FIXS>", "return", "MI", ".", "mayLoad", "(", ")", "&&", "hasLoadFromStackSlot", "(", "MI", ",", "Dummy", ",", "FrameIndex", ")", ";", "<FIXE>" ]

[ "return", "<NUM_LIT>", ";", "}", "<BUGS>", "unsigned", "ARMBaseInstrInfo", "::", "isLoadFromStackSlotPostFE", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "<BUGE>", "const", "MachineMemOperand", "*", "Dummy", ";", "<BUGS>", "return", "MI", "->", "mayLoad", "(", ")", "&&", "hasLoadFromStackSlot", "(", "MI", ",", "Dummy", ",", "FrameIndex", ")", ";", "<BUGE>", "}" ]

[ "}" ]

[ "RegisterAsmPrinter", "<", "AArch64AsmPrinter", ">", "Z", "(", "getTheARM64Target", "(", ")", ")", ";", "RegisterAsmPrinter", "<", "AArch64AsmPrinter", ">", "W", "(", "getTheARM64_32Target", "(", ")", ")", ";", "RegisterAsmPrinter", "<", "AArch64AsmPrinter", ">", "V", "(", "getTheAArch64_32Target", "(", ")", ")", ";" ]

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

[ "_", "_", "arm_vadciq_m_s32", "(", "int32x4_t", "_", "_", "inactive", ",", "int32x4_t", "_", "_", "a", ",", "int32x4_t", "_", "_", "b", ",", "unsigned", "*", "_", "_", "carry_out", ",", "mve_pred16_t", "_", "_", "p", ")", "{", "int32x4_t", "_", "_", "res", "=", "_", "_", "builtin_mve_vadciq_m_sv4si", "(", "_", "_", "inactive", ",", "_", "_" ]

[ "<FIXS>", "fprintf", "(", "file", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "reg_names", "[", "subreg_regno", "(", "x", ")", "]", ")", ";", "<FIXE>" ]

[ "break", ";", "case", "SUBREG", ":", "<BUGS>", "fprintf", "(", "file", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "SUBREG_REG", "(", "x", ")", ")", "+", "SUBREG_WORD", "(", "x", ")", "]", ")", ";", "<BUGE>", "break", ";", "case", "CONST_DOUBLE", ":" ]

[ "return", "NULL_TREE", ";" ]

[ "static", "tree", "aarch64_lookup_simd_builtin_type", "(", "enum", "machine_mode", "mode", ",", "enum", "aarch64_type_qualifiers", "q", ")", "{", "int", "i", ";", "int", "nelts", "=", "sizeof", "(", "aarch64_simd_types", ")", "/", "sizeof", "(", "aarch64_simd_types", "[", "<NUM_LIT>", "]", ")", ";", "if", "(", "q", "!=", "qualifier_poly", "&&", "!", "VECTOR_MODE_P", "(", "mode", ")", ")", "return", "aarch64_simd_builtin_std_type", "(", "mode", ",", "q", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "nelts", ";", "i", "++", ")", "if", "(", "aarch64_simd_types", "[", "i", "]", ".", "mode", "==", "mode", "&&", "aarch64_simd_types", "[", "i", "]", ".", "q", "==", "q", ")", "return", "aarch64_simd_types", "[", "i", "]", ".", "itype", ";" ]

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

[ "return", "(", "_", "_", "m64", ")", "_", "_", "builtin_arm_wmaddun", "(", "(", "_", "_", "v4hi", ")", "a", ",", "(", "_" ]

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

[ "def", "J4_cmpeqi_f_jumpnv_nt", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "IntRegs", ":", "$", "Ns8", ",", "u5_0Imm", ":", "$", "II", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_bd8382d1", ",", "TypeNCJ", ">", ",", "Enc_eafd18", ",", "PredRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch" ]

[ "int", "mt_reg_ok_for_base_p", "(", "rtx", "x", ",", "int", "strict", ")", "{", "if", "(", "strict", ")", "return", "(", "(", "(", "unsigned", ")", "REGNO", "(", "x", ")", ")", "<", "FIRST_PSEUDO_REGISTER", ")", ";", "return", "<NUM_LIT>", ";", "}" ]

[ "Implement", "REG_OK_FOR_BASE_P", "." ]

[ "case", "ARM", "::", "fixup_t2_movw_lo16", ":" ]

[ "return", "<NUM_LIT>", ";", "case", "FK_Data_4", ":", "return", "<NUM_LIT>", ";", "case", "ARM", "::", "fixup_arm_thumb_bcc", ":", "case", "ARM", "::", "fixup_arm_thumb_cp", ":", "case", "ARM", "::", "fixup_thumb_adr_pcrel_10", ":", "case", "ARM", "::", "fixup_arm_thumb_br", ":", "case", "ARM", "::", "fixup_arm_thumb_cb", ":", "return", "<NUM_LIT>", ";", "case", "ARM", "::", "fixup_arm_pcrel_10_unscaled", ":", "case", "ARM", "::", "fixup_arm_ldst_pcrel_12", ":", "case", "ARM", "::", "fixup_arm_pcrel_10", ":", "case", "ARM", "::", "fixup_arm_adr_pcrel_12", ":", "case", "ARM", "::", "fixup_arm_uncondbl", ":", "case", "ARM", "::", "fixup_arm_condbl", ":", "case", "ARM", "::", "fixup_arm_blx", ":", "case", "ARM", "::", "fixup_arm_condbranch", ":", "case", "ARM", "::", "fixup_arm_uncondbranch", ":", "case", "ARM", "::", "fixup_t2_ldst_pcrel_12", ":", "case", "ARM", "::", "fixup_t2_condbranch", ":", "case", "ARM", "::", "fixup_t2_uncondbranch", ":", "case", "ARM", "::", "fixup_t2_pcrel_10", ":", "case", "ARM", "::", "fixup_t2_adr_pcrel_12", ":", "case", "ARM", "::", "fixup_arm_thumb_bl", ":", "case", "ARM", "::", "fixup_arm_thumb_blx", ":", "case", "ARM", "::", "fixup_arm_movt_hi16", ":", "case", "ARM", "::", "fixup_arm_movw_lo16", ":", "case", "ARM", "::", "fixup_t2_movt_hi16", ":" ]

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

[ "def", "r128", ":", "StoreAForm", "<" ]

[ ")", "_", "mm_setzero_si128", "(", ")", ",", "(", "_", "_", "mmask8", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_cvtpd2qq128_mask", "(", "(", "_", "_", "v2df", ")", "_", "_", "A", ",", "(", "_", "_", "v2di" ]

[ "const", "char", "*", "SystemZTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "Opcode", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "break", ";", "OPCODE", "(", "RET_FLAG", ")", ";", "OPCODE", "(", "CALL", ")", ";", "OPCODE", "(", "SIBCALL", ")", ";", "OPCODE", "(", "TLS_GDCALL", ")", ";", "OPCODE", "(", "TLS_LDCALL", ")", ";", "OPCODE", "(", "PCREL_WRAPPER", ")", ";", "OPCODE", "(", "PCREL_OFFSET", ")", ";", "OPCODE", "(", "IABS", ")", ";", "OPCODE", "(", "ICMP", ")", ";", "OPCODE", "(", "FCMP", ")", ";", "OPCODE", "(", "TM", ")", ";", "OPCODE", "(", "BR_CCMASK", ")", ";", "OPCODE", "(", "SELECT_CCMASK", ")", ";", "OPCODE", "(", "ADJDYNALLOC", ")", ";", "OPCODE", "(", "POPCNT", ")", ";", "OPCODE", "(", "UMUL_LOHI64", ")", ";", "OPCODE", "(", "SDIVREM32", ")", ";", "OPCODE", "(", "SDIVREM64", ")", ";", "OPCODE", "(", "UDIVREM32", ")", ";", "OPCODE", "(", "UDIVREM64", ")", ";", "OPCODE", "(", "MVC", ")", ";", "OPCODE", "(", "MVC_LOOP", ")", ";", "OPCODE", "(", "NC", ")", ";", "OPCODE", "(", "NC_LOOP", ")", ";", "OPCODE", "(", "OC", ")", ";", "OPCODE", "(", "OC_LOOP", ")", ";", "OPCODE", "(", "XC", ")", ";", "OPCODE", "(", "XC_LOOP", ")", ";", "OPCODE", "(", "CLC", ")", ";", "OPCODE", "(", "CLC_LOOP", ")", ";", "OPCODE", "(", "STPCPY", ")", ";", "OPCODE", "(", "STRCMP", ")", ";", "OPCODE", "(", "SEARCH_STRING", ")", ";", "OPCODE", "(", "IPM", ")", ";", "OPCODE", "(", "SERIALIZE", ")", ";", "OPCODE", "(", "MEMBARRIER", ")", ";", "OPCODE", "(", "TBEGIN", ")", ";", "OPCODE", "(", "TBEGIN_NOFLOAT", ")", ";", "OPCODE", "(", "TEND", ")", ";", "OPCODE", "(", "BYTE_MASK", ")", ";", "OPCODE", "(", "ROTATE_MASK", ")", ";", "OPCODE", "(", "REPLICATE", ")", ";", "OPCODE", "(", "JOIN_DWORDS", ")", ";", "OPCODE", "(", "SPLAT", ")", ";", "OPCODE", "(", "MERGE_HIGH", ")", ";", "OPCODE", "(", "MERGE_LOW", ")", ";", "OPCODE", "(", "SHL_DOUBLE", ")", ";", "OPCODE", "(", "PERMUTE_DWORDS", ")", ";", "OPCODE", "(", "PERMUTE", ")", ";", "OPCODE", "(", "PACK", ")", ";", "OPCODE", "(", "PACKS_CC", ")", ";", "OPCODE", "(", "PACKLS_CC", ")", ";", "OPCODE", "(", "UNPACK_HIGH", ")", ";", "OPCODE", "(", "UNPACKL_HIGH", ")", ";", "OPCODE", "(", "UNPACK_LOW", ")", ";", "OPCODE", "(", "UNPACKL_LOW", ")", ";", "OPCODE", "(", "VSHL_BY_SCALAR", ")", ";", "OPCODE", "(", "VSRL_BY_SCALAR", ")", ";", "OPCODE", "(", "VSRA_BY_SCALAR", ")", ";", "OPCODE", "(", "VSUM", ")", ";", "OPCODE", "(", "VICMPE", ")", ";", "OPCODE", "(", "VICMPH", ")", ";", "OPCODE", "(", "VICMPHL", ")", ";", "OPCODE", "(", "VICMPES", ")", ";", "OPCODE", "(", "VICMPHS", ")", ";", "OPCODE", "(", "VICMPHLS", ")", ";", "OPCODE", "(", "VFCMPE", ")", ";", "OPCODE", "(", "VFCMPH", ")", ";", "OPCODE", "(", "VFCMPHE", ")", ";", "OPCODE", "(", "VFCMPES", ")", ";", "OPCODE", "(", "VFCMPHS", ")", ";", "OPCODE", "(", "VFCMPHES", ")", ";", "OPCODE", "(", "VFTCI", ")", ";", "OPCODE", "(", "VEXTEND", ")", ";", "OPCODE", "(", "VROUND", ")", ";", "OPCODE", "(", "VTM", ")", ";", "OPCODE", "(", "VFAE_CC", ")", ";", "OPCODE", "(", "VFAEZ_CC", ")", ";", "OPCODE", "(", "VFEE_CC", ")", ";", "OPCODE", "(", "VFEEZ_CC", ")", ";", "OPCODE", "(", "VFENE_CC", ")", ";", "OPCODE", "(", "VFENEZ_CC", ")", ";", "OPCODE", "(", "VISTR_CC", ")", ";", "OPCODE", "(", "VSTRC_CC", ")", ";", "OPCODE", "(", "VSTRCZ_CC", ")", ";", "OPCODE", "(", "TDC", ")", ";", "OPCODE", "(", "ATOMIC_SWAPW", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_ADD", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_SUB", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_AND", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_OR", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_XOR", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_NAND", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_MIN", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_MAX", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_UMIN", ")", ";", "OPCODE", "(", "ATOMIC_LOADW_UMAX", ")", ";", "OPCODE", "(", "ATOMIC_CMP_SWAPW", ")", ";", "OPCODE", "(", "LRV", ")", ";", "OPCODE", "(", "STRV", ")", ";", "OPCODE", "(", "PREFETCH", ")", ";", "}", "return", "nullptr", ";", "}" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

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

[ "needIndirectCall", "=", "false", ";", "}", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "{", "if", "(", "!", "DAG", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "isJITCodeModel", "(", ")", ")", "{", "unsigned", "OpFlags", "=", "<NUM_LIT>", ";", "if", "(", "DAG", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Static", "&&", "PPCSubTarget", ".", "getDarwinVers", "(", ")", "<", "<NUM_LIT>", "&&", "(", "G", "->", "getGlobal", "(", ")", "->", "isDeclaration", "(", ")", "||", "G", "->", "getGlobal", "(", ")", "->", "isWeakForLinker", "(", ")", ")", ")", "{", "OpFlags", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "Callee", "=", "DAG", ".", "getTargetGlobalAddress", "(", "G", "->", "getGlobal", "(", ")", ",", "dl", ",", "Callee", ".", "getValueType", "(", ")", ",", "<NUM_LIT>", ",", "OpFlags", ")", ";", "needIndirectCall", "=", "false", ";", "}", "}", "if", "(", "ExternalSymbolSDNode", "*", "S", "=", "dyn_cast", "<", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ")", "{", "unsigned", "char", "OpFlags", "=", "<NUM_LIT>", ";", "if", "(", "DAG", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Static", "&&", "PPCSubTarget", ".", "getDarwinVers", "(", ")", "<", "<NUM_LIT>", ")", "{", "OpFlags", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "Callee", "=", "DAG", ".", "getTargetExternalSymbol", "(", "S", "->", "getSymbol", "(", ")", ",", "Callee", ".", "getValueType", "(", ")", ",", "OpFlags", ")", ";", "needIndirectCall", "=", "false", ";", "}", "if", "(", "needIndirectCall", ")", "{", "SDValue", "MTCTROps", "[", "]", "=", "{", "Chain", ",", "Callee", ",", "InFlag", "}", ";", "if", "(", "isSVR4ABI", "&&", "isPPC64", ")", "{", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "i64", ",", "MVT", "::", "Other", ",", "MVT", "::", "Flag", ")", ";", "SDValue", "LoadFuncPtr", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VTs", ",", "MTCTROps", ",", "InFlag", ".", "getNode", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "Chain", "=", "LoadFuncPtr", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "InFlag", "=", "LoadFuncPtr", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "SDValue", "PtrOff", "=", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ")", ";", "SDValue", "AddPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "MVT", "::", "i64", ",", "Callee", ",", "PtrOff", ")", ";", "SDValue", "LoadEnvPtr", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VTs", ",", "Chain", ",", "AddPtr", "," ]

[ "<FIXS>", "const", "TargetRegisterClass", "*", "SrcRC", ",", "DebugLoc", "DL", ")", "const", ";", "<FIXE>" ]

[ "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "const", "TargetRegisterClass", "*", "DestRC", ",", "<BUGS>", "const", "TargetRegisterClass", "*", "SrcRC", ")", "const", ";", "<BUGE>", "virtual", "void", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", "," ]

[ "Ws1", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";" ]

[ "MachineRegisterInfo", "&", "RegInfo", "=", "BB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "&", "Mips", "::", "MSA128WRegClass", ";", "unsigned", "Ws1", "=", "RegInfo", ".", "createVirtualRegister", "(", "RC", ")", ";", "unsigned", "Ws2", "=", "RegInfo", ".", "createVirtualRegister", "(", "RC", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "*", "BB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "LDI_W", ")", "," ]

[ "<STR_LIT>", ")" ]

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

[ ".", "createVirtualRegister", "(", "RC", ")", ";" ]

[ "static", "unsigned", "addLiveIn", "(", "MachineFunction", "&", "MF", ",", "unsigned", "PReg", ",", "const", "TargetRegisterClass", "*", "RC", ")", "{", "Register", "VReg", "=", "MF", ".", "getRegInfo", "(", ")" ]

[ "QPR", ":", "$", "Vd", ",", "(", "Ty", "(", "ShOp", "QPR", ":", "$", "src1", ",", "QPR", ":", "$", "Vm", ",", "(", "i32", "imm", ":", "$", "SIMM", ")", ")", ")", ")", "]", ">", ";" ]

[ "class", "N2VQShIns", "<", "bit", "op24", ",", "bit", "op23", ",", "bits", "<", "<NUM_LIT>", ">", "op11_8", ",", "bit", "op7", ",", "bit", "op4", ",", "Operand", "ImmTy", ",", "Format", "f", ",", "string", "OpcodeStr", ",", "string", "Dt", ",", "ValueType", "Ty", ",", "SDNode", "ShOp", ">", ":", "N2VImm", "<", "op24", ",", "op23", ",", "op11_8", ",", "op7", ",", "<NUM_LIT>", ",", "op4", ",", "(", "outs", "QPR", ":", "$", "Vd", ")", ",", "(", "ins", "QPR", ":", "$", "src1", ",", "QPR", ":", "$", "Vm", ",", "ImmTy", ":", "$", "SIMM", ")", ",", "f", ",", "IIC_VSHLiQ", ",", "OpcodeStr", ",", "Dt", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set" ]

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

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

[ "<STR_LIT>" ]

[ "[", "(", "set", "(", "match_operand", ":", "VSX_SPLAT_I", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_duplicate", ":", "VSX_SPLAT_I", "(", "truncate", ":", "<", "VS_scalar", ">", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>" ]

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

[ "[", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "ior", ":", "BLK", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "use", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "CC_REGNUM", ")", ")", "]", ")", "]", "{", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "operands" ]

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

[ "if", "(", "!", "ItinData", "||", "ItinData", "->", "isEmpty", "(", ")", ")", "return", "<NUM_LIT>", ";", "const", "MCInstrDesc", "&", "MCID", "=", "MI", "->", "getDesc", "(", ")", ";", "unsigned", "Class", "=", "MCID", ".", "getSchedClass", "(", ")", ";", "unsigned", "UOps", "=", "ItinData", "->", "Itineraries", "[", "Class", "]", ".", "NumMicroOps", ";", "if", "(", "PredCost", "&&", "MCID", ".", "hasImplicitDefOfPhysReg", "(", "ARM", "::", "CPSR" ]

[ ")", ")" ]

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

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

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

[ ";" ]

[ "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isMoveImm", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>" ]

[ "float32x2_t", "_", "_", "b", ")", "{" ]

[ "vcadd_rot90_f32", "(", "float32x2_t", "_", "_", "a", "," ]

[ "$", "vl", ",", "v256f64", ":", "$", "pt", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "int_ve_vl_vminsl_vvvvl", "v256f64", ":", "$", "vy", ",", "v256f64", ":", "$", "vz", ",", "v256f64", ":", "$", "pt", ",", "i32", ":", "$", "vl", ")", ",", "(", "VMINSLvvl_v", "v256f64", ":", "$", "vy", ",", "v256f64", ":", "$", "vz", ",", "i32", ":" ]

[ "}" ]

[ "_", "_", "arm_vmulq_x_u8", "(", "uint8x16_t", "_", "_", "a", ",", "uint8x16_t", "_", "_", "b", ",", "mve_pred16_t", "_", "_", "p", ")", "{", "return", "_", "_", "builtin_mve_vmulq_m_uv16qi", "(", "_", "_", "arm_vuninitializedq_u8", "(", ")", ",", "_", "_", "a", ",", "_", "_", "b", ",", "_", "_", "p", ")", ";" ]

[ "else", "Operands", ".", "push_back", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "getPointerWidth", "(", ")", ",", "Disp", ",", "Start", ",", "End", ",", "Size", ",", "StringRef", "(", ")", ",", "nullptr", ",", "<NUM_LIT>", ",", "false", ",", "MaybeDirectBranchDest", ")", ")", ";" ]

[ "unsigned", "IndexReg", "=", "SM", ".", "getIndexReg", "(", ")", ";", "if", "(", "IndexReg", "&&", "BaseReg", "==", "X86", "::", "RIP", ")", "BaseReg", "=", "<NUM_LIT>", ";", "unsigned", "Scale", "=", "SM", ".", "getScale", "(", ")", ";", "if", "(", "!", "PtrInOperand", ")", "Size", "=", "SM", ".", "getElementSize", "(", ")", "<<", "<NUM_LIT>", ";", "if", "(", "Scale", "==", "<NUM_LIT>", "&&", "BaseReg", "!=", "X86", "::", "ESP", "&&", "BaseReg", "!=", "X86", "::", "RSP", "&&", "(", "IndexReg", "==", "X86", "::", "ESP", "||", "IndexReg", "==", "X86", "::", "RSP", ")", ")", "std", "::", "swap", "(", "BaseReg", ",", "IndexReg", ")", ";", "if", "(", "Scale", "==", "<NUM_LIT>", "&&", "!", "(", "X86MCRegisterClasses", "[", "X86", "::", "VR128XRegClassID", "]", ".", "contains", "(", "IndexReg", ")", "||", "X86MCRegisterClasses", "[", "X86", "::", "VR256XRegClassID", "]", ".", "contains", "(", "IndexReg", ")", "||", "X86MCRegisterClasses", "[", "X86", "::", "VR512RegClassID", "]", ".", "contains", "(", "IndexReg", ")", ")", "&&", "(", "X86MCRegisterClasses", "[", "X86", "::", "VR128XRegClassID", "]", ".", "contains", "(", "BaseReg", ")", "||", "X86MCRegisterClasses", "[", "X86", "::", "VR256XRegClassID", "]", ".", "contains", "(", "BaseReg", ")", "||", "X86MCRegisterClasses", "[", "X86", "::", "VR512RegClassID", "]", ".", "contains", "(", "BaseReg", ")", ")", ")", "std", "::", "swap", "(", "BaseReg", ",", "IndexReg", ")", ";", "if", "(", "Scale", "!=", "<NUM_LIT>", "&&", "X86MCRegisterClasses", "[", "X86", "::", "GR16RegClassID", "]", ".", "contains", "(", "IndexReg", ")", ")", "return", "Error", "(", "Start", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ")", ";", "if", "(", "Scale", "==", "<NUM_LIT>", ")", "Scale", "=", "<NUM_LIT>", ";", "if", "(", "(", "BaseReg", "==", "X86", "::", "SI", "||", "BaseReg", "==", "X86", "::", "DI", ")", "&&", "(", "IndexReg", "==", "X86", "::", "BX", "||", "IndexReg", "==", "X86", "::", "BP", ")", ")", "std", "::", "swap", "(", "BaseReg", ",", "IndexReg", ")", ";", "if", "(", "(", "BaseReg", "||", "IndexReg", ")", "&&", "CheckBaseRegAndIndexRegAndScale", "(", "BaseReg", ",", "IndexReg", ",", "Scale", ",", "is64BitMode", "(", ")", ",", "ErrMsg", ")", ")", "return", "Error", "(", "Start", ",", "ErrMsg", ")", ";", "if", "(", "isParsingMSInlineAsm", "(", ")", ")", "return", "CreateMemForMSInlineAsm", "(", "RegNo", ",", "Disp", ",", "BaseReg", ",", "IndexReg", ",", "Scale", ",", "Start", ",", "End", ",", "Size", ",", "SM", ".", "getSymName", "(", ")", ",", "SM", ".", "getIdentifierInfo", "(", ")", ",", "Operands", ")", ";", "unsigned", "DefaultBaseReg", "=", "X86", "::", "NoRegister", ";", "bool", "MaybeDirectBranchDest", "=", "true", ";", "if", "(", "Parser", ".", "isParsingMasm", "(", ")", ")", "{", "bool", "IsUnconditionalBranch", "=", "Name", ".", "equals_insensitive", "(", "<STR_LIT>", "jmp", "<STR_LIT>", ")", "||", "Name", ".", "equals_insensitive", "(", "<STR_LIT>", "call", "<STR_LIT>", ")", ";", "if", "(", "is64BitMode", "(", ")", "&&", "SM", ".", "getElementSize", "(", ")", ">", "<NUM_LIT>", ")", "{", "DefaultBaseReg", "=", "X86", "::", "RIP", ";", "}", "if", "(", "IsUnconditionalBranch", ")", "{", "if", "(", "PtrInOperand", ")", "{", "MaybeDirectBranchDest", "=", "false", ";", "if", "(", "is64BitMode", "(", ")", ")", "DefaultBaseReg", "=", "X86", "::", "RIP", ";", "}", "else", "if", "(", "!", "BaseReg", "&&", "!", "IndexReg", "&&", "Disp", "&&", "Disp", "->", "getKind", "(", ")", "==", "MCExpr", "::", "SymbolRef", ")", "{", "if", "(", "is64BitMode", "(", ")", ")", "{", "if", "(", "SM", ".", "getSize", "(", ")", "==", "<NUM_LIT>", ")", "{", "MaybeDirectBranchDest", "=", "false", ";", "DefaultBaseReg", "=", "X86", "::", "RIP", ";", "}", "}", "else", "{", "if", "(", "SM", ".", "getSize", "(", ")", "==", "<NUM_LIT>", "||", "SM", ".", "getSize", "(", ")", "==", "<NUM_LIT>", ")", "MaybeDirectBranchDest", "=", "false", ";", "}", "}", "}", "}", "if", "(", "(", "BaseReg", "||", "IndexReg", "||", "RegNo", "||", "DefaultBaseReg", "!=", "X86", "::", "NoRegister", ")", ")", "Operands", ".", "push_back", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "getPointerWidth", "(", ")", ",", "RegNo", ",", "Disp", ",", "BaseReg", ",", "IndexReg", ",", "Scale", ",", "Start", ",", "End", ",", "Size", ",", "DefaultBaseReg", ",", "StringRef", "(", ")", ",", "nullptr", ",", "<NUM_LIT>", ",", "false", ",", "MaybeDirectBranchDest", ")", ")", ";" ]

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

[ "class", "BaseExtractImm", "<", "RegisterClass", "regtype", ",", "Operand", "imm_type", ",", "string", "asm", ",", "list", "<", "dag", ">", "patterns", ">", ":", "I", "<", "(", "outs", "regtype", ":", "$", "Rd", ")", ",", "(", "ins", "regtype", ":", "$", "Rn", ",", "regtype", ":", "$", "Rm", ",", "imm_type", ":", "$", "imm", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "patterns", ">", ",", "Sched", "<", "[", "WriteExtr", ",", "ReadExtrHi", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "bits", "<", "<NUM_LIT>", ">", "imm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";" ]

[ "}" ]

[ "vrshl_u64", "(", "uint64x1_t", "_", "_", "a", ",", "int64x1_t", "_", "_", "b", ")", "{", "return", "(", "uint64x1_t", ")", "_", "_", "builtin_neon_vrshludi", "(", "(", "int64x1_t", ")", "_", "_", "a", ",", "_", "_", "b", ")", ";" ]

[ "<FIXS>", "def", "ORI", ":", "ALU_2RI12", "<NUM_LIT>", ",", "<STR_LIT>", ",", "uimm12_ori", ">", ";", "<FIXE>" ]

[ "def", "ANDN", ":", "ALU_3R", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "def", "ORN", ":", "ALU_3R", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "def", "ANDI", ":", "ALU_2RI12", "<NUM_LIT>", ",", "<STR_LIT>", ",", "uimm12", ">", ";", "<BUGS>", "def", "ORI", ":", "ALU_2RI12", "<NUM_LIT>", ",", "<STR_LIT>", ",", "uimm12", ">", ";", "<BUGE>", "def", "XORI", ":", "ALU_2RI12", "<NUM_LIT>", ",", "<STR_LIT>", ",", "uimm12", ">", ";", "def", "MUL_W", ":", "ALU_3R", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";", "def", "MULH_W", ":", "ALU_3R", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";" ]

[ "<FIXS>", "{", "rtx", "src_base", "=", "XEXP", "(", "part", "[", "<NUM_LIT>", "]", "[", "nparts", "-", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ";", "if", "(", "!", "TARGET_64BIT", "&&", "nparts", "==", "<NUM_LIT>", "&&", "mode", "==", "XFmode", "&&", "TARGET_128BIT_LONG_DOUBLE", ")", "src_base", "=", "plus_constant", "(", "src_base", ",", "<NUM_LIT>", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "nparts", ";", "i", "++", ")", "part", "[", "<NUM_LIT>", "]", "[", "i", "]", "=", "change_address", "(", "part", "[", "<NUM_LIT>", "]", "[", "i", "]", ",", "GET_MODE", "(", "part", "[", "<NUM_LIT>", "]", "[", "i", "]", ")", ",", "src_base", ")", ";", "}", "<FIXE>" ]

[ "if", "(", "push", "&&", "MEM_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&&", "reg_overlap_mentioned_p", "(", "stack_pointer_rtx", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "<BUGS>", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "nparts", "-", "<NUM_LIT>", ";", "i", "++", ")", "part", "[", "<NUM_LIT>", "]", "[", "i", "]", "=", "change_address", "(", "part", "[", "<NUM_LIT>", "]", "[", "i", "]", ",", "GET_MODE", "(", "part", "[", "<NUM_LIT>", "]", "[", "i", "]", ")", ",", "XEXP", "(", "part", "[", "<NUM_LIT>", "]", "[", "i", "+", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ")", ";", "<BUGE>" ]

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

[ "let", "isExtended", "=", "<NUM_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>", ";" ]

[ "}" ]

[ "SDValue", "getAddrGlobalLargeGOT", "(", "NodeTy", "*", "N", ",", "EVT", "Ty", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "HiFlag", ",", "unsigned", "LoFlag", ",", "SDValue", "Chain", ",", "const", "MachinePointerInfo", "&", "PtrInfo", ")", "const", "{", "SDLoc", "DL", "(", "N", ")", ";", "SDValue", "Hi", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "Ty", ",", "getTargetNode", "(", "N", ",", "Ty", ",", "DAG", ",", "HiFlag", ")", ")", ";", "Hi", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "Ty", ",", "Hi", ",", "getGlobalReg", "(", "DAG", ",", "Ty", ")", ")", ";", "SDValue", "Wrapper", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "Ty", ",", "Hi", ",", "getTargetNode", "(", "N", ",", "Ty", ",", "DAG", ",", "LoFlag", ")", ")", ";", "return", "DAG", ".", "getLoad", "(", "Ty", ",", "DL", ",", "Chain", ",", "Wrapper", ",", "PtrInfo", ")", ";" ]