Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "default", ":" ]

[ "size", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "op", ")", ")", ";", "operand_length", "=", "h8300_classify_operand", "(", "op", ",", "size", ",", "&", "opclass", ")", ";", "switch", "(", "opclass", ")", "{", "case", "H8OP_REGISTER", ":", "return", "<NUM_LIT>", ";", "case", "H8OP_MEM_BASE", ":", "case", "H8OP_MEM_ABSOLUTE", ":", "case", "H8OP_MEM_COMPLEX", ":", "return", "<NUM_LIT>", "+", "operand_length", ";" ]

[ "}" ]

[ "else", "EmitARMMappingSymbol", "(", ")", ";", "MCELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";" ]

[ "static", "std", "::", "string", "toString", "(", "const", "APFloat", "&", "FP", ")", "{", "if", "(", "FP", ".", "isNaN", "(", ")", "&&", "!", "FP", ".", "bitwiseIsEqual", "(", "APFloat", "::", "getQNaN", "(", "FP", ".", "getSemantics", "(", ")", ")", ")", "&&", "!", "FP", ".", "bitwiseIsEqual", "(", "APFloat", "::", "getQNaN", "(", "FP", ".", "getSemantics", "(", ")", ",", "true", ")", ")", ")", "{", "APInt", "AI", "=", "FP", ".", "bitcastToAPInt", "(", ")", ";", "return", "std", "::", "string", "(", "AI", ".", "isNegative", "(", ")", "?", "<STR_LIT>", "-", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", ")", "+", "<STR_LIT>", "nan:0x", "<STR_LIT>", "+", "utohexstr", "(", "AI", ".", "getZExtValue", "(", ")", "&", "(", "AI", ".", "getBitWidth", "(", ")", "==", "<NUM_LIT>", "?", "INT64_C", "(", "<NUM_LIT>", ")", ":", "INT64_C", "(", "<NUM_LIT>", ")", ")", ",", "true", ")", ";", "}", "static", "const", "size_t", "BufBytes", "=", "<NUM_LIT>", ";", "char", "buf", "[", "BufBytes", "]", ";", "auto", "Written", "=", "FP", ".", "convertToHexString", "(", "buf", ",", "<NUM_LIT>", ",", "false", ",", "APFloat", "::", "rmNearestTiesToEven", ")", ";", "(", "void", ")", "Written", ";", "assert", "(", "Written", "!=", "<NUM_LIT>", ")", ";", "assert", "(", "Written", "<", "BufBytes", ")", ";", "return", "buf", ";", "}" ]

[ "Convert", "to", "a", "decimal", "representation", "in", "a", "string", "." ]

[ "}" ]

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

[ ",", "GIComplexPatternEquiv", "<", "ro_Xindexed8", ">", ";" ]

[ "def", "gi_ro_Xindexed8", ":", "GIComplexOperandMatcher", "<", "s64", ",", "<STR_LIT>", ">" ]

[ "<FIXS>", "string", "asm", ",", "string", "mem", ",", "X86FoldableSchedWrite", "sched", ",", "<FIXE>", "<FIXS>", "def", "rr", ":", "SI", "opc", ",", "MRMSrcReg", ",", "(", "outs", "DstRC", ":", "$", "dst", ")", ",", "(", "ins", "SrcRC", ":", "$", "src", ")", ",", "!", "strconcat", "(", "asm", ",", "<STR_LIT>", ")", ",", "[", "(", "set", "DstRC", ":", "$", "dst", ",", "(", "OpNode", "SrcRC", ":", "$", "src", ")", ")", "]", ">", ",", "Sched", "[", "sched", ",", "Int2Fpu", "]", ">", ";", "def", "rm", ":", "SI", "opc", ",", "MRMSrcMem", ",", "(", "outs", "DstRC", ":", "$", "dst", ")", ",", "(", "ins", "x86memop", ":", "$", "src", ")", ",", "mem", "#", "<STR_LIT>", ",", "[", "(", "set", "DstRC", ":", "$", "dst", ",", "(", "OpNode", "(", "ld_frag", "addr", ":", "$", "src", ")", ")", ")", "]", ">", ",", "Sched", "[", "sched", ".", "Folded", "]", ">", ";", "<FIXE>" ]

[ "multiclass", "sse12_cvt_s", "bits", "<NUM_LIT>", ">", "opc", ",", "RegisterClass", "SrcRC", ",", "RegisterClass", "DstRC", ",", "SDNode", "OpNode", ",", "X86MemOperand", "x86memop", ",", "PatFrag", "ld_frag", ",", "<BUGS>", "string", "asm", ",", "X86FoldableSchedWrite", "sched", ",", "<BUGE>", "SchedRead", "Int2Fpu", "=", "ReadDefault", ">", "{", "<BUGS>", "def", "rr", ":", "SI", "opc", ",", "MRMSrcReg", ",", "(", "outs", "DstRC", ":", "$", "dst", ")", ",", "(", "ins", "SrcRC", ":", "$", "src", ")", ",", "asm", ",", "[", "(", "set", "DstRC", ":", "$", "dst", ",", "(", "OpNode", "SrcRC", ":", "$", "src", ")", ")", "]", ">", ",", "Sched", "[", "sched", ",", "Int2Fpu", "]", ">", ";", "def", "rm", ":", "SI", "opc", ",", "MRMSrcMem", ",", "(", "outs", "DstRC", ":", "$", "dst", ")", ",", "(", "ins", "x86memop", ":", "$", "src", ")", ",", "asm", ",", "[", "(", "set", "DstRC", ":", "$", "dst", ",", "(", "OpNode", "(", "ld_frag", "addr", ":", "$", "src", ")", ")", ")", "]", ">", ",", "Sched", "[", "sched", ".", "Folded", "]", ">", ";", "<BUGE>", "}", "multiclass", "sse12_cvt_p", "bits", "<NUM_LIT>", ">", "opc", ",", "RegisterClass", "RC", ",", "X86MemOperand", "x86memop", "," ]

[ "void", "HexagonTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "isHvxOperation", "(", "N", ",", "DAG", ")", ")", "{", "ReplaceHvxNodeResults", "(", "N", ",", "Results", ",", "DAG", ")", ";", "if", "(", "!", "Results", ".", "empty", "(", ")", ")", "return", ";", "}", "const", "SDLoc", "&", "dl", "(", "N", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SHL", ":", "return", ";", "case", "ISD", "::", "BITCAST", ":", "if", "(", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", "==", "MVT", "::", "i8", ")", "{", "SDValue", "P", "=", "getInstr", "(", "Hexagon", "::", "C2_tfrpr", ",", "dl", ",", "MVT", "::", "i32", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ")", ";", "SDValue", "T", "=", "DAG", ".", "getAnyExtOrTrunc", "(", "P", ",", "dl", ",", "MVT", "::", "i8", ")", ";", "Results", ".", "push_back", "(", "T", ")", ";", "}", "break", ";", "}", "}" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "<FIXS>", "register", "const", "char", "*", "fmt", ";", "<FIXE>" ]

[ "rtx", "x0", "=", "*", "x", ";", "int", "code", "=", "GET_CODE", "(", "x0", ")", ";", "register", "int", "i", ",", "j", ";", "<BUGS>", "register", "char", "*", "fmt", ";", "<BUGE>", "switch", "(", "code", ")", "{" ]

[ "if", "(", "is128BitLaneCrossingShuffleMask", "(", "MVT", "::", "v16i16", ",", "Mask", ")", ")", "return", "lowerVectorShuffleAsLanePermuteAndBlend", "(", "DL", ",", "MVT", "::", "v16i16", ",", "V1", ",", "V2", ",", "Mask", ",", "DAG", ")", ";" ]

