Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "<STR_LIT>", ")" ]

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

[ "A64SELECT_CC", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ",", "SetCC", ",", "IfTrue", ",", "A64SELECT_CC", ",", "A64cc", ")", ";" ]

[ "SDValue", "A64cc", "=", "DAG", ".", "getConstant", "(", "CondCode", ",", "MVT", "::", "i32", ")", ";", "SDValue", "SetCC", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32", ",", "LHS", ",", "RHS", ",", "DAG", ".", "getCondCode", "(", "CC", ")", ")", ";", "SDValue", "A64SELECT_CC", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ",", "SetCC", ",", "IfTrue", ",", "IfFalse", ",", "A64cc", ")", ";", "if", "(", "Alternative", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "A64cc", "=", "DAG", ".", "getConstant", "(", "Alternative", ",", "MVT", "::", "i32", ")", ";" ]

[ "<NUM_LIT>", ";" ]

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

[ "NewStore", "->", "getOperand", "(", "X86", "::", "AddrNumOperands", ")", ".", "setIsKill", "(", "StoreSrcVReg", ".", "isKill", "(", ")", ")", ";" ]

[ "LLVM_DEBUG", "(", "NewLoad", "->", "dump", "(", ")", ")", ";", "MachineInstr", "*", "StInst", "=", "StoreInst", ";", "auto", "PrevInstrIt", "=", "skipDebugInstructionsBackward", "(", "std", "::", "prev", "(", "MachineBasicBlock", "::", "instr_iterator", "(", "StoreInst", ")", ")", ",", "MBB", "->", "instr_begin", "(", ")", ")", ";", "if", "(", "PrevInstrIt", ".", "getNodePtr", "(", ")", "==", "LoadInst", ")", "StInst", "=", "LoadInst", ";", "MachineInstr", "*", "NewStore", "=", "BuildMI", "(", "*", "MBB", ",", "StInst", ",", "StInst", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "NStoreOpcode", ")", ")", ".", "add", "(", "StoreBase", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "X86", "::", "NoRegister", ")", ".", "addImm", "(", "StoreDisp", ")", ".", "addReg", "(", "X86", "::", "NoRegister", ")", ".", "addReg", "(", "Reg1", ")", ".", "addMemOperand", "(", "MBB", "->", "getParent", "(", ")", "->", "getMachineMemOperand", "(", "SMMO", ",", "SMMOffset", ",", "Size", ")", ")", ";", "if", "(", "StoreBase", ".", "isReg", "(", ")", ")", "getBaseOperand", "(", "NewStore", ")", ".", "setIsKill", "(", "false", ")", ";", "MachineOperand", "&", "StoreSrcVReg", "=", "StoreInst", "->", "getOperand", "(", "X86", "::", "AddrNumOperands", ")", ";", "assert", "(", "StoreSrcVReg", ".", "isReg", "(", ")", "&&", "<STR_LIT>", "Expected virtual register", "<STR_LIT>", ")", ";" ]

[ "<FIXS>", "bool", "SelectDirectAddr", "(", "SDValue", "N", ",", "SDValue", "&", "Address", ")", ";", "<FIXE>" ]

[ "SDNode", "*", "Select", "(", "SDNode", "*", "N", ")", ";", "<BUGS>", "bool", "SelectDirectAddr", "(", "SDNode", "*", "Op", ",", "SDValue", "N", ",", "SDValue", "&", "Address", ")", ";", "<BUGE>", "}", ";" ]

[ ":" ]

[ "const", "unsigned", "BitWidth", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "switch", "(", "Op", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unhandled atomic op", "<STR_LIT>", ")", ";", "case", "AtomicRMWInst", "::", "Add", ":", "case", "AtomicRMWInst", "::", "Sub", ":", "case", "AtomicRMWInst", "::", "Or", ":", "case", "AtomicRMWInst", "::", "Xor", ":", "case", "AtomicRMWInst", "::", "UMax", ":", "return", "ConstantInt", "::", "get", "(", "C", ",", "APInt", "::", "getMinValue", "(", "BitWidth", ")", ")", ";", "case", "AtomicRMWInst", "::", "And", ":", "case", "AtomicRMWInst", "::", "UMin", ":", "return", "ConstantInt", "::", "get", "(", "C", ",", "APInt", "::", "getMaxValue", "(", "BitWidth", ")", ")", ";", "case", "AtomicRMWInst", "::", "Max", ":", "return", "ConstantInt", "::", "get", "(", "C", ",", "APInt", "::", "getSignedMinValue", "(", "BitWidth", ")", ")", ";", "case", "AtomicRMWInst", "::", "Min" ]

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

[ "bool", "hasUnalignedScratchAccess", "(" ]

[ "}" ]

[ "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

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

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

[ "MCOperand", "SystemZMCInstLower", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "unknown operand type", "<STR_LIT>", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "return", "MCOperand", "(", ")", ";", "return", "MCOperand", "::", "CreateReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "return", "MCOperand", "::", "CreateImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "return", "lowerSymbolOperand", "(", "MO", ",", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "<NUM_LIT>", ")", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "return", "lowerSymbolOperand", "(", "MO", ",", "Mang", "->", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "MO", ".", "getOffset", "(", ")", ")", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "{", "StringRef", "Name", "=", "MO", ".", "getSymbolName", "(", ")", ";", "return", "lowerSymbolOperand", "(", "MO", ",", "AsmPrinter", ".", "GetExternalSymbolSymbol", "(", "Name", ")", ",", "MO", ".", "getOffset", "(", ")", ")", ";", "}", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "return", "lowerSymbolOperand", "(", "MO", ",", "AsmPrinter", ".", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ",", "<NUM_LIT>", ")", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "return", "lowerSymbolOperand", "(", "MO", ",", "AsmPrinter", ".", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ",", "MO", ".", "getOffset", "(", ")", ")", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "{", "const", "BlockAddress", "*", "BA", "=", "MO", ".", "getBlockAddress", "(", ")", ";", "return", "lowerSymbolOperand", "(", "MO", ",", "AsmPrinter", ".", "GetBlockAddressSymbol", "(", "BA", ")", ",", "MO", ".", "getOffset", "(", ")", ")", ";", "}", "}", "}" ]

[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]

[ "}" ]

[ "class", "BaseSIMDThreeSameVectorDot", "<", "bit", "Q", ",", "bit", "U", ",", "bit", "Mixed", ",", "string", "asm", ",", "string", "kind1", ",", "string", "kind2", ",", "RegisterOperand", "RegType", ",", "ValueType", "AccumType", ",", "ValueType", "InputType", ",", "SDPatternOperator", "OpNode", ">", ":", "BaseSIMDThreeSameVectorTied", "<", "Q", ",", "U", ",", "<NUM_LIT>", ",", "{", "<NUM_LIT>", ",", "Mixed", "}", ",", "RegType", ",", "asm", ",", "kind1", ",", "[", "(", "set", "(", "AccumType", "RegType", ":", "$", "dst", ")", ",", "(", "OpNode", "(", "AccumType", "RegType", ":", "$", "Rd", ")", ",", "(", "InputType", "RegType", ":", "$", "Rn", ")", ",", "(", "InputType", "RegType", ":", "$", "Rm", ")", ")", ")", "]", ">", "{", "let", "AsmString", "=", "!", "strconcat", "(", "asm", ",", "<STR_LIT>", "#", "kind1", "#", "<STR_LIT>", "#", "kind2", "#", "<STR_LIT>", "#", "kind2", "#", "<STR_LIT>", ")", ";" ]

[ "(", "KernelDescriptor", ")", "-", "offsetof", "(", "amdhsa", "::", "kernel_descriptor_t", ",", "kernel_code_entry_byte_offset", ")", "-", "sizeof", "(", "KernelDescriptor", ".", "kernel_code_entry_byte_offset", ")", ")", ")", ";" ]

[ "auto", "&", "Streamer", "=", "getStreamer", "(", ")", ";", "auto", "&", "Context", "=", "Streamer", ".", "getContext", "(", ")", ";", "MCSymbolELF", "*", "KernelDescriptorSymbol", "=", "cast", "<", "MCSymbolELF", ">", "(", "Context", ".", "getOrCreateSymbol", "(", "Twine", "(", "KernelName", ")", "+", "Twine", "(", "<STR_LIT>", ".kd", "<STR_LIT>", ")", ")", ")", ";", "KernelDescriptorSymbol", "->", "setBinding", "(", "ELF", "::", "STB_GLOBAL", ")", ";", "KernelDescriptorSymbol", "->", "setType", "(", "ELF", "::", "STT_OBJECT", ")", ";", "KernelDescriptorSymbol", "->", "setSize", "(", "MCConstantExpr", "::", "create", "(", "sizeof", "(", "KernelDescriptor", ")", ",", "Context", ")", ")", ";", "MCSymbolELF", "*", "KernelCodeSymbol", "=", "cast", "<", "MCSymbolELF", ">", "(", "Context", ".", "getOrCreateSymbol", "(", "Twine", "(", "KernelName", ")", ")", ")", ";", "KernelCodeSymbol", "->", "setBinding", "(", "ELF", "::", "STB_LOCAL", ")", ";", "Streamer", ".", "EmitLabel", "(", "KernelDescriptorSymbol", ")", ";", "Streamer", ".", "EmitBytes", "(", "StringRef", "(", "(", "const", "char", "*", ")", "&", "(", "KernelDescriptor", ")", ",", "offsetof", "(", "amdhsa", "::", "kernel_descriptor_t", ",", "kernel_code_entry_byte_offset", ")", ")", ")", ";", "Streamer", ".", "EmitValue", "(", "MCBinaryExpr", "::", "createSub", "(", "MCSymbolRefExpr", "::", "create", "(", "KernelCodeSymbol", ",", "MCSymbolRefExpr", "::", "VK_AMDGPU_REL64", ",", "Context", ")", ",", "MCSymbolRefExpr", "::", "create", "(", "KernelDescriptorSymbol", ",", "MCSymbolRefExpr", "::", "VK_None", ",", "Context", ")", ",", "Context", ")", ",", "sizeof", "(", "KernelDescriptor", ".", "kernel_code_entry_byte_offset", ")", ")", ";", "Streamer", ".", "EmitBytes", "(", "StringRef", "(", "(", "const", "char", "*", ")", "&", "(", "KernelDescriptor", ")", "+", "offsetof", "(", "amdhsa", "::", "kernel_descriptor_t", ",", "kernel_code_entry_byte_offset", ")", "+", "sizeof", "(", "KernelDescriptor", ".", "kernel_code_entry_byte_offset", ")", ",", "sizeof" ]

[ ";" ]

[ "struct", "CleanupObject", "{", "SmallVector", "<", "MCParsedAsmOperand", "*", ",", "<NUM_LIT>", ">", "Operands", ";", "~", "CleanupObject", "(", ")", "{", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "Operands", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "delete", "Operands", "[", "I", "]", ";", "}", "}", "CO", ";", "if", "(", "parseRegisterList", "(", "CO", ".", "Operands", ")", ")", "return", "false", ";", "ARMOperand", "*", "Op", "=", "(", "ARMOperand", "*", ")", "CO", ".", "Operands", "[", "<NUM_LIT>", "]", ";", "if", "(", "!", "IsVector", "&&", "!", "Op", "->", "isRegList", "(", ")", ")", "{", "Error", "(", "L", ",", "<STR_LIT>", ".save expects GPR registers", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "if", "(", "IsVector", "&&", "!", "Op", "->", "isDPRRegList", "(", ")", ")", "{", "Error", "(", "L", ",", "<STR_LIT>", ".vsave expects DPR registers", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "getTargetStreamer", "(", ")", ".", "emitRegSave", "(", "Op", "->", "getRegList", "(", ")", ",", "IsVector", ")", ";", "return", "false" ]

[ "<FIXS>", "SDValue", "TargetConstVal", "=", "CurDAG", "->", "getTargetConstant", "(", "Val", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "SDValue", "TargetConst0", "=", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "<FIXE>" ]

[ "const", "HexagonInstrInfo", "&", "TII", "=", "*", "HST", "->", "getInstrInfo", "(", ")", ";", "if", "(", "TII", ".", "isValidAutoIncImm", "(", "LoadedVT", ",", "Val", ")", ")", "{", "<BUGS>", "SDValue", "TargetConstVal", "=", "CurDAG", "->", "getTargetConstant", "(", "Val", ",", "MVT", "::", "i32", ")", ";", "SDValue", "TargetConst0", "=", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ";", "<BUGE>", "SDNode", "*", "Result_1", "=", "CurDAG", "->", "getMachineNode", "(", "Opcode", ",", "dl", ",", "MVT", "::", "i32", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ",", "Base", ",", "TargetConstVal", ",", "Chain", ")", ";" ]

[ "fprintf", "(", "file", ",", "<STR_LIT>", "\\t%s r12,lo16(%s)(r11)\\n", "<STR_LIT>", ",", "(", "TARGET_64BIT", "?", "<STR_LIT>", "ldu", "<STR_LIT>", ":", "<STR_LIT>", "lwzu", "<STR_LIT>", ")", ",", "lazy_ptr_name", ")", ";" ]

[ "if", "(", "flag_pic", "==", "<NUM_LIT>", ")", "{", "fprintf", "(", "file", ",", "<STR_LIT>", "\\t.align 5\\n", "<STR_LIT>", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "%s:\\n", "<STR_LIT>", ",", "stub", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "\\t.indirect_symbol %s\\n", "<STR_LIT>", ",", "symbol_name", ")", ";", "label", "++", ";", "local_label_0", "=", "XALLOCAVEC", "(", "char", ",", "sizeof", "(", "<STR_LIT>", "\\\"L00000000000$spb\\\"", "<STR_LIT>", ")", ")", ";", "sprintf", "(", "local_label_0", ",", "<STR_LIT>", "\\\"L%011d$spb\\\"", "<STR_LIT>", ",", "label", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "\\tmflr r0\\n", "<STR_LIT>", ")", ";", "if", "(", "TARGET_LINK_STACK", ")", "{", "char", "name", "[", "<NUM_LIT>", "]", ";", "get_ppc476_thunk_name", "(", "name", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "\\tbl %s\\n", "<STR_LIT>", ",", "name", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "%s:\\n\\tmflr r11\\n", "<STR_LIT>", ",", "local_label_0", ")", ";", "}", "else", "{", "fprintf", "(", "file", ",", "<STR_LIT>", "\\tbcl 20,31,%s\\n", "<STR_LIT>", ",", "local_label_0", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "%s:\\n\\tmflr r11\\n", "<STR_LIT>", ",", "local_label_0", ")", ";", "}", "fprintf", "(", "file", ",", "<STR_LIT>", "\\taddis r11,r11,ha16(%s-%s)\\n", "<STR_LIT>", ",", "lazy_ptr_name", ",", "local_label_0", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "\\tmtlr r0\\n", "<STR_LIT>", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "\\t%s r12,lo16(%s-%s)(r11)\\n", "<STR_LIT>", ",", "(", "TARGET_64BIT", "?", "<STR_LIT>", "ldu", "<STR_LIT>", ":", "<STR_LIT>", "lwzu", "<STR_LIT>", ")", ",", "lazy_ptr_name", ",", "local_label_0", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "\\tmtctr r12\\n", "<STR_LIT>", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "\\tbctr\\n", "<STR_LIT>", ")", ";", "}", "else", "{", "fprintf", "(", "file", ",", "<STR_LIT>", "\\t.align 4\\n", "<STR_LIT>", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "%s:\\n", "<STR_LIT>", ",", "stub", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "\\t.indirect_symbol %s\\n", "<STR_LIT>", ",", "symbol_name", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "\\tlis r11,ha16(%s)\\n", "<STR_LIT>", ",", "lazy_ptr_name", ")", ";" ]

[ "Copy", ",", "Chain", ")", ";" ]

[ "SDValue", "ArgValue", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VReg", ",", "RegVT", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "dl", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "else", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "dl", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "Full", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "ArgValue", ")", ";", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "}", "}", "else", "{", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "unsigned", "ObjSize", "=", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", "/", "<NUM_LIT>", ";", "if", "(", "ObjSize", ">", "<NUM_LIT>", ")", "{", "errs", "(", ")", "<<", "<STR_LIT>", "LowerFormalArguments Unhandled argument type: ", "<STR_LIT>", "<<", "EVT", "(", "VA", ".", "getLocVT", "(", ")", ")", ".", "getEVTString", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "}", "int", "FI", "=", "MFI", "->", "CreateFixedObject", "(", "ObjSize", ",", "VA", ".", "getLocMemOffset", "(", ")", ",", "true", ")", ";", "SDValue", "FIN", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "InVals", ".", "push_back", "(", "DAG", ".", "getLoad", "(", "VA", ".", "getLocVT", "(", ")", ",", "dl", ",", "Chain", ",", "FIN", ",", "MachinePointerInfo", "::", "getFixedStack", "(", "FI", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ")", ";", "}", "}", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "unsigned", "Reg", "=", "OR1KMFI", "->", "getSRetReturnReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "{", "Reg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "getRegClassFor", "(", "MVT", "::", "i32", ")", ")", ";", "OR1KMFI", "->", "setSRetReturnReg", "(", "Reg", ")", ";", "}", "SDValue", "Copy", "=", "DAG", ".", "getCopyToReg", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "dl", ",", "Reg", ",", "InVals", "[", "<NUM_LIT>", "]", ")", ";", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", "," ]

[ "<NUM_LIT>", ";" ]

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

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";" ]

[ "_", "_", "b", "=", "vec_splat", "(", "(", "_", "_", "v4sf", ")", "_", "_", "B", ",", "<NUM_LIT>", ")", ";" ]

[ "_", "_", "v4sf", "_", "_", "a", ",", "_", "_", "b", ",", "_", "_", "c", ";", "_", "_", "a", "=", "vec_splat", "(", "(", "_", "_", "v4sf", ")", "_", "_", "A", ",", "<NUM_LIT>", ")", ";" ]

[ "EncodingType", "::", "Itanium", ";" ]

[ "SupportsDebugInformation", "=", "true", ";", "CodePointerSize", "=", "<NUM_LIT>", ";", "CommentString", "=", "<STR_LIT>", ";", "<STR_LIT>", ";", "ExceptionsType", "=", "ExceptionHandling", "::", "WinEH", ";", "WinEHEncodingType", "=", "WinEH", "::" ]

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

[ "extern", "_", "_", "inline", "_", "_", "m512i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_cvt_roundps_epu64", "(", "_", "_", "m256", "_", "_", "A", ",", "const", "int", "_", "_", "R", ")", "{", "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_cvtps2uqq512_mask", "(", "(", "_", "_", "v8sf", ")", "_", "_", "A", ",", "(", "_", "_", "v8di" ]

[ "$", "lane", ")", ",", "IIC_VLD2ln", ",", "<STR_LIT>", ",", "Dt", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "WriteVLD1", "]", ">", "{" ]

[ "class", "VLD2LN", "<", "bits", "<", "<NUM_LIT>", ">", "op11_8", ",", "bits", "<", "<NUM_LIT>", ">", "op7_4", ",", "string", "Dt", ">", ":", "NLdStLn", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "op11_8", ",", "op7_4", ",", "(", "outs", "DPR", ":", "$", "Vd", ",", "DPR", ":", "$", "dst2", ")", ",", "(", "ins", "addrmode6", ":", "$", "Rn", ",", "DPR", ":", "$", "src1", ",", "DPR", ":", "$", "src2", ",", "nohash_imm", ":" ]

[ "<FIXS>", "Stores", ".", "push_back", "(", "DAG", ".", "getTruncStore", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "dl", ",", "BVN", "->", "getOperand", "(", "i", ")", ",", "Idx", ",", "PtrInfo", ".", "getWithOffset", "(", "Offset", ")", ",", "MVT", "::", "i32", ")", ")", ";", "<FIXE>", "<FIXS>", "Stores", ".", "push_back", "(", "DAG", ".", "getStore", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "dl", ",", "StoreValue", ",", "Idx", ",", "PtrInfo", ".", "getWithOffset", "(", "Offset", ")", ")", ")", ";", "<FIXE>" ]

[ "unsigned", "StoreSize", "=", "BVN", "->", "getOperand", "(", "i", ")", ".", "getValueType", "(", ")", ".", "getStoreSize", "(", ")", ";", "if", "(", "StoreSize", ">", "<NUM_LIT>", ")", "{", "<BUGS>", "Stores", ".", "push_back", "(", "DAG", ".", "getTruncStore", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "dl", ",", "BVN", "->", "getOperand", "(", "i", ")", ",", "Idx", ",", "PtrInfo", ".", "getWithOffset", "(", "Offset", ")", ",", "MVT", "::", "i32", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "}", "else", "{", "SDValue", "StoreValue", "=", "BVN", "->", "getOperand", "(", "i", ")", ";", "if", "(", "StoreSize", "<NUM_LIT>", ")", "StoreValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "dl", ",", "MVT", "::", "i32", ",", "StoreValue", ")", ";", "<BUGS>", "Stores", ".", "push_back", "(", "DAG", ".", "getStore", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "dl", ",", "StoreValue", ",", "Idx", ",", "PtrInfo", ".", "getWithOffset", "(", "Offset", ")", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "}", "}" ]

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

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

[ "else", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", ";" ]

[ "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "const", "GlobalValue", "*", "GVal", "=", "MO", ".", "getGlobal", "(", ")", ";", "auto", "*", "GVar", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GVal", ")", ";", "if", "(", "GVar", "&&", "GVar", "->", "hasAttribute", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "{", "uint32_t", "Imm", "=", "PatchImms", "[", "GVar", "]", ";", "OutMI", ".", "setOpcode", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ";", "if", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", ")", "OutMI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ")", ";" ]

[ "}" ]

[ "bool", "PPCTargetLowering", "::", "SelectAddressEVXRegReg", "(", "SDValue", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Index", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "for", "(", "SDNode", "*", "U", ":", "N", "->", "uses", "(", ")", ")", "{", "if", "(", "MemSDNode", "*", "Memop", "=", "dyn_cast", "<", "MemSDNode", ">", "(", "U", ")", ")", "{", "if", "(", "Memop", "->", "getMemoryVT", "(", ")", "==", "MVT", "::", "f64", ")", "{", "Base", "=", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Index", "=", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}" ]

[ "Rn", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "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>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opcode", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=" ]

[ ";" ]

[ "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "<STR_LIT>", "unexpected inline asm memory operand", "<STR_LIT>", ")", ";", "O", "<<", "<STR_LIT>", "[$", "<STR_LIT>", "<<", "PatmosInstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", "<<", "<STR_LIT>", "]", "<STR_LIT>", ";", "return", "false" ]

[ "<FIXS>", "return", "!", "Query", ".", "Types", "[", "<NUM_LIT>", "]", ".", "isVector", "(", ")", "&&", "needToSplitMemOp", "(", "Query", ",", "Op", "==", "G_LOAD", ")", ";", "<FIXE>" ]

[ ".", "customIf", "(", "typeIs", "(", "<NUM_LIT>", ",", "Constant32Ptr", ")", ")", ".", "narrowScalarIf", "(", "[", "=", "]", "(", "const", "LegalityQuery", "&", "Query", ")", "->", "bool", "{", "<BUGS>", "return", "!", "Query", ".", "Types", "[", "<NUM_LIT>", "]", ".", "isVector", "(", ")", "&&", "needToSplitLoad", "(", "Query", ")", ";", "<BUGE>", "}", ",", "[", "=", "]", "(", "const", "LegalityQuery", "&", "Query", ")", "->", "std", "::", "pair", "unsigned", ",", "LLT", ">", "{", "const", "LLT", "DstTy", "=", "Query", ".", "Types", "[", "<NUM_LIT>", "]", ";" ]

[ "::", "TEST32i32", ";", "break", ";" ]

[ "case", "X86", "::", "MOV32mr", ":", "NewOpc", "=", "X86", "::", "MOV32o32a", ";", "break", ";", "case", "X86", "::", "MOV32rm", ":", "NewOpc", "=", "X86", "::", "MOV32ao32", ";", "break", ";", "}", "SimplifyShortMoveForm", "(", "AsmPrinter", ",", "OutMI", ",", "NewOpc", ")", ";", "break", ";", "}", "case", "X86", "::", "ADC8ri", ":", "case", "X86", "::", "ADC16ri", ":", "case", "X86", "::", "ADC32ri", ":", "case", "X86", "::", "ADC64ri32", ":", "case", "X86", "::", "ADD8ri", ":", "case", "X86", "::", "ADD16ri", ":", "case", "X86", "::", "ADD32ri", ":", "case", "X86", "::", "ADD64ri32", ":", "case", "X86", "::", "AND8ri", ":", "case", "X86", "::", "AND16ri", ":", "case", "X86", "::", "AND32ri", ":", "case", "X86", "::", "AND64ri32", ":", "case", "X86", "::", "CMP8ri", ":", "case", "X86", "::", "CMP16ri", ":", "case", "X86", "::", "CMP32ri", ":", "case", "X86", "::", "CMP64ri32", ":", "case", "X86", "::", "OR8ri", ":", "case", "X86", "::", "OR16ri", ":", "case", "X86", "::", "OR32ri", ":", "case", "X86", "::", "OR64ri32", ":", "case", "X86", "::", "SBB8ri", ":", "case", "X86", "::", "SBB16ri", ":", "case", "X86", "::", "SBB32ri", ":", "case", "X86", "::", "SBB64ri32", ":", "case", "X86", "::", "SUB8ri", ":", "case", "X86", "::", "SUB16ri", ":", "case", "X86", "::", "SUB32ri", ":", "case", "X86", "::", "SUB64ri32", ":", "case", "X86", "::", "TEST8ri", ":", "case", "X86", "::", "TEST16ri", ":", "case", "X86", "::", "TEST32ri", ":", "case", "X86", "::", "TEST64ri32", ":", "case", "X86", "::", "XOR8ri", ":", "case", "X86", "::", "XOR16ri", ":", "case", "X86", "::", "XOR32ri", ":", "case", "X86", "::", "XOR64ri32", ":", "{", "unsigned", "NewOpc", ";", "switch", "(", "OutMI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Invalid opcode", "<STR_LIT>", ")", ";", "case", "X86", "::", "ADC8ri", ":", "NewOpc", "=", "X86", "::", "ADC8i8", ";", "break", ";", "case", "X86", "::", "ADC16ri", ":", "NewOpc", "=", "X86", "::", "ADC16i16", ";", "break", ";", "case", "X86", "::", "ADC32ri", ":", "NewOpc", "=", "X86", "::", "ADC32i32", ";", "break", ";", "case", "X86", "::", "ADC64ri32", ":", "NewOpc", "=", "X86", "::", "ADC64i32", ";", "break", ";", "case", "X86", "::", "ADD8ri", ":", "NewOpc", "=", "X86", "::", "ADD8i8", ";", "break", ";", "case", "X86", "::", "ADD16ri", ":", "NewOpc", "=", "X86", "::", "ADD16i16", ";", "break", ";", "case", "X86", "::", "ADD32ri", ":", "NewOpc", "=", "X86", "::", "ADD32i32", ";", "break", ";", "case", "X86", "::", "ADD64ri32", ":", "NewOpc", "=", "X86", "::", "ADD64i32", ";", "break", ";", "case", "X86", "::", "AND8ri", ":", "NewOpc", "=", "X86", "::", "AND8i8", ";", "break", ";", "case", "X86", "::", "AND16ri", ":", "NewOpc", "=", "X86", "::", "AND16i16", ";", "break", ";", "case", "X86", "::", "AND32ri", ":", "NewOpc", "=", "X86", "::", "AND32i32", ";", "break", ";", "case", "X86", "::", "AND64ri32", ":", "NewOpc", "=", "X86", "::", "AND64i32", ";", "break", ";", "case", "X86", "::", "CMP8ri", ":", "NewOpc", "=", "X86", "::", "CMP8i8", ";", "break", ";", "case", "X86", "::", "CMP16ri", ":", "NewOpc", "=", "X86", "::", "CMP16i16", ";", "break", ";", "case", "X86", "::", "CMP32ri", ":", "NewOpc", "=", "X86", "::", "CMP32i32", ";", "break", ";", "case", "X86", "::", "CMP64ri32", ":", "NewOpc", "=", "X86", "::", "CMP64i32", ";", "break", ";", "case", "X86", "::", "OR8ri", ":", "NewOpc", "=", "X86", "::", "OR8i8", ";", "break", ";", "case", "X86", "::", "OR16ri", ":", "NewOpc", "=", "X86", "::", "OR16i16", ";", "break", ";", "case", "X86", "::", "OR32ri", ":", "NewOpc", "=", "X86", "::", "OR32i32", ";", "break", ";", "case", "X86", "::", "OR64ri32", ":", "NewOpc", "=", "X86", "::", "OR64i32", ";", "break", ";", "case", "X86", "::", "SBB8ri", ":", "NewOpc", "=", "X86", "::", "SBB8i8", ";", "break", ";", "case", "X86", "::", "SBB16ri", ":", "NewOpc", "=", "X86", "::", "SBB16i16", ";", "break", ";", "case", "X86", "::", "SBB32ri", ":", "NewOpc", "=", "X86", "::", "SBB32i32", ";", "break", ";", "case", "X86", "::", "SBB64ri32", ":", "NewOpc", "=", "X86", "::", "SBB64i32", ";", "break", ";", "case", "X86", "::", "SUB8ri", ":", "NewOpc", "=", "X86", "::", "SUB8i8", ";", "break", ";", "case", "X86", "::", "SUB16ri", ":", "NewOpc", "=", "X86", "::", "SUB16i16", ";", "break", ";", "case", "X86", "::", "SUB32ri", ":", "NewOpc", "=", "X86", "::", "SUB32i32", ";", "break", ";", "case", "X86", "::", "SUB64ri32", ":", "NewOpc", "=", "X86", "::", "SUB64i32", ";", "break", ";", "case", "X86", "::", "TEST8ri", ":", "NewOpc", "=", "X86", "::", "TEST8i8", ";", "break", ";", "case", "X86", "::", "TEST16ri", ":", "NewOpc", "=", "X86", "::", "TEST16i16", ";", "break", ";", "case", "X86", "::", "TEST32ri", ":", "NewOpc", "=", "X86" ]

[ "<FIXS>", "addr", "=", "eliminate_constant_term", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ",", "&", "offset", ")", ";", "<FIXE>" ]

[ "case", "CONST", ":", "{", "rtx", "offset", "=", "const0_rtx", ";", "<BUGS>", "addr", "=", "eliminate_constant_term", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ",", "&", "offset", ")", ";", "<BUGE>", "if", "(", "GET_CODE", "(", "addr", ")", "==", "LABEL_REF", ")", "return", "<NUM_LIT>", ";" ]

[ "=", "false", ";" ]

[ "unsigned", "IntrinsicID", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "IntrinsicID", "==", "Intrinsic", "::", "thread_pointer", ")", "{", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "DAG", ".", "getRegister", "(", "PPC", "::", "X13", ",", "MVT", "::", "i64", ")", ";", "return", "DAG", ".", "getRegister", "(", "PPC", "::", "R2", ",", "MVT", "::", "i32", ")", ";", "}", "SDLoc", "dl", "(", "Op", ")", ";", "int", "CompareOpc", ";", "bool", "isDot", ";", "if", "(", "!", "getVectorCompareInfo", "(", "Op", ",", "CompareOpc", ",", "isDot", ",", "Subtarget", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "!", "isDot", ")", "{", "SDValue", "Tmp", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "CompareOpc", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ",", "Tmp", ")", ";", "}", "SDValue", "Ops", "[", "]", "=", "{", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "CompareOpc", ",", "dl", ",", "MVT", "::", "i32", ")", "}", ";", "EVT", "VTs", "[", "]", "=", "{", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ",", "MVT", "::", "Glue", "}", ";", "SDValue", "CompNode", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VTs", ",", "Ops", ")", ";", "SDValue", "Flags", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32", ",", "DAG", ".", "getRegister", "(", "PPC", "::", "CR6", ",", "MVT", "::", "i32", ")", ",", "CompNode", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "unsigned", "BitNo", ";", "bool", "InvertBit", ";", "switch", "(", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ")", "{", "default", ":", "case", "<NUM_LIT>", ":", "BitNo", "=", "<NUM_LIT>", ";", "InvertBit" ]

[ "}" ]

[ "case", "ISD", "::", "SINT_TO_FP", ":", "case", "ISD", "::", "FABS", ":", "case", "ISD", "::", "FSQRT", ":", "case", "ISD", "::", "FSIN", ":", "case", "ISD", "::", "FCOS", ":", "case", "ISD", "::", "FPOWI", ":", "case", "ISD", "::", "FPOW", ":", "case", "ISD", "::", "FLOG", ":", "case", "ISD", "::", "FLOG2", ":", "case", "ISD", "::", "FLOG10", ":", "case", "ISD", "::", "FEXP", ":", "case", "ISD", "::", "FEXP2", ":", "case", "ISD", "::", "FCEIL", ":", "case", "ISD", "::", "FTRUNC", ":", "case", "ISD", "::", "FRINT", ":", "case", "ISD", "::", "FNEARBYINT", ":", "case", "ISD", "::", "FROUND", ":", "case", "ISD", "::", "FFLOOR", ":", "case", "ISD", "::", "FMINNUM", ":", "case", "ISD", "::", "FMAXNUM", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "Subtarget", "->", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "GFX9", ";", "case", "ISD", "::", "FP_ROUND", ":", "return", "Subtarget", "->", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "VOLCANIC_ISLANDS", ";", "case", "ISD", "::", "FMA", ":", "case", "ISD", "::", "FMAD", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "Subtarget", "->", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "VOLCANIC_ISLANDS", ";", "default", ":", "return", "false", ";" ]

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

[ "def", "MSYNC", ":", "XForm_24_sync", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", ")", ",", "<STR_LIT>", ",", "IIC_LdStSync", ",", "[", "]", ">", "{", "let", "L" ]

[ "<FIXS>", "multiclass", "MipsHiLoRelocs", "Instruction", "Lui", ",", "Instruction", "Addiu", ",", "Register", "ZeroReg", ",", "RegisterOperand", "GPROpnd", ">", "{", "def", ":", "MipsPat", "(", "MipsHi", "tglobaladdr", ":", "$", "in", ")", ",", "(", "Lui", "tglobaladdr", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "MipsHi", "tblockaddress", ":", "$", "in", ")", ",", "(", "Lui", "tblockaddress", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "MipsHi", "tjumptable", ":", "$", "in", ")", ",", "(", "Lui", "tjumptable", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "MipsHi", "tconstpool", ":", "$", "in", ")", ",", "(", "Lui", "tconstpool", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "MipsHi", "tglobaltlsaddr", ":", "$", "in", ")", ",", "(", "Lui", "tglobaltlsaddr", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "MipsHi", "texternalsym", ":", "$", "in", ")", ",", "(", "Lui", "texternalsym", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "MipsLo", "tglobaladdr", ":", "$", "in", ")", ",", "(", "Addiu", "ZeroReg", ",", "tglobaladdr", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "MipsLo", "tblockaddress", ":", "$", "in", ")", ",", "(", "Addiu", "ZeroReg", ",", "tblockaddress", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "MipsLo", "tjumptable", ":", "$", "in", ")", ",", "(", "Addiu", "ZeroReg", ",", "tjumptable", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "MipsLo", "tconstpool", ":", "$", "in", ")", ",", "(", "Addiu", "ZeroReg", ",", "tconstpool", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "MipsLo", "tglobaltlsaddr", ":", "$", "in", ")", ",", "(", "Addiu", "ZeroReg", ",", "tglobaltlsaddr", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "MipsLo", "texternalsym", ":", "$", "in", ")", ",", "(", "Addiu", "ZeroReg", ",", "texternalsym", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "add", "GPROpnd", ":", "$", "hi", ",", "(", "MipsLo", "tglobaladdr", ":", "$", "lo", ")", ")", ",", "(", "Addiu", "GPROpnd", ":", "$", "hi", ",", "tglobaladdr", ":", "$", "lo", ")", ">", ";", "def", ":", "MipsPat", "(", "add", "GPROpnd", ":", "$", "hi", ",", "(", "MipsLo", "tblockaddress", ":", "$", "lo", ")", ")", ",", "(", "Addiu", "GPROpnd", ":", "$", "hi", ",", "tblockaddress", ":", "$", "lo", ")", ">", ";", "def", ":", "MipsPat", "(", "add", "GPROpnd", ":", "$", "hi", ",", "(", "MipsLo", "tjumptable", ":", "$", "lo", ")", ")", ",", "(", "Addiu", "GPROpnd", ":", "$", "hi", ",", "tjumptable", ":", "$", "lo", ")", ">", ";", "def", ":", "MipsPat", "(", "add", "GPROpnd", ":", "$", "hi", ",", "(", "MipsLo", "tconstpool", ":", "$", "lo", ")", ")", ",", "(", "Addiu", "GPROpnd", ":", "$", "hi", ",", "tconstpool", ":", "$", "lo", ")", ">", ";", "def", ":", "MipsPat", "(", "add", "GPROpnd", ":", "$", "hi", ",", "(", "MipsLo", "tglobaltlsaddr", ":", "$", "lo", ")", ")", ",", "(", "Addiu", "GPROpnd", ":", "$", "hi", ",", "tglobaltlsaddr", ":", "$", "lo", ")", ">", ";", "}", "defm", ":", "MipsHiLoRelocs", "LUi", ",", "ADDiu", ",", "ZERO", ",", "GPR32Opnd", ">", ";", "def", ":", "MipsPat", "(", "MipsGotHi", "tglobaladdr", ":", "$", "in", ")", ",", "(", "LUi", "tglobaladdr", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "MipsGotHi", "texternalsym", ":", "$", "in", ")", ",", "(", "LUi", "texternalsym", ":", "$", "in", ")", ">", ";", "<FIXE>" ]

[ "def", ":", "MipsPat", "(", "MipsTailCall", "(", "iPTR", "texternalsym", ":", "$", "dst", ")", ")", ",", "(", "TAILCALL", "texternalsym", ":", "$", "dst", ")", ">", ";", "<BUGS>", "def", ":", "MipsPat", "(", "MipsHi", "tglobaladdr", ":", "$", "in", ")", ",", "(", "LUi", "tglobaladdr", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "MipsHi", "tblockaddress", ":", "$", "in", ")", ",", "(", "LUi", "tblockaddress", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "MipsHi", "tjumptable", ":", "$", "in", ")", ",", "(", "LUi", "tjumptable", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "MipsHi", "tconstpool", ":", "$", "in", ")", ",", "(", "LUi", "tconstpool", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "MipsHi", "tglobaltlsaddr", ":", "$", "in", ")", ",", "(", "LUi", "tglobaltlsaddr", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "MipsHi", "texternalsym", ":", "$", "in", ")", ",", "(", "LUi", "texternalsym", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "MipsLo", "tglobaladdr", ":", "$", "in", ")", ",", "(", "ADDiu", "ZERO", ",", "tglobaladdr", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "MipsLo", "tblockaddress", ":", "$", "in", ")", ",", "(", "ADDiu", "ZERO", ",", "tblockaddress", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "MipsLo", "tjumptable", ":", "$", "in", ")", ",", "(", "ADDiu", "ZERO", ",", "tjumptable", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "MipsLo", "tconstpool", ":", "$", "in", ")", ",", "(", "ADDiu", "ZERO", ",", "tconstpool", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "MipsLo", "tglobaltlsaddr", ":", "$", "in", ")", ",", "(", "ADDiu", "ZERO", ",", "tglobaltlsaddr", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "MipsLo", "texternalsym", ":", "$", "in", ")", ",", "(", "ADDiu", "ZERO", ",", "texternalsym", ":", "$", "in", ")", ">", ";", "def", ":", "MipsPat", "(", "add", "GPR32", ":", "$", "hi", ",", "(", "MipsLo", "tglobaladdr", ":", "$", "lo", ")", ")", ",", "(", "ADDiu", "GPR32", ":", "$", "hi", ",", "tglobaladdr", ":", "$", "lo", ")", ">", ";", "def", ":", "MipsPat", "(", "add", "GPR32", ":", "$", "hi", ",", "(", "MipsLo", "tblockaddress", ":", "$", "lo", ")", ")", ",", "(", "ADDiu", "GPR32", ":", "$", "hi", ",", "tblockaddress", ":", "$", "lo", ")", ">", ";", "def", ":", "MipsPat", "(", "add", "GPR32", ":", "$", "hi", ",", "(", "MipsLo", "tjumptable", ":", "$", "lo", ")", ")", ",", "(", "ADDiu", "GPR32", ":", "$", "hi", ",", "tjumptable", ":", "$", "lo", ")", ">", ";", "def", ":", "MipsPat", "(", "add", "GPR32", ":", "$", "hi", ",", "(", "MipsLo", "tconstpool", ":", "$", "lo", ")", ")", ",", "(", "ADDiu", "GPR32", ":", "$", "hi", ",", "tconstpool", ":", "$", "lo", ")", ">", ";", "def", ":", "MipsPat", "(", "add", "GPR32", ":", "$", "hi", ",", "(", "MipsLo", "tglobaltlsaddr", ":", "$", "lo", ")", ")", ",", "(", "ADDiu", "GPR32", ":", "$", "hi", ",", "tglobaltlsaddr", ":", "$", "lo", ")", ">", ";", "<BUGE>", "def", ":", "MipsPat", "(", "add", "GPR32", ":", "$", "gp", ",", "(", "MipsGPRel", "tglobaladdr", ":", "$", "in", ")", ")", "," ]

[ "static", "void", "expand_cmp_vec_sequence", "(", "unsigned", "HOST_WIDE_INT", "bytes_to_compare", ",", "rtx", "or", "ig_src1", ",", "rtx", "or", "ig_src2", ",", "rtx", "s1addr", ",", "rtx", "s2addr", ",", "rtx", "off_reg", ",", "rtx", "s1data", ",", "rtx", "s2data", ",", "rtx", "vec_result", ",", "bool", "equality_compare_rest", ",", "rtx", "*", "p_cleanup_label", ",", "rtx", "final_move_label", ",", "bool", "checkzero", ")", "{", "machine_mode", "load_mode", ";", "unsigned", "int", "load_mode_size", ";", "unsigned", "HOST_WIDE_INT", "cmp_bytes", "=", "<NUM_LIT>", ";", "unsigned", "HOST_WIDE_INT", "offset", "=", "<NUM_LIT>", ";", "rtx", "zero_reg", "=", "NULL", ";", "gcc_assert", "(", "p_cleanup_label", "!=", "NULL", ")", ";", "rtx", "cleanup_label", "=", "*", "p_cleanup_label", ";", "emit_move_insn", "(", "s1addr", ",", "force_reg", "(", "Pmode", ",", "XEXP", "(", "or", "ig_src1", ",", "<NUM_LIT>", ")", ")", ")", ";", "emit_move_insn", "(", "s2addr", ",", "force_reg", "(", "Pmode", ",", "XEXP", "(", "or", "ig_src2", ",", "<NUM_LIT>", ")", ")", ")", ";", "if", "(", "checkzero", "&&", "!", "TARGET_P9_VECTOR", ")", "{", "zero_reg", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "emit_move_insn", "(", "zero_reg", ",", "CONST0_RTX", "(", "V16QImode", ")", ")", ";", "}", "while", "(", "bytes_to_compare", ">", "<NUM_LIT>", ")", "{", "load_mode", "=", "V16QImode", ";", "load_mode_size", "=", "GET_MODE_SIZE", "(", "load_mode", ")", ";", "if", "(", "bytes_to_compare", ">=", "load_mode_size", ")", "cmp_bytes", "=", "load_mode_size", ";", "else", "{", "unsigned", "int", "extra_bytes", "=", "load_mode_size", "-", "bytes_to_compare", ";", "cmp_bytes", "=", "bytes_to_compare", ";", "gcc_assert", "(", "offset", ">", "extra_bytes", ")", ";", "offset", "-=", "extra_bytes", ";", "cmp_bytes", "=", "load_mode_size", ";", "bytes_to_compare", "=", "cmp_bytes", ";", "}", "emit_move_insn", "(", "off_reg", ",", "GEN_INT", "(", "offset", ")", ")", ";", "rtx", "addr1", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "s1addr", ",", "off_reg", ")", ";", "do_load_for_compare_from_addr", "(", "load_mode", ",", "s1data", ",", "addr1", ",", "or", "ig_src1", ")", ";", "rtx", "addr2", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "s2addr", ",", "off_reg", ")", ";", "do_load_for_compare_from_addr", "(", "load_mode", ",", "s2data", ",", "addr2", ",", "or", "ig_src2", ")", ";", "unsigned", "HOST_WIDE_INT", "remain", "=", "bytes_to_compare", "-", "cmp_bytes", ";", "if", "(", "checkzero", ")", "{", "if", "(", "TARGET_P9_VECTOR", ")", "emit_insn", "(", "gen_vcmpnezb_p", "(", "vec_result", ",", "s1data", ",", "s2data", ")", ")", ";", "else", "{", "rtx", "cmp_res", "=", "gen_reg_rtx", "(", "load_mode", ")", ";", "rtx", "cmp_zero", "=", "gen_reg_rtx", "(", "load_mode", ")", ";", "rtx", "cmp_combined", "=", "gen_reg_rtx", "(", "load_mode", ")", ";", "emit_insn", "(", "gen_altivec_eqv16qi", "(", "cmp_res", ",", "s1data", ",", "s2data", ")", ")", ";", "emit_insn", "(", "gen_altivec_eqv16qi", "(", "cmp_zero", ",", "s1data", ",", "zero_reg", ")", ")", ";", "emit_insn", "(", "gen_orcv16qi3", "(", "vec_result", ",", "cmp_zero", ",", "cmp_res", ")", ")", ";", "emit_insn", "(", "gen_altivec_vcmpequb_p", "(", "cmp_combined", ",", "vec_result", ",", "zero_reg", ")", ")", ";", "}", "}", "else", "emit_insn", "(", "gen_altivec_vcmpequb_p", "(", "vec_result", ",", "s1data", ",", "s2data", ")", ")", ";", "bool", "branch_to_cleanup", "=", "(", "remain", ">", "<NUM_LIT>", "||", "equality_compare_rest", ")", ";", "rtx", "cr6", "=", "gen_rtx_REG", "(", "CCmode", ",", "CR6_REGNO", ")", ";", "rtx", "dst_label", ";", "rtx", "cmp_rtx", ";", "if", "(", "branch_to_cleanup", ")", "{", "if", "(", "!", "cleanup_label", ")", "cleanup_label", "=", "gen_label_rtx", "(", ")", ";", "dst_label", "=", "cleanup_label", ";", "if", "(", "TARGET_P9_VECTOR", "&&", "checkzero", ")", "cmp_rtx", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cr6", ",", "const0_rtx", ")", ";", "else", "cmp_rtx", "=", "gen_rtx_GE", "(", "VOIDmode", ",", "cr6", ",", "const0_rtx", ")", ";", "}", "else", "{", "dst_label", "=", "final_move_label", ";", "if", "(", "TARGET_P9_VECTOR", "&&", "checkzero", ")", "cmp_rtx", "=", "gen_rtx_EQ", "(", "VOIDmode", ",", "cr6", ",", "const0_rtx", ")", ";", "else", "cmp_rtx", "=", "gen_rtx_LT", "(", "VOIDmode", ",", "cr6", ",", "const0_rtx", ")", ";", "}", "rtx", "lab_ref", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "dst_label", ")", ";", "rtx", "ifelse", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "cmp_rtx", ",", "lab_ref", ",", "pc_rtx", ")", ";", "rtx_insn", "*", "j2", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "ifelse", ")", ")", ";", "add_reg_br_prob_note", "(", "j2", ",", "profile_probability", "::", "likely", "(", ")", ")", ";", "JUMP_LABEL", "(", "j2", ")", "=", "dst_label", ";", "LABEL_NUSES", "(", "dst_label", ")", "+=", "<NUM_LIT>", ";", "offset", "+=", "cmp_bytes", ";", "bytes_to_compare", "-=", "cmp_bytes", ";", "}", "*", "p_cleanup_label", "=", "cleanup_label", ";", "return", ";", "}" ]

[ "Generate", "the", "sequence", "of", "compares", "for", "strcmp/strncmp", "using", "vec/vsx", "instructions", ".", "BYTES_TO_COMPARE", "is", "the", "number", "of", "bytes", "to", "be", "compared", ".", "ORIG_SRC1", "is", "the", "unmodified", "rtx", "for", "the", "first", "string", ".", "ORIG_SRC2", "is", "the", "unmodified", "rtx", "for", "the", "second", "string", ".", "S1ADDR", "is", "the", "register", "to", "use", "for", "the", "base", "address", "of", "the", "first", "string", ".", "S2ADDR", "is", "the", "register", "to", "use", "for", "the", "base", "address", "of", "the", "second", "string", ".", "OFF_REG", "is", "the", "register", "to", "use", "for", "the", "string", "offset", "for", "loads", ".", "S1DATA", "is", "the", "register", "for", "loading", "the", "first", "string", ".", "S2DATA", "is", "the", "register", "for", "loading", "the", "second", "string", ".", "VEC_RESULT", "is", "the", "rtx", "for", "the", "vector", "result", "indicating", "the", "byte", "difference", ".", "EQUALITY_COMPARE_REST", "is", "a", "flag", "to", "indicate", "we", "need", "to", "make", "a", "cleanup", "call", "to", "strcmp/strncmp", "if", "we", "have", "equality", "at", "the", "end", "of", "the", "inline", "comparison", ".", "P_CLEANUP_LABEL", "is", "a", "pointer", "to", "rtx", "for", "a", "label", "we", "generate", "if", "we", "need", "code", "to", "clean", "up", "and", "generate", "the", "final", "comparison", "result", ".", "FINAL_MOVE_LABEL", "is", "rtx", "for", "a", "label", "we", "can", "branch", "to", "when", "we", "can", "just", "set", "the", "final", "result", ".", "CHECKZERO", "indicates", "whether", "the", "sequence", "should", "check", "for", "zero", "bytes", "for", "use", "doing", "strncmp", ",", "or", "not", "(", "for", "use", "doing", "memcmp", ")", "." ]

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

[ "def", ":", "ReadAdvance", "<", "ReadAfterVecXLd" ]

[ "let", "Uses", "=", "[", "CS", "]", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "SIGfx7CacheControl", "(", "const", "GCNSubtarget", "&", "ST", ")", ":", "SIGfx6CacheControl", "(", "ST", ")", "{", "}", "<FIXE>" ]

[ "class", "SIGfx7CacheControl", ":", "public", "SIGfx6CacheControl", "{", "public", ":", "<BUGS>", "SIGfx7CacheControl", "(", "const", "GCNSubtarget", "&", "ST", ")", ":", "SIGfx6CacheControl", "(", "ST", ")", "{", "}", ";", "<BUGE>", "bool", "insertAcquire", "(", "MachineBasicBlock", "::", "iterator", "&", "MI", ",", "SIAtomicScope", "Scope", "," ]

[ "<FIXS>", "{", "got", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "ggc_strdup", "(", "toc_label_name", ")", ")", ";", "need_toc_init", "=", "<NUM_LIT>", ";", "}", "<FIXE>" ]

[ "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "<STR_LIT>", "L", "<STR_LIT>", ",", "CODE_LABEL_NUMBER", "(", "lab", ")", ")", ";", "lab", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "ggc_strdup", "(", "buf", ")", ")", ";", "if", "(", "flag_pic", "==", "<NUM_LIT>", ")", "<BUGS>", "got", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "ggc_strdup", "(", "toc_label_name", ")", ")", ";", "<BUGE>", "elsegot", "=", "rs6000_got_sym", "(", ")", ";", "tmp1", "=", "tmp2", "=", "dest", ";" ]

[ "false", ";" ]

[ "bool", "SparcTargetMachine", "::", "addCodeEmitter", "(", "PassManagerBase", "&", "PM", ",", "JITCodeEmitter", "&", "JCE", ")", "{", "PM", ".", "add", "(", "createSparcJITCodeEmitterPass", "(", "*", "this", ",", "JCE", ")", ")", ";", "return" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";" ]

[ "microMIPS instruction size reduction pass", "<STR_LIT>", ";" ]

[ "return", "<STR_LIT>" ]

[ ">", ";" ]

[ "def", "CEIL", ":", "R600_1OP_Helper", "<", "<NUM_LIT>", ",", "<STR_LIT>", ",", "fceil" ]

[ "ARM", "::", "tBLXr_noip", ":", "ARM", "::", "tBLXr", ";" ]

[ "return", "(", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "hardenSlsBlr", "(", ")", ")", "?" ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc2Mods", ",", "src2_modifiers", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc2Mods", ",", "src2_modifiers", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc0", ",", "src0", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc1", ",", "src1", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc2", ",", "src2", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasOMod", ",", "omod", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc0Mods", ",", "src0_modifiers", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc1Mods", ",", "src1_modifiers", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ";" ]

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

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

[ "}" ]

[ "<STR_LIT>", "::", "<STR_LIT>", "CC", "=", "static_cast", "<", "<STR_LIT>", "::", "<STR_LIT>", ">", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ")", ";", "switch", "(", "CC", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Invalid branch condition!", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "CC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "CC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "CC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "CC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "CC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "CC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "}", "Cond", "[", "<NUM_LIT>", "]", ".", "setImm", "(", "CC", ")", ";", "return", "false", ";" ]

[ "}" ]

[ "case", "M4_and_andn", ":", "return", "C4_and_andn", ";", "case", "M4_and_or", ":", "return", "C4_and_or", ";", "case", "A2_or", ":", "case", "A2_orp", ":", "return", "C2_or", ";", "case", "A4_orn", ":", "case", "A4_ornp", ":", "return", "C2_orn", ";", "case", "M4_or_and", ":", "return", "C4_or_and", ";", "case", "M4_or_andn", ":", "return", "C4_or_andn", ";", "case", "M4_or_or", ":", "return", "C4_or_or", ";", "case", "A2_xor", ":", "case", "A2_xorp", ":", "return", "C2_xor", ";", "case", "C2_tfrrp", ":", "return", "COPY", ";" ]

[ "return", "Val", ";" ]

[ "Value", "*", "SPPtr", "=", "Builder", "->", "CreateIntToPtr", "(", "OldSP", ",", "OpTy", "->", "getPointerTo", "(", ")", ")", ";", "Value", "*", "Val", "=", "Builder", "->", "CreateLoad", "(", "SPPtr", ")", ";", "setReg", "(", "X86", "::", "RSP", ",", "NewSP", ")", ";" ]

[ "<STR_LIT>" ]

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

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

[ "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "and", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "ashift", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")" ]

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

[ "(", "vec_select", ":", "V16QI", "(", "match_operand", ":", "V32QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "}" ]

[ "}", "addr", "=", "convert_memory_address", "(", "Pmode", ",", "XEXP", "(", "m_tramp", ",", "<NUM_LIT>", ")", ")", ";", "fnaddr", "=", "convert_memory_address", "(", "Pmode", ",", "fnaddr", ")", ";", "static_chain", "=", "convert_memory_address", "(", "Pmode", ",", "static_chain", ")", ";", "addr_reg", "=", "copy_to_reg", "(", "addr", ")", ";", "m_tramp", "=", "adjust_automodify_address", "(", "m_tramp", ",", "Pmode", ",", "addr_reg", ",", "<NUM_LIT>", ")", ";", "tramp", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "<STR_LIT>", "__ia64_trampoline", "<STR_LIT>", ")", ";", "if", "(", "TARGET_ABI_OPEN_VMS", ")", "{", "rtx", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "SYMBOL_REF_FLAGS", "(", "tramp", ")", "|=", "SYMBOL_FLAG_FUNCTION", ";", "emit_move_insn", "(", "reg", ",", "tramp", ")", ";", "emit_move_insn", "(", "reg", ",", "gen_rtx_MEM", "(", "Pmode", ",", "reg", ")", ")", ";", "tramp", "=", "reg", ";" ]

[ "}", "]", ">", ";" ]

[ "return", "CurDAG", "-", ">", "getTargetConstant", "(", "N", "-", ">", "getSExtValue", "(", ")", "&", "(", "-", "<NUM_LIT>", "<", "<", "<NUM_LIT>", ")", ",", "MVT", ":", ":", "i32", ")", ";", "}", "]", ">", ";", "def", "maskEight", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "N", "-", ">", "getSExtValue", "(", ")", "&", "(", "-", "<NUM_LIT>", "<", "<", "<NUM_LIT>", ")", ",", "MVT", ":", ":", "i32", ")", ";", "}", "]", ">", ";", "def", "maskNine", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "N", "-", ">", "getSExtValue", "(", ")", "&", "(", "-", "<NUM_LIT>", "<", "<", "<NUM_LIT>", ")", ",", "MVT", ":", ":", "i32", ")", ";" ]

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

[ "(", "define_int_iterator", "VPMAXMINF", "[", "UNSPEC_VPMAX" ]

[ "RegIdx", ".", "RealRegister", ")", ":", "<STR_LIT>", "<NULL>", "<STR_LIT>", ")", "<<", "<STR_LIT>", "=", "<STR_LIT>", "<<", "RegIdx", ".", "RealRegister", "<<", "<STR_LIT>", "): ", "<STR_LIT>", "<<", "Result", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";" ]

[ "bool", "isCheriAsmReg", "(", ")", "const", "{", "bool", "Result", "=", "isRegIdx", "(", ")", "&&", "RegIdx", ".", "Kind", "&", "RegKind_Cheri", "&&", "RegIdx", ".", "RegInfo", "->", "getRegClass", "(", "Mips", "::", "CheriGPROrCNullRegClassID", ")", ".", "contains", "(", "RegIdx", ".", "RealRegister", ")", ";", "if", "(", "isRegIdx", "(", ")", ")", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "_", "_", "func__", "<<", "<STR_LIT>", " CheriGPROrCNullRegClassID contains(", "<STR_LIT>", "<<", "(", "RegIdx", ".", "RealRegister", "?", "RegIdx", ".", "RegInfo", "->", "getName", "(" ]

[ "true", ";" ]

[ "case", "AMDGPU", "::", "OQBP", ":", "case", "AMDGPU", "::", "AR_X", ":", "return", "false", ";", "default", ":", "return" ]

[ "tc_0ae0825c", ",", "TypeS_2op", ">", ",", "Enc_b9c5fb", "{" ]

[ "def", "A2_notp", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ")", ",", "<STR_LIT>", "," ]

[ "int64x2_t", ")", "_", "_", "a", ")", ";" ]

[ "return", "(", "uint32x2_t", ")", "_", "_", "builtin_neon_vqmovnuv2di", "(", "(" ]

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

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

[ "<FIXS>", "let", "lds", "=", "<NUM_LIT>", ";", "<FIXE>" ]

[ "class", "MUBUF_si", "bits", "<NUM_LIT>", ">", "op", ",", "dag", "outs", ",", "dag", "ins", ",", "string", "asm", ",", "list", "dag", ">", "pattern", ">", ":", "MUBUF", "outs", ",", "ins", ",", "asm", ",", "pattern", ">", ",", "MUBUFe", "op", ">", "{", "<BUGS>", "let", "lds", "=", "<NUM_LIT>", ";", "<BUGE>", "}", "class", "MUBUF_vi", "bits", "<NUM_LIT>", ">", "op", ",", "dag", "outs", ",", "dag", "ins", ",", "string", "asm", ",", "list", "dag", ">", "pattern", ">", ":" ]

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

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

[ "&", "State", ")", ")", "{" ]

[ "char", "Needs", "=", "StateExact", "|", "StateWQM", ";", "char", "OutNeeds", "=", "<NUM_LIT>", ";", "if", "(", "FirstWQM", "==", "IE", ")", "FirstWQM", "=", "II", ";", "if", "(", "FirstWWM", "==", "IE", ")", "FirstWWM", "=", "II", ";", "if", "(", "II", "!=", "IE", ")", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "if", "(", "MI", ".", "isTerminator", "(", ")", "||", "TII", "->", "mayReadEXEC", "(", "*", "MRI", ",", "MI", ")", ")", "{", "auto", "III", "=", "Instructions", ".", "find", "(", "&", "MI", ")", ";", "if", "(", "III", "!=", "Instructions", ".", "end", "(", ")", ")", "{", "if", "(", "III", "->", "second", ".", "Needs", "&", "StateWWM", ")", "Needs", "=", "StateWWM", ";", "else", "if", "(", "III", "->", "second", ".", "Needs", "&", "StateWQM", ")", "Needs", "=", "StateWQM", ";", "else", "Needs", "&=", "~", "III", "->", "second", ".", "Disabled", ";", "OutNeeds", "=", "III", "->", "second", ".", "OutNeeds", ";", "}", "}", "else", "{", "Needs", "=", "StateExact", "|", "StateWQM", "|", "StateWWM", ";", "}", "if", "(", "MI", ".", "isTerminator", "(", ")", "&&", "OutNeeds", "==", "StateExact", ")", "Needs", "=", "StateExact", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "SI_ELSE", "&&", "BI", ".", "OutNeeds", "==", "StateExact", ")", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "setImm", "(", "<NUM_LIT>", ")", ";", "++", "Next", ";", "}", "else", "{", "if", "(", "BI", ".", "OutNeeds", "&", "StateWQM", ")", "Needs", "=", "StateWQM", ";", "else", "if", "(", "BI", ".", "OutNeeds", "==", "StateExact", ")", "Needs", "=", "StateExact", ";", "else", "Needs", "=", "StateWQM", "|", "StateExact", ";", "}", "if", "(", "!", "(", "Needs" ]

[ ";" ]

[ "if", "(", "MEM_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&&", "MEM_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "return", "false", ";", "return", "true" ]

[ "}" ]

[ "getTargetStreamer", "(", ")", ".", "EmitARM64WinCFIAllocStack", "(", "Size", ")", ";", "return", "false", ";" ]

[ ",", "const", "int", "_", "_", "c", ")", "{" ]

[ "vqrdmulhq_lane_s32", "(", "int32x4_t", "_", "_", "a", ",", "int32x2_t", "_", "_", "b" ]

[ ";" ]

[ "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>" ]

[ "if", "(", "helper_use_relative_reloc", "(", "*", "rsym", ",", "pParent", ")", ")", "{" ]

[ "assert", "(", "pParent", ".", "getSymGOTMap", "(", ")", ".", "lookUp", "(", "*", "rsym", ")", "==", "NULL", ")", ";", "HexagonGOTEntry", "*", "got_entry", "=", "ld_backend", ".", "getGOT", "(", ")", ".", "create", "(", ")", ";", "pParent", ".", "getSymGOTMap", "(", ")", ".", "record", "(", "*", "rsym", ",", "*", "got_entry", ")", ";", "if", "(", "!", "pHasRel", ")", "{", "got_entry", "->", "setValue", "(", "HexagonRelocator", "::", "SymVal", ")", ";", "}", "else", "{" ]

[ "else", "emit_jump_insn", "(", "gen_cbranchsi4", "(", "test", ",", "src_reg", ",", "final_src", ",", "label", ")", ")", ";" ]

[ "length", "-=", "leftover", ";", "mips_adjust_block_mem", "(", "src", ",", "bytes_per_iter", ",", "&", "src_reg", ",", "&", "src", ")", ";", "mips_adjust_block_mem", "(", "dest", ",", "bytes_per_iter", ",", "&", "dest_reg", ",", "&", "dest", ")", ";", "final_src", "=", "expand_simple_binop", "(", "Pmode", ",", "PLUS", ",", "src_reg", ",", "GEN_INT", "(", "length", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "OPTAB_WIDEN", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "mips_block_move_straight", "(", "dest", ",", "src", ",", "bytes_per_iter", ")", ";", "mips_emit_move", "(", "src_reg", ",", "plus_constant", "(", "Pmode", ",", "src_reg", ",", "bytes_per_iter", ")", ")", ";", "mips_emit_move", "(", "dest_reg", ",", "plus_constant", "(", "Pmode", ",", "dest_reg", ",", "bytes_per_iter", ")", ")", ";", "test", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "src_reg", ",", "final_src", ")", ";", "if", "(", "Pmode", "==", "DImode", ")", "emit_jump_insn", "(", "gen_cbranchdi4", "(", "test", ",", "src_reg", ",", "final_src", ",", "label", ")", ")", ";" ]

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

[ "SDValue", "SubReg1", "=", "CurDAG", "->", "getTargetConstant", "(", "ARM", "::", "qsub_1", ",", "MVT", "::", "i32", ")", ";", "SDValue", "SubReg2", "=", "CurDAG", "->", "getTargetConstant", "(", "ARM", "::", "qsub_2", ",", "MVT", "::", "i32", ")", ";", "SDValue", "SubReg3", "=", "CurDAG", "->", "getTargetConstant", "(", "ARM", "::", "qsub_3", ",", "MVT", "::" ]

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

[ "return", "Ins", "[", "<NUM_LIT>", "]", ".", "Flags", ".", "isSRet" ]

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

[ "return", "_", "_", "builtin_ia32_sqrtph256_mask", "(", "_", "_", "A", ",", "_", "mm256_setzero_ph", "(", ")", ",", "(", "_", "_", "mmask16", ")" ]

[ ")", "]" ]

[ "(", "ashift", ":", "DI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "R_MDC", ")" ]

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

[ "class", "VLD1D3", "<", "bits", "<", "<NUM_LIT>", ">", "op7_4", ",", "string", "Dt", ",", "Operand", "AddrMode", ">", ":", "NLdSt", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "op7_4", ",", "(", "outs", "VecListThreeD", ":", "$", "Vd", ")", ",", "(", "ins", "AddrMode", ":", "$", "Rn", ")", ",", "IIC_VLD1x3", ",", "<STR_LIT>", ",", "Dt", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "WriteVLD3", "]", ">", "{", "let", "Rm", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Rn", "{", "<NUM_LIT>", "}", ";" ]

[ "DONE" ]

[ "FAIL", "emit_insn", "(", "gen_extzv_internal", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")" ]

[ "}" ]

[ "if", "(", "isTopOfStack", "(", "BB", ")", ")", "closeControlFlow", "(", "BB", ")", ";", "continue", ";", "}", "if", "(", "I", ".", "nodeVisited", "(", "Term", "->", "getSuccessor", "(", "<NUM_LIT>", ")", ")", ")", "{", "if", "(", "isTopOfStack", "(", "BB", ")", ")", "closeControlFlow", "(", "BB", ")", ";", "handleLoop", "(", "Term", ")", ";", "continue", ";", "}", "if", "(", "isTopOfStack", "(", "BB", ")", ")", "{", "PHINode", "*", "Phi", "=", "dyn_cast", "<", "PHINode", ">", "(", "Term", "->", "getCondition", "(", ")", ")", ";", "if", "(", "Phi", "&&", "Phi", "->", "getParent", "(", ")", "==", "BB", "&&", "isElse", "(", "Phi", ")", ")", "{", "insertElse", "(", "Term", ")", ";", "eraseIfUnused", "(", "Phi", ")", ";", "continue", ";" ]

[ "static", "tree", "make_resolver_func", "(", "const", "tree", "default_decl", ",", "const", "tree", "dispatch_decl", ",", "basic_block", "*", "empty_bb", ")", "{", "tree", "decl_name", "=", "clone_function_name", "(", "default_decl", ",", "<STR_LIT>", "resolver", "<STR_LIT>", ")", ";", "const", "char", "*", "resolver_name", "=", "IDENTIFIER_POINTER", "(", "decl_name", ")", ";", "tree", "type", "=", "build_function_type_list", "(", "ptr_type_node", ",", "NULL_TREE", ")", ";", "tree", "decl", "=", "build_fn_decl", "(", "resolver_name", ",", "type", ")", ";", "SET_DECL_ASSEMBLER_NAME", "(", "decl", ",", "decl_name", ")", ";", "DECL_NAME", "(", "decl", ")", "=", "decl_name", ";", "TREE_USED", "(", "decl", ")", "=", "<NUM_LIT>", ";", "DECL_ARTIFICIAL", "(", "decl", ")", "=", "<NUM_LIT>", ";", "DECL_IGNORED_P", "(", "decl", ")", "=", "<NUM_LIT>", ";", "TREE_PUBLIC", "(", "decl", ")", "=", "<NUM_LIT>", ";", "DECL_UNINLINABLE", "(", "decl", ")", "=", "<NUM_LIT>", ";", "DECL_EXTERNAL", "(", "decl", ")", "=", "<NUM_LIT>", ";", "DECL_EXTERNAL", "(", "dispatch_decl", ")", "=", "<NUM_LIT>", ";", "DECL_CONTEXT", "(", "decl", ")", "=", "NULL_TREE", ";", "DECL_INITIAL", "(", "decl", ")", "=", "make_node", "(", "BLOCK", ")", ";", "DECL_STATIC_CONSTRUCTOR", "(", "decl", ")", "=", "<NUM_LIT>", ";", "if", "(", "DECL_COMDAT_GROUP", "(", "default_decl", ")", "||", "TREE_PUBLIC", "(", "default_decl", ")", ")", "{", "DECL_COMDAT", "(", "decl", ")", "=", "<NUM_LIT>", ";", "make_decl_one_only", "(", "decl", ",", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ";", "}", "else", "TREE_PUBLIC", "(", "dispatch_decl", ")", "=", "<NUM_LIT>", ";", "tree", "t", "=", "build_decl", "(", "UNKNOWN_LOCATION", ",", "RESULT_DECL", ",", "NULL_TREE", ",", "ptr_type_node", ")", ";", "DECL_CONTEXT", "(", "t", ")", "=", "decl", ";", "DECL_ARTIFICIAL", "(", "t", ")", "=", "<NUM_LIT>", ";", "DECL_IGNORED_P", "(", "t", ")", "=", "<NUM_LIT>", ";", "DECL_RESULT", "(", "decl", ")", "=", "t", ";", "gimplify_function_tree", "(", "decl", ")", ";", "push_cfun", "(", "DECL_STRUCT_FUNCTION", "(", "decl", ")", ")", ";", "*", "empty_bb", "=", "init_lowered_empty_function", "(", "decl", ",", "false", ",", "profile_count", "::", "uninitialized", "(", ")", ")", ";", "cgraph_node", "::", "add_new_function", "(", "decl", ",", "true", ")", ";", "symtab", "->", "call_cgraph_insertion_hooks", "(", "cgraph_node", "::", "get_create", "(", "decl", ")", ")", ";", "pop_cfun", "(", ")", ";", "DECL_ATTRIBUTES", "(", "dispatch_decl", ")", "=", "make_attribute", "(", "<STR_LIT>", "ifunc", "<STR_LIT>", ",", "resolver_name", ",", "DECL_ATTRIBUTES", "(", "dispatch_decl", ")", ")", ";", "cgraph_node", "::", "create_same_body_alias", "(", "dispatch_decl", ",", "decl", ")", ";", "return", "decl", ";", "}" ]

[ "Make", "the", "resolver", "function", "decl", "to", "dispatch", "the", "versions", "of", "a", "multi-", "versioned", "function", ",", "DEFAULT_DECL", ".", "Create", "an", "empty", "basic", "block", "in", "the", "resolver", "and", "store", "the", "pointer", "in", "EMPTY_BB", ".", "Return", "the", "decl", "of", "the", "resolver", "function", "." ]

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

[ "ReverseImm", "=", "reverseBits", "<", "int32_t", ">", "(", "static_cast", "<", "int32_t", ">", "(", "Src", ".", "getImm", "(", ")", ")", ")", ";", "return", "ReverseImm", ">=", "-", "<NUM_LIT>" ]

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

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

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

[ "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>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "size2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opcode", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "<STR_LIT>", ")" ]

[ "<STR_LIT>", ")", "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", "(", "match_operand", ":", "V4SF", "<NUM_LIT>", "<STR_LIT>", ")", "(", "ior", "(", "match_operand", ":", "V2SI", "<NUM_LIT>" ]

[ "&", "&", "small_int_operand", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "mode", ")" ]

[ "return", "(", "register_operand", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "mode", ")", "&", "&", "small_int_operand", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "mode", ")" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "PPCISD::MTFSB0", "<STR_LIT>", ";" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "PPCISD::NOP", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "PPCISD::MTCTR", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "PPCISD::BCTRL_Darwin", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "PPCISD::BCTRL_SVR4", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "PPCISD::RET_FLAG", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "PPCISD::MFCR", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "PPCISD::VCMP", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "PPCISD::VCMPo", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "PPCISD::LBRX", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "PPCISD::STBRX", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "PPCISD::LARX", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "PPCISD::STCX", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "PPCISD::COND_BRANCH", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "PPCISD::MFFS", "<STR_LIT>", ";" ]

[ "int", "LowWidth", "=", "(", "LowOffset", "==", "OffsetA", ")", "?", "WidthA", ":", "WidthB", ";" ]

[ "int", "OffsetA", "=", "<NUM_LIT>", ",", "OffsetB", "=", "<NUM_LIT>", ";", "int", "WidthA", "=", "<NUM_LIT>", ",", "WidthB", "=", "<NUM_LIT>", ";", "assert", "(", "MIa", "&&", "MIa", "->", "mayLoadOrStore", "(", ")", "&&", "<STR_LIT>", "MIa must be a load or store.", "<STR_LIT>", ")", ";", "assert", "(", "MIb", "&&", "MIb", "->", "mayLoadOrStore", "(", ")", "&&", "<STR_LIT>", "MIb must be a load or store.", "<STR_LIT>", ")", ";", "if", "(", "MIa", "->", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", "->", "hasUnmodeledSideEffects", "(", ")", "||", "MIa", "->", "hasOrderedMemoryRef", "(", ")", "||", "MIb", "->", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "if", "(", "getLdStBaseRegImmOfsWidth", "(", "MIa", ",", "BaseRegA", ",", "OffsetA", ",", "WidthA", ",", "TRI", ")", "&&", "getLdStBaseRegImmOfsWidth", "(", "MIb", ",", "BaseRegB", ",", "OffsetB", ",", "WidthB", ",", "TRI", ")", ")", "{", "if", "(", "BaseRegA", "==", "BaseRegB", ")", "{", "int", "LowOffset", "=", "OffsetA", "<", "OffsetB", "?", "OffsetA", ":", "OffsetB", ";", "int", "HighOffset", "=", "OffsetA", "<", "OffsetB", "?", "OffsetB", ":", "OffsetA", ";" ]

[ "}" ]

[ "const", "TargetRegisterClass", "*", "RC", ";", "if", "(", "AFI", "->", "isThumb1OnlyFunction", "(", ")", ")", "RC", "=", "&", "ARM", "::", "tGPRRegClass", ";", "else", "RC", "=", "&", "ARM", "::", "GPRRegClass", ";", "unsigned", "VReg", "=", "MF", ".", "addLiveIn", "(", "GPRArgRegs", "[", "firstRegToSaveIndex", "]", ",", "RC", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VReg", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Store", "=", "DAG", ".", "getStore", "(", "Val", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "dl", ",", "Val", ",", "FIN", ",", "MachinePointerInfo", "(", "OrigArg", ",", "OffsetFromOrigArg", "+", "<NUM_LIT>", "*", "i", ")", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "MemOps", ".", "push_back", "(", "Store", ")", ";", "FIN", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "getPointerTy", "(", ")", ",", "FIN", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "getPointerTy", "(", ")", ")", ")", ";" ]

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

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

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

[ "unsigned", "int", "issue_info", "=", "la_vect_issue_info", ";", "unsigned", "int", "reduc_factor", "=", "m_reduc_factor", ">", "<NUM_LIT>", "?", "m_reduc_factor", ":", "<NUM_LIT>", ";", "unsigned", "int", "uf", "=", "CEIL", "(", "reduc_factor", "*", "issue_info", ",", "nstmts_nonldst", ")", ";", "uf", "=", "MIN", "(", "(", "unsigned", "int", ")", "la_vect_unroll_limit" ]

[ "int", "memory_ok_for_ldd", "(", "rtx", "op", ")", "{", "if", "(", "!", "mem_min_alignment", "(", "op", ",", "<NUM_LIT>", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "(", "reload_in_progress", "||", "reload_completed", ")", "&&", "!", "strict_memory_address_p", "(", "Pmode", ",", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "lra_in_progress", "&&", "!", "memory_address_p", "(", "Pmode", ",", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ")", ")", "return", "<NUM_LIT>", ";", "return", "<NUM_LIT>", ";", "}" ]

[ "Return", "1", "if", "OP", ",", "a", "MEM", ",", "has", "an", "address", "which", "is", "known", "to", "be", "aligned", "to", "an", "8-byte", "boundary", "." ]

[ ")", ";" ]

[ "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "Kind", "=", "MCSymbolRefExpr", "::", "VK_WASM_TBREL", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown target flag on GV operand", "<STR_LIT>", ")", ";", "}", "const", "MCExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "Kind", ",", "Ctx", ")", ";", "if", "(", "MO", ".", "getOffset", "(", ")", "!=", "<NUM_LIT>", ")", "{", "const", "auto", "*", "WasmSym", "=", "cast", "<", "MCSymbolWasm", ">", "(", "Sym", ")", ";", "if", "(", "TargetFlags", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "report_fatal_error", "(", "<STR_LIT>", "GOT symbol references do not support offsets", "<STR_LIT>", ")", ";", "if", "(", "WasmSym", "->", "isFunction", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "Function addresses with offsets not supported", "<STR_LIT>", ")", ";", "if", "(", "WasmSym", "->", "isGlobal", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "Global indexes with offsets not supported", "<STR_LIT>" ]

[ "let", "ParserMatchClass", "=", "DataTypeAsmOperand", ";" ]

[ "def", "DataType", ":", "Operand", "<", "i8", ">", "{", "let", "OperandNamespace", "=", "<STR_LIT>", ";", "let", "PrintMethod", "=", "<STR_LIT>", ";" ]

[ "]", ")", "&", "CALL_V4_SET_FP_ARGS", ")" ]

[ "[", "(", "call", "(", "mem", ":", "SI", "(", "match_operand", ":", "P", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", "<NUM_LIT>", ")", ")", "(", "use", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "reg", ":", "P", "LR_REGNO", ")", ")", "]", "<STR_LIT>", "{", "if", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m256i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_maskz_expand_epi32", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m256i", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_expandsi256_maskz", "(", "(", "_", "_", "v8si", ")", "_", "_", "A", ",", "(", "_", "_", "v8si", ")", "_", "mm256_avx512_setzero_si256", "(", ")", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "}", "else", "{" ]

[ "void", "CodeNode", "::", "addMember", "(", "NodeAddr", "<", "NodeBase", "*", ">", "NA", ",", "const", "DataFlowGraph", "&", "G", ")", "{", "NodeAddr", "<", "NodeBase", "*", ">", "ML", "=", "getLastMember", "(", "G", ")", ";", "if", "(", "ML", ".", "Id", "!=", "<NUM_LIT>", ")", "{", "ML", ".", "Addr", "->", "append", "(", "NA", ")", ";" ]

[ ";" ]

[ "unsigned", "ANDReg", "=", "createResultReg", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "ANDReg", ")", ".", "addReg", "(", "CondReg", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "ANDReg", ")", ".", "addReg", "(", "ANDReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "unsigned", "CC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "FuncInfo", ".", "MBB", "->", "isLayoutSuccessor", "(", "TBB", ")", ")", "{", "std", "::", "swap", "(", "TBB", ",", "FBB", ")", ";", "CC", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "CC", ")", ".", "addMBB", "(", "TBB", ")", ";", "FuncInfo", ".", "MBB", "->", "addSuccessor", "(", "TBB", ")", ";", "FastEmitBranch", "(", "FBB", ",", "DbgLoc", ")", ";", "return", "true", ";", "}", "}", "else", "if", "(", "const", "ConstantInt", "*", "CI", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "BI", "->", "getCondition", "(", ")", ")", ")", "{", "uint64_t", "Imm", "=", "CI", "->", "getZExtValue", "(", ")", ";", "MachineBasicBlock", "*", "Target", "=", "(", "Imm", "==", "<NUM_LIT>", ")", "?", "FBB", ":", "TBB", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addMBB", "(", "Target", ")", ";", "FuncInfo", ".", "MBB", "->", "addSuccessor", "(", "Target", ")", ";", "return", "true" ]

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

[ "initializeDXILPrettyPrinterPass", "(", "*", "PassRegistry", "::", "getPassRegistry", "(" ]

[ "{" ]

[ "void", "setHasSEHFramePtrSave", "(", "bool", "V", ")" ]

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

[ "void", "M68kOperand", "::", "addAddrOperands", "(", "MCInst", "&", "Inst", ",", "unsigned" ]

[ "mm512_srav_epi32", "(", "_", "_", "m512i", "_", "_", "X", ",", "_", "_", "m512i", "_", "_", "Y", ")", "{" ]

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

[ "isMClass", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";" ]

[ "PrefAlign", "=", "(", "Subtarget", "->", "hasV6Ops", "(", ")", "&&", "!", "Subtarget", "->" ]