Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "return", "output_387_reg_move", "(", "insn", ",", "operands", ")" ]

[ "(", "float_extend", ":", "DF", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "switch", "(", "which_alternative", ")", "{", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":" ]

[ "<FIXS>", ":", "AMDGPUPassConfig", "(", "TM", ",", "PM", ")", "{", "}", "<FIXE>" ]

[ "class", "R600PassConfig", "final", ":", "public", "AMDGPUPassConfig", "{", "public", ":", "R600PassConfig", "(", "TargetMachine", "*", "TM", ",", "PassManagerBase", "&", "PM", ")", "<BUGS>", ":", "AMDGPUPassConfig", "(", "TM", ",", "PM", ")", "{", "}", "<BUGE>", "ScheduleDAGInstrs", "*", "createMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{" ]

[ "addReg", "(", "BitmaskReg", ")", ";" ]

[ "if", "(", "!", "needsSP", "(", "MF", ")", ")", "return", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "auto", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ";", "const", "auto", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "InsertPt", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "InsertPt", "!=", "MBB", ".", "end", "(", ")", "&&", "WebAssembly", "::", "isArgument", "(", "InsertPt", "->", "getOpcode", "(", ")", ")", ")", "++", "InsertPt", ";", "DebugLoc", "DL", ";", "const", "TargetRegisterClass", "*", "PtrRC", "=", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getPointerRegClass", "(", "MF", ")", ";", "unsigned", "SPReg", "=", "getSPReg", "(", "MF", ")", ";", "if", "(", "StackSize", ")", "SPReg", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "const", "char", "*", "ES", "=", "<STR_LIT>", "__stack_pointer", "<STR_LIT>", ";", "auto", "*", "SPSymbol", "=", "MF", ".", "createExternalSymbolName", "(", "ES", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "getOpcGlobGet", "(", "MF", ")", ")", ",", "SPReg", ")", ".", "addExternalSymbol", "(", "SPSymbol", ")", ";", "bool", "HasBP", "=", "hasBP", "(", "MF", ")", ";", "if", "(", "HasBP", ")", "{", "auto", "FI", "=", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "Register", "BasePtr", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "FI", "->", "setBasePointerVreg", "(", "BasePtr", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "COPY", ")", ",", "BasePtr", ")", ".", "addReg", "(", "SPReg", ")", ";", "}", "if", "(", "StackSize", ")", "{", "Register", "OffsetReg", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "getOpcConst", "(", "MF", ")", ")", ",", "OffsetReg", ")", ".", "addImm", "(", "StackSize", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "getOpcSub", "(", "MF", ")", ")", ",", "getSPReg", "(", "MF", ")", ")", ".", "addReg", "(", "SPReg", ")", ".", "addReg", "(", "OffsetReg", ")", ";", "}", "if", "(", "HasBP", ")", "{", "Register", "BitmaskReg", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "Align", "Alignment", "=", "MFI", ".", "getMaxAlign", "(", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "getOpcConst", "(", "MF", ")", ")", ",", "BitmaskReg", ")", ".", "addImm", "(", "(", "int64_t", ")", "~", "(", "Alignment", ".", "value", "(", ")", "-", "<NUM_LIT>", ")", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "getOpcAnd", "(", "MF", ")", ")", ",", "getSPReg", "(", "MF", ")", ")", ".", "addReg", "(", "getSPReg", "(", "MF", ")", ")", "." ]

[ ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "sz", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "U", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zda", ";", "let", "Constraints", "=", "<STR_LIT>" ]

[ "case", "ISD", "::", "OR", ":", "FPOpcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";" ]

[ "static", "SDValue", "combineBitcast", "(", "SDNode", "*", "N", ",", "SelectionDAG", "&", "DAG", ",", "const", "X86Subtarget", "&", "Subtarget", ")", "{", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "if", "(", "VT", "==", "MVT", "::", "x86mmx", "&&", "N0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BUILD_VECTOR", "&&", "N0", ".", "getValueType", "(", ")", "==", "MVT", "::", "v2i32", "&&", "isNullConstant", "(", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "SDValue", "N00", "=", "N0", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "N00", ".", "getValueType", "(", ")", "==", "MVT", "::", "i32", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "SDLoc", "(", "N00", ")", ",", "VT", ",", "N00", ")", ";", "}", "unsigned", "FPOpcode", ";", "switch", "(", "N0", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "AND", ":", "FPOpcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";" ]

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

[ "let", "Inst", "{", "<NUM_LIT>" ]

[ ")" ]

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

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

[ "def", "SQDMULHssv_2S", ":", "NeonI_ScalarXIndexedElemArith", "<", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "FPR32", ",", "FPR32", ",", "VPR64", ",", "neon_uimm1_bare", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Imm", "{", "<NUM_LIT>", "}", ";" ]

[ "}" ]

[ "static", "inline", "unsigned", "int", "avr_ret_register", "(", "void", ")", "{", "return", "<NUM_LIT>", ";" ]

[ "U", ",", "_", "MM_FROUND_CUR_DIRECTION", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "mmask8", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_mask_cmpneq_pd_mask", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m512d", "_", "_", "X", ",", "_", "_", "m512d", "_", "_", "Y", ")", "{", "return", "(", "_", "_", "mmask8", ")", "_", "_", "builtin_ia32_cmppd512_mask", "(", "(", "_", "_", "v8df", ")", "_", "_", "X", ",", "(", "_", "_", "v8df", ")", "_", "_", "Y", ",", "_", "CMP_NEQ_UQ", ",", "(", "_", "_", "mmask8", ")", "_", "_" ]

[ "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setReg", "(", "ARM", "::", "CPSR", ")", ";" ]

[ "}", "if", "(", "!", "MI", ")", "return", "false", ";", "}", "}", "if", "(", "MI", "->", "getParent", "(", ")", "!=", "CmpInstr", "->", "getParent", "(", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "const_iterator", "I", "=", "CmpInstr", ",", "E", "=", "MI", ",", "B", "=", "MI", "->", "getParent", "(", ")", "->", "begin", "(", ")", ";", "if", "(", "I", "==", "B", ")", "return", "false", ";", "--", "I", ";", "for", "(", ";", "I", "!=", "E", ";", "--", "I", ")", "{", "const", "MachineInstr", "&", "Instr", "=", "*", "I", ";", "for", "(", "unsigned", "IO", "=", "<NUM_LIT>", ",", "EO", "=", "Instr", ".", "getNumOperands", "(", ")", ";", "IO", "!=", "EO", ";", "++", "IO", ")", "{", "const", "MachineOperand", "&", "MO", "=", "Instr", ".", "getOperand", "(", "IO", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "continue", ";", "if", "(", "MO", ".", "getReg", "(", ")", "==", "ARM", "::", "CPSR", ")", "return", "false", ";", "}", "if", "(", "I", "==", "B", ")", "return", "false", ";", "}", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "ADDri", ":", "case", "ARM", "::", "ANDri", ":", "case", "ARM", "::", "t2ANDri", ":", "case", "ARM", "::", "SUBri", ":", "case", "ARM", "::", "t2ADDri", ":", "case", "ARM", "::", "t2SUBri", ":" ]

[ ")", ";" ]

[ "if", "(", "insn", "==", "NULL_RTX", ")", "return", "false", ";", "return", "s390_is_fxd", "(", "insn", ")", "||", "s390_is_fpd", "(", "insn" ]

[ "const", "override", "{" ]

[ "EVT", "getOptimalMemOpType", "(", "const", "MemOp", "&", "Op", ",", "const", "AttributeList", "&", "FuncAttributes", ")" ]

[ "=", "Imm1_64Operand", ";" ]

[ "def", "tvecshiftR64", ":", "Operand", "<", "i32", ">", ",", "TImmLeaf", "<", "i32", ",", "[", "{", "return", "(", "(", "(", "uint32_t", ")", "Imm", ")", ">", "<NUM_LIT>", ")", "&", "&", "(", "(", "(", "uint32_t", ")", "Imm", ")", "<", "<NUM_LIT>", ")", ";", "}", "]", ">", "{", "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass" ]

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

[ "class", "AAI", "<", "bits", "<", "<NUM_LIT>", ">", "op27_20", ",", "bits", "<", "<NUM_LIT>", ">", "op11_4", ",", "string", "opc", ",", "list", "<", "dag", ">", "pattern", "=", "[", "]", ",", "dag", "iops", "=", "(", "ins", "GPRnopc", ":", "$", "Rn", ",", "GPRnopc", ":", "$", "Rm", ")", ",", "string", "asm", "=", "<STR_LIT>", ">", ":", "AI", "<", "(", "outs", "GPRnopc", ":", "$", "Rd", ")", ",", "iops", ",", "DPFrm", ",", "IIC_iALUr", ",", "opc", ",", "asm", ",", "pattern", ">", ",", "Sched", "<", "[", "WriteALU", ",", "ReadALU", ",", "ReadALU", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rn", ";" ]

[ "void", "PPCRegisterInfo", "::", "lowerDynamicAlloc", "(", "MachineBasicBlock", "::", "iterator", "II", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "bool", "LP64", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "unsigned", "maxCallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "TargetAlign", "=", "Subtarget", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ";", "unsigned", "MaxAlign", "=", "MFI", "->", "getMaxAlignment", "(", ")", ";", "assert", "(", "(", "maxCallFrameSize", "&", "(", "MaxAlign", "-", "<NUM_LIT>", ")", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Maximum call-frame size not sufficiently aligned", "<STR_LIT>", ")", ";", "const", "TargetRegisterClass", "*", "G8RC", "=", "&", "PPC", "::", "G8RCRegClass", ";", "const", "TargetRegisterClass", "*", "GPRC", "=", "&", "PPC", "::", "GPRCRegClass", ";", "unsigned", "Reg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "LP64", "?", "G8RC", ":", "GPRC", ")", ";", "if", "(", "MaxAlign", "<", "TargetAlign", "&&", "isInt", "<", "<NUM_LIT>", ">", "(", "FrameSize", ")", ")", "{", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "ADDI", ")", ",", "Reg", ")", ".", "addReg", "(", "PPC", "::", "R31", ")", ".", "addImm", "(", "FrameSize", ")", ";", "}", "else", "if", "(", "LP64", ")", "{", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "LD", ")", ",", "Reg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "PPC", "::", "X1", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "LWZ", ")", ",", "Reg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "PPC", "::", "R1", ")", ";", "}", "bool", "KillNegSizeReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isKill", "(", ")", ";", "unsigned", "NegSizeReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "LP64", ")", "{", "if", "(", "MaxAlign", ">", "TargetAlign", ")", "{", "unsigned", "UnalNegSizeReg", "=", "NegSizeReg", ";", "NegSizeReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "G8RC", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "LI8", ")", ",", "NegSizeReg", ")", ".", "addImm", "(", "~", "(", "MaxAlign", "-", "<NUM_LIT>", ")", ")", ";", "unsigned", "NegSizeReg1", "=", "NegSizeReg", ";", "NegSizeReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "G8RC", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "AND8", ")", ",", "NegSizeReg", ")", ".", "addReg", "(", "UnalNegSizeReg", ",", "getKillRegState", "(", "KillNegSizeReg", ")", ")", ".", "addReg", "(", "NegSizeReg1", ",", "RegState", "::", "Kill", ")", ";", "KillNegSizeReg", "=", "true", ";", "}", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "STDUX", ")", ",", "PPC", "::", "X1", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "PPC", "::", "X1", ")", ".", "addReg", "(", "NegSizeReg", ",", "getKillRegState", "(", "KillNegSizeReg", ")", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "ADDI8", ")", ",", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "PPC", "::", "X1", ")", ".", "addImm", "(", "maxCallFrameSize", ")", ";", "}", "else", "{", "if", "(", "MaxAlign", ">", "TargetAlign", ")", "{", "unsigned", "UnalNegSizeReg", "=", "NegSizeReg", ";", "NegSizeReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "GPRC", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "LI", ")", ",", "NegSizeReg", ")", ".", "addImm", "(", "~", "(", "MaxAlign", "-", "<NUM_LIT>", ")", ")", ";", "unsigned", "NegSizeReg1", "=", "NegSizeReg", ";", "NegSizeReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "GPRC", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "AND", ")", ",", "NegSizeReg", ")", ".", "addReg", "(", "UnalNegSizeReg", ",", "getKillRegState", "(", "KillNegSizeReg", ")", ")", ".", "addReg", "(", "NegSizeReg1", ",", "RegState", "::", "Kill", ")", ";", "KillNegSizeReg", "=", "true", ";", "}", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "STWUX", ")", ",", "PPC", "::", "R1", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "PPC", "::", "R1", ")", ".", "addReg", "(", "NegSizeReg", ",", "getKillRegState", "(", "KillNegSizeReg", ")", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "ADDI", ")", ",", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "PPC", "::", "R1", ")", ".", "addImm", "(", "maxCallFrameSize", ")", ";", "}", "MBB", ".", "erase", "(", "II", ")", ";", "}" ]

[ "lowerDynamicAlloc", "-", "Generate", "the", "code", "for", "allocating", "an", "object", "in", "the", "current", "frame", "." ]

[ "bool", "SystemZFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "SystemZMachineFunctionInfo", "*", "ZFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "bool", "IsVarArg", "=", "MF", ".", "getFunction", "(", ")", ".", "isVarArg", "(", ")", ";", "DebugLoc", "DL", ";", "unsigned", "LowGPR", "=", "<NUM_LIT>", ";", "unsigned", "HighGPR", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "unsigned", "StartOffset", "=", "-", "<NUM_LIT>", "U", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "CSI", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "I", "]", ".", "getReg", "(", ")", ";", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "Reg", ")", ")", "{", "unsigned", "Offset", "=", "RegSpillOffsets", "[", "Reg", "]", ";", "assert", "(", "Offset", "&&", "<STR_LIT>", "Unexpected GPR save", "<STR_LIT>", ")", ";", "if", "(", "StartOffset", ">", "Offset", ")", "{", "LowGPR", "=", "Reg", ";", "StartOffset", "=", "Offset", ";", "}", "}", "}", "ZFI", "->", "setLowSavedGPR", "(", "LowGPR", ")", ";", "ZFI", "->", "setHighSavedGPR", "(", "HighGPR", ")", ";", "if", "(", "IsVarArg", ")", "{", "unsigned", "FirstGPR", "=", "ZFI", "->", "getVarArgsFirstGPR", "(", ")", ";", "if", "(", "FirstGPR", "<", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "unsigned", "Reg", "=", "<STR_LIT>", "::", "<STR_LIT>", "[", "FirstGPR", "]", ";", "unsigned", "Offset", "=", "RegSpillOffsets", "[", "Reg", "]", ";", "if", "(", "StartOffset", ">", "Offset", ")", "{", "LowGPR", "=", "Reg", ";", "StartOffset", "=", "Offset", ";", "}", "}", "}", "if", "(", "LowGPR", ")", "{", "assert", "(", "LowGPR", "!=", "HighGPR", "&&", "<STR_LIT>", "Should be saving %r15 and something else", "<STR_LIT>", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "addSavedGPR", "(", "MBB", ",", "MIB", ",", "LowGPR", ",", "false", ")", ";", "addSavedGPR", "(", "MBB", ",", "MIB", ",", "HighGPR", ",", "false", ")", ";", "MIB", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "StartOffset", ")", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "CSI", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "I", "]", ".", "getReg", "(", ")", ";", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "Reg", ")", ")", "addSavedGPR", "(", "MBB", ",", "MIB", ",", "Reg", ",", "true", ")", ";", "}", "if", "(", "IsVarArg", ")", "for", "(", "unsigned", "I", "=", "ZFI", "->", "getVarArgsFirstGPR", "(", ")", ";", "I", "<", "<STR_LIT>", "::", "<STR_LIT>", ";", "++", "I", ")", "addSavedGPR", "(", "MBB", ",", "MIB", ",", "<STR_LIT>", "::", "<STR_LIT>", "[", "I", "]", ",", "true", ")", ";", "}", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "CSI", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "I", "]", ".", "getReg", "(", ")", ";", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "Reg", ")", ")", "{", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "TII", "->", "storeRegToStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ",", "true", ",", "CSI", "[", "I", "]", ".", "getFrameIdx", "(", ")", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ",", "TRI", ")", ";", "}", "}", "return", "true", ";", "}" ]

[ "spillCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "spill", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "store", "instructions", "via", "storeRegToStackSlot", "(", ")", "." ]

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

[ "static", "bool", "rx_is_ms_bitfield_layout", "(", "const_tree", "record_type", "ATTRIBUTE_UNUSED", ")", "{", "return", "!", "TYPE_PACKED", "(" ]

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

[ "auto", "SlotIdx", "=", "LIS", "->", "getInstructionIndex", "(", "*", "MI", ")", ".", "getRegSlot", "(", ")", ";", "RegOpers", ".", "adjustLaneLiveness", "(", "*", "LIS", ",", "MRI", ",", "SlotIdx", ",", "MI", ")", ";", "}", "Top", "=", "std", "::", "next", "(", "MI", "->", "getIterator", "(", ")", ")", ";", "}", "RegionBegin", "=", "getMachineInstr", "(", "Schedule", ".", "front", "(", ")", ")", ";", "if", "(", "!", "std", "::", "is_same_v", "<", "decltype", "(", "*", "Schedule", ".", "begin", "(", ")", ")", ",", "MachineInstr", "*", ">", ")", "{", "placeDebugValues", "(", ")", ";", "RegionEnd", "=", "R", ".", "End", ";", "}", "R", ".", "Begin", "=", "RegionBegin", ";", "R", ".", "MaxPressure", "=", "MaxRP", ";", "const", "auto", "RegionMaxRP", "=", "getRegionPressure", "(", "R", ")", ";", "const", "auto", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">" ]

[ "<STR_LIT>", ")" ]

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

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

[ "class", "Enc_1cf4ca", ":", "OpcodeHexagon", "{", "bits", "<", "<NUM_LIT>", ">", "Ii", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Pv4", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pv4", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rt32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}" ]

[ ")", "]" ]

[ "(", "unspec", ":", "P", "[", "(", "match_operand", ":", "P", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>" ]

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

[ "(", "define_mode_attr", "kmov_isa", "[", "(", "QI", "<STR_LIT>", ")", "(", "HI", "<STR_LIT>", ")" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "vec_select", ":", "DI", "(", "match_operand", ":", "V2DI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "]", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "vec_select", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "]", "{", "operands", "[", "<NUM_LIT>", "]", "=", "gen_lowpart", "(", "SImode", "," ]

[ "true", ";" ]

[ "DCI", ".", "AddToWorklist", "(", "Res", ".", "getNode", "(", ")", ")", ";", "Res", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "ShuffleVT", ",", "Res", ",", "Zero", ",", "DAG", ".", "getConstant", "(", "BlendMask", ",", "DL", ",", "MVT", "::", "i8", ")", ")", ";", "DCI", ".", "AddToWorklist", "(", "Res", ".", "getNode", "(", ")", ")", ";", "DCI", ".", "CombineTo", "(", "Root", ".", "getNode", "(", ")", ",", "DAG", ".", "getBitcast", "(", "RootVT", ",", "Res", ")", ",", "true", ")", ";", "return", "true", ";", "}", "}", "if", "(", "Depth", "<", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "(", "Depth", ">=", "<NUM_LIT>", "||", "HasPSHUFB", ")", "&&", "(", "(", "VT", ".", "is128BitVector", "(", ")", "&&", "Subtarget", ".", "hasSSSE3", "(", ")", ")", "||", "(", "VT", ".", "is256BitVector", "(", ")", "&&", "Subtarget", ".", "hasAVX2", "(", ")", ")", "||", "(", "VT", ".", "is512BitVector", "(", ")", "&&", "Subtarget", ".", "hasBWI", "(", ")", ")", ")", ")", "{", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "PSHUFBMask", ";", "int", "NumBytes", "=", "VT", ".", "getSizeInBits", "(", ")", "/", "<NUM_LIT>", ";", "int", "Ratio", "=", "NumBytes", "/", "NumMaskElts", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "NumBytes", ";", "++", "i", ")", "{", "int", "M", "=", "Mask", "[", "i", "/", "Ratio", "]", ";", "if", "(", "M", "==", "SM_SentinelUndef", ")", "{", "PSHUFBMask", ".", "push_back", "(", "DAG", ".", "getUNDEF", "(", "MVT", "::", "i8", ")", ")", ";", "continue", ";", "}", "if", "(", "M", "==", "SM_SentinelZero", ")", "{", "PSHUFBMask", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i8", ")", ")", ";", "continue", ";", "}", "M", "=", "Ratio", "*", "M", "+", "i", "%", "Ratio", ";", "if", "(", "(", "M", "/", "<NUM_LIT>", ")", "!=", "(", "i", "/", "<NUM_LIT>", ")", ")", "return", "false", ";", "PSHUFBMask", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "M", ",", "DL", ",", "MVT", "::", "i8", ")", ")", ";", "}", "MVT", "ByteVT", "=", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i8", ",", "NumBytes", ")", ";", "Res", "=", "DAG", ".", "getBitcast", "(", "ByteVT", ",", "Input", ")", ";", "DCI", ".", "AddToWorklist", "(", "Res", ".", "getNode", "(", ")", ")", ";", "SDValue", "PSHUFBMaskOp", "=", "DAG", ".", "getBuildVector", "(", "ByteVT", ",", "DL", ",", "PSHUFBMask", ")", ";", "DCI", ".", "AddToWorklist", "(", "PSHUFBMaskOp", ".", "getNode", "(", ")", ")", ";", "Res", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "ByteVT", ",", "Res", ",", "PSHUFBMaskOp", ")", ";", "DCI", ".", "AddToWorklist", "(", "Res", ".", "getNode", "(", ")", ")", ";", "DCI", ".", "CombineTo", "(", "Root", ".", "getNode", "(", ")", ",", "DAG", ".", "getBitcast", "(", "RootVT", ",", "Res", ")", ",", "true", ")", ";", "return" ]

[ ")" ]

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

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

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

[ "<FIXS>", "void", "EmitOpcodePrefix", "(", "uint64_t", "TSFlags", ",", "unsigned", "&", "CurByte", ",", "int", "MemOperand", ",", "<FIXE>" ]

[ "const", "MCInst", "&", "MI", ",", "const", "TargetInstrDesc", "&", "Desc", ",", "raw_ostream", "&", "OS", ")", "const", ";", "<BUGS>", "void", "EmitOpcodePrefix", "(", "uint64_t", "TSFlags", ",", "unsigned", "&", "CurByte", ",", "<BUGE>", "const", "MCInst", "&", "MI", ",", "const", "TargetInstrDesc", "&", "Desc", ",", "raw_ostream", "&", "OS", ")", "const", ";", "}", ";" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ "if", "(", "regJustKilledBefore", "(", "LIs", ",", "r", ",", "MI", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Killing chain ", "<STR_LIT>", "<<", "printReg", "(", "r", ",", "TRI", ")", "<<", "<STR_LIT>", " at ", "<STR_LIT>", ";", "MI", ".", "print", "(", "dbgs", "(", ")", ")", ";", ")", ";", "toDel", ".", "push_back", "(", "r", ")", ";", "}", "while", "(", "!", "toDel", ".", "empty", "(", ")", ")", "{", "Chains", ".", "remove", "(", "toDel", ".", "back", "(", ")", ")", ";", "toDel", ".", "pop_back", "(", ")", ";", "}", "}", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ ",", "_", "MM_FROUND_CUR_DIRECTION", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m512i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_mask_cvttps_epu64", "(", "_", "_", "m512i", "_", "_", "W", ",", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m256", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_cvttps2uqq512_mask", "(", "(", "_", "_", "v8sf", ")", "_", "_", "A", ",", "(", "_", "_", "v8di", ")", "_", "_", "W", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U" ]

[ "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "ccset", ",", "set", ")", ")", ")", ";" ]

[ "emit_move_insn", "(", "dst", ",", "src", ")", ";", "emit_move_insn", "(", "ccreg", ",", "gen_rtx_COMPARE", "(", "CCmode", ",", "dst", ",", "const0_rtx", ")", ")", ";", "return", ";", "}", "rtx", "ccset", "=", "gen_rtx_SET", "(", "ccreg", ",", "gen_rtx_COMPARE", "(", "CCmode", ",", "src", ",", "const0_rtx", ")", ")", ";", "if", "(", "dot", "==", "<NUM_LIT>", ")", "{", "rtx", "clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "dst", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "ccset", ",", "clobber", ")", ")", ")", ";", "}", "else", "{", "rtx", "set", "=", "gen_rtx_SET", "(", "dst", ",", "src", ")", ";" ]

[ "vsetult_v16i8", ",", "MSA128BOpnd", ">", ";" ]

[ "class", "CLT_U_B_DESC", ":", "MSA_3R_DESC_BASE", "<", "<STR_LIT>", "," ]

[ "const", "uint16_t", "*", "XCoreRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "uint16_t", "CalleeSavedRegs", "[", "]", "=", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", "}", ";", "return", "CalleeSavedRegs", ";", "}" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "}" ]

[ "raw_string_ostream", "os", "(", "str", ")", ";", "node", "->", "printAsOperand", "(", "os", ",", "false", ")", ";", "return", "os", ".", "str", "(", ")", ";" ]

[ "}" ]

[ "if", "(", "Reg", "==", "<NUM_LIT>", ")", "continue", ";", "if", "(", "MO", ".", "isDef", "(", ")", ")", "RegDefs", ".", "insert", "(", "Reg", ")", ";", "if", "(", "MO", ".", "isUse", "(", ")", ")", "{", "if", "(", "MO", ".", "isImplicit", "(", ")", "&&", "MI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "continue", ";", "RegUses", ".", "insert", "(", "Reg", ")", ";" ]

[ "<STR_LIT>", ";" ]

[ "string", "AsmString", "=", "!", "strconcat", "(", "instr_asm", ",", "<STR_LIT>", ")", ";", "list", "<", "dag", ">", "Pattern", "=", "[", "(", "set", "ROWD", ":", "$", "wd", ",", "(", "MipsVSHF", "ROWD", ":", "$", "wd_in", ",", "ROWS", ":", "$", "ws", ",", "ROWT", ":", "$", "wt", ")", ")", "]", ";", "string", "Constraints", "=" ]

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

[ "bool", "FixupBWInstPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "FixupBWInsts", "||", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "this", "->", "MF", "=", "&", "MF", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", "." ]

[ ")", ";" ]

[ "void", "pdp11_output_def", "(", "FILE", "*", "file", ",", "const", "char", "*", "label1", ",", "const", "char", "*", "label2", ")", "{", "if", "(", "TARGET_DEC_ASM", ")", "{", "assemble_name", "(", "file", ",", "label1", ")", ";", "putc", "(", "'", "=", "'", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "label2", ")", ";", "}", "else", "{", "fputs", "(", "<STR_LIT>", "\\t.set\\t", "<STR_LIT>", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "label1" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "def", "RCR64ri", ":", "RIi8", "<NUM_LIT>", ",", "MRM3r", ",", "(", "outs", "GR64", ":", "$", "dst", ")", ",", "(", "ins", "GR64", ":", "$", "src", ",", "i8imm", ":", "$", "cnt", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ";", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "}", "let", "isTwoAddress", "=", "<NUM_LIT>", "in", "{", "def", "RCL64m1", ":", "RI", "<NUM_LIT>", ",", "MRM2m", ",", "(", "outs", ")", ",", "(", "ins", "i64mem", ":", "$", "dst", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ";", "def", "RCL64mi", ":", "RIi8", "<NUM_LIT>", ",", "MRM2m", ",", "(", "outs", ")", ",", "(", "ins", "i64mem", ":", "$", "dst", ",", "i8imm", ":", "$", "cnt", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ";", "def", "RCR64m1", ":", "RI", "<NUM_LIT>", ",", "MRM3m", ",", "(", "outs", ")", ",", "(", "ins", "i64mem", ":", "$", "dst", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ";", "def", "RCR64mi", ":", "RIi8", "<NUM_LIT>", ",", "MRM3m", ",", "(", "outs", ")", ",", "(", "ins", "i64mem", ":", "$", "dst", ",", "i8imm", ":", "$", "cnt", ")", ",", "<FIXE>" ]

[ "let", "isTwoAddress", "=", "<NUM_LIT>", "in", "{", "def", "RCL64r1", ":", "RI", "<NUM_LIT>", ",", "MRM2r", ",", "(", "outs", "GR64", ":", "$", "dst", ")", ",", "(", "ins", "GR64", ":", "$", "src", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ";", "<BUGS>", "def", "RCL64m1", ":", "RI", "<NUM_LIT>", ",", "MRM2m", ",", "(", "outs", "i64mem", ":", "$", "dst", ")", ",", "(", "ins", "i64mem", ":", "$", "src", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ";", "let", "Uses", "=", "[", "CL", "]", "in", "{", "def", "RCL64rCL", ":", "RI", "<NUM_LIT>", ",", "MRM2r", ",", "(", "outs", "GR64", ":", "$", "dst", ")", ",", "(", "ins", "GR64", ":", "$", "src", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ";", "def", "RCL64mCL", ":", "RI", "<NUM_LIT>", ",", "MRM2m", ",", "(", "outs", "i64mem", ":", "$", "dst", ")", ",", "(", "ins", "i64mem", ":", "$", "src", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ";", "}", "<BUGE>", "def", "RCL64ri", ":", "RIi8", "<NUM_LIT>", ",", "MRM2r", ",", "(", "outs", "GR64", ":", "$", "dst", ")", ",", "(", "ins", "GR64", ":", "$", "src", ",", "i8imm", ":", "$", "cnt", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ";", "<BUGS>", "def", "RCL64mi", ":", "RIi8", "<NUM_LIT>", ",", "MRM2m", ",", "(", "outs", "i64mem", ":", "$", "dst", ")", ",", "(", "ins", "i64mem", ":", "$", "src", ",", "i8imm", ":", "$", "cnt", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ";", "<BUGE>", "def", "RCR64r1", ":", "RI", "<NUM_LIT>", ",", "MRM3r", ",", "(", "outs", "GR64", ":", "$", "dst", ")", ",", "(", "ins", "GR64", ":", "$", "src", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ";", "<BUGS>", "def", "RCR64m1", ":", "RI", "<NUM_LIT>", ",", "MRM3m", ",", "(", "outs", "i64mem", ":", "$", "dst", ")", ",", "(", "ins", "i64mem", ":", "$", "src", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ";", "<BUGE>", "let", "Uses", "=", "[", "CL", "]", "in", "{", "def", "RCR64rCL", ":", "RI", "<NUM_LIT>", ",", "MRM3r", ",", "(", "outs", "GR64", ":", "$", "dst", ")", ",", "(", "ins", "GR64", ":", "$", "src", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ";", "<BUGS>", "def", "RCR64mCL", ":", "RI", "<NUM_LIT>", ",", "MRM3m", ",", "(", "outs", "i64mem", ":", "$", "dst", ")", ",", "(", "ins", "i64mem", ":", "$", "src", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ";", "<BUGE>", "}", "<BUGS>", "def", "RCR64ri", ":", "RIi8", "<NUM_LIT>", ",", "MRM3r", ",", "(", "outs", "GR64", ":", "$", "dst", ")", ",", "(", "ins", "GR64", ":", "$", "src", ",", "i8imm", ":", "$", "cnt", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ";", "def", "RCR64mi", ":", "RIi8", "<NUM_LIT>", ",", "MRM3m", ",", "(", "outs", "i64mem", ":", "$", "dst", ")", ",", "(", "ins", "i64mem", ":", "$", "src", ",", "i8imm", ":", "$", "cnt", ")", ",", "<BUGE>", "<STR_LIT>", ",", "[", "]", ">", ";", "}", "let", "isTwoAddress", "=", "<NUM_LIT>", "in", "{" ]

[ "break", ";" ]

[ "flags", "|=", "_", "_", "VSTRING_FLAG_ZS", ";", "break", ";", "default", ":", "break", ";", "}", "switch", "(", "ob_fcode", ")", "{", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_eq_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_ne_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_eq_or_0_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_ne_or_0_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_eq_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_ne_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmprg_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmpnrg_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmprg_or_0_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmpnrg_or_0_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmprg_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmpnrg_cc", ":", "flags", "|=", "_", "_", "VSTRING_FLAG_CS", ";", "break", ";", "default", ":" ]

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

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "CC_STATUS_INIT", "return", "<STR_LIT>", "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "SDLoc", "DL", "(", "N", ")", ";" ]

[ "if", "(", "!", "ExtElt", ".", "hasOneUse", "(", ")", "||", "ExtElt", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "EXTRACT_VECTOR_ELT", "||", "!", "isNullConstant", "(", "ExtElt", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "return", "SDValue", "(", ")", ";", "EVT", "TruncVT", "=", "Trunc", ".", "getValueType", "(", ")", ";", "EVT", "SrcVT", "=", "ExtElt", ".", "getValueType", "(", ")", ";", "unsigned", "DestWidth", "=", "TruncVT", ".", "getSizeInBits", "(", ")", ";", "unsigned", "SrcWidth", "=", "SrcVT", ".", "getSizeInBits", "(", ")", ";", "if", "(", "SrcWidth", "%", "DestWidth", "!=", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "EVT", "SrcVecVT", "=", "ExtElt", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ";", "unsigned", "VecWidth", "=", "SrcVecVT", ".", "getSizeInBits", "(", ")", ";", "unsigned", "NumElts", "=", "VecWidth", "/", "DestWidth", ";", "EVT", "BitcastVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "TruncVT", ",", "NumElts", ")", ";", "SDValue", "BitcastVec", "=", "DAG", ".", "getBitcast", "(", "BitcastVT", ",", "ExtElt", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "else", "emit_insn", "(", "gen_ic_invalidate_line", "(", "tramp", ")", ")", ";" ]

[ "else", "{", "sh_emit_storehi", "(", "tramp_mem", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "sh_emit_storehi", "(", "tramp_mem", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "sh_emit_storesi", "(", "tramp_mem", ",", "<NUM_LIT>", ",", "cxt", ")", ";", "sh_emit_storesi", "(", "tramp_mem", ",", "<NUM_LIT>", ",", "fnaddr", ")", ";", "}", "if", "(", "TARGET_HARD_SH4", ")", "{", "if", "(", "!", "TARGET_INLINE_IC_INVALIDATE", "||", "(", "!", "(", "TARGET_SH4A", "||", "TARGET_SH4_300", ")", "&&", "TARGET_USERMODE", ")", ")", "emit_library_call", "(", "function_symbol", "(", "NULL", ",", "<STR_LIT>", "__ic_invalidate", "<STR_LIT>", ",", "FUNCTION_ORDINARY", ")", ".", "sym", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "<NUM_LIT>", ",", "tramp", ",", "SImode", ")", ";" ]

[ "<STR_LIT>", "Couldn't find non-copy def for register\\n", "<STR_LIT>", ")", ";" ]

[ "static", "bool", "getConstantValueForReg", "(", "unsigned", "Reg", ",", "MachineRegisterInfo", "&", "MRI", ",", "unsigned", "&", "Val", ")", "{", "MachineInstr", "*", "Def", "=", "MRI", ".", "getVRegDef", "(", "Reg", ")", ";", "if", "(", "!", "Def", ")", "return", "false", ";", "if", "(", "Def", "->", "isCopy", "(", ")", ")", "{", "Reg", "=", "Def", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "auto", "It", "=", "find_if_not", "(", "MRI", ".", "reg_nodbg_instructions", "(", "Reg", ")", ",", "[", "]", "(", "const", "MachineInstr", "&", "MI", ")", "{", "return", "MI", ".", "isCopy", "(", ")", ";", "}", ")", ";", "if", "(", "It", "==", "MRI", ".", "reg_instr_nodbg_end", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<" ]

[ "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";" ]

[ "let", "InOperandList", "=", "(", "ins", "Rsrc", ":", "$", "src", ",", "SwitchSet", ":", "$", "sw", ",", "Rdst", ":", "$", "income", ",", "Pred", ":", "$", "pred", ")", ";", "let", "Itinerary", "=", "IIC_LoadOp", ";", "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "src", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "SrcA", "=", "src", ";", "let", "Dest", "=", "dest", ";", "let", "Switches", "=", "{", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "<NUM_LIT>", "}", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "VectorPred", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Pred", ")", ",", "<STR_LIT>", ")", ";" ]

[ "if", "(", "!", "FIXED_POINT_TYPE_P", "(", "type0", ")", ")", "{" ]

[ "if", "(", "args", ".", "length", "(", ")", "!=", "<NUM_LIT>", ")", "{", "error_at", "(", "loc", ",", "<STR_LIT>", "%qs expects 1 argument but %d given", "<STR_LIT>", ",", "<STR_LIT>", "absfx", "<STR_LIT>", ",", "(", "int", ")", "args", ".", "length", "(", ")", ")", ";", "fold", "=", "error_mark_node", ";", "break", ";", "}", "type0", "=", "TREE_TYPE", "(", "args", "[", "<NUM_LIT>", "]", ")", ";", "if", "(", "!", "FIXED_POINT_TYPE_P", "(", "type0", ")", ")", "{", "error_at", "(", "loc", ",", "<STR_LIT>", "%qs expects a fixed-point value as argument", "<STR_LIT>", ",", "<STR_LIT>", "absfx", "<STR_LIT>", ")", ";", "fold", "=", "error_mark_node", ";", "}", "switch", "(", "TYPE_MODE", "(", "type0", ")", ")", "{", "case", "E_QQmode", ":", "id", "=", "AVR_BUILTIN_ABSHR", ";", "break", ";", "case", "E_HQmode", ":", "id", "=", "AVR_BUILTIN_ABSR", ";", "break", ";", "case", "E_SQmode", ":", "id", "=", "AVR_BUILTIN_ABSLR", ";", "break", ";", "case", "E_DQmode", ":", "id", "=", "AVR_BUILTIN_ABSLLR", ";", "break", ";", "case", "E_HAmode", ":", "id", "=", "AVR_BUILTIN_ABSHK", ";", "break", ";", "case", "E_SAmode", ":", "id", "=", "AVR_BUILTIN_ABSK", ";", "break", ";", "case", "E_DAmode", ":", "id", "=", "AVR_BUILTIN_ABSLK", ";", "break", ";", "case", "E_TAmode", ":", "id", "=", "AVR_BUILTIN_ABSLLK", ";", "break", ";", "case", "E_UQQmode", ":", "case", "E_UHQmode", ":", "case", "E_USQmode", ":", "case", "E_UDQmode", ":", "case", "E_UHAmode", ":", "case", "E_USAmode", ":", "case", "E_UDAmode", ":", "case", "E_UTAmode", ":", "warning_at", "(", "loc", ",", "<NUM_LIT>", ",", "<STR_LIT>", "using %qs with unsigned type has no effect", "<STR_LIT>", ",", "<STR_LIT>", "absfx", "<STR_LIT>", ")", ";", "return", "args", "[", "<NUM_LIT>", "]", ";", "default", ":", "error_at", "(", "loc", ",", "<STR_LIT>", "no matching fixed-point overload found for %qs", "<STR_LIT>", ",", "<STR_LIT>", "absfx", "<STR_LIT>", ")", ";", "fold", "=", "error_mark_node", ";", "break", ";", "}", "fold", "=", "targetm", ".", "builtin_decl", "(", "id", ",", "true", ")", ";", "if", "(", "fold", "!=", "error_mark_node", ")", "fold", "=", "build_function_call_vec", "(", "loc", ",", "vNULL", ",", "fold", ",", "&", "args", ",", "NULL", ")", ";", "break", ";", "case", "AVR_BUILTIN_ROUNDFX", ":", "if", "(", "args", ".", "length", "(", ")", "!=", "<NUM_LIT>", ")", "{", "error_at", "(", "loc", ",", "<STR_LIT>", "%qs expects 2 arguments but %d given", "<STR_LIT>", ",", "<STR_LIT>", "roundfx", "<STR_LIT>", ",", "(", "int", ")", "args", ".", "length", "(", ")", ")", ";", "fold", "=", "error_mark_node", ";", "break", ";", "}", "type0", "=", "TREE_TYPE", "(", "args", "[", "<NUM_LIT>", "]", ")", ";", "type1", "=", "TREE_TYPE", "(", "args", "[", "<NUM_LIT>", "]", ")", ";", "if", "(", "!", "FIXED_POINT_TYPE_P", "(", "type0", ")", ")", "{", "error_at", "(", "loc", ",", "<STR_LIT>", "%qs expects a fixed-point value as first argument", "<STR_LIT>", ",", "<STR_LIT>", "roundfx", "<STR_LIT>", ")", ";", "fold", "=", "error_mark_node", ";", "}", "if", "(", "!", "INTEGRAL_TYPE_P", "(", "type1", ")", ")", "{", "error_at", "(", "loc", ",", "<STR_LIT>", "%qs expects an integer value as second argument", "<STR_LIT>", ",", "<STR_LIT>", "roundfx", "<STR_LIT>", ")", ";", "fold", "=", "error_mark_node", ";", "}", "switch", "(", "TYPE_MODE", "(", "type0", ")", ")", "{", "case", "E_QQmode", ":", "id", "=", "AVR_BUILTIN_ROUNDHR", ";", "break", ";", "case", "E_HQmode", ":", "id", "=", "AVR_BUILTIN_ROUNDR", ";", "break", ";", "case", "E_SQmode", ":", "id", "=", "AVR_BUILTIN_ROUNDLR", ";", "break", ";", "case", "E_DQmode", ":", "id", "=", "AVR_BUILTIN_ROUNDLLR", ";", "break", ";", "case", "E_UQQmode", ":", "id", "=", "AVR_BUILTIN_ROUNDUHR", ";", "break", ";", "case", "E_UHQmode", ":", "id", "=", "AVR_BUILTIN_ROUNDUR", ";", "break", ";", "case", "E_USQmode", ":", "id", "=", "AVR_BUILTIN_ROUNDULR", ";", "break", ";", "case", "E_UDQmode", ":", "id", "=", "AVR_BUILTIN_ROUNDULLR", ";", "break", ";", "case", "E_HAmode", ":", "id", "=", "AVR_BUILTIN_ROUNDHK", ";", "break", ";", "case", "E_SAmode", ":", "id", "=", "AVR_BUILTIN_ROUNDK", ";", "break", ";", "case", "E_DAmode", ":", "id", "=", "AVR_BUILTIN_ROUNDLK", ";", "break", ";", "case", "E_TAmode", ":", "id", "=", "AVR_BUILTIN_ROUNDLLK", ";", "break", ";", "case", "E_UHAmode", ":", "id", "=", "AVR_BUILTIN_ROUNDUHK", ";", "break", ";", "case", "E_USAmode", ":", "id", "=", "AVR_BUILTIN_ROUNDUK", ";", "break", ";", "case", "E_UDAmode", ":", "id", "=", "AVR_BUILTIN_ROUNDULK", ";", "break", ";", "case", "E_UTAmode", ":", "id", "=", "AVR_BUILTIN_ROUNDULLK", ";", "break", ";", "default", ":", "error_at", "(", "loc", ",", "<STR_LIT>", "no matching fixed-point overload found for %qs", "<STR_LIT>", ",", "<STR_LIT>", "roundfx", "<STR_LIT>", ")", ";", "fold", "=", "error_mark_node", ";", "break", ";", "}", "fold", "=", "targetm", ".", "builtin_decl", "(", "id", ",", "true", ")", ";", "if", "(", "fold", "!=", "error_mark_node", ")", "fold", "=", "build_function_call_vec", "(", "loc", ",", "vNULL", ",", "fold", ",", "&", "args", ",", "NULL", ")", ";", "break", ";", "case", "AVR_BUILTIN_COUNTLSFX", ":", "if", "(", "args", ".", "length", "(", ")", "!=", "<NUM_LIT>", ")", "{", "error_at", "(", "loc", ",", "<STR_LIT>", "%qs expects 1 argument but %d given", "<STR_LIT>", ",", "<STR_LIT>", "countlsfx", "<STR_LIT>", ",", "(", "int", ")", "args", ".", "length", "(", ")", ")", ";", "fold", "=", "error_mark_node", ";", "break", ";", "}", "type0", "=", "TREE_TYPE", "(", "args", "[", "<NUM_LIT>", "]", ")", ";" ]

[ ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "dst", ";", "bits", "<", "<NUM_LIT>", ">", "src", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dst", ";", "let", "SrcA", "=", "src", ";", "let", "SrcB", "=", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "SrcC", "=", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Switches", "=", "{", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "<NUM_LIT>", "}", ";", "let", "hasSrcC", "=", "<NUM_LIT>" ]

[ "Rn", ",", "sub_32", ")", ",", "(", "SUBREG_TO_REG", "(", "i64", "<NUM_LIT>", ")", ",", "FPR32", ":", "$", "Rm", ",", "sub_32", ")", ")", ",", "sub_32", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v1i32", "(", "mul", "FPR32", ":", "$", "Rn", ",", "FPR32", ":", "$", "Rm", ")", ")", ",", "(", "EXTRACT_SUBREG", "(", "MULvvv_2S", "(", "SUBREG_TO_REG", "(", "i64", "<NUM_LIT>", ")", ",", "FPR32", ":", "$" ]

[ "(", "clobber", "(", "reg", ":", "SI", "R0_REG", ")", ")", "]", ")", "]" ]

[ "(", "use", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "PR_REG", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "R4_REG", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "R5_REG", ")", ")" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "scale", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "isUnsigned", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "unsigned", "mmix_dbx_register_number", "(", "unsigned", "regno", ")", "{", "regno", "=", "MMIX_OUTPUT_REGNO", "(", "regno", ")", ";", "return", "regno", ">=", "<NUM_LIT>", "?", "(", "regno", "-", "<NUM_LIT>", ")", ":", "(", "regno", "+", "<NUM_LIT>", ")", ";", "}" ]

[ "DBX_REGISTER_NUMBER", "." ]

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

[ "[", "(", "set", "(", "match_operand", ":", "ANYF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "ANYF", "[", "(", "match_operand", ":", "ANYF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_RECIP1", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "const", "{", "return", "RI", ";", "}" ]

[ "const", "Nios2RegisterInfo", "&", "getRegisterInfo", "(", ")" ]

[ "_", "_", "v8df", ")", "_", "_", "v1", ",", "_", "_", "scale", ")", ";" ]

[ "_", "_", "builtin_ia32_scatterdiv8df", "(", "_", "_", "addr", ",", "_", "_", "mask", ",", "(", "_", "_", "v8di", ")", "_", "_", "index", ",", "(" ]

[ "unsigned", "ARMBaseInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "!", "BytesAdded", "&&", "<STR_LIT>", "code size not handled", "<STR_LIT>", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MBB", ".", "getParent", "(", ")", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "int", "BOpc", "=", "!", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "B", ":", "(", "AFI", "->", "isThumb2Function", "(", ")", "?", "ARM", "::", "t2B", ":", "ARM", "::", "tB", ")", ";", "int", "BccOpc", "=", "!", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "Bcc", ":", "(", "AFI", "->", "isThumb2Function", "(", ")", "?", "ARM", "::", "t2Bcc", ":", "ARM", "::", "tBcc", ")", ";", "bool", "isThumb", "=", "AFI", "->", "isThumbFunction", "(", ")", "||", "AFI", "->", "isThumb2Function", "(", ")", ";", "assert", "(", "TBB", "&&", "<STR_LIT>", "insertBranch must not be told to insert a fallthrough", "<STR_LIT>", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "<NUM_LIT>", "||", "Cond", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "ARM branch conditions have two components!", "<STR_LIT>", ")", ";", "if", "(", "!", "FBB", ")", "{", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "if", "(", "isThumb", ")", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "BOpc", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "else", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "BOpc", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "}", "else", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "BccOpc", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "addImm", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ")", ".", "add", "(", "Cond", "[", "<NUM_LIT>", "]", ")", ";", "return", "<NUM_LIT>", ";", "}", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "BccOpc", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "addImm", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ")", ".", "add", "(", "Cond", "[", "<NUM_LIT>", "]", ")", ";", "if", "(", "isThumb", ")", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "BOpc", ")", ")", ".", "addMBB", "(", "FBB", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "else", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "BOpc", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "return", "<NUM_LIT>", ";", "}" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "second", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";" ]

[ "for", "(", "const", "std", "::", "pair", "<", "unsigned", ",", "RegisterCell", ">", "P", ":", "Map", ")", "dbgs", "(", ")", "<<", "printReg", "(", "P", ".", "first", ",", "&", "ME", ".", "TRI", ")", "<<", "<STR_LIT>", " -> ", "<STR_LIT>", "<<", "P", "." ]

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

[ "def", "HasFPARMv8", ":", "Predicate", "<", "<STR_LIT>", ">", ",", "AssemblerPredicate" ]

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

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

[ "}" ]

[ "int", "cris_cfun_uses_pic_table", "(", "void", ")", "{", "return", "current_function_uses_pic_offset_table", ";" ]

[ "}", "=", "opcode", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "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>" ]

[ "}" ]

[ "SDValue", "SizeNode", "=", "DAG", ".", "getConstant", "(", "Flags", ".", "getByValSize", "(", ")", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "return", "DAG", ".", "getMemcpy", "(", "Chain", ",", "dl", ",", "Dst", ",", "Src", ",", "SizeNode", ",", "Flags", ".", "getNonZeroByValAlign", "(", ")", ",", "false", ",", "true", ",", "false", ",", "MachinePointerInfo", "(", ")", ",", "MachinePointerInfo", "(", ")", ")", ";" ]

[ "<FIXS>", "switch", "(", "RelTy", ")", "{", "<FIXE>" ]

[ "bool", "MBlazeELFWriterInfo", "::", "isPCRelativeRel", "(", "unsigned", "RelTy", ")", "const", "{", "<BUGS>", "switch", "(", "RelTy", ")", "{", "<BUGE>", "case", "R_MICROBLAZE_32_PCREL", ":", "case", "R_MICROBLAZE_64_PCREL", ":", "case", "R_MICROBLAZE_32_PCREL_LO", ":" ]

[ ")", ";" ]

[ "if", "(", "N0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SRL", "&&", "N1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SHL", ")", "std", "::", "swap", "(", "N0", ",", "N1", ")", ";", "if", "(", "N0", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "SHL", "||", "N1", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "SRL", ")", "return", "SDValue", "(", ")", ";", "if", "(", "!", "N0", ".", "hasOneUse", "(", ")", "||", "!", "N1", ".", "hasOneUse", "(", ")", ")", "return", "SDValue", "(", ")", ";", "SDValue", "ShAmt0", "=", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "ShAmt0", ".", "getValueType", "(", ")", "!=", "MVT", "::", "i8", ")", "return", "SDValue", "(", ")", ";", "SDValue", "ShAmt1", "=", "N1", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "ShAmt1", ".", "getValueType", "(", ")", "!=", "MVT", "::", "i8", ")", "return", "SDValue", "(", ")", ";", "SDValue", "ShMsk0", ";", "if", "(", "ShAmt0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "AND", "&&", "isa", "<", "ConstantSDNode", ">", "(", "ShAmt0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "&&", "ShAmt0", ".", "getConstantOperandVal", "(", "<NUM_LIT>", ")", "==", "(", "Bits", "-", "<NUM_LIT>", ")", ")", "{", "ShMsk0", "=", "ShAmt0", ";", "ShAmt0", "=", "ShAmt0", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "}", "SDValue", "ShMsk1", ";", "if", "(", "ShAmt1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "AND", "&&", "isa", "<", "ConstantSDNode", ">", "(", "ShAmt1", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "&&", "ShAmt1", ".", "getConstantOperandVal", "(", "<NUM_LIT>", ")", "==", "(", "Bits", "-", "<NUM_LIT>", ")", ")", "{", "ShMsk1", "=", "ShAmt1", ";", "ShAmt1", "=", "ShAmt1", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "}", "if", "(", "ShAmt0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "TRUNCATE", ")", "ShAmt0", "=", "ShAmt0", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "ShAmt1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "TRUNCATE", ")", "ShAmt1", "=", "ShAmt1", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "unsigned", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "SDValue", "Op0", "=", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Op1", "=", "N1", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "ShAmt0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SUB", "||", "ShAmt0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "XOR", ")", "{", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "std", "::", "swap", "(", "Op0", ",", "Op1", ")", ";", "std", "::", "swap", "(", "ShAmt0", ",", "ShAmt1", ")", ";", "std", "::", "swap", "(", "ShMsk0", ",", "ShMsk1", ")", ";", "}", "if", "(", "ShAmt1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SUB", ")", "{", "SDValue", "Sum", "=", "ShAmt1", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "auto", "*", "SumC", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Sum", ")", ")", "{", "SDValue", "ShAmt1Op1", "=", "ShAmt1", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "ShAmt1Op1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "TRUNCATE", ")", "ShAmt1Op1", "=", "ShAmt1Op1", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "(", "SumC", "->", "getAPIntValue", "(", ")", "==", "Bits", "||", "(", "SumC", "->", "getAPIntValue", "(", ")", "==", "<NUM_LIT>", "&&", "ShMsk1", ")", ")", "&&", "ShAmt1Op1", "==", "ShAmt0", ")", "return", "DAG", ".", "getNode", "(", "Opc", ",", "DL", ",", "VT", ",", "Op0", ",", "Op1", ",", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "MVT", "::", "i8", ",", "ShAmt0", ")", ")", ";", "}", "}", "else", "if", "(", "auto", "*", "ShAmt1C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "ShAmt1", ")", ")", "{", "auto", "*", "ShAmt0C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "ShAmt0", ")", ";", "if", "(", "ShAmt0C", "&&", "(", "ShAmt0C", "->", "getSExtValue", "(", ")", "+", "ShAmt1C", "->", "getSExtValue", "(", ")", ")", "==", "Bits", ")", "return", "DAG", ".", "getNode", "(", "Opc", ",", "DL", ",", "VT", ",", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "N1", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "MVT", "::", "i8", ",", "ShAmt0", ")", ")", ";", "}", "else", "if", "(", "ShAmt1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "XOR", ")", "{", "SDValue", "Mask", "=", "ShAmt1", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "auto", "*", "MaskC", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Mask", ")", ")", "{", "unsigned", "InnerShift", "=", "(", "<STR_LIT>", "::", "<STR_LIT>", "==", "Opc", "?", "ISD", "::", "SRL", ":", "ISD", "::", "SHL", ")", ";", "SDValue", "ShAmt1Op0", "=", "ShAmt1", ".", "getOperand", "(", "<NUM_LIT>" ]

[ "<FIXS>", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "is64bit", "?", "PPC", "::", "ADD8", ":", "PPC", "::", "ADD4", ")", ",", "Ptr1Reg", ")", "<FIXE>", "<FIXS>", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "PPC", "::", "RLWINM", ")", ",", "Shift1Reg", ")", ".", "addReg", "(", "Ptr1Reg", ")", "<FIXE>", "<FIXS>", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "is64bit", "?", "PPC", "::", "XORI8", ":", "PPC", "::", "XORI", ")", ",", "ShiftReg", ")", "<FIXE>", "<FIXS>", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "PPC", "::", "RLDICR", ")", ",", "PtrReg", ")", "<FIXE>", "<FIXS>", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "PPC", "::", "RLWINM", ")", ",", "PtrReg", ")", "<FIXE>", "<FIXS>", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "PPC", "::", "SLW", ")", ",", "Incr2Reg", ")", "<FIXE>", "<FIXS>", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "PPC", "::", "LI", ")", ",", "Mask2Reg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "<FIXE>", "<FIXS>", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "PPC", "::", "LI", ")", ",", "Mask3Reg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "PPC", "::", "ORI", ")", ",", "Mask2Reg", ")", ".", "addReg", "(", "Mask3Reg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "<FIXE>", "<FIXS>", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "PPC", "::", "SLW", ")", ",", "MaskReg", ")", "<FIXE>", "<FIXS>", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "PPC", "::", "LWARX", ")", ",", "TmpDestReg", ")", "<FIXE>", "<FIXS>", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "BinOpcode", ")", ",", "TmpReg", ")", "<FIXE>", "<FIXS>", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "is64bit", "?", "PPC", "::", "ANDC8", ":", "PPC", "::", "ANDC", ")", ",", "Tmp2Reg", ")", "<FIXE>", "<FIXS>", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "is64bit", "?", "PPC", "::", "AND8", ":", "PPC", "::", "AND", ")", ",", "Tmp3Reg", ")", "<FIXE>", "<FIXS>", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "is64bit", "?", "PPC", "::", "OR8", ":", "PPC", "::", "OR", ")", ",", "Tmp4Reg", ")", "<FIXE>", "<FIXS>", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "PPC", "::", "STWCX", ")", ")", "<FIXE>", "<FIXS>", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "PPC", "::", "BCC", ")", ")", "<FIXE>" ]

[ "if", "(", "ptrA", "!=", "PPC", "::", "R0", ")", "{", "Ptr1Reg", "=", "RegInfo", ".", "createVirtualRegister", "(", "RC", ")", ";", "<BUGS>", "BuildMI", "(", "BB", ",", "TII", "->", "get", "(", "is64bit", "?", "PPC", "::", "ADD8", ":", "PPC", "::", "ADD4", ")", ",", "Ptr1Reg", ")", "<BUGE>", ".", "addReg", "(", "ptrA", ")", ".", "addReg", "(", "ptrB", ")", ";", "}", "else", "{", "Ptr1Reg", "=", "ptrB", ";", "}", "<BUGS>", "BuildMI", "(", "BB", ",", "TII", "->", "get", "(", "PPC", "::", "RLWINM", ")", ",", "Shift1Reg", ")", ".", "addReg", "(", "Ptr1Reg", ")", "<BUGE>", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "is8bit", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "<BUGS>", "BuildMI", "(", "BB", ",", "TII", "->", "get", "(", "is64bit", "?", "PPC", "::", "XORI8", ":", "PPC", "::", "XORI", ")", ",", "ShiftReg", ")", "<BUGE>", ".", "addReg", "(", "Shift1Reg", ")", ".", "addImm", "(", "is8bit", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "if", "(", "is64bit", ")", "<BUGS>", "BuildMI", "(", "BB", ",", "TII", "->", "get", "(", "PPC", "::", "RLDICR", ")", ",", "PtrReg", ")", "<BUGE>", ".", "addReg", "(", "Ptr1Reg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "else", "<BUGS>", "BuildMI", "(", "BB", ",", "TII", "->", "get", "(", "PPC", "::", "RLWINM", ")", ",", "PtrReg", ")", "<BUGE>", ".", "addReg", "(", "Ptr1Reg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "<BUGS>", "BuildMI", "(", "BB", ",", "TII", "->", "get", "(", "PPC", "::", "SLW", ")", ",", "Incr2Reg", ")", "<BUGE>", ".", "addReg", "(", "incr", ")", ".", "addReg", "(", "ShiftReg", ")", ";", "if", "(", "is8bit", ")", "<BUGS>", "BuildMI", "(", "BB", ",", "TII", "->", "get", "(", "PPC", "::", "LI", ")", ",", "Mask2Reg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "<BUGE>", "else", "{", "<BUGS>", "BuildMI", "(", "BB", ",", "TII", "->", "get", "(", "PPC", "::", "LI", ")", ",", "Mask3Reg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "BB", ",", "TII", "->", "get", "(", "PPC", "::", "ORI", ")", ",", "Mask2Reg", ")", ".", "addReg", "(", "Mask3Reg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "<BUGE>", "}", "<BUGS>", "BuildMI", "(", "BB", ",", "TII", "->", "get", "(", "PPC", "::", "SLW", ")", ",", "MaskReg", ")", "<BUGE>", ".", "addReg", "(", "Mask2Reg", ")", ".", "addReg", "(", "ShiftReg", ")", ";", "BB", "=", "loopMBB", ";", "<BUGS>", "BuildMI", "(", "BB", ",", "TII", "->", "get", "(", "PPC", "::", "LWARX", ")", ",", "TmpDestReg", ")", "<BUGE>", ".", "addReg", "(", "PPC", "::", "R0", ")", ".", "addReg", "(", "PtrReg", ")", ";", "if", "(", "BinOpcode", ")", "<BUGS>", "BuildMI", "(", "BB", ",", "TII", "->", "get", "(", "BinOpcode", ")", ",", "TmpReg", ")", "<BUGE>", ".", "addReg", "(", "Incr2Reg", ")", ".", "addReg", "(", "TmpDestReg", ")", ";", "<BUGS>", "BuildMI", "(", "BB", ",", "TII", "->", "get", "(", "is64bit", "?", "PPC", "::", "ANDC8", ":", "PPC", "::", "ANDC", ")", ",", "Tmp2Reg", ")", "<BUGE>", ".", "addReg", "(", "TmpDestReg", ")", ".", "addReg", "(", "MaskReg", ")", ";", "<BUGS>", "BuildMI", "(", "BB", ",", "TII", "->", "get", "(", "is64bit", "?", "PPC", "::", "AND8", ":", "PPC", "::", "AND", ")", ",", "Tmp3Reg", ")", "<BUGE>", ".", "addReg", "(", "TmpReg", ")", ".", "addReg", "(", "MaskReg", ")", ";", "<BUGS>", "BuildMI", "(", "BB", ",", "TII", "->", "get", "(", "is64bit", "?", "PPC", "::", "OR8", ":", "PPC", "::", "OR", ")", ",", "Tmp4Reg", ")", "<BUGE>", ".", "addReg", "(", "Tmp3Reg", ")", ".", "addReg", "(", "Tmp2Reg", ")", ";", "<BUGS>", "BuildMI", "(", "BB", ",", "TII", "->", "get", "(", "PPC", "::", "STWCX", ")", ")", "<BUGE>", ".", "addReg", "(", "Tmp4Reg", ")", ".", "addReg", "(", "PPC", "::", "R0", ")", ".", "addReg", "(", "PtrReg", ")", ";", "<BUGS>", "BuildMI", "(", "BB", ",", "TII", "->", "get", "(", "PPC", "::", "BCC", ")", ")", "<BUGE>", ".", "addImm", "(", "PPC", "::", "PRED_NE", ")", ".", "addReg", "(", "PPC", "::", "CR0", ")", ".", "addMBB", "(", "loopMBB", ")", ";", "BB", "->", "addSuccessor", "(", "loopMBB", ")", ";", "BB", "->", "addSuccessor", "(", "exitMBB", ")", ";" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Q", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "U", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "size", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

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

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

[ "_", "_", "arm_vmulhq_u16", "(", "uint16x8_t", "_", "_", "a", ",", "uint16x8_t", "_", "_", "b", ")", "{", "return", "_", "_", "builtin_mve_vmulhq_uv8hi", "(", "_", "_", "a" ]

[ "}" ]

[ "bool", "isBoundary", "(", "MachineOperand", "&", "MO", ")", "const", "{", "if", "(", "BoundarySel", ")", "{", "if", "(", "!", "MO", ".", "isImm", "(", ")", ")", "return", "false", ";", "return", "MO", ".", "getImm", "(", ")", "==", "Boundary", ".", "ImmVal", ";", "}", "else", "{", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "return", "false", ";", "return", "MO", ".", "getReg", "(", ")", "==", "Boundary", ".", "Reg", ";", "}" ]

[ "false", ";" ]

[ "if", "(", "!", "isa", "<", "ConstantSDNode", ">", "(", "N", ".", "getNode", "(", ")", ")", ")", "return", "false", ";", "uint64_t", "Immed", "=", "cast", "<", "ConstantSDNode", ">", "(", "N", ".", "getNode", "(", ")", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "Immed", "==", "<NUM_LIT>", ")", "return" ]

[ ")", ",", "MI", ".", "getNumOperands", "(", ")", ")", ";" ]

[ "void", "RegDefsUses", "::", "init", "(", "const", "MachineInstr", "&", "MI", ")", "{", "update", "(", "MI", ",", "<NUM_LIT>", ",", "MI", ".", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", ")", ";", "if", "(", "MI", ".", "isCall", "(", ")", ")", "Defs", ".", "set", "(", "Mips", "::", "RA", ")", ";", "if", "(", "MI", ".", "isBranch", "(", ")", ")", "{", "update", "(", "MI", ",", "MI", ".", "getDesc", "(", ")", ".", "getNumOperands", "(" ]

[ "<FIXS>", "if", "(", "MI", ".", "mayLoad", "(", ")", "&&", "hasLoadFromStackSlot", "(", "MI", ",", "Accesses", ")", "&&", "Accesses", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "{", "<FIXE>" ]

[ "unsigned", "ARMBaseInstrInfo", "::", "isLoadFromStackSlotPostFE", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "SmallVector", "const", "MachineMemOperand", "*", ",", "<NUM_LIT>", ">", "Accesses", ";", "<BUGS>", "if", "(", "MI", ".", "mayLoad", "(", ")", "&&", "hasLoadFromStackSlot", "(", "MI", ",", "Accesses", ")", ")", "{", "<BUGE>", "FrameIndex", "=", "cast", "FixedStackPseudoSourceValue", ">", "(", "Accesses", ".", "front", "(", ")", "->", "getPseudoValue", "(", ")", ")", "<BUGS>", "getFrameIndex", "(", ")", ";", "<BUGE>" ]

[ "<NUM_LIT>", ";" ]

[ "def", "F2_conv_uw2sf", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_3a867367", ",", "TypeS_2op", ">", ",", "Enc_5e2823", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=" ]

[ "break", ";" ]

[ "Streamer", ".", "EmitIntValue", "(", "TagHeaderSize", "+", "ContentsSize", ",", "<NUM_LIT>", ")", ";", "for", "(", "unsigned", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "Contents", ".", "size", "(", ")", ";", "++", "i", ")", "{", "AttributeItemType", "item", "=", "Contents", "[", "i", "]", ";", "Streamer", ".", "EmitULEB128IntValue", "(", "item", ".", "Tag", ")", ";", "switch", "(", "item", ".", "Type", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Invalid attribute type", "<STR_LIT>", ")", ";", "case", "AttributeItemType", "::", "NumericAttribute", ":", "Streamer", ".", "EmitULEB128IntValue", "(", "item", ".", "IntValue", ")", ";", "break", ";", "case", "AttributeItemType", "::", "TextAttribute", ":", "Streamer", ".", "EmitBytes", "(", "item", ".", "StringValue", ".", "upper", "(", ")", ")", ";", "Streamer", ".", "EmitIntValue", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";" ]

[ "return", "DAG", ".", "getNode", "(", "Opc", ",", "SDLoc", "(", "N", ")", ",", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "Pg", ",", "Op1", ",", "Op2", ")", ";" ]

[ "static", "SDValue", "convertMergedOpToPredOp", "(", "SDNode", "*", "N", ",", "unsigned", "Opc", ",", "SelectionDAG", "&", "DAG", ",", "bool", "UnpredOp", "=", "false", ",", "bool", "SwapOperands", "=", "false", ")", "{", "assert", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "INTRINSIC_WO_CHAIN", "&&", "<STR_LIT>", "Expected intrinsic!", "<STR_LIT>", ")", ";", "assert", "(", "N", "->", "getNumOperands", "(", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Expected 3 operand intrinsic!", "<STR_LIT>", ")", ";", "SDValue", "Pg", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Op1", "=", "N", "->", "getOperand", "(", "SwapOperands", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "SDValue", "Op2", "=", "N", "->", "getOperand", "(", "SwapOperands", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "if", "(", "isAllActivePredicate", "(", "DAG", ",", "Pg", ")", ")", "{", "if", "(", "UnpredOp", ")", "return", "DAG", ".", "getNode", "(", "Opc", ",", "SDLoc", "(", "N", ")", ",", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "Op1", ",", "Op2", ")", ";" ]

[ "}" ]

[ "static", "SDValue", "Extract256BitVector", "(", "SDValue", "Vec", ",", "unsigned", "IdxVal", ",", "SelectionDAG", "&", "DAG", ",", "SDLoc", "dl", ")", "{", "assert", "(", "Vec", ".", "getValueType", "(", ")", ".", "is512BitVector", "(", ")", "&&", "<STR_LIT>", "Unexpected vector size!", "<STR_LIT>", ")", ";", "return", "ExtractSubVector", "(", "Vec", ",", "IdxVal", ",", "DAG", ",", "dl", ",", "<NUM_LIT>", ")", ";" ]

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

[ "if", "(", "n_gpr", "+", "cfun", "->", "va_list_gpr_size", ">", "GP_ARG_NUM_REG", "||", "n_fpr", "+", "cfun", "->", "va_list_fpr_size", ">", "FP_ARG_NUM_REG", "||", "TARGET_VX_ABI", ")", "{", "if", "(", "cfun", "->", "machine", "->", "split_stack_varargs_pointer", "==", "NULL_RTX", ")", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "ovf", ")", ",", "virtual_incoming_args_rtx", ")", ";", "else", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "ovf", ")", ",", "cfun", "->", "machine", "->", "split_stack_varargs_pointer", ")", ";", "off", "=", "INTVAL", "(", "crtl", "->", "args", ".", "arg_offset_rtx", ")", ";", "off", "=", "off", "<", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "off", ";", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "va_start: n_gpr = %d, n_fpr = %d off %d\\n", "<STR_LIT>", ",", "(", "int", ")", "n_gpr", ",", "(", "int", ")", "n_fpr", ",", "off", ")", ";", "t", "=", "fold_build_pointer_plus_hwi", "(", "t", ",", "off", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "ovf", ")", ",", "ovf", ",", "t", ")", ";", "TREE_SIDE_EFFECTS", "(", "t", ")", "=", "<NUM_LIT>", ";", "expand_expr", "(", "t", ",", "const0_rtx", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "}", "if", "(", "(", "cfun", "->", "va_list_gpr_size", "&&", "n_gpr", "<", "GP_ARG_NUM_REG", ")", "||", "(", "cfun", "->", "va_list_fpr_size", "&&", "n_fpr", "<", "FP_ARG_NUM_REG", ")", ")", "{", "t", "=", "make_tree", "(", "TREE_TYPE", "(", "sav", ")", ",", "return_address_pointer_rtx", ")", ";", "t", "=", "fold_build_pointer_plus_hwi", "(", "t", ",", "-", "RETURN_REGNUM", "*", "UNITS_PER_LONG", ")", ";", "t", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "sav", ")", ",", "sav", ",", "t", ")", ";", "TREE_SIDE_EFFECTS", "(", "t", ")" ]

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

[ "static", "rtx", "sparc_function_arg", "(", "cumulative_args_t", "cum", ",", "const", "function_arg_info", "&", "arg", ")", "{", "return", "sparc_function_arg_1", "(", "cum", ",", "arg" ]

[ "bool", "HexagonInstrInfo", "::", "isValidOffset", "(", "unsigned", "Opcode", ",", "int", "Offset", ",", "bool", "Extend", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "Hexagon", "::", "STriq_pred_V6", ":", "case", "Hexagon", "::", "STriq_pred_vec_V6", ":", "case", "Hexagon", "::", "STriv_pseudo_V6", ":", "case", "Hexagon", "::", "STrivv_pseudo_V6", ":", "case", "Hexagon", "::", "LDriq_pred_V6", ":", "case", "Hexagon", "::", "LDriq_pred_vec_V6", ":", "case", "Hexagon", "::", "LDriv_pseudo_V6", ":", "case", "Hexagon", "::", "LDrivv_pseudo_V6", ":", "case", "Hexagon", "::", "LDrivv_indexed", ":", "case", "Hexagon", "::", "STrivv_indexed", ":", "case", "Hexagon", "::", "V6_vL32b_ai", ":", "case", "Hexagon", "::", "V6_vS32b_ai", ":", "case", "Hexagon", "::", "V6_vL32Ub_ai", ":", "case", "Hexagon", "::", "V6_vS32Ub_ai", ":", "return", "(", "Offset", ">=", "Hexagon_MEMV_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMV_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "STriq_pred_V6_128B", ":", "case", "Hexagon", "::", "STriq_pred_vec_V6_128B", ":", "case", "Hexagon", "::", "STriv_pseudo_V6_128B", ":", "case", "Hexagon", "::", "STrivv_pseudo_V6_128B", ":", "case", "Hexagon", "::", "LDriq_pred_V6_128B", ":", "case", "Hexagon", "::", "LDriq_pred_vec_V6_128B", ":", "case", "Hexagon", "::", "LDriv_pseudo_V6_128B", ":", "case", "Hexagon", "::", "LDrivv_pseudo_V6_128B", ":", "case", "Hexagon", "::", "LDrivv_indexed_128B", ":", "case", "Hexagon", "::", "STrivv_indexed_128B", ":", "case", "Hexagon", "::", "V6_vL32b_ai_128B", ":", "case", "Hexagon", "::", "V6_vS32b_ai_128B", ":", "case", "Hexagon", "::", "V6_vL32Ub_ai_128B", ":", "case", "Hexagon", "::", "V6_vS32Ub_ai_128B", ":", "return", "(", "Offset", ">=", "Hexagon_MEMV_OFFSET_MIN_128B", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMV_OFFSET_MAX_128B", ")", ";", "case", "Hexagon", "::", "J2_loop0i", ":", "case", "Hexagon", "::", "J2_loop1i", ":", "return", "isUInt", "<", "<NUM_LIT>", ">", "(", "Offset", ")", ";", "}", "if", "(", "Extend", ")", "return", "true", ";", "switch", "(", "Opcode", ")", "{", "case", "Hexagon", "::", "L2_loadri_io", ":", "case", "Hexagon", "::", "S2_storeri_io", ":", "return", "(", "Offset", ">=", "Hexagon_MEMW_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMW_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "L2_loadrd_io", ":", "case", "Hexagon", "::", "S2_storerd_io", ":", "return", "(", "Offset", ">=", "Hexagon_MEMD_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMD_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "L2_loadrh_io", ":", "case", "Hexagon", "::", "L2_loadruh_io", ":", "case", "Hexagon", "::", "S2_storerh_io", ":", "return", "(", "Offset", ">=", "Hexagon_MEMH_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMH_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "L2_loadrb_io", ":", "case", "Hexagon", "::", "L2_loadrub_io", ":", "case", "Hexagon", "::", "S2_storerb_io", ":", "return", "(", "Offset", ">=", "Hexagon_MEMB_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMB_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "A2_addi", ":", "return", "(", "Offset", ">=", "Hexagon_ADDI_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_ADDI_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "L4_iadd_memopw_io", ":", "case", "Hexagon", "::", "L4_isub_memopw_io", ":", "case", "Hexagon", "::", "L4_add_memopw_io", ":", "case", "Hexagon", "::", "L4_sub_memopw_io", ":", "case", "Hexagon", "::", "L4_and_memopw_io", ":", "case", "Hexagon", "::", "L4_or_memopw_io", ":", "return", "(", "<NUM_LIT>", "<=", "Offset", "&&", "Offset", "<=", "<NUM_LIT>", ")", ";", "case", "Hexagon", "::", "L4_iadd_memoph_io", ":", "case", "Hexagon", "::", "L4_isub_memoph_io", ":", "case", "Hexagon", "::", "L4_add_memoph_io", ":", "case", "Hexagon", "::", "L4_sub_memoph_io", ":", "case", "Hexagon", "::", "L4_and_memoph_io", ":", "case", "Hexagon", "::", "L4_or_memoph_io", ":", "return", "(", "<NUM_LIT>", "<=", "Offset", "&&", "Offset", "<=", "<NUM_LIT>", ")", ";", "case", "Hexagon", "::", "L4_iadd_memopb_io", ":", "case", "Hexagon", "::", "L4_isub_memopb_io", ":", "case", "Hexagon", "::", "L4_add_memopb_io", ":", "case", "Hexagon", "::", "L4_sub_memopb_io", ":", "case", "Hexagon", "::", "L4_and_memopb_io", ":", "case", "Hexagon", "::", "L4_or_memopb_io", ":", "return", "(", "<NUM_LIT>", "<=", "Offset", "&&", "Offset", "<=", "<NUM_LIT>", ")", ";", "case", "Hexagon", "::", "STriw_pred", ":", "case", "Hexagon", "::", "LDriw_pred", ":", "case", "Hexagon", "::", "STriw_mod", ":", "case", "Hexagon", "::", "LDriw_mod", ":", "return", "true", ";", "case", "Hexagon", "::", "TFR_FI", ":", "case", "Hexagon", "::", "TFR_FIA", ":", "case", "Hexagon", "::", "INLINEASM", ":", "return", "true", ";", "case", "Hexagon", "::", "L2_ploadrbt_io", ":", "case", "Hexagon", "::", "L2_ploadrbf_io", ":", "case", "Hexagon", "::", "L2_ploadrubt_io", ":", "case", "Hexagon", "::", "L2_ploadrubf_io", ":", "case", "Hexagon", "::", "S2_pstorerbt_io", ":", "case", "Hexagon", "::", "S2_pstorerbf_io", ":", "case", "Hexagon", "::", "S4_storeirb_io", ":", "case", "Hexagon", "::", "S4_storeirbt_io", ":", "case", "Hexagon", "::", "S4_storeirbf_io", ":", "return", "isUInt", "<", "<NUM_LIT>", ">", "(", "Offset", ")", ";", "case", "Hexagon", "::", "L2_ploadrht_io", ":", "case", "Hexagon", "::", "L2_ploadrhf_io", ":", "case", "Hexagon", "::", "L2_ploadruht_io", ":", "case", "Hexagon", "::", "L2_ploadruhf_io", ":", "case", "Hexagon", "::", "S2_pstorerht_io", ":", "case", "Hexagon", "::", "S2_pstorerhf_io", ":", "case", "Hexagon", "::", "S4_storeirh_io", ":", "case", "Hexagon", "::", "S4_storeirht_io", ":", "case", "Hexagon", "::", "S4_storeirhf_io", ":", "return", "isShiftedUInt", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ">", "(", "Offset", ")", ";", "case", "Hexagon", "::", "L2_ploadrit_io", ":", "case", "Hexagon", "::", "L2_ploadrif_io", ":", "case", "Hexagon", "::", "S2_pstorerit_io", ":", "case", "Hexagon", "::", "S2_pstorerif_io", ":", "case", "Hexagon", "::", "S4_storeiri_io", ":", "case", "Hexagon", "::", "S4_storeirit_io", ":", "case", "Hexagon", "::", "S4_storeirif_io", ":", "return", "isShiftedUInt", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ">", "(", "Offset", ")", ";", "case", "Hexagon", "::", "L2_ploadrdt_io", ":", "case", "Hexagon", "::", "L2_ploadrdf_io", ":", "case", "Hexagon", "::", "S2_pstorerdt_io", ":", "case", "Hexagon", "::", "S2_pstorerdf_io", ":", "return", "isShiftedUInt", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ">", "(", "Offset", ")", ";", "}", "llvm_unreachable", "(", "<STR_LIT>", "No offset range is defined for this opcode. ", "<STR_LIT>", "<STR_LIT>", "Please define it in the above switch statement!", "<STR_LIT>", ")", ";", "}" ]

[ "Test", "the", "validity", "of", "offset", "." ]

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

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

[ "}" ]

[ "def", "Wrrr", ":", "BaseMulAccum", "<", "isSub", ",", "<NUM_LIT>", ",", "GPR32", ",", "GPR32", ",", "asm", ",", "[", "]", ">", ",", "Sched", "<", "[", "WriteIM32", ",", "ReadIM", ",", "ReadIM", ",", "ReadIMA", "]", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ ")", ";" ]

[ "auto", "AlignVectors", "::", "getUpwardDeps", "(", "Instruction", "*", "In", ",", "Instruction", "*", "Base", ")", "const", "->", "DepList", "{", "BasicBlock", "*", "Parent", "=", "Base", "->", "getParent", "(", ")", ";", "assert", "(", "In", "->", "getParent", "(", ")", "==", "Parent", "&&", "<STR_LIT>", "Base and In should be in the same block", "<STR_LIT>", ")", ";", "assert", "(", "Base", "->", "comesBefore", "(", "In", ")", "&&", "<STR_LIT>", "Base should come before In", "<STR_LIT>", ")", ";", "DepList", "Deps", ";", "std", "::", "deque", "<", "Instruction", "*", ">", "WorkQ", "=", "{", "In", "}", ";", "while", "(", "!", "WorkQ", ".", "empty", "(", ")", ")", "{", "Instruction", "*", "D", "=", "WorkQ", ".", "front", "(", ")", ";", "WorkQ", ".", "pop_front", "(" ]

[ "<FIXS>", "auto", "Signature", "=", "signatureFromMVTs", "(", "OutContext", ",", "ResultVTs", ",", "ParamVTs", ")", ";", "<FIXE>", "<FIXS>", "WasmSym", "->", "setSignature", "(", "Signature", ")", ";", "<FIXE>" ]

[ "SmallVector", "MVT", ",", "<NUM_LIT>", ">", "ParamVTs", ";", "computeSignatureVTs", "(", "F", ".", "getFunctionType", "(", ")", ",", "&", "F", ",", "F", ",", "TM", ",", "ParamVTs", ",", "ResultVTs", ")", ";", "<BUGS>", "auto", "Signature", "=", "signatureFromMVTs", "(", "ResultVTs", ",", "ParamVTs", ")", ";", "<BUGE>", "auto", "*", "WasmSym", "=", "cast", "MCSymbolWasm", ">", "(", "CurrentFnSym", ")", ";", "<BUGS>", "WasmSym", "->", "setSignature", "(", "Signature", ".", "get", "(", ")", ")", ";", "addSignature", "(", "std", "::", "move", "(", "Signature", ")", ")", ";", "<BUGE>", "WasmSym", "->", "setType", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "getTargetStreamer", "(", ")", "->", "emitFunctionType", "(", "WasmSym", ")", ";" ]

[ "}" ]

[ "assert", "(", "Reg", ">=", "X86", "::", "FP0", "&&", "Reg", "<=", "X86", "::", "FP6", "&&", "<STR_LIT>", "Expected FP register!", "<STR_LIT>", ")", ";", "return", "Reg", "-", "X86", "::", "FP0", ";" ]

[ "I", "=", "llvm", "::", "make_unique", "<", "PPCSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ")", ";" ]

[ "Attribute", "CPUAttr", "=", "FnAttrs", ".", "getAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "<STR_LIT>", "target-cpu", "<STR_LIT>", ")", ";", "Attribute", "FSAttr", "=", "FnAttrs", ".", "getAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "<STR_LIT>", "target-features", "<STR_LIT>", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";" ]

[ "break", ";" ]

[ "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "LoweredMI", "=", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addImm", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "LoweredMI", "=", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addImm", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "LoweredMI", "=", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addImm", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ".", "addImm", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "LoweredMI", "=", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addImm", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ".", "addImm", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "LoweredMI", "=", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addImm", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "LoweredMI", "=", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addImm", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "LoweredMI", "=", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addImm", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ".", "addImm", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "LoweredMI", "=", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addImm", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ".", "addImm", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "LoweredMI", "=", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addExpr", "(", "getTLSGetOffset", "(", "MF", "->", "getContext", "(", ")", ")", ")", ".", "addExpr", "(", "Lower", ".", "getExpr", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "MCSymbolRefExpr", "::", "VK_TLSGD", ")", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "LoweredMI", "=", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addExpr", "(", "getTLSGetOffset", "(", "MF", "->", "getContext", "(", ")", ")", ")", ".", "addExpr", "(", "Lower", ".", "getExpr", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "MCSymbolRefExpr", "::", "VK_TLSLDM", ")", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "LoweredMI", "=", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addExpr", "(", "getGlobalOffsetTable", "(", "MF", "->", "getContext", "(", ")", ")", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "LoweredMI", "=", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", ".", "addImm", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "LoweredMI", "=", "MCInstBuilder", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", ".", "addImm", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "LoweredMI", "=", "lowerRIEfLow", "(", "MI", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "LoweredMI", "=", "lowerRIEfLow", "(", "MI", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

[ "if", "(", "IsNested", ")", "BuildMI", "(", "allocMBB", ",", "DL", ",", "TII", ".", "get", "(", "MOVrr", ")", ",", "RegAX", ")", ".", "addReg", "(", "Reg10", ")", ";" ]

[ "if", "(", "STI", ".", "isTargetLinux", "(", ")", ")", "{", "TlsReg", "=", "X86", "::", "GS", ";", "TlsOffset", "=", "<NUM_LIT>", ";", "}", "else", "if", "(", "STI", ".", "isTargetDarwin", "(", ")", ")", "{", "TlsReg", "=", "X86", "::", "GS", ";", "TlsOffset", "=", "<NUM_LIT>", "+", "<NUM_LIT>", "*", "<NUM_LIT>", ";", "}", "else", "if", "(", "STI", ".", "isTargetWin32", "(", ")", ")", "{", "TlsReg", "=", "X86", "::", "FS", ";", "TlsOffset", "=", "<NUM_LIT>", ";", "}", "else", "if", "(", "STI", ".", "isTargetFreeBSD", "(", ")", ")", "{", "report_fatal_error", "(", "<STR_LIT>", "Segmented stacks not supported on FreeBSD i386.", "<STR_LIT>", ")", ";", "}", "else", "{", "report_fatal_error", "(", "<STR_LIT>", "Segmented stacks not supported on this platform.", "<STR_LIT>", ")", ";", "}", "if", "(", "CompareStackPointer", ")", "ScratchReg", "=", "X86", "::", "ESP", ";", "else", "BuildMI", "(", "checkMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "LEA32r", ")", ",", "ScratchReg", ")", ".", "addReg", "(", "X86", "::", "ESP", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "-", "StackSize", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ";", "if", "(", "STI", ".", "isTargetLinux", "(", ")", "||", "STI", ".", "isTargetWin32", "(", ")", "||", "STI", ".", "isTargetWin64", "(", ")", ")", "{", "BuildMI", "(", "checkMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "CMP32rm", ")", ")", ".", "addReg", "(", "ScratchReg", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "TlsOffset", ")", ".", "addReg", "(", "TlsReg", ")", ";", "}", "else", "if", "(", "STI", ".", "isTargetDarwin", "(", ")", ")", "{", "unsigned", "ScratchReg2", ";", "bool", "SaveScratch2", ";", "if", "(", "CompareStackPointer", ")", "{", "ScratchReg2", "=", "GetScratchRegister", "(", "Is64Bit", ",", "IsLP64", ",", "MF", ",", "true", ")", ";", "SaveScratch2", "=", "false", ";", "}", "else", "{", "ScratchReg2", "=", "GetScratchRegister", "(", "Is64Bit", ",", "IsLP64", ",", "MF", ",", "false", ")", ";", "SaveScratch2", "=", "MF", ".", "getRegInfo", "(", ")", ".", "isLiveIn", "(", "ScratchReg2", ")", ";", "}", "assert", "(", "(", "!", "MF", ".", "getRegInfo", "(", ")", ".", "isLiveIn", "(", "ScratchReg2", ")", "||", "SaveScratch2", ")", "&&", "<STR_LIT>", "Scratch register is live-in and not saved", "<STR_LIT>", ")", ";", "if", "(", "SaveScratch2", ")", "BuildMI", "(", "checkMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "PUSH32r", ")", ")", ".", "addReg", "(", "ScratchReg2", ",", "RegState", "::", "Kill", ")", ";", "BuildMI", "(", "checkMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "MOV32ri", ")", ",", "ScratchReg2", ")", ".", "addImm", "(", "TlsOffset", ")", ";", "BuildMI", "(", "checkMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "CMP32rm", ")", ")", ".", "addReg", "(", "ScratchReg", ")", ".", "addReg", "(", "ScratchReg2", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "TlsReg", ")", ";", "if", "(", "SaveScratch2", ")", "BuildMI", "(", "checkMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "POP32r", ")", ",", "ScratchReg2", ")", ";", "}", "}", "BuildMI", "(", "checkMBB", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "JA_4", ")", ")", ".", "addMBB", "(", "&", "prologueMBB", ")", ";", "if", "(", "Is64Bit", ")", "{", "const", "unsigned", "RegAX", "=", "IsLP64", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ";", "const", "unsigned", "Reg10", "=", "IsLP64", "?", "X86", "::", "R10", ":", "X86", "::", "R10D", ";", "const", "unsigned", "Reg11", "=", "IsLP64", "?", "X86", "::", "R11", ":", "X86", "::", "R11D", ";", "const", "unsigned", "MOVrr", "=", "IsLP64", "?", "X86", "::", "MOV64rr", ":", "X86", "::", "MOV32rr", ";", "const", "unsigned", "MOVri", "=", "IsLP64", "?", "X86", "::", "MOV64ri", ":", "X86", "::", "MOV32ri", ";" ]

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

[ "class", "BSETI_H_DESC", ":", "MSA_BIT_H_DESC_BASE", "<", "<STR_LIT>", ",", "or", ",", "vsplat_uimm_pow2" ]

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

[ "class", "Enc_d44e31", ":", "OpcodeHexagon", "{", "bits", "<", "<NUM_LIT>", ">", "Ii", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rs32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rs32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

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

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

[ "}" ]

[ "class", "SBR", "<", "bits", "<", "<NUM_LIT>", ">", "op1", ",", "dag", "outs", ",", "dag", "ins", ",", "string", "asmstr", ",", "list", "<", "dag", ">", "pattern", ">", ":", "T16", "<", "outs", ",", "ins", ",", "asmstr", ",", "pattern", ">", "{", "bits", "<", "<NUM_LIT>", ">", "s2", ";", "bits", "<", "<NUM_LIT>", ">", "disp4", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "s2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "disp4", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op1", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

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

[ "vzipq_u16", "(", "uint16x8_t", "_", "_", "a", ",", "uint16x8_t", "_", "_", "b", ")", "{", "uint16x8x2_t", "_", "_", "rv", ";", "_", "_", "rv", ".", "val", "[", "<NUM_LIT>", "]", "=", "_", "_", "builtin_shuffle", "(", "_", "_", "a", ",", "_", "_", "b", ",", "(", "uint16x8_t", ")", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ";", "_", "_", "rv", ".", "val", "[", "<NUM_LIT>", "]", "=", "_", "_", "builtin_shuffle", "(", "_", "_", "a", ",", "_", "_", "b", ",", "(", "uint16x8_t" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "debug_rtx_list", "(", "get_insns", "(", ")", ",", "<NUM_LIT>", ")", ";", "final", "(", "get_insns", "(", ")", ",", "file", ",", "FALSE", ",", "FALSE", ")", ";", "<FIXE>" ]

[ "{", "start_sequence", "(", ")", ";", "<BUGS>", "<BUGE>", "emit_note", "(", "<NUM_LIT>", ",", "NOTE_INSN_DELETED", ")", ";", "rs6000_emit_prologue", "(", ")", ";", "emit_note", "(", "<NUM_LIT>", ",", "NOTE_INSN_DELETED", ")", ";", "if", "(", "TARGET_DEBUG_STACK", ")", "<BUGS>", "debug_rtx_list", "(", "get_insns", "(", ")", ",", "<NUM_LIT>", ")", ";", "final", "(", "get_insns", "(", ")", ",", "file", ",", "FALSE", ",", "FALSE", ")", ";", "<BUGE>", "end_sequence", "(", ")", ";", "}" ]

[ "if", "(", "Subtarget", "->", "hasXMM", "(", ")", ")", "getMaxByValAlign", "(", "Ty", ",", "Align", ")", ";" ]

[ "unsigned", "X86TargetLowering", "::", "getByValTypeAlignment", "(", "Type", "*", "Ty", ")", "const", "{", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", ")", "{", "unsigned", "TyAlign", "=", "TD", "->", "getABITypeAlignment", "(", "Ty", ")", ";", "if", "(", "TyAlign", ">", "<NUM_LIT>", ")", "return", "TyAlign", ";", "return", "<NUM_LIT>", ";", "}", "unsigned", "Align", "=", "<NUM_LIT>", ";" ]

[ "StringRef", "AArch64MCExpr", "::", "getVariantKindName", "(", ")", "const", "{", "switch", "(", "static_cast", "<", "uint32_t", ">", "(", "getKind", "(", ")", ")", ")", "{", "case", "VK_CALL", ":", "return", "<STR_LIT>", "<STR_LIT>", ";", "case", "VK_LO12", ":", "return", "<STR_LIT>", ":lo12:", "<STR_LIT>", ";", "case", "VK_ABS_G3", ":", "return", "<STR_LIT>", ":abs_g3:", "<STR_LIT>", ";", "case", "VK_ABS_G2", ":", "return", "<STR_LIT>", ":abs_g2:", "<STR_LIT>", ";", "case", "VK_ABS_G2_S", ":", "return", "<STR_LIT>", ":abs_g2_s:", "<STR_LIT>", ";", "case", "VK_ABS_G2_NC", ":", "return", "<STR_LIT>", ":abs_g2_nc:", "<STR_LIT>", ";", "case", "VK_ABS_G1", ":", "return", "<STR_LIT>", ":abs_g1:", "<STR_LIT>", ";", "case", "VK_ABS_G1_S", ":", "return", "<STR_LIT>", ":abs_g1_s:", "<STR_LIT>", ";", "case", "VK_ABS_G1_NC", ":", "return", "<STR_LIT>", ":abs_g1_nc:", "<STR_LIT>", ";", "case", "VK_ABS_G0", ":", "return", "<STR_LIT>", ":abs_g0:", "<STR_LIT>", ";", "case", "VK_ABS_G0_S", ":", "return", "<STR_LIT>", ":abs_g0_s:", "<STR_LIT>", ";", "case", "VK_ABS_G0_NC", ":", "return", "<STR_LIT>", ":abs_g0_nc:", "<STR_LIT>", ";", "case", "VK_PREL_G3", ":", "return", "<STR_LIT>", ":prel_g3:", "<STR_LIT>", ";", "case", "VK_PREL_G2", ":", "return", "<STR_LIT>", ":prel_g2:", "<STR_LIT>", ";", "case", "VK_PREL_G2_NC", ":", "return", "<STR_LIT>", ":prel_g2_nc:", "<STR_LIT>", ";", "case", "VK_PREL_G1", ":", "return", "<STR_LIT>", ":prel_g1:", "<STR_LIT>", ";", "case", "VK_PREL_G1_NC", ":", "return", "<STR_LIT>", ":prel_g1_nc:", "<STR_LIT>", ";", "case", "VK_PREL_G0", ":", "return", "<STR_LIT>", ":prel_g0:", "<STR_LIT>", ";", "case", "VK_PREL_G0_NC", ":", "return", "<STR_LIT>", ":prel_g0_nc:", "<STR_LIT>", ";", "case", "VK_DTPREL_G2", ":", "return", "<STR_LIT>", ":dtprel_g2:", "<STR_LIT>", ";", "case", "VK_DTPREL_G1", ":", "return", "<STR_LIT>", ":dtprel_g1:", "<STR_LIT>", ";", "case", "VK_DTPREL_G1_NC", ":", "return", "<STR_LIT>", ":dtprel_g1_nc:", "<STR_LIT>", ";", "case", "VK_DTPREL_G0", ":", "return", "<STR_LIT>", ":dtprel_g0:", "<STR_LIT>", ";", "case", "VK_DTPREL_G0_NC", ":", "return", "<STR_LIT>", ":dtprel_g0_nc:", "<STR_LIT>", ";", "case", "VK_DTPREL_HI12", ":", "return", "<STR_LIT>", ":dtprel_hi12:", "<STR_LIT>", ";", "case", "VK_DTPREL_LO12", ":", "return", "<STR_LIT>", ":dtprel_lo12:", "<STR_LIT>", ";", "case", "VK_DTPREL_LO12_NC", ":", "return", "<STR_LIT>", ":dtprel_lo12_nc:", "<STR_LIT>", ";", "case", "VK_TPREL_G2", ":", "return", "<STR_LIT>", ":tprel_g2:", "<STR_LIT>", ";", "case", "VK_TPREL_G1", ":", "return", "<STR_LIT>", ":tprel_g1:", "<STR_LIT>", ";", "case", "VK_TPREL_G1_NC", ":", "return", "<STR_LIT>", ":tprel_g1_nc:", "<STR_LIT>", ";", "case", "VK_TPREL_G0", ":", "return", "<STR_LIT>", ":tprel_g0:", "<STR_LIT>", ";", "case", "VK_TPREL_G0_NC", ":", "return", "<STR_LIT>", ":tprel_g0_nc:", "<STR_LIT>", ";", "case", "VK_TPREL_HI12", ":", "return", "<STR_LIT>", ":tprel_hi12:", "<STR_LIT>", ";", "case", "VK_TPREL_LO12", ":", "return", "<STR_LIT>", ":tprel_lo12:", "<STR_LIT>", ";", "case", "VK_TPREL_LO12_NC", ":", "return", "<STR_LIT>", ":tprel_lo12_nc:", "<STR_LIT>", ";", "case", "VK_TLSDESC_LO12", ":", "return", "<STR_LIT>", ":tlsdesc_lo12:", "<STR_LIT>", ";", "case", "VK_ABS_PAGE", ":", "return", "<STR_LIT>", "<STR_LIT>", ";", "case", "VK_ABS_PAGE_NC", ":", "return", "<STR_LIT>", ":pg_hi21_nc:", "<STR_LIT>", ";", "case", "VK_GOT", ":", "return", "<STR_LIT>", ":got:", "<STR_LIT>", ";", "case", "VK_GOT_PAGE", ":", "return", "<STR_LIT>", ":got:", "<STR_LIT>", ";", "case", "VK_GOT_LO12", ":", "return", "<STR_LIT>", ":got_lo12:", "<STR_LIT>", ";", "case", "VK_GOTTPREL", ":", "return", "<STR_LIT>", ":gottprel:", "<STR_LIT>", ";", "case", "VK_GOTTPREL_PAGE", ":", "return", "<STR_LIT>", ":gottprel:", "<STR_LIT>", ";", "case", "VK_GOTTPREL_LO12_NC", ":", "return", "<STR_LIT>", ":gottprel_lo12:", "<STR_LIT>", ";", "case", "VK_GOTTPREL_G1", ":", "return", "<STR_LIT>", ":gottprel_g1:", "<STR_LIT>", ";", "case", "VK_GOTTPREL_G0_NC", ":", "return", "<STR_LIT>", ":gottprel_g0_nc:", "<STR_LIT>", ";", "case", "VK_TLSDESC", ":", "return", "<STR_LIT>", "<STR_LIT>", ";", "case", "VK_TLSDESC_PAGE", ":", "return", "<STR_LIT>", ":tlsdesc:", "<STR_LIT>", ";", "case", "VK_SECREL_LO12", ":", "return", "<STR_LIT>", ":secrel_lo12:", "<STR_LIT>", ";", "case", "VK_SECREL_HI12", ":", "return", "<STR_LIT>", ":secrel_hi12:", "<STR_LIT>", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Invalid ELF symbol kind", "<STR_LIT>", ")", ";", "}", "}" ]

[ "Convert", "the", "variant", "kind", "into", "an", "ELF-appropriate", "modifier", "(", "e.g", "." ]

[ "<FIXS>", "defm", ":", "X86WriteRes", "WriteFLoad", ",", "[", "SBPort23", "]", ",", "<NUM_LIT>", ",", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ">", ";", "defm", ":", "X86WriteRes", "WriteFLoadX", ",", "[", "SBPort23", "]", ",", "<NUM_LIT>", ",", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ">", ";", "defm", ":", "X86WriteRes", "WriteFLoadY", ",", "[", "SBPort23", "]", ",", "<NUM_LIT>", ",", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ">", ";", "<FIXE>" ]

[ "defm", ":", "SBWriteResPair", "WriteBZHI", ",", "[", "SBPort1", "]", ",", "<NUM_LIT>", ">", ";", "<BUGS>", "defm", ":", "X86WriteRes", "WriteFLoad", ",", "[", "SBPort23", "]", ",", "<NUM_LIT>", ",", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ">", ";", "<BUGE>", "defm", ":", "X86WriteRes", "WriteFMaskedLoad", ",", "[", "SBPort23", ",", "SBPort05", "]", ",", "<NUM_LIT>", ",", "[", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ">", ";", "defm", ":", "X86WriteRes", "WriteFMaskedLoadY", ",", "[", "SBPort23", ",", "SBPort05", "]", ",", "<NUM_LIT>", ",", "[", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ">", ";", "defm", ":", "X86WriteRes", "WriteFStore", ",", "[", "SBPort23", ",", "SBPort4", "]", ",", "<NUM_LIT>", ",", "[", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ">", ";", "defm", ":", "X86WriteRes", "WriteFMaskedStore", ",", "[", "SBPort4", ",", "SBPort01", ",", "SBPort23", "]", ",", "<NUM_LIT>", ",", "[", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ">", ";", "defm", ":", "X86WriteRes", "WriteFMaskedStoreY", ",", "[", "SBPort4", ",", "SBPort01", ",", "SBPort23", "]", ",", "<NUM_LIT>", ",", "[", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ">", ";", "defm", ":", "X86WriteRes", "WriteFMove", ",", "[", "SBPort5", "]", ",", "<NUM_LIT>", ",", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ">", ";", "defm", ":", "X86WriteRes", "WriteEMMS", ",", "[", "SBPort015", "]", ",", "<NUM_LIT>", ",", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ">", ";", "defm", ":", "SBWriteResPair", "WriteFAdd", ",", "[", "SBPort1", "]", ",", "<NUM_LIT>", ",", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ">", ";" ]

[ "<STR_LIT>", "@ InlineAsm End", "<STR_LIT>", ";" ]

[ "BaseTAI", "::", "CommentString", "=", "<STR_LIT>", "@", "<STR_LIT>", ";", "BaseTAI", "::", "ConstantPoolSection", "=", "<STR_LIT>", "\\t.text\\n", "<STR_LIT>", ";", "BaseTAI", "::", "COMMDirectiveTakesAlignment", "=", "false", ";", "BaseTAI", "::", "InlineAsmStart", "=", "<STR_LIT>", "@ InlineAsm Start", "<STR_LIT>", ";", "BaseTAI", "::", "InlineAsmEnd", "=" ]

[ "ro_Wextend8", ":", "$", "extend", ")", ")", "]", ">", ",", "Sched", "<", "[", "WriteSTIdx", ",", "ReadST", ",", "ReadAdrBase", "]", ">", "{" ]

[ "def", "roW", ":", "LoadStore8RO", "<", "sz", ",", "V", ",", "opc", ",", "asm", ",", "(", "outs", ")", ",", "(", "ins", "regtype", ":", "$", "Rt", ",", "GPR64sp", ":", "$", "Rn", ",", "GPR32", ":", "$", "Rm", ",", "ro_Wextend8", ":", "$", "extend", ")", ",", "[", "(", "storeop", "(", "Ty", "regtype", ":", "$", "Rt", ")", ",", "(", "ro_Windexed8", "GPR64sp", ":", "$", "Rn", ",", "GPR32", ":", "$", "Rm", "," ]

[ "}", ")" ]

[ "return", "(", "GET_CODE", "(", "op", ")", "=", "=", "CONST_INT", "&", "&", "(", "INTVAL", "(", "op", ")", "&", "<NUM_LIT>", ")", "=", "=", "INTVAL", "(", "op", ")", ")" ]

[ "<FIXS>", "#", "define", "PTA_3DNOW", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "#", "define", "PTA_3DNOW_A", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<FIXE>", "<FIXS>", "#", "define", "PTA_AES", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<FIXE>", "<FIXS>", "#", "define", "PTA_BMI", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<FIXE>", "<FIXS>", "#", "define", "PTA_FMA4", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<FIXE>", "<FIXS>", "#", "define", "PTA_LWP", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "#", "define", "PTA_LZCNT", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<FIXE>", "<FIXS>", "#", "define", "PTA_RDRND", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<FIXE>", "<FIXS>", "#", "define", "PTA_SSE4_1", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "#", "define", "PTA_SSE4_2", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<FIXE>", "<FIXS>", "#", "define", "PTA_TBM", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "#", "define", "PTA_XOP", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<FIXE>", "<FIXS>", "#", "define", "PTA_BMI2", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "#", "define", "PTA_RTM", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<FIXE>" ]

[ "unsigned", "int", "ix86_arch_mask", ";", "const", "bool", "ix86_tune_specified", "=", "(", "opts", "->", "x_ix86_tune_string", "!=", "NULL", ")", ";", "<BUGS>", "#", "define", "PTA_3DNOW", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "#", "define", "PTA_3DNOW_A", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<BUGE>", "#", "define", "PTA_64BIT", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "#", "define", "PTA_ABM", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<BUGS>", "#", "define", "PTA_AES", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<BUGE>", "#", "define", "PTA_AVX", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<BUGS>", "#", "define", "PTA_BMI", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<BUGE>", "#", "define", "PTA_CX16", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "#", "define", "PTA_F16C", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "#", "define", "PTA_FMA", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<BUGS>", "#", "define", "PTA_FMA4", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<BUGE>", "#", "define", "PTA_FSGSBASE", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<BUGS>", "#", "define", "PTA_LWP", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "#", "define", "PTA_LZCNT", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<BUGE>", "#", "define", "PTA_MMX", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "#", "define", "PTA_MOVBE", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "#", "define", "PTA_NO_SAHF", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "#", "define", "PTA_PCLMUL", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "#", "define", "PTA_POPCNT", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "#", "define", "PTA_PREFETCH_SSE", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<BUGS>", "#", "define", "PTA_RDRND", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<BUGE>", "#", "define", "PTA_SSE", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "#", "define", "PTA_SSE2", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "#", "define", "PTA_SSE3", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<BUGS>", "#", "define", "PTA_SSE4_1", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "#", "define", "PTA_SSE4_2", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<BUGE>", "#", "define", "PTA_SSE4A", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "#", "define", "PTA_SSSE3", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<BUGS>", "#", "define", "PTA_TBM", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "#", "define", "PTA_XOP", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<BUGE>", "#", "define", "PTA_AVX2", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<BUGS>", "#", "define", "PTA_BMI2", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "#", "define", "PTA_RTM", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "<BUGE>", "#", "define", "PTA_HLE", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "#", "define", "PTA_PRFCHW", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")", "#", "define", "PTA_RDSEED", "(", "HOST_WIDE_INT_1", "<<", "<NUM_LIT>", ")" ]

[ "_", "_", "E", ")", ";" ]

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