[ "ShuffleVectorSDNode", "*", "SVOp", "=", "cast", "<", "ShuffleVectorSDNode", ">", "(", "Op", ")", ";", "ArrayRef", "<", "int", ">", "Mask", "=", "SVOp", "->", "getMask", "(", ")", ";", "assert", "(", "Mask", ".", "size", "(", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Unexpected mask size for v16 shuffle!", "<STR_LIT>", ")", ";", "assert", "(", "Subtarget", ".", "hasAVX2", "(", ")", "&&", "<STR_LIT>", "We can only lower v16i16 with AVX2!", "<STR_LIT>", ")", ";", "if", "(", "SDValue", "ZExt", "=", "lowerVectorShuffleAsZeroOrAnyExtend", "(", "DL", ",", "MVT", "::", "v16i16", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "ZExt", ";", "if", "(", "SDValue", "Broadcast", "=", "lowerVectorShuffleAsBroadcast", "(", "DL", ",", "MVT", "::", "v16i16", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "Broadcast", ";", "if", "(", "SDValue", "Blend", "=", "lowerVectorShuffleAsBlend", "(", "DL", ",", "MVT", "::", "v16i16", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "Blend", ";", "if", "(", "SDValue", "V", "=", "lowerVectorShuffleWithUNPCK", "(", "DL", ",", "MVT", "::", "v16i16", ",", "Mask", ",", "V1", ",", "V2", ",", "DAG", ")", ")", "return", "V", ";", "if", "(", "SDValue", "Shift", "=", "lowerVectorShuffleAsShift", "(", "DL", ",", "MVT", "::", "v16i16", ",", "V1", ",", "V2", ",", "Mask", ",", "DAG", ")", ")", "return", "Shift", ";", "if", "(", "SDValue", "Rotate", "=", "lowerVectorShuffleAsByteRotate", "(", "DL", ",", "MVT", "::", "v16i16", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "Rotate", ";", "if", "(", "SDValue", "V", "=", "lowerShuffleAsRepeatedMaskAndLanePermute", "(", "DL", ",", "MVT", "::", "v16i16", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "V", ";", "if", "(", "isSingleInputShuffleMask", "(", "Mask", ")", ")", "{" ]

[ "static", "void", "mips_output_args_xfer", "(", "int", "fp_code", ",", "char", "direction", ")", "{", "unsigned", "int", "gparg", ",", "fparg", ",", "f", ";", "CUMULATIVE_ARGS", "cum", ";", "gcc_assert", "(", "TARGET_OLDABI", ")", ";", "mips_init_cumulative_args", "(", "&", "cum", ",", "NULL", ")", ";", "for", "(", "f", "=", "(", "unsigned", "int", ")", "fp_code", ";", "f", "!=", "<NUM_LIT>", ";", "f", ">>=", "<NUM_LIT>", ")", "{", "machine_mode", "mode", ";", "struct", "mips_arg_info", "info", ";", "if", "(", "(", "f", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "mode", "=", "SFmode", ";", "else", "if", "(", "(", "f", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "mode", "=", "DFmode", ";", "else", "gcc_unreachable", "(", ")", ";", "mips_get_arg_info", "(", "&", "info", ",", "&", "cum", ",", "mode", ",", "NULL", ",", "true", ")", ";", "gparg", "=", "mips_arg_regno", "(", "&", "info", ",", "false", ")", ";", "fparg", "=", "mips_arg_regno", "(", "&", "info", ",", "true", ")", ";", "if", "(", "mode", "==", "SFmode", ")", "mips_output_32bit_xfer", "(", "direction", ",", "gparg", ",", "fparg", ")", ";", "else", "mips_output_64bit_xfer", "(", "direction", ",", "gparg", ",", "fparg", ")", ";", "mips_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "cum", ")", ",", "mode", ",", "NULL", ",", "true", ")", ";", "}", "}" ]

[ "Write", "out", "code", "to", "move", "floating-point", "arguments", "into", "or", "out", "of", "general", "registers", ".", "FP_CODE", "is", "the", "code", "describing", "which", "arguments", "are", "present", "(", "see", "the", "comment", "above", "the", "definition", "of", "CUMULATIVE_ARGS", "in", "mips.h", ")", ".", "DIRECTION", "is", "as", "for", "mips_output_32bit_xfer", "." ]

[ "offset", ")", ")", "]", ">", ",", "Sched", "<", "[", "WriteAdr", ",", "WriteST", "]", ">", ";" ]

[ "class", "StorePostIdx", "<", "bits", "<", "<NUM_LIT>", ">", "sz", ",", "bit", "V", ",", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "RegisterOperand", "regtype", ",", "string", "asm", ",", "SDPatternOperator", "storeop", ",", "ValueType", "Ty", ">", ":", "BaseLoadStorePostIdx", "<", "sz", ",", "V", ",", "opc", ",", "(", "outs", "GPR64sp", ":", "$", "wback", ")", ",", "(", "ins", "regtype", ":", "$", "Rt", ",", "GPR64sp", ":", "$", "Rn", ",", "simm9", ":", "$", "offset", ")", ",", "asm", ",", "<STR_LIT>", ",", "[", "(", "set", "GPR64sp", ":", "$", "wback", ",", "(", "storeop", "(", "Ty", "regtype", ":", "$", "Rt", ")", ",", "GPR64sp", ":", "$", "Rn", ",", "simm9", ":", "$" ]

[ "for", "(", "unsigned", "Reg", ":", "Extras", ")", "{" ]

[ "--", "RegDeficit", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "PrintReg", "(", "Reg", ",", "TRI", ")", "<<", "<STR_LIT>", " is saved low register, RegDeficit = ", "<STR_LIT>", "<<", "RegDeficit", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "}", "else", "{", "AvailableRegs", ".", "push_back", "(", "Reg", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "PrintReg", "(", "Reg", ",", "TRI", ")", "<<", "<STR_LIT>", " is non-saved low register, adding to AvailableRegs\\n", "<STR_LIT>", ")", ";", "}", "}", "if", "(", "!", "HasFP", ")", "{", "if", "(", "SavedRegs", ".", "test", "(", "ARM", "::", "R7", ")", ")", "{", "--", "RegDeficit", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "%R7 is saved low register, RegDeficit = ", "<STR_LIT>", "<<", "RegDeficit", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "}", "else", "{", "AvailableRegs", ".", "push_back", "(", "ARM", "::", "R7", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "%R7 is non-saved low register, adding to AvailableRegs\\n", "<STR_LIT>", ")", ";", "}", "}", "for", "(", "unsigned", "Reg", ":", "{", "ARM", "::", "R8", ",", "ARM", "::", "R9", ",", "ARM", "::", "R10", ",", "ARM", "::", "R11", "}", ")", "{", "if", "(", "SavedRegs", ".", "test", "(", "Reg", ")", ")", "{", "++", "RegDeficit", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "PrintReg", "(", "Reg", ",", "TRI", ")", "<<", "<STR_LIT>", " is saved high register, RegDeficit = ", "<STR_LIT>", "<<", "RegDeficit", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "}", "}", "if", "(", "(", "EntryRegDeficit", ">", "ExitRegDeficit", ")", "&&", "!", "(", "MF", ".", "getRegInfo", "(", ")", ".", "isLiveIn", "(", "ARM", "::", "LR", ")", "&&", "MF", ".", "getFrameInfo", "(", ")", ".", "isReturnAddressTaken", "(", ")", ")", ")", "{", "if", "(", "SavedRegs", ".", "test", "(", "ARM", "::", "LR", ")", ")", "{", "--", "RegDeficit", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "%LR is saved register, RegDeficit = ", "<STR_LIT>", "<<", "RegDeficit", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "}", "else", "{", "AvailableRegs", ".", "push_back", "(", "ARM", "::", "LR", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "%LR is not saved, adding to AvailableRegs\\n", "<STR_LIT>", ")", ";", "}", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Final RegDeficit = ", "<STR_LIT>", "<<", "RegDeficit", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "for", "(", ";", "RegDeficit", ">", "<NUM_LIT>", "&&", "!", "AvailableRegs", ".", "empty", "(", ")", ";", "--", "RegDeficit", ")", "{", "unsigned", "Reg", "=", "AvailableRegs", ".", "pop_back_val", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Spilling ", "<STR_LIT>", "<<", "PrintReg", "(", "Reg", ",", "TRI", ")", "<<", "<STR_LIT>", " to make up reg deficit\\n", "<STR_LIT>", ")", ";", "SavedRegs", ".", "set", "(", "Reg", ")", ";", "NumGPRSpills", "++", ";", "CS1Spilled", "=", "true", ";", "assert", "(", "!", "MRI", ".", "isReserved", "(", "Reg", ")", "&&", "<STR_LIT>", "Should not be reserved", "<STR_LIT>", ")", ";", "if", "(", "!", "MRI", ".", "isPhysRegUsed", "(", "Reg", ")", ")", "ExtraCSSpill", "=", "true", ";", "UnspilledCS1GPRs", ".", "erase", "(", "llvm", "::", "find", "(", "UnspilledCS1GPRs", ",", "Reg", ")", ")", ";", "if", "(", "Reg", "==", "ARM", "::", "LR", ")", "LRSpilled", "=", "true", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "After adding spills, RegDeficit = ", "<STR_LIT>", "<<", "RegDeficit", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "}", "if", "(", "!", "LRSpilled", "&&", "CS1Spilled", ")", "{", "SavedRegs", ".", "set", "(", "ARM", "::", "LR", ")", ";", "NumGPRSpills", "++", ";", "SmallVectorImpl", "<", "unsigned", ">", "::", "iterator", "LRPos", ";", "LRPos", "=", "llvm", "::", "find", "(", "UnspilledCS1GPRs", ",", "(", "unsigned", ")", "ARM", "::", "LR", ")", ";", "if", "(", "LRPos", "!=", "UnspilledCS1GPRs", ".", "end", "(", ")", ")", "UnspilledCS1GPRs", ".", "erase", "(", "LRPos", ")", ";", "ForceLRSpill", "=", "false", ";", "if", "(", "!", "MRI", ".", "isReserved", "(", "ARM", "::", "LR", ")", "&&", "!", "MRI", ".", "isPhysRegUsed", "(", "ARM", "::", "LR", ")", ")", "ExtraCSSpill", "=", "true", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "NumGPRSpills = ", "<STR_LIT>", "<<", "NumGPRSpills", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "unsigned", "TargetAlign", "=", "getStackAlignment", "(", ")", ";", "if", "(", "TargetAlign", ">=", "<NUM_LIT>", "&&", "(", "NumGPRSpills", "&", "<NUM_LIT>", ")", ")", "{", "if", "(", "CS1Spilled", "&&", "!", "UnspilledCS1GPRs", ".", "empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "UnspilledCS1GPRs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "UnspilledCS1GPRs", "[", "i", "]", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", "||", "(", "STI", ".", "isTargetWindows", "(", ")", "&&", "Reg", "==", "ARM", "::", "R11", ")", "||", "isARMLowRegister", "(", "Reg", ")", "||", "Reg", "==", "ARM", "::", "LR", ")", "{", "SavedRegs", ".", "set", "(", "Reg", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Spilling ", "<STR_LIT>", "<<", "PrintReg", "(", "Reg", ",", "TRI", ")", "<<", "<STR_LIT>", " to make up alignment\\n", "<STR_LIT>", ")", ";", "if", "(", "!", "MRI", ".", "isReserved", "(", "Reg", ")", "&&", "!", "MRI", ".", "isPhysRegUsed", "(", "Reg", ")", ")", "ExtraCSSpill", "=", "true", ";", "break", ";", "}", "}", "}", "else", "if", "(", "!", "UnspilledCS2GPRs", ".", "empty", "(", ")", "&&", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", ")", "{", "unsigned", "Reg", "=", "UnspilledCS2GPRs", ".", "front", "(", ")", ";", "SavedRegs", ".", "set", "(", "Reg", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Spilling ", "<STR_LIT>", "<<", "PrintReg", "(", "Reg", ",", "TRI", ")", "<<", "<STR_LIT>", " to make up alignment\\n", "<STR_LIT>", ")", ";", "if", "(", "!", "MRI", ".", "isReserved", "(", "Reg", ")", "&&", "!", "MRI", ".", "isPhysRegUsed", "(", "Reg", ")", ")", "ExtraCSSpill", "=", "true", ";", "}", "}", "if", "(", "BigFrameOffsets", "&&", "!", "ExtraCSSpill", ")", "{", "unsigned", "NumExtras", "=", "TargetAlign", "/", "<NUM_LIT>", ";", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "Extras", ";", "while", "(", "NumExtras", "&&", "!", "UnspilledCS1GPRs", ".", "empty", "(", ")", ")", "{", "unsigned", "Reg", "=", "UnspilledCS1GPRs", ".", "back", "(", ")", ";", "UnspilledCS1GPRs", ".", "pop_back", "(", ")", ";", "if", "(", "!", "MRI", ".", "isReserved", "(", "Reg", ")", "&&", "(", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", "||", "isARMLowRegister", "(", "Reg", ")", "||", "Reg", "==", "ARM", "::", "LR", ")", ")", "{", "Extras", ".", "push_back", "(", "Reg", ")", ";", "NumExtras", "--", ";", "}", "}", "if", "(", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", ")", "{", "while", "(", "NumExtras", "&&", "!", "UnspilledCS2GPRs", ".", "empty", "(", ")", ")", "{", "unsigned", "Reg", "=", "UnspilledCS2GPRs", ".", "back", "(", ")", ";", "UnspilledCS2GPRs", ".", "pop_back", "(", ")", ";", "if", "(", "!", "MRI", ".", "isReserved", "(", "Reg", ")", ")", "{", "Extras", ".", "push_back", "(", "Reg", ")", ";", "NumExtras", "--", ";", "}", "}", "}", "if", "(", "NumExtras", "==", "<NUM_LIT>", ")", "{" ]

[ ",", "Bitcast", ",", "TwoP52FP", ")", ";" ]

[ "const", "LLT", "s64", "=", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "G_LOAD", ":", "case", "G_STORE", ":", "{", "unsigned", "MemSize", "=", "(", "*", "*", "MI", ".", "memoperands_begin", "(", ")", ")", ".", "getSize", "(", ")", ";", "Register", "Val", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "Size", "=", "MRI", ".", "getType", "(", "Val", ")", ".", "getSizeInBits", "(", ")", ";", "MachineMemOperand", "*", "MMOBase", "=", "*", "MI", ".", "memoperands_begin", "(", ")", ";", "assert", "(", "MemSize", "<=", "<NUM_LIT>", "&&", "<STR_LIT>", "MemSize is too large", "<STR_LIT>", ")", ";", "assert", "(", "Size", "<=", "<NUM_LIT>", "&&", "<STR_LIT>", "Scalar size is too large", "<STR_LIT>", ")", ";", "unsigned", "P2HalfMemSize", ",", "RemMemSize", ";", "if", "(", "isPowerOf2_64", "(", "MemSize", ")", ")", "{", "P2HalfMemSize", "=", "RemMemSize", "=", "MemSize", "/", "<NUM_LIT>", ";", "}", "else", "{", "P2HalfMemSize", "=", "<NUM_LIT>", "<<", "Log2_32", "(", "MemSize", ")", ";", "RemMemSize", "=", "MemSize", "-", "P2HalfMemSize", ";", "}", "Register", "BaseAddr", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "LLT", "PtrTy", "=", "MRI", ".", "getType", "(", "BaseAddr", ")", ";", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "auto", "P2HalfMemOp", "=", "MF", ".", "getMachineMemOperand", "(", "MMOBase", ",", "<NUM_LIT>", ",", "P2HalfMemSize", ")", ";", "auto", "RemMemOp", "=", "MF", ".", "getMachineMemOperand", "(", "MMOBase", ",", "P2HalfMemSize", ",", "RemMemSize", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "G_STORE", ")", "{", "if", "(", "Size", "<", "<NUM_LIT>", ")", "Val", "=", "MIRBuilder", ".", "buildAnyExt", "(", "s32", ",", "Val", ")", ".", "getReg", "(", "<NUM_LIT>", ")", ";", "if", "(", "Size", ">", "<NUM_LIT>", "&&", "Size", "<", "<NUM_LIT>", ")", "Val", "=", "MIRBuilder", ".", "buildAnyExt", "(", "s64", ",", "Val", ")", ".", "getReg", "(", "<NUM_LIT>", ")", ";", "auto", "C_P2HalfMemSize", "=", "MIRBuilder", ".", "buildConstant", "(", "s32", ",", "P2HalfMemSize", ")", ";", "auto", "Addr", "=", "MIRBuilder", ".", "buildPtrAdd", "(", "PtrTy", ",", "BaseAddr", ",", "C_P2HalfMemSize", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "G_STORE", "&&", "MemSize", "<=", "<NUM_LIT>", ")", "{", "MIRBuilder", ".", "buildStore", "(", "Val", ",", "BaseAddr", ",", "*", "P2HalfMemOp", ")", ";", "auto", "C_P2Half_InBits", "=", "MIRBuilder", ".", "buildConstant", "(", "s32", ",", "P2HalfMemSize", "*", "<NUM_LIT>", ")", ";", "auto", "Shift", "=", "MIRBuilder", ".", "buildLShr", "(", "s32", ",", "Val", ",", "C_P2Half_InBits", ")", ";", "MIRBuilder", ".", "buildStore", "(", "Shift", ",", "Addr", ",", "*", "RemMemOp", ")", ";", "}", "else", "{", "auto", "Unmerge", "=", "MIRBuilder", ".", "buildUnmerge", "(", "s32", ",", "Val", ")", ";", "MIRBuilder", ".", "buildStore", "(", "Unmerge", ".", "getReg", "(", "<NUM_LIT>", ")", ",", "BaseAddr", ",", "*", "P2HalfMemOp", ")", ";", "MIRBuilder", ".", "buildStore", "(", "Unmerge", ".", "getReg", "(", "<NUM_LIT>", ")", ",", "Addr", ",", "*", "RemMemOp", ")", ";", "}", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "G_LOAD", ")", "{", "if", "(", "MemSize", "<=", "<NUM_LIT>", ")", "{", "auto", "*", "Load4MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MMOBase", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "if", "(", "Size", "==", "<NUM_LIT>", ")", "MIRBuilder", ".", "buildLoad", "(", "Val", ",", "BaseAddr", ",", "*", "Load4MMO", ")", ";", "else", "{", "auto", "Load", "=", "MIRBuilder", ".", "buildLoad", "(", "s32", ",", "BaseAddr", ",", "*", "Load4MMO", ")", ";", "MIRBuilder", ".", "buildTrunc", "(", "Val", ",", "Load", ".", "getReg", "(", "<NUM_LIT>", ")", ")", ";", "}", "}", "else", "{", "auto", "C_P2HalfMemSize", "=", "MIRBuilder", ".", "buildConstant", "(", "s32", ",", "P2HalfMemSize", ")", ";", "auto", "Addr", "=", "MIRBuilder", ".", "buildPtrAdd", "(", "PtrTy", ",", "BaseAddr", ",", "C_P2HalfMemSize", ")", ";", "auto", "Load_P2Half", "=", "MIRBuilder", ".", "buildLoad", "(", "s32", ",", "BaseAddr", ",", "*", "P2HalfMemOp", ")", ";", "auto", "Load_Rem", "=", "MIRBuilder", ".", "buildLoad", "(", "s32", ",", "Addr", ",", "*", "RemMemOp", ")", ";", "if", "(", "Size", "==", "<NUM_LIT>", ")", "MIRBuilder", ".", "buildMerge", "(", "Val", ",", "{", "Load_P2Half", ",", "Load_Rem", "}", ")", ";", "else", "{", "auto", "Merge", "=", "MIRBuilder", ".", "buildMerge", "(", "s64", ",", "{", "Load_P2Half", ",", "Load_Rem", "}", ")", ";", "MIRBuilder", ".", "buildTrunc", "(", "Val", ",", "Merge", ")", ";", "}", "}", "}", "MI", ".", "eraseFromParent", "(", ")", ";", "break", ";", "}", "case", "G_UITOFP", ":", "{", "Register", "Dst", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Register", "Src", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "LLT", "DstTy", "=", "MRI", ".", "getType", "(", "Dst", ")", ";", "LLT", "SrcTy", "=", "MRI", ".", "getType", "(", "Src", ")", ";", "if", "(", "SrcTy", "!=", "s32", ")", "return", "false", ";", "if", "(", "DstTy", "!=", "s32", "&&", "DstTy", "!=", "s64", ")", "return", "false", ";", "auto", "C_HiMask", "=", "MIRBuilder", ".", "buildConstant", "(", "s32", ",", "UINT32_C", "(", "<NUM_LIT>", ")", ")", ";", "auto", "Bitcast", "=", "MIRBuilder", ".", "buildMerge", "(", "s64", ",", "{", "Src", ",", "C_HiMask", ".", "getReg", "(", "<NUM_LIT>", ")", "}", ")", ";", "MachineInstrBuilder", "TwoP52FP", "=", "MIRBuilder", ".", "buildFConstant", "(", "s64", ",", "BitsToDouble", "(", "UINT64_C", "(", "<NUM_LIT>", ")", ")", ")", ";", "if", "(", "DstTy", "==", "s64", ")", "MIRBuilder", ".", "buildFSub", "(", "Dst", ",", "Bitcast", ",", "TwoP52FP", ")", ";", "else", "{", "MachineInstrBuilder", "ResF64", "=", "MIRBuilder", ".", "buildFSub", "(", "s64" ]

[ "}" ]

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

[ "<STR_LIT>", ")" ]

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

[ "<FIXS>", "DenseMap", "unsigned", "*", ",", "std", "::", "pair", "unsigned", ",", "unsigned", ">", ">", "::", "const_iterator", "I", "=", "<FIXE>" ]

[ "if", "(", "OpcodeTablePtr", ")", "{", "<BUGS>", "DenseMap", "unsigned", "*", ",", "std", "::", "pair", "unsigned", ",", "unsigned", ">", ">", "::", "iterator", "I", "=", "<BUGE>", "OpcodeTablePtr", "->", "find", "(", "(", "unsigned", "*", ")", "Opc", ")", ";", "if", "(", "I", "!=", "OpcodeTablePtr", "->", "end", "(", ")", ")", "return", "true", ";" ]

[ "_", "_", "builtin_neon_vst2v2si", "(", "(", "_", "_", "builtin_neon_si", "*", ")", "_", "_", "a", ",", "_", "_", "bu", ".", "_", "_", "o", ")", ";" ]

[ "vst2_u32", "(", "uint32_t", "*", "_", "_", "a", ",", "uint32x2x2_t", "_", "_", "b", ")", "{", "union", "{", "uint32x2x2_t", "_", "_", "i", ";", "_", "_", "builtin_neon_ti", "_", "_", "o", ";", "}", "_", "_", "bu", "=", "{", "_", "_", "b", "}", ";" ]

[ "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", ")", "{" ]

[ "unsigned", "FuncSize", "=", "<NUM_LIT>", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "Fn", ".", "begin", "(", ")", ",", "E", "=", "Fn", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "MFI", ";", "unsigned", "BlockSize", "=", "<NUM_LIT>", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", "->", "begin", "(", ")", ",", "EE", "=", "MBB", "->", "end", "(", ")", ";", "MBBI", "!=", "EE", ";", "++", "MBBI", ")", "BlockSize", "+=", "TII", "->", "GetInstSizeInBytes", "(", "MBBI", ")", ";", "BlockSizes", "[", "MBB", "->", "getNumber", "(", ")", "]", "=", "BlockSize", ";", "FuncSize", "+=", "BlockSize", ";", "}", "if", "(", "FuncSize", "<", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", ")", "{", "BlockSizes", ".", "clear", "(", ")", ";", "return", "false", ";", "}", "bool", "MadeChange", "=", "true", ";", "bool", "EverMadeChange", "=", "false", ";", "while", "(", "MadeChange", ")", "{", "MadeChange", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "Fn", ".", "begin", "(", ")", ",", "E", "=", "Fn", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";", "unsigned", "MBBStartOffset", "=", "<NUM_LIT>", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "PPC", "::", "BCC", "||" ]

[ "}" ]

[ "uint8_t", "Cost", "=", "<NUM_LIT>", ";", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "return", "TargetLowering", "::", "findRepresentativeClass", "(", "TRI", ",", "VT", ")", ";", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "i64", ":", "RRC", "=", "Subtarget", ".", "is64Bit", "(", ")", "?", "&", "X86", "::", "GR64RegClass", ":", "&", "X86", "::", "GR32RegClass", ";", "break", ";", "case", "MVT", "::", "x86mmx", ":", "RRC", "=", "&", "X86", "::", "VR64RegClass", ";", "break", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "case", "MVT", "::", "v16i8", ":", "case", "MVT", "::", "v8i16", ":", "case", "MVT", "::", "v4i32", ":", "case", "MVT", "::", "v2i64", ":", "case", "MVT", "::", "v4f32", ":", "case", "MVT", "::", "v2f64", ":", "case", "MVT", "::", "v32i8", ":", "case", "MVT", "::", "v16i16", ":", "case", "MVT", "::", "v8i32", ":", "case", "MVT", "::", "v4i64", ":", "case", "MVT", "::", "v8f32", ":", "case", "MVT", "::", "v4f64", ":", "case", "MVT", "::", "v64i8", ":", "case", "MVT", "::", "v32i16", ":", "case", "MVT", "::", "v16i32", ":", "case", "MVT", "::", "v8i64", ":", "case", "MVT", "::", "v16f32", ":", "case", "MVT", "::", "v8f64", ":", "RRC", "=", "&", "X86", "::", "VR128XRegClass", ";", "break", ";" ]

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

[ "(", "match_operand", ":", "VIMAX_AVX512VL", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "/", "<NUM_LIT>", ")", "return", "<STR_LIT>", "}" ]

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

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

[ "regy2", "=", "force_reg", "(", "Pmode", ",", "force_operand", "(", "XEXP", "(", "y", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ";" ]

[ "rtx", "legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", "ATTRIBUTE_UNUSED", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "flag_pic", "&&", "!", "legitimate_pic_operand_p", "(", "x", ")", ")", "x", "=", "legitimize_pic_address", "(", "oldx", ",", "NULL_RTX", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "symbolic_operand", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "VOIDmode", ")", ")", "{", "rtx", "regx1", ",", "regy1", ",", "regy2", ",", "y", ";", "y", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "y", ")", "==", "CONST", ")", "y", "=", "XEXP", "(", "y", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "y", ")", "==", "PLUS", "||", "GET_CODE", "(", "y", ")", "==", "MINUS", ")", "{", "regx1", "=", "force_reg", "(", "Pmode", ",", "force_operand", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ";", "regy1", "=", "force_reg", "(", "Pmode", ",", "force_operand", "(", "XEXP", "(", "y", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ";" ]

[ "return", "combineAddOrSubToADCOrSBB", "(", "N", ",", "DAG", ")", ";" ]

[ "if", "(", "SDValue", "MAdd", "=", "combineLoopMAddPattern", "(", "N", ",", "DAG", ",", "Subtarget", ")", ")", "return", "MAdd", ";", "}", "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "SDValue", "Op0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Op1", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "(", "(", "Subtarget", ".", "hasSSSE3", "(", ")", "&&", "(", "VT", "==", "MVT", "::", "v8i16", "||", "VT", "==", "MVT", "::", "v4i32", ")", ")", "||", "(", "Subtarget", ".", "hasInt256", "(", ")", "&&", "(", "VT", "==", "MVT", "::", "v16i16", "||", "VT", "==", "MVT", "::", "v8i32", ")", ")", ")", "&&", "isHorizontalBinOp", "(", "Op0", ",", "Op1", ",", "true", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "SDLoc", "(", "N", ")", ",", "VT", ",", "Op0", ",", "Op1", ")", ";" ]

[ "}" ]

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

[ ",", "(", "v16i8", "V128", ":", "$", "Rm", ")", ")", ")", ")", "]", ">", ";" ]

[ "def", "v16i8", ":", "BaseSIMDThreeSameVector", "<", "<NUM_LIT>", ",", "U", ",", "<NUM_LIT>", ",", "opc", ",", "V128", ",", "asm", ",", "<STR_LIT>", ",", "[", "(", "set", "V128", ":", "$", "Rd", ",", "(", "v16i8", "(", "OpNode", "(", "v16i8", "V128", ":", "$", "Rn", ")" ]

[ "const", "{" ]

[ "const", "uint16_t", "*", "XNCMRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")" ]

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

[ "class", "PRECRQ_QB_PH_DESC", ":", "CMP_EQ_QB_R3_DESC_BASE", "<", "<STR_LIT>", ",", "int_mips_precrq_qb_ph", ",", "NoItinerary", ",", "DSPROpnd", "," ]

[ "}" ]

[ "ARMConstantPoolValue", "*", "CPV", "=", "ARMConstantPoolSymbol", "::", "Create", "(", "*", "Context", ",", "<STR_LIT>", "_GLOBAL_OFFSET_TABLE_", "<STR_LIT>", ",", "ARMPCLabelIndex", ",", "PCAdj", ")", ";", "unsigned", "Align", "=", "MF", ".", "getDataLayout", "(", ")", ".", "getPrefTypeAlignment", "(", "Type", "::", "getInt32PtrTy", "(", "*", "Context", ")", ")", ";", "unsigned", "Idx", "=", "MF", ".", "getConstantPool", "(", ")", "->", "getConstantPoolIndex", "(", "CPV", ",", "Align", ")", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "FirstMBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "unsigned", "TempReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "ARM", "::", "rGPRRegClass", ")", ";", "unsigned", "Opc", "=", "STI", ".", "isThumb2", "(", ")", "?", "ARM", "::", "t2LDRpci", ":", "ARM", "::", "LDRcp", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "TempReg", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "LDRcp", ")", "MIB", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "unsigned", "GlobalBaseReg", "=", "AFI", "->", "getGlobalBaseReg", "(", ")", ";", "Opc", "=", "STI", ".", "isThumb2", "(", ")", "?", "ARM", "::", "tPICADD", ":", "ARM", "::", "PICADD", ";", "MIB", "=", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "TempReg", ")", ".", "addImm", "(", "ARMPCLabelIndex", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "PICADD", ")", "AddDefaultPred", "(", "MIB", ")", ";", "return", "true", ";" ]

[ "}" ]

[ "MVT", "VT", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ".", "getSimpleVT", "(", ")", ";", "unsigned", "BitWidth", "=", "KnownZero", ".", "getBitWidth", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "v8i8", "||", "VT", "==", "MVT", "::", "v16i8", ")", "{", "assert", "(", "BitWidth", ">=", "<NUM_LIT>", "&&", "<STR_LIT>", "Unexpected width!", "<STR_LIT>", ")", ";", "APInt", "Mask", "=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "<NUM_LIT>", ")", ";", "KnownZero", "|=", "Mask", ";", "}", "else", "if", "(", "VT", "==", "MVT", "::", "v4i16", "||", "VT", "==", "MVT", "::", "v8i16", ")", "{", "assert", "(", "BitWidth", ">=", "<NUM_LIT>", "&&", "<STR_LIT>", "Unexpected width!", "<STR_LIT>", ")", ";", "APInt", "Mask", "=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "<NUM_LIT>", ")", ";", "KnownZero", "|=", "Mask", ";", "}", "break", ";", "}", "break", ";", "}", "}", "}" ]

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

[ "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "HexagonConstEvaluator", "HCE", "(" ]

[ "bool", "Emitter", "<", "CodeEmitter", ">", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MMI", "=", "&", "getAnalysis", "<", "MachineModuleInfo", ">", "(", ")", ";", "MCE", ".", "setModuleInfo", "(", "MMI", ")", ";", "II", "=", "TM", ".", "getInstrInfo", "(", ")", ";", "TD", "=", "TM", ".", "getTargetData", "(", ")", ";", "Is64BitMode", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ";", "IsPIC", "=", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ";", "do", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "JITTing function '", "<STR_LIT>", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "<STR_LIT>", "'\\n", "<STR_LIT>", ")", ";", "MCE", ".", "startFunction", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MBB", "!=", "E", ";", "++", "MBB", ")", "{", "MCE", ".", "StartMachineBasicBlock", "(", "MBB", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", "->", "begin", "(", ")", ",", "E", "=", "MBB", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "const", "MCInstrDesc", "&", "Desc", "=", "I", "->", "getDesc", "(", ")", ";", "emitInstruction", "(", "*", "I", ",", "&", "Desc", ")", ";", "if", "(", "Desc", ".", "getOpcode", "(", ")", "==", "X86", "::", "MOVPC32r", ")", "emitInstruction", "(", "*", "I", ",", "&", "II", "->", "get", "(", "X86", "::", "POP32r", ")", ")", ";", "++", "NumEmitted", ";", "}", "}", "}", "while", "(", "MCE", ".", "finishFunction", "(", "MF", ")", ")", ";", "return", "false", ";", "}" ]

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

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

[ "def", "J4_cmpgti_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", "=", "<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>", ";" ]

[ "}" ]

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

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

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

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

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

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

[ "char", "*", "str", "=", "strcpy", "(", "(", "char", "*", ")", "alloca", "(", "strlen", "(", "const_str", ")", "+", "<NUM_LIT>", ")", ",", "const_str", ")", ";", "while", "(", "<NUM_LIT>", ")", "{", "char", "*", "dash", "=", "strchr", "(", "str", ",", "'", "-", "'", ")", ";", "if", "(", "!", "dash", ")", "{", "warning", "(", "<NUM_LIT>", ",", "<STR_LIT>", "value of %<-mfixed-range%> must have form REG1-REG2", "<STR_LIT>", ")", ";", "return", ";", "}", "*", "dash", "=", "'", "\\0", "'", ";", "char", "*", "comma", "=", "strchr", "(", "dash", "+", "<NUM_LIT>", ",", "'", ",", "'", ")", ";", "if", "(", "comma", ")", "*", "comma", "=", "'", "\\0", "'", ";", "int", "first", "=", "decode_reg_name", "(", "str", ")", ";", "if", "(", "first", "<", "<NUM_LIT>", ")", "{", "warning", "(", "<NUM_LIT>", ",", "<STR_LIT>", "unknown register name: %s", "<STR_LIT>", ",", "str", ")", ";", "return", ";", "}", "int", "last", "=", "decode_reg_name", "(", "dash" ]

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

[ "(", "and", "(" ]

[ "unsigned", "PPCVSXSwapRemoval", "::", "lookThruCopyLike", "(", "unsigned", "SrcReg", ",", "unsigned", "VecIdx", ")", "{", "MachineInstr", "*", "MI", "=", "MRI", "->", "getVRegDef", "(", "SrcReg", ")", ";", "if", "(", "!", "MI", "->", "isCopyLike", "(", ")", ")", "return", "SrcReg", ";", "unsigned", "CopySrcReg", ";", "if", "(", "MI", "->", "isCopy", "(", ")", ")", "CopySrcReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "else", "{", "assert", "(", "MI", "->", "isSubregToReg", "(", ")", "&&", "<STR_LIT>", "bad opcode for lookThruCopyLike", "<STR_LIT>", ")", ";", "CopySrcReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "}", "if", "(", "!", "Register", "::", "isVirtualRegister", "(", "CopySrcReg", ")", ")", "{", "if", "(", "!", "isScalarVecReg", "(", "CopySrcReg", ")", ")", "SwapVector", "[", "VecIdx", "]", ".", "MentionsPhysVR", "=", "<NUM_LIT>", ";", "return", "CopySrcReg", ";", "}", "return", "lookThruCopyLike", "(", "CopySrcReg", ",", "VecIdx", ")", ";", "}" ]

[ "Returns", "the", "original", "SrcReg", "unless", "it", "is", "the", "target", "of", "a", "copy-like", "operation", ",", "in", "which", "case", "we", "chain", "backwards", "through", "all", "such", "operations", "to", "the", "ultimate", "source", "register", "." ]

[ "<NUM_LIT>", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";", "let", "SrcA", "=", "<NUM_LIT>", ";", "let", "HasImm", "=", "<NUM_LIT>", ";", "let", "immOpNum", "=" ]

[ "}" ]

[ "_", "_", "arm_vreinterpretq_s16_s64", "(", "int64x2_t", "_", "_", "a", ")", "{", "return", "(", "int16x8_t", ")", "_", "_", "a", ";" ]

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

[ "unsigned", "PPCMCCodeEmitter", "::", "getTLSRegEncoding", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "getMachineOpValue", "(", "MI", ",", "MO", "," ]

[ "DAG", ".", "getConstant", "(", "Offset", ",", "SL", ",", "PtrVT", ")", ")", ";" ]

[ "const", "SIRegisterInfo", "*", "TRI", "=", "getSubtarget", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "unsigned", "InputPtrReg", "=", "TRI", "->", "getPreloadedValue", "(", "MF", ",", "SIRegisterInfo", "::", "KERNARG_SEGMENT_PTR", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ";", "MVT", "PtrVT", "=", "getPointerTy", "(", "DL", ",", "AMDGPUASI", ".", "CONSTANT_ADDRESS", ")", ";", "SDValue", "BasePtr", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "SL", ",", "MRI", ".", "getLiveInVirtReg", "(", "InputPtrReg", ")", ",", "PtrVT", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "SL", ",", "PtrVT", ",", "BasePtr", "," ]

[ "StringRef", "Msg", ";" ]

[ "auto", "*", "CA", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Ptr", ")", ";", "if", "(", "!", "CA", ")", "return", "true", ";", "unsigned", "Addr", "=", "CA", "->", "getZExtValue", "(", ")", ";", "Align", "HaveAlign", "=", "Addr", "!=", "<NUM_LIT>", "?", "Align", "(", "<NUM_LIT>", "ull", "<<", "llvm", "::", "countr_zero", "(", "Addr", ")", ")", ":", "NeedAlign", ";", "if", "(", "HaveAlign", ">=", "NeedAlign", ")", "return", "true", ";", "static", "int", "DK_MisalignedTrap", "=", "llvm", "::", "getNextAvailablePluginDiagnosticKind", "(", ")", ";", "struct", "DiagnosticInfoMisalignedTrap", ":", "public", "DiagnosticInfo", "{", "DiagnosticInfoMisalignedTrap", "(", "StringRef", "M", ")", ":", "DiagnosticInfo", "(", "DK_MisalignedTrap", ",", "DS_Remark", ")", ",", "Msg", "(", "M", ")", "{", "}", "void", "print", "(", "DiagnosticPrinter", "&", "DP", ")", "const", "override", "{", "DP", "<<", "Msg", ";", "}", "static", "bool", "classof", "(", "const", "DiagnosticInfo", "*", "DI", ")", "{", "return", "DI", "->", "getKind", "(", ")", "==", "DK_MisalignedTrap", ";", "}" ]

[ "I", "->", "eraseFromParent", "(", ")", ";" ]

[ "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "return", "<NUM_LIT>", ";", "--", "I", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", "&&", "I", "->", "getOpcode", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "<NUM_LIT>", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "MVT", "::", "v4i32", ",", "AnyExt", ")", ")", ";" ]

[ "LLVMContext", "*", "Context", "=", "DAG", ".", "getContext", "(", ")", ";", "DebugLoc", "dl", "=", "Op", ".", "getDebugLoc", "(", ")", ";", "MVT", "OpVT", "=", "Op", ".", "getValueType", "(", ")", ".", "getSimpleVT", "(", ")", ";", "if", "(", "!", "OpVT", ".", "is128BitVector", "(", ")", ")", "{", "EVT", "VT128", "=", "EVT", "::", "getVectorVT", "(", "*", "Context", ",", "OpVT", ".", "getVectorElementType", "(", ")", ",", "OpVT", ".", "getVectorNumElements", "(", ")", "/", "<NUM_LIT>", ")", ";", "Op", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "dl", ",", "VT128", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "return", "Insert128BitVector", "(", "DAG", ".", "getUNDEF", "(", "OpVT", ")", ",", "Op", ",", "<NUM_LIT>", ",", "DAG", ",", "dl", ")", ";", "}", "if", "(", "OpVT", "==", "MVT", "::", "v1i64", "&&", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "i64", ")", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "dl", ",", "MVT", "::", "v1i64", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "AnyExt", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "dl", ",", "MVT", "::", "i32", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "assert", "(", "OpVT", ".", "is128BitVector", "(", ")", "&&", "<STR_LIT>", "Expected an SSE type!", "<STR_LIT>", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "OpVT", ",", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "dl", "," ]

[ "}" ]

[ "ModulePass", "*", "llvm", "::", "createAMDGPUUnifyMetadataPass", "(", ")", "{", "return", "new", "AMDGPUUnifyMetadata", "(", ")", ";" ]

[ "SGPR_192RegClassID", ";" ]

[ "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "VGPR_32RegClassID", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "VReg_64RegClassID", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "VReg_96RegClassID", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "VReg_128RegClassID", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "VReg_160RegClassID", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "VReg_192RegClassID", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "VReg_224RegClassID", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "VReg_256RegClassID", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "VReg_512RegClassID", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "VReg_1024RegClassID", ";", "}", "}", "else", "if", "(", "Is", "==", "IS_TTMP", ")", "{", "switch", "(", "RegWidth", ")", "{", "default", ":", "return", "-", "<NUM_LIT>", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "TTMP_32RegClassID", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "TTMP_64RegClassID", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "TTMP_128RegClassID", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "TTMP_256RegClassID", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "TTMP_512RegClassID", ";", "}", "}", "else", "if", "(", "Is", "==", "IS_SGPR", ")", "{", "switch", "(", "RegWidth", ")", "{", "default", ":", "return", "-", "<NUM_LIT>", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "SGPR_32RegClassID", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "SGPR_64RegClassID", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "SGPR_96RegClassID", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "SGPR_128RegClassID", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::", "SGPR_160RegClassID", ";", "case", "<NUM_LIT>", ":", "return", "AMDGPU", "::" ]

[ "}" ]

[ "auto", "HorizOpcode", "=", "IsFadd", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "assert", "(", "(", "IsFadd", "||", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FSUB", ")", "&&", "<STR_LIT>", "Wrong opcode", "<STR_LIT>", ")", ";", "if", "(", "(", "(", "Subtarget", ".", "hasSSE3", "(", ")", "&&", "(", "VT", "==", "MVT", "::", "v4f32", "||", "VT", "==", "MVT", "::", "v2f64", ")", ")", "||", "(", "Subtarget", ".", "hasAVX", "(", ")", "&&", "(", "VT", "==", "MVT", "::", "v8f32", "||", "VT", "==", "MVT", "::", "v4f64", ")", ")", ")", "&&", "isHorizontalBinOp", "(", "LHS", ",", "RHS", ",", "IsFadd", ")", "&&", "shouldUseHorizontalOp", "(", "LHS", "==", "RHS", ",", "DAG", ",", "Subtarget", ")", ")", "return", "DAG", ".", "getNode", "(", "HorizOpcode", ",", "SDLoc", "(", "N", ")", ",", "VT", ",", "LHS", ",", "RHS", ")", ";", "return", "SDValue", "(", ")", ";" ]

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

[ "bool", "MipsFrameInfo", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF" ]

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

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

[ ">", "::", "min", "(", ")", ")", ";" ]

[ "int64_t", "Val", "=", "Memory", ".", "OffsetImm", "->", "getValue", "(", ")", ";", "return", "(", "Val", ">", "-", "<NUM_LIT>", "&&", "Val", "<", "<NUM_LIT>", ")", "||", "(", "Val", "==", "std", "::", "numeric_limits", "<", "int32_t" ]

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

[ "DEBUG", "(", "IPI", "->", "first", "->", "print", "(", "dbgs", "(", ")", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "\\nat considered insertion point.\\n", "<STR_LIT>", ")", ";", "appendAndTransferDominatedUses", "(", "NewPt", ",", "Use", ",", "IPI", ",", "InsertPts", ")", ";", "return", "true", ";", "}", "BasicBlock", "*", "CommonDominator", "=", "DT", ".", "findNearestCommonDominator", "(", "NewBB", ",", "CurBB", ")", ";", "if", "(", "!", "CommonDominator", ")", "continue", ";", "if", "(", "CommonDominator", "!=", "NewBB", ")", "{", "assert", "(", "CommonDominator", "!=", "CurBB", "&&", "<STR_LIT>", "Instruction has not been rejected during isDominated check!", "<STR_LIT>", ")", ";", "NewPt", "=", "CommonDominator", "->", "getTerminator", "(", ")", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Merge insertion point with:\\n", "<STR_LIT>", ")", ";", "DEBUG", "(", "IPI", "->", "first", "->", "print", "(", "dbgs", "(", ")", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "'", "\\n", "'", ")", ";", "DEBUG", "(", "NewPt", "->", "print", "(", "dbgs", "(" ]

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

[ "let", "InOperandList", "=", "(", "ins", "Src", ":", "$", "src", ",", "i8imm", ":", "$", "flavor", ",", "SwitchSet", ":", "$", "sw", ",", "Rdst", ":", "$", "income", ",", "Pred", ":", "$", "pred", ")", ";", "let", "Itinerary", "=", "IIC_VectorOp", ";", "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "src", ";", "bits", "<", "<NUM_LIT>", ">", "flavor", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Switches", "=", "sw", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "src", ";", "let", "SrcB", "=", "flavor", ";", "let", "OperandType", "=", "OpType", ".", "UINT32", ";", "let", "VectorPred", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Pred", ")", ",", "<STR_LIT>", ")", ";", "let", "PredAddress", "=", "pred", "{" ]

[ "static", "int", "fp_regs_to_save", "(", "void", ")", "{", "int", "i", ",", "n", "=", "<NUM_LIT>", ";", "if", "(", "!", "TARGET_AM33_2", ")", "return", "<NUM_LIT>", ";", "for", "(", "i", "=", "FIRST_FP_REGNUM", ";", "i", "<=", "LAST_FP_REGNUM", ";", "++", "i", ")", "if", "(", "df_regs_ever_live_p", "(", "i", ")", "&&", "!", "call_used_regs", "[", "i", "]", ")", "++", "n", ";", "return", "n", ";", "}" ]

[ "Count", "the", "number", "of", "FP", "registers", "that", "have", "to", "be", "saved", "." ]

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

[ "extern", "_", "_", "inline", "_", "_", "m256i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_maskz_srai_epi32", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m256i", "_", "_", "A", ",", "const", "int", "_", "_", "imm", ")", "{", "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_psradi256_mask", "(", "(", "_", "_", "v8si", ")", "_", "_", "A", ",", "_", "_", "imm", ",", "(", "_", "_", "v8si", ")", "_", "mm256_setzero_si256", "(", ")" ]

[ ")", ";" ]

[ "void", "WebAssemblyCFGStackify", "::", "releaseMemory", "(", ")", "{", "ScopeTops", ".", "clear", "(", ")", ";", "BeginToEnd", ".", "clear", "(" ]

[ "a", ",", "qword", "b", ")", "{" ]

[ "static", "_", "_", "inline", "qword", "si_cgth", "(", "qword" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "zero_extend", ":", "DI", "(", "truncate", ":", "SI", "(", "lshiftrt", ":", "DI", "(", "mult", ":", "DI", "(", "zero_extend", ":", "DI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>" ]

[ "}" ]

[ "if", "(", "getTargetMachine", "(", ")", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", "&&", "!", "Subtarget", "->", "isTargetMachO", "(", ")", ")", "{", "return", "getAddrLarge", "(", "BA", ",", "DAG", ")", ";", "}", "else", "if", "(", "getTargetMachine", "(", ")", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Tiny", ")", "{", "return", "getAddrTiny", "(", "BA", ",", "DAG", ")", ";" ]

[ "}" ]

[ "static", "inline", "const", "MachineInstrBuilder", "&", "addRegIndirectWithDisp", "(", "const", "MachineInstrBuilder", "&", "MIB", ",", "unsigned", "Reg", ",", "bool", "isKill", ",", "int", "Offset", ")", "{", "return", "MIB", ".", "addImm", "(", "Offset", ")", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "isKill", ")", ")", ";" ]

[ "return", "DAG", ".", "getZExtOrTrunc", "(", "RetVal", ",", "DL", ",", "VT", ")", ";" ]

[ "const", "TargetFrameLowering", "&", "TFI", "=", "*", "Subtarget", ".", "getFrameLowering", "(", ")", ";", "const", "Align", "StackAlignment", "(", "TFI", ".", "getStackAlignment", "(", ")", ")", ";", "MVT", "VT", "=", "Op", ".", "getSimpleValueType", "(", ")", ";", "SDLoc", "DL", "(", "Op", ")", ";", "int", "SSFI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateStackObject", "(", "<NUM_LIT>", ",", "StackAlignment", ".", "value", "(", ")", ",", "false", ")", ";", "SDValue", "StackSlot", "=", "DAG", ".", "getFrameIndex", "(", "SSFI", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "SSFI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "DAG", ".", "getEntryNode", "(", ")", ",", "StackSlot", "}", ";", "SDValue", "Chain", "=", "DAG", ".", "getMemIntrinsicNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "DAG", ".", "getVTList", "(", "MVT", "::", "Other", ")", ",", "Ops", ",", "MVT", "::", "i16", ",", "MMO", ")", ";", "SDValue", "CWD", "=", "DAG", ".", "getLoad", "(", "MVT", "::", "i16", ",", "DL", ",", "Chain", ",", "StackSlot", ",", "MachinePointerInfo", "(", ")", ")", ";", "SDValue", "Shift", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "MVT", "::", "i16", ",", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "MVT", "::", "i16", ",", "CWD", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i16", ")", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i8", ")", ")", ";", "Shift", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "MVT", "::", "i8", ",", "Shift", ")", ";", "SDValue", "LUT", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "SDValue", "RetVal", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "MVT", "::", "i32", ",", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "MVT", "::", "i32", ",", "LUT", ",", "Shift", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";" ]

[ "<FIXS>", "LowerVAStart", "(", "SDOperand", "Chain", ",", "SelectionDAG", "&", "DAG", ",", "SDOperand", "Dest", ")", ";", "<FIXE>", "<FIXS>", "LowerVAArgNext", "(", "SDOperand", "Chain", ",", "SDOperand", "VAList", ",", "<FIXE>" ]

[ "SelectionDAG", "&", "DAG", ")", ";", "virtual", "std", "::", "pair", "SDOperand", ",", "SDOperand", ">", "<BUGS>", "LowerVAStart", "(", "SDOperand", "Chain", ",", "SelectionDAG", "&", "DAG", ")", ";", "<BUGE>", "virtual", "std", "::", "pair", "SDOperand", ",", "SDOperand", ">", "<BUGS>", "LowerVAArgNext", "(", "bool", "isVANext", ",", "SDOperand", "Chain", ",", "SDOperand", "VAList", ",", "<BUGE>", "const", "Type", "*", "ArgTy", ",", "SelectionDAG", "&", "DAG", ")", ";", "virtual", "std", "::", "pair", "SDOperand", ",", "SDOperand", ">" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128h", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_maskz_max_round_sh", "(", "_", "_", "mmask8", "_", "_", "A", ",", "_", "_", "m128h", "_", "_", "B", ",", "_", "_", "m128h", "_", "_", "C", ",", "const", "int", "_", "_", "D", ")", "{", "return", "_", "_", "builtin_ia32_maxsh_mask_round", "(", "_", "_", "B", ",", "_", "_", "C", ",", "_", "mm_setzero_ph", "(", ")", ",", "_", "_", "A", ",", "_", "_", "D", ")", ";" ]

[ "}" ]

[ "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isPseudo", "=", "<NUM_LIT>", ";", "let", "isCodeGenOnly", "=", "<NUM_LIT>", ";" ]

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

[ "def", "F2_sfimm_n", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "u10_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_9e313203", ",", "TypeALU64", ">", ",", "Enc_6c9440", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}" ]

[ "if", "(", "Imm", "&", "<NUM_LIT>", ")", "EncVal", "|=", "<NUM_LIT>", "ULL", ";" ]

[ "else", "EncVal", "|=", "<NUM_LIT>", "ULL", ";", "if", "(", "Imm", "&", "<NUM_LIT>", ")", "EncVal", "|=", "<NUM_LIT>", "ULL", ";", "if", "(", "Imm", "&", "<NUM_LIT>", ")", "EncVal", "|=", "<NUM_LIT>", "ULL", ";", "if", "(", "Imm", "&", "<NUM_LIT>", ")", "EncVal", "|=", "<NUM_LIT>", "ULL", ";", "if", "(", "Imm", "&", "<NUM_LIT>", ")", "EncVal", "|=", "<NUM_LIT>", "ULL", ";" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "shift", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "N", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "src2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "shift", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "src1", ";" ]

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

[ "Triple", "TheTriple", "(", "TT", ")", ";", "if", "(", "TheTriple", ".", "isOSDarwin", "(", ")", ")", "assert", "(", "<NUM_LIT>", "&&", "<STR_LIT>", "Mac not supported on MBlaze", "<STR_LIT>", ")", ";", "if", "(", "TheTriple", ".", "isOSWindows", "(", ")", ")", "assert", "(", "<NUM_LIT>", "&&", "<STR_LIT>", "Windows not supported on MBlaze", "<STR_LIT>", ")", ";", "uint8_t", "OSABI", "=", "MCELFObjectTargetWriter", "::", "getOSABI", "(", "TheTriple", ".", "getOS", "(", ")", ")", ";", "return", "new", "ELFMBlazeAsmBackend", "(", "T" ]

[ "_", "_", "R", ")", ";" ]

[ "extern", "_", "_", "inline", "int", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_cvt_roundsd_i32", "(", "_", "_", "m128d", "_", "_", "A", ",", "const", "int", "_", "_", "R", ")", "{", "return", "(", "int", ")", "_", "_", "builtin_ia32_vcvtsd2si32", "(", "(", "_", "_", "v2df", ")", "_", "_", "A", "," ]

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

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "pc", ")", "(", "if_then_else", "(", "match_operator", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", ":", "FI48MODE", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "FI48MODE", "<NUM_LIT>", "<STR_LIT>", ")", "]", ")", "(", "label_ref", "(", "match_operand", "<NUM_LIT>" ]

[ "}" ]

[ "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DenseMap", "<", "unsigned", ",", "unsigned", ">", "Reg2Local", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", "->", "begin", "(", ")", ",", "E", "=", "MF", ".", "begin", "(", ")", "->", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", "++", ";", "if", "(", "!", "WebAssembly", "::", "isArgument", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "break", ";", "Register", "Reg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "assert", "(", "!", "MFI", ".", "isVRegStackified", "(", "Reg", ")", ")", ";", "Reg2Local", "[", "Reg", "]", "=", "static_cast", "<", "unsigned", ">", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "Changed", "=", "true", ";", "}", "unsigned", "CurLocal", "=", "static_cast", "<", "unsigned", ">", "(", "MFI", ".", "getParams", "(", ")", ".", "size", "(", ")", ")", ";", "BitVector", "UseEmpty", "(", "MRI", ".", "getNumVirtRegs", "(", ")", ")", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "MRI", ".", "getNumVirtRegs", "(", ")", ";", "I", "<", "E", ";", "++", "I", ")", "UseEmpty", "[", "I", "]", "=", "MRI", ".", "use_empty", "(", "Register", "::", "index2VirtReg", "(", "I", ")", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", "++", ";", "assert", "(", "!", "WebAssembly", "::", "isArgument", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", ";", "if", "(", "MI", ".", "isDebugInstr", "(", ")", "||", "MI", ".", "isLabel", "(", ")", ")", "continue", ";", "if", "(", "WebAssembly", "::", "isTee", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "assert", "(", "MFI", ".", "isVRegStackified", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", ";", "assert", "(", "!", "MFI", ".", "isVRegStackified", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", ";", "Register", "OldReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "MRI", ".", "getRegClass", "(", "OldReg", ")", ";", "if", "(", "!", "MFI", ".", "isVRegStackified", "(", "OldReg", ")", ")", "{", "unsigned", "LocalId", "=", "getLocalId", "(", "Reg2Local", ",", "MFI", ",", "CurLocal", ",", "OldReg", ")", ";", "Register", "NewReg", "=", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ";", "unsigned", "Opc", "=", "getLocalGetOpcode", "(", "RC", ")", ";", "BuildMI", "(", "MBB", ",", "&", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "Opc", ")", ",", "NewReg", ")", ".", "addImm", "(", "LocalId", ")", ";", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "setReg", "(", "NewReg", ")", ";", "MFI", ".", "stackifyVReg", "(", "NewReg", ")", ";", "}", "unsigned", "LocalId", "=", "getLocalId", "(", "Reg2Local", ",", "MFI", ",", "CurLocal", ",", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "unsigned", "Opc", "=", "getLocalTeeOpcode", "(", "RC", ")", ";", "BuildMI", "(", "MBB", ",", "&", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "Opc", ")", ",", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addImm", "(", "LocalId", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "WebAssemblyDebugValueManager", "(", "&", "MI", ")", ".", "replaceWithLocal", "(", "LocalId", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "Changed", "=", "true", ";", "continue", ";", "}", "assert", "(", "MI", ".", "getDesc", "(", ")", ".", "getNumDefs", "(", ")", "<=", "<NUM_LIT>", ")", ";", "if", "(", "MI", ".", "getDesc", "(", ")", ".", "getNumDefs", "(", ")", "==", "<NUM_LIT>", ")", "{", "Register", "OldReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "MFI", ".", "isVRegStackified", "(", "OldReg", ")", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "MRI", ".", "getRegClass", "(", "OldReg", ")", ";", "Register", "NewReg", "=", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ";", "auto", "InsertPt", "=", "std", "::", "next", "(", "MI", ".", "getIterator", "(", ")", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "WebAssembly", "::", "IMPLICIT_DEF", ")", "{", "MI", ".", "eraseFromParent", "(", ")", ";", "Changed", "=", "true", ";", "continue", ";", "}", "if", "(", "UseEmpty", "[", "Register", "::", "virtReg2Index", "(", "OldReg", ")", "]", ")", "{", "unsigned", "Opc", "=", "getDropOpcode", "(", "RC", ")", ";", "MachineInstr", "*", "Drop", "=", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "NewReg", ")", ";", "Drop", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setIsKill", "(", ")", ";", "}", "else", "{", "unsigned", "LocalId", "=", "getLocalId", "(", "Reg2Local", ",", "MFI", ",", "CurLocal", ",", "OldReg", ")", ";", "unsigned", "Opc", "=", "getLocalSetOpcode", "(", "RC", ")", ";", "WebAssemblyDebugValueManager", "(", "&", "MI", ")", ".", "replaceWithLocal", "(", "LocalId", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "Opc", ")", ")", ".", "addImm", "(", "LocalId", ")", ".", "addReg", "(", "NewReg", ")", ";", "}", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "setReg", "(", "NewReg", ")", ";", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "setIsDead", "(", "false", ")", ";", "MFI", ".", "stackifyVReg", "(", "NewReg", ")", ";", "Changed", "=", "true", ";", "}" ]

[ ")", ")" ]

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

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

[ "def", ":", "InstRW", "<", "[", "KryoWrite_4cyc_X_noRSV_113ln", "]", "," ]

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

[ "let", "Opcode", "=", "<NUM_LIT>", ";", "let", "funct", "=", "_funct", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "rx", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "ry", ";" ]

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

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

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

[ "for", "(", "int", "Idx", "=", "<NUM_LIT>", ";", "Idx", "<", "Size", ";", "++", "Idx", ")", "{", "const", "auto", "&", "Op", "=", "Opr", "[", "Idx", "]", ";", "if", "(", "!", "Op", ".", "isSupported", "(", "STI", ")", ")", "continue", ";", "UsedOprMask", "|=", "Op", ".", "getMask", "(", ")", ";", "unsigned", "Val", "=", "Op", ".", "decode", "(", "Code", ")", ";", "if", "(", "!", "Op", ".", "isValid", "(", "Val", ")", ")", "return", "false", ";", "HasNonDefaultVal", "|=", "(", "Val", "!=", "Op", ".", "Default", ")", ";", "}", "return", "(", "Code", "&", "~", "UsedOprMask" ]

[ "<STR_LIT>", ")" ]

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

[ "<FIXS>", "return", "frame_insn", "(", "gen_rtx_SET", "(", "to", ",", "from", ")", ")", ";", "<FIXE>" ]

[ "static", "rtx_insn", "*", "frame_move_insn", "(", "rtx", "to", ",", "rtx", "from", ")", "{", "<BUGS>", "return", "frame_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "to", ",", "from", ")", ")", ";", "<BUGE>", "}" ]

[ ")", ")" ]

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

[ "}" ]

[ "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "GetMemOperand", "(", "MBB", ",", "FI", ",", "MachineMemOperand", "::", "MOLoad", ")", ";", "unsigned", "Opc", "=", "<NUM_LIT>", ";", "if", "(", "Mips", "::", "CPU16RegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "Mips", "::", "LwRxSpImmX16", ";", "assert", "(", "Opc", "&&", "<STR_LIT>", "Register class not handled!", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";" ]

[ "}" ]

[ "(", "unspec_volatile", ":", "QHSD", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "]", "VUNSPEC_ATOMIC_OP", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "CC_REGNUM", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "{", "arm_split_atomic_op", "(", "<", "CODE", ">", ",", "NULL", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", "DONE" ]

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

[ "void", "X86InstrInfo", "::", "loadRegFromAddr", "(", "MachineFunction", "&", "MF", ",", "unsigned", "DestReg", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Addr", ",", "const", "TargetRegisterClass", "*", "RC", ",", "MachineInstr", "::", "mmo_iterator", "MMOBegin", ",", "MachineInstr", "::", "mmo_iterator", "MMOEnd", ",", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "&", "NewMIs", ")", "const", "{", "bool", "isAligned", "=", "(", "*", "MMOBegin", ")", "->", "getAlignment", "(", ")", ">=", "<NUM_LIT>", ";", "unsigned", "Opc", "=", "getLoadRegOpcode", "(", "DestReg", ",", "RC", ",", "isAligned", ",", "TM", ")", ";", "DebugLoc", "DL", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MF", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "Addr", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "MIB", ".", "addOperand", "(", "Addr", "[", "i", "]", ")", ";", "(", "*", "MIB", ")", ".", "setMemRefs", "(", "MMOBegin", "," ]

[ ")", ")" ]

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

[ "static", "int", "shmedia_target_regs_stack_space", "(", "HARD_REG_SET", "*", "live_regs_mask", ")", "{", "int", "reg", ";", "int", "stack_space", "=", "<NUM_LIT>", ";", "int", "interrupt_handler", "=", "sh_cfun_interrupt_handler_p", "(", ")", ";", "for", "(", "reg", "=", "LAST_TARGET_REG", ";", "reg", ">=", "FIRST_TARGET_REG", ";", "reg", "--", ")", "if", "(", "(", "!", "call_really_used_regs", "[", "reg", "]", "||", "interrupt_handler", ")", "&&", "!", "TEST_HARD_REG_BIT", "(", "*", "live_regs_mask", ",", "reg", ")", ")", "stack_space", "+=", "GET_MODE_SIZE", "(", "REGISTER_NATURAL_MODE", "(", "reg", ")", ")", ";", "return", "stack_space", ";", "}" ]

[ "Calculate", "how", "much", "extra", "space", "is", "needed", "to", "save", "all", "callee-saved", "target", "registers", ".", "LIVE_REGS_MASK", "is", "the", "register", "mask", "calculated", "by", "calc_live_regs", "." ]

[ "}", "=", "Pd", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "imm7", ";", "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>", "}", "=", "imm7", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "opc", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pg", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zn", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "opc", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

[ "<STR_LIT>" ]

[ "(", "match_operand", ":", "VSTRUCT", "<NUM_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "VQ", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "UNSPEC_VSTRUCTDUMMY", ")", "]" ]

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

[ "bool", "ARMFastISel", "::", "isLoadTypeLegal", "(", "Type", "*", "Ty", ",", "MVT", "&", "VT", ")", "{", "if", "(", "isTypeLegal", "(", "Ty", ",", "VT", ")", ")", "return", "true", ";", "if", "(", "VT", "==", "MVT", "::", "i1", "||", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i16", ")", "return", "true", ";" ]

[ "auto", "Tmp1", "=", "B", ".", "buildSelect", "(", "S64", ",", "ExpLt0", ",", "SignBit64", ",", "Tmp0", ")", ";" ]

[ "const", "auto", "SignBitMask", "=", "B", ".", "buildConstant", "(", "S32", ",", "UINT32_C", "(", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ")", ";", "auto", "SignBit", "=", "B", ".", "buildAnd", "(", "S32", ",", "Hi", ",", "SignBitMask", ")", ";", "const", "auto", "FractMask", "=", "B", ".", "buildConstant", "(", "S64", ",", "(", "UINT64_C", "(", "<NUM_LIT>", ")", "<<", "FractBits", ")", "-", "<NUM_LIT>", ")", ";", "const", "auto", "Zero32", "=", "B", ".", "buildConstant", "(", "S32", ",", "<NUM_LIT>", ")", ";", "auto", "SignBit64", "=", "B", ".", "buildMerge", "(", "S64", ",", "{", "Zero32", ",", "SignBit", "}", ")", ";", "auto", "Shr", "=", "B", ".", "buildAShr", "(", "S64", ",", "FractMask", ",", "Exp", ")", ";", "auto", "Not", "=", "B", ".", "buildNot", "(", "S64", ",", "Shr", ")", ";", "auto", "Tmp0", "=", "B", ".", "buildAnd", "(", "S64", ",", "Src", ",", "Not", ")", ";", "auto", "FiftyOne", "=", "B", ".", "buildConstant", "(", "S32", ",", "FractBits", "-", "<NUM_LIT>", ")", ";", "auto", "ExpLt0", "=", "B", ".", "buildICmp", "(", "CmpInst", "::", "ICMP_SLT", ",", "S1", ",", "Exp", ",", "Zero32", ")", ";", "auto", "ExpGt51", "=", "B", ".", "buildICmp", "(", "CmpInst", "::", "ICMP_SGT", ",", "S1", ",", "Exp", ",", "FiftyOne", ")", ";" ]

[ "}" ]

[ "mask", "=", "(", "(", "mask", ">>", "<NUM_LIT>", ")", "+", "mask", ")", ";", "return", "(", "mask", "+", "(", "mask", ">>", "<NUM_LIT>", ")", ")", "&", "<NUM_LIT>", ";" ]

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

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

[ "DEBUG", "(", "print", "(", "dbgs", "(", ")", ")", ")", ";" ]

[ "void", "PatmosSinglePathInfo", "::", "analyzeFunction", "(", "MachineFunction", "&", "MF", ")", "{", "checkIrreducibility", "(", "MF", ")", ";", "Root", "=", "SPScope", "::", "createSPScopeTree", "(", "MF", ",", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ",", "TII", ")", ";" ]

[ "<FIXS>", "need_barrier", "=", "rws_access_reg", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "new", "_", "flags", ",", "pred", ")", ";", "<FIXE>", "<FIXS>", "need_barrier", "|=", "rws_access_reg", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "new", "_", "flags", ",", "pred", ")", ";", "<FIXE>" ]

[ "abort", "(", ")", ";", "new", "_", "flags", ".", "is_write", "=", "<NUM_LIT>", ";", "<BUGS>", "need_barrier", "=", "rws_access_reg", "(", "REGNO", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ",", "new", "_", "flags", ",", "pred", ")", ";", "<BUGE>", "need_barrier", "|=", "rtx_needs_barrier", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "new", "_", "flags", ",", "pred", ")", ";", "new", "_", "flags", ".", "is_write", "=", "<NUM_LIT>", ";", "<BUGS>", "need_barrier", "|=", "rws_access_reg", "(", "REGNO", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ",", "new", "_", "flags", ",", "pred", ")", ";", "<BUGE>", "break", ";" ]

[ ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "*", "I", ")", ".", "addReg", "(", "NewVR", ")", ";" ]

[ "if", "(", "ARM", "::", "GPRRegClass", ".", "contains", "(", "*", "I", ")", ")", "RC", "=", "&", "ARM", "::", "GPRRegClass", ";", "else", "if", "(", "ARM", "::", "DPRRegClass", ".", "contains", "(", "*", "I", ")", ")", "RC", "=", "&", "ARM", "::", "DPRRegClass", ";", "else", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected register class in CSRsViaCopy!", "<STR_LIT>", ")", ";", "unsigned", "NewVR", "=", "MRI", "->", "createVirtualRegister", "(", "RC", ")", ";", "assert", "(", "Entry", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "NoUnwind", ")", "&&", "<STR_LIT>", "Function should be nounwind in insertCopiesSplitCSR!", "<STR_LIT>", ")", ";", "Entry", "->", "addLiveIn", "(", "*", "I", ")", ";", "BuildMI", "(", "*", "Entry", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "NewVR", ")", ".", "addReg", "(", "*", "I", ")", ";", "for", "(", "auto", "*", "Exit", ":", "Exits", ")", "BuildMI", "(", "*", "Exit", ",", "Exit", "->", "getFirstTerminator", "(", ")", ",", "DebugLoc", "(" ]

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

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

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

[ "(", "define_mode_iterator", "VWB", "[", "V2SI" ]

[ "AU", ".", "addPreserved", "<", "SlotIndexes", ">", "(", ")", ";" ]

[ "AU", ".", "addRequired", "<", "LiveIntervals", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "LiveIntervals", ">", "(", ")", ";" ]

[ "<STR_LIT>", ")" ]

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

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

[ "(", "bswap", ":", "HI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "{", "if", "(", "!", "REG_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&", "&", "!", "REG_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "operands", "[", "<NUM_LIT>", "]", "=", "force_reg", "(", "HImode", ",", "operands", "[", "<NUM_LIT>", "]", ")" ]

[ "}" ]

[ "static", "int", "rs6000_register_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "from", ",", "reg_class_t", "to", ")", "{", "int", "ret", ";", "reg_class_t", "rclass", ";", "if", "(", "TARGET_DEBUG_COST", ")", "dbg_cost_ctrl", "++", ";", "HARD_REG_SET", "to_vsx", ",", "from_vsx", ";", "to_vsx", "=", "reg_class_contents", "[", "to", "]", "&", "reg_class_contents", "[", "VSX_REGS", "]", ";", "from_vsx", "=", "reg_class_contents", "[", "from", "]", "&", "reg_class_contents", "[", "VSX_REGS", "]", ";", "if", "(", "!", "hard_reg_set_empty_p", "(", "to_vsx", ")", "&&", "!", "hard_reg_set_empty_p", "(", "from_vsx", ")", "&&", "(", "TARGET_VSX", "||", "hard_reg_set_intersect_p", "(", "to_vsx", ",", "from_vsx", ")", ")", ")", "{", "int", "reg", "=", "FIRST_FPR_REGNO", ";", "if", "(", "TARGET_VSX", "||", "(", "TEST_HARD_REG_BIT", "(", "to_vsx", ",", "FIRST_ALTIVEC_REGNO", ")", "&&", "TEST_HARD_REG_BIT", "(", "from_vsx", ",", "FIRST_ALTIVEC_REGNO", ")", ")", ")", "reg", "=", "FIRST_ALTIVEC_REGNO", ";", "ret", "=", "<NUM_LIT>", "*", "hard_regno_nregs", "(", "reg", ",", "mode", ")", ";", "}", "else", "if", "(", "(", "rclass", "=", "from", ",", "reg_classes_intersect_p", "(", "to", ",", "GENERAL_REGS", ")", ")", "||", "(", "rclass", "=", "to", ",", "reg_classes_intersect_p", "(", "from", ",", "GENERAL_REGS", ")", ")", ")", "{", "if", "(", "rclass", "==", "FLOAT_REGS", "||", "rclass", "==", "ALTIVEC_REGS", "||", "rclass", "==", "VSX_REGS", ")", "{", "if", "(", "TARGET_DIRECT_MOVE", ")", "{", "if", "(", "rs6000_tune", "==", "PROCESSOR_POWER9", "||", "rs6000_tune", "==", "PROCESSOR_POWER10", ")", "ret", "=", "<NUM_LIT>", "*", "hard_regno_nregs", "(", "FIRST_GPR_REGNO", ",", "mode", ")", ";", "else", "ret", "=", "<NUM_LIT>", "*", "hard_regno_nregs", "(", "FIRST_GPR_REGNO", ",", "mode", ")", ";", "if", "(", "mode", "==", "SFmode", ")", "ret", "+=", "<NUM_LIT>", ";" ]