std::unique_ptr<IRProgram> IRGenerator::generate(Unit* unit) { IRGenerator ir; ir.codegen(unit); return std::unique_ptr<IRProgram>(ir.program()); }
IRProgram* IRGenerator::generate(Unit* unit) { IRGenerator ir; ir.codegen(unit); return ir.program(); }
void seekFrame(int nDiff) { XnStatus nRetVal = XN_STATUS_OK; if (isPlayerOn()) { const XnChar* strNodeName = NULL; if (g_pPrimary != NULL) { strNodeName = g_pPrimary->GetName(); } else if (g_Depth.IsValid()) { strNodeName = g_Depth.GetName(); } else if (g_Image.IsValid()) { strNodeName = g_Image.GetName(); } else if (g_IR.IsValid()) { strNodeName = g_IR.GetName(); } else if (g_Audio.IsValid()) { strNodeName = g_Audio.GetName(); } nRetVal = g_Player.SeekToFrame(strNodeName, nDiff, XN_PLAYER_SEEK_CUR); if (nRetVal != XN_STATUS_OK) { displayMessage("Failed to seek: %s", xnGetStatusString(nRetVal)); return; } XnUInt32 nFrame = 0; XnUInt32 nNumFrames = 0; nRetVal = g_Player.TellFrame(strNodeName, nFrame); if (nRetVal != XN_STATUS_OK) { displayMessage("Failed to tell frame: %s", xnGetStatusString(nRetVal)); return; } nRetVal = g_Player.GetNumFrames(strNodeName, nNumFrames); if (nRetVal != XN_STATUS_OK) { displayMessage("Failed to get number of frames: %s", xnGetStatusString(nRetVal)); return; } displayMessage("Seeked %s to frame %u/%u", strNodeName, nFrame, nNumFrames); } }
void closeDevice() { g_Player.Release(); g_Device.Release(); g_Depth.Release(); g_Image.Release(); g_IR.Release(); g_Audio.Release(); g_scriptNode.Release(); g_Context.Release(); }
void readFrame() { if (!g_Depth.IsValid() && !g_Image.IsValid() && !g_IR.IsValid() && !g_Audio.IsValid()) // @@@dded return; XnStatus rc = XN_STATUS_OK; if (g_pPrimary != NULL) { rc = g_Context.WaitOneUpdateAll(*g_pPrimary); } else { rc = g_Context.WaitAnyUpdateAll(); } if (rc != XN_STATUS_OK) { printf("Error: %s\n", xnGetStatusString(rc)); } if (g_Depth.IsValid()) { g_Depth.GetMetaData(g_DepthMD); } if (g_Image.IsValid()) { g_Image.GetMetaData(g_ImageMD); } if (g_IR.IsValid()) { g_IR.GetMetaData(g_irMD); } if (g_Audio.IsValid()) { g_Audio.GetMetaData(g_AudioMD); } }
XnStatus prepare(char useScene, char useDepth, char useImage, char useIr, char useHistogram) { //TODO handle possible failures! Gotcha! if (useDepth) { mDepthGen.GetMetaData(depthMD); nXRes = depthMD.XRes(); nYRes = depthMD.YRes(); pDepth = depthMD.Data(); if (useHistogram) { calcHist(); // rewind the pointer pDepth = depthMD.Data(); } } if (useScene) { mUserGen.GetUserPixels(0, sceneMD); nXRes = sceneMD.XRes(); nYRes = sceneMD.YRes(); pLabels = sceneMD.Data(); } if (useImage) { mImageGen.GetMetaData(imageMD); nXRes = imageMD.XRes(); nYRes = imageMD.YRes(); pRGB = imageMD.RGB24Data(); // HISTOGRAM????? } if (useIr) { mIrGen.GetMetaData(irMD); nXRes = irMD.XRes(); nYRes = irMD.YRes(); pIR = irMD.Data(); // HISTOGRAM???? } }
/* * Class: org_OpenNI_Samples_Assistant_NativeMethods * Method: dispose * Signature: ()I */ JNIEXPORT jint JNICALL Java_org_OpenNI_Samples_Assistant_NativeMethods_dispose (JNIEnv *, jclass) { LOGD("dispose_start"); disposeGraphics(); mUserGen.Release(); hasUserGen = 0; mDepthGen.Release(); hasDepthGen = 0; mImageGen.Release(); hasUserGen = 0; mIrGen.Release(); hasIrGen = 0; mContext->Release(); delete mContext; mContext = 0; LOGD("dispose_end"); return XN_STATUS_OK; }
IRGenModule::IRGenModule(IRGenerator &irgen, std::unique_ptr<llvm::TargetMachine> &&target, SourceFile *SF, llvm::LLVMContext &LLVMContext, StringRef ModuleName, StringRef OutputFilename) : IRGen(irgen), Context(irgen.SIL.getASTContext()), ClangCodeGen(createClangCodeGenerator(Context, LLVMContext, irgen.Opts, ModuleName)), Module(*ClangCodeGen->GetModule()), LLVMContext(Module.getContext()), DataLayout(target->createDataLayout()), Triple(Context.LangOpts.Target), TargetMachine(std::move(target)), silConv(irgen.SIL), OutputFilename(OutputFilename), TargetInfo(SwiftTargetInfo::get(*this)), DebugInfo(nullptr), ModuleHash(nullptr), ObjCInterop(Context.LangOpts.EnableObjCInterop), Types(*new TypeConverter(*this)) { irgen.addGenModule(SF, this); auto &opts = irgen.Opts; EnableValueNames = opts.shouldProvideValueNames(); VoidTy = llvm::Type::getVoidTy(getLLVMContext()); Int1Ty = llvm::Type::getInt1Ty(getLLVMContext()); Int8Ty = llvm::Type::getInt8Ty(getLLVMContext()); Int16Ty = llvm::Type::getInt16Ty(getLLVMContext()); Int32Ty = llvm::Type::getInt32Ty(getLLVMContext()); Int64Ty = llvm::Type::getInt64Ty(getLLVMContext()); Int8PtrTy = llvm::Type::getInt8PtrTy(getLLVMContext()); Int8PtrPtrTy = Int8PtrTy->getPointerTo(0); SizeTy = DataLayout.getIntPtrType(getLLVMContext(), /*addrspace*/ 0); auto CI = static_cast<ClangImporter*>(&*Context.getClangModuleLoader()); assert(CI && "no clang module loader"); auto &clangASTContext = CI->getClangASTContext(); ObjCBoolTy = Int1Ty; if (clangASTContext.getTargetInfo().useSignedCharForObjCBool()) ObjCBoolTy = Int8Ty; RefCountedStructTy = llvm::StructType::create(getLLVMContext(), "swift.refcounted"); RefCountedPtrTy = RefCountedStructTy->getPointerTo(/*addrspace*/ 0); RefCountedNull = llvm::ConstantPointerNull::get(RefCountedPtrTy); // For now, native weak references are just a pointer. WeakReferencePtrTy = createStructPointerType(*this, "swift.weak", { RefCountedPtrTy }); // Native unowned references are just a pointer. UnownedReferencePtrTy = createStructPointerType(*this, "swift.unowned", { RefCountedPtrTy }); // A type metadata record is the structure pointed to by the canonical // address point of a type metadata. This is at least one word, and // potentially more than that, past the start of the actual global // structure. TypeMetadataStructTy = createStructType(*this, "swift.type", { MetadataKindTy // MetadataKind Kind; }); TypeMetadataPtrTy = TypeMetadataStructTy->getPointerTo(DefaultAS); // A protocol descriptor describes a protocol. It is not type metadata in // and of itself, but is referenced in the structure of existential type // metadata records. ProtocolDescriptorStructTy = createStructType(*this, "swift.protocol", { Int8PtrTy, // objc isa Int8PtrTy, // name Int8PtrTy, // inherited protocols Int8PtrTy, // required objc instance methods Int8PtrTy, // required objc class methods Int8PtrTy, // optional objc instance methods Int8PtrTy, // optional objc class methods Int8PtrTy, // objc properties Int32Ty, // size Int32Ty, // flags Int16Ty, // mandatory requirement count Int16Ty, // total requirement count Int32Ty // requirements array }); ProtocolDescriptorPtrTy = ProtocolDescriptorStructTy->getPointerTo(); ProtocolRequirementStructTy = createStructType(*this, "swift.protocol_requirement", { Int32Ty, // flags Int32Ty // default implementation }); // A tuple type metadata record has a couple extra fields. auto tupleElementTy = createStructType(*this, "swift.tuple_element_type", { TypeMetadataPtrTy, // Metadata *Type; SizeTy // size_t Offset; }); TupleTypeMetadataPtrTy = createStructPointerType(*this, "swift.tuple_type", { TypeMetadataStructTy, // (base) SizeTy, // size_t NumElements; Int8PtrTy, // const char *Labels; llvm::ArrayType::get(tupleElementTy, 0) // Element Elements[]; }); // A full type metadata record is basically just an adjustment to the // address point of a type metadata. Resilience may cause // additional data to be laid out prior to this address point. FullTypeMetadataStructTy = createStructType(*this, "swift.full_type", { WitnessTablePtrTy, TypeMetadataStructTy }); FullTypeMetadataPtrTy = FullTypeMetadataStructTy->getPointerTo(DefaultAS); // A metadata pattern is a structure from which generic type // metadata are allocated. We leave this struct type intentionally // opaque, because the compiler basically never needs to access // anything from one. TypeMetadataPatternStructTy = llvm::StructType::create(getLLVMContext(), "swift.type_pattern"); TypeMetadataPatternPtrTy = TypeMetadataPatternStructTy->getPointerTo(DefaultAS); DeallocatingDtorTy = llvm::FunctionType::get(VoidTy, RefCountedPtrTy, false); llvm::Type *dtorPtrTy = DeallocatingDtorTy->getPointerTo(); // A full heap metadata is basically just an additional small prefix // on a full metadata, used for metadata corresponding to heap // allocations. FullHeapMetadataStructTy = createStructType(*this, "swift.full_heapmetadata", { dtorPtrTy, WitnessTablePtrTy, TypeMetadataStructTy }); FullHeapMetadataPtrTy = FullHeapMetadataStructTy->getPointerTo(DefaultAS); // A full box metadata is non-type heap metadata for a heap allocation of a // single value. The box tracks the offset to the value inside the box. FullBoxMetadataStructTy = createStructType(*this, "swift.full_boxmetadata", { dtorPtrTy, WitnessTablePtrTy, TypeMetadataStructTy, Int32Ty, CaptureDescriptorPtrTy, }); FullBoxMetadataPtrTy = FullBoxMetadataStructTy->getPointerTo(DefaultAS); llvm::Type *refCountedElts[] = {TypeMetadataPtrTy, Int32Ty, Int32Ty}; RefCountedStructTy->setBody(refCountedElts); PtrSize = Size(DataLayout.getPointerSize(DefaultAS)); FunctionPairTy = createStructType(*this, "swift.function", { FunctionPtrTy, RefCountedPtrTy, }); OpaqueTy = llvm::StructType::create(LLVMContext, "swift.opaque"); OpaquePtrTy = OpaqueTy->getPointerTo(DefaultAS); ProtocolConformanceRecordTy = createStructType(*this, "swift.protocol_conformance", { RelativeAddressTy, RelativeAddressTy, RelativeAddressTy, Int32Ty }); ProtocolConformanceRecordPtrTy = ProtocolConformanceRecordTy->getPointerTo(DefaultAS); NominalTypeDescriptorTy = llvm::StructType::create(LLVMContext, "swift.type_descriptor"); NominalTypeDescriptorPtrTy = NominalTypeDescriptorTy->getPointerTo(DefaultAS); MethodDescriptorStructTy = createStructType(*this, "swift.method_descriptor", { RelativeAddressTy, Int32Ty }); TypeMetadataRecordTy = createStructType(*this, "swift.type_metadata_record", { RelativeAddressTy, Int32Ty }); TypeMetadataRecordPtrTy = TypeMetadataRecordTy->getPointerTo(DefaultAS); FieldDescriptorTy = llvm::StructType::create(LLVMContext, "swift.field_descriptor"); FieldDescriptorPtrTy = FieldDescriptorTy->getPointerTo(DefaultAS); FixedBufferTy = nullptr; for (unsigned i = 0; i != MaxNumValueWitnesses; ++i) ValueWitnessTys[i] = nullptr; ObjCPtrTy = llvm::StructType::create(getLLVMContext(), "objc_object") ->getPointerTo(DefaultAS); BridgeObjectPtrTy = llvm::StructType::create(getLLVMContext(), "swift.bridge") ->getPointerTo(DefaultAS); ObjCClassStructTy = llvm::StructType::create(LLVMContext, "objc_class"); ObjCClassPtrTy = ObjCClassStructTy->getPointerTo(DefaultAS); llvm::Type *objcClassElts[] = { ObjCClassPtrTy, ObjCClassPtrTy, OpaquePtrTy, OpaquePtrTy, IntPtrTy }; ObjCClassStructTy->setBody(objcClassElts); ObjCSuperStructTy = llvm::StructType::create(LLVMContext, "objc_super"); ObjCSuperPtrTy = ObjCSuperStructTy->getPointerTo(DefaultAS); llvm::Type *objcSuperElts[] = { ObjCPtrTy, ObjCClassPtrTy }; ObjCSuperStructTy->setBody(objcSuperElts); ObjCBlockStructTy = llvm::StructType::create(LLVMContext, "objc_block"); ObjCBlockPtrTy = ObjCBlockStructTy->getPointerTo(DefaultAS); llvm::Type *objcBlockElts[] = { ObjCClassPtrTy, // isa Int32Ty, // flags Int32Ty, // reserved FunctionPtrTy, // invoke function pointer Int8PtrTy, // TODO: block descriptor pointer. // We will probably need a struct type for that at some // point too. }; ObjCBlockStructTy->setBody(objcBlockElts); auto ErrorStructTy = llvm::StructType::create(LLVMContext, "swift.error"); // ErrorStruct is currently opaque to the compiler. ErrorPtrTy = ErrorStructTy->getPointerTo(DefaultAS); llvm::Type *openedErrorTriple[] = { OpaquePtrTy, TypeMetadataPtrTy, WitnessTablePtrTy, }; OpenedErrorTripleTy = llvm::StructType::get(getLLVMContext(), openedErrorTriple, /*packed*/ false); OpenedErrorTriplePtrTy = OpenedErrorTripleTy->getPointerTo(DefaultAS); InvariantMetadataID = LLVMContext.getMDKindID("invariant.load"); InvariantNode = llvm::MDNode::get(LLVMContext, {}); DereferenceableID = LLVMContext.getMDKindID("dereferenceable"); C_CC = llvm::CallingConv::C; // TODO: use "tinycc" on platforms that support it DefaultCC = SWIFT_LLVM_CC(DefaultCC); // If it is an interpreter, don't use try to use any // advanced calling conventions and use instead a // more conservative C calling convention. This // makes sure that none of the registers eventually // used by the dynamic linker are used by generated code. // TODO: Check that the deployment target supports the new // calling convention. Older versions of the runtime library // may not contain the entries using the new calling convention. // Only use the new calling conventions on platforms that support it. auto Arch = Triple.getArch(); (void)Arch; if (SWIFT_RT_USE_RegisterPreservingCC && Arch == llvm::Triple::ArchType::aarch64) RegisterPreservingCC = SWIFT_LLVM_CC(RegisterPreservingCC); else RegisterPreservingCC = DefaultCC; SwiftCC = SWIFT_LLVM_CC(SwiftCC); UseSwiftCC = (SwiftCC == llvm::CallingConv::Swift); if (IRGen.Opts.DebugInfoKind > IRGenDebugInfoKind::None) DebugInfo = IRGenDebugInfo::createIRGenDebugInfo(IRGen.Opts, *CI, *this, Module, SF); initClangTypeConverter(); if (ClangASTContext) { auto atomicBoolTy = ClangASTContext->getAtomicType(ClangASTContext->BoolTy); AtomicBoolSize = Size(ClangASTContext->getTypeSize(atomicBoolTy)); AtomicBoolAlign = Alignment(ClangASTContext->getTypeSize(atomicBoolTy)); } IsSwiftErrorInRegister = clang::CodeGen::swiftcall::isSwiftErrorLoweredInRegister( ClangCodeGen->CGM()); }
const IRMetaData* getIRMetaData() { return g_IR.IsValid() ? &g_irMD : NULL; }
IRGenerator* getIRGenerator() { return g_IR.IsValid() ? &g_IR : NULL; }
IRGenModule::IRGenModule(IRGenerator &irgen, std::unique_ptr<llvm::TargetMachine> &&target, SourceFile *SF, llvm::LLVMContext &LLVMContext, StringRef ModuleName, StringRef OutputFilename, StringRef MainInputFilenameForDebugInfo) : IRGen(irgen), Context(irgen.SIL.getASTContext()), ClangCodeGen(createClangCodeGenerator(Context, LLVMContext, irgen.Opts, ModuleName)), Module(*ClangCodeGen->GetModule()), LLVMContext(Module.getContext()), DataLayout(irgen.getClangDataLayout()), Triple(irgen.getEffectiveClangTriple()), TargetMachine(std::move(target)), silConv(irgen.SIL), OutputFilename(OutputFilename), MainInputFilenameForDebugInfo(MainInputFilenameForDebugInfo), TargetInfo(SwiftTargetInfo::get(*this)), DebugInfo(nullptr), ModuleHash(nullptr), ObjCInterop(Context.LangOpts.EnableObjCInterop), UseDarwinPreStableABIBit(Context.LangOpts.UseDarwinPreStableABIBit), Types(*new TypeConverter(*this)) { irgen.addGenModule(SF, this); auto &opts = irgen.Opts; EnableValueNames = opts.shouldProvideValueNames(); VoidTy = llvm::Type::getVoidTy(getLLVMContext()); Int1Ty = llvm::Type::getInt1Ty(getLLVMContext()); Int8Ty = llvm::Type::getInt8Ty(getLLVMContext()); Int16Ty = llvm::Type::getInt16Ty(getLLVMContext()); Int32Ty = llvm::Type::getInt32Ty(getLLVMContext()); Int32PtrTy = Int32Ty->getPointerTo(); Int64Ty = llvm::Type::getInt64Ty(getLLVMContext()); Int8PtrTy = llvm::Type::getInt8PtrTy(getLLVMContext()); Int8PtrPtrTy = Int8PtrTy->getPointerTo(0); SizeTy = DataLayout.getIntPtrType(getLLVMContext(), /*addrspace*/ 0); // For the relative address type, we want to use the int32 bit type // on most architectures, e.g. x86_64, because it produces valid // fixups/relocations. The exception is 16-bit architectures, // so we shorten the relative address type there. if (SizeTy->getBitWidth()<32) { RelativeAddressTy = SizeTy; } else { RelativeAddressTy = Int32Ty; } RelativeAddressPtrTy = RelativeAddressTy->getPointerTo(); FloatTy = llvm::Type::getFloatTy(getLLVMContext()); DoubleTy = llvm::Type::getDoubleTy(getLLVMContext()); auto CI = static_cast<ClangImporter*>(&*Context.getClangModuleLoader()); assert(CI && "no clang module loader"); auto &clangASTContext = CI->getClangASTContext(); ObjCBoolTy = Int1Ty; if (clangASTContext.getTargetInfo().useSignedCharForObjCBool()) ObjCBoolTy = Int8Ty; RefCountedStructTy = llvm::StructType::create(getLLVMContext(), "swift.refcounted"); RefCountedPtrTy = RefCountedStructTy->getPointerTo(/*addrspace*/ 0); RefCountedNull = llvm::ConstantPointerNull::get(RefCountedPtrTy); // For now, references storage types are just pointers. #define CHECKED_REF_STORAGE(Name, name, ...) \ Name##ReferencePtrTy = \ createStructPointerType(*this, "swift." #name, { RefCountedPtrTy }); #include "swift/AST/ReferenceStorage.def" // A type metadata record is the structure pointed to by the canonical // address point of a type metadata. This is at least one word, and // potentially more than that, past the start of the actual global // structure. TypeMetadataStructTy = createStructType(*this, "swift.type", { MetadataKindTy // MetadataKind Kind; }); TypeMetadataPtrTy = TypeMetadataStructTy->getPointerTo(DefaultAS); TypeMetadataResponseTy = createStructType(*this, "swift.metadata_response", { TypeMetadataPtrTy, SizeTy }); OffsetPairTy = llvm::StructType::get(getLLVMContext(), { SizeTy, SizeTy }); // The TypeLayout structure, including all possible trailing components. FullTypeLayoutTy = createStructType(*this, "swift.full_type_layout", { SizeTy, // size SizeTy, // flags SizeTy, // alignment SizeTy // extra inhabitant flags (optional) }); // A protocol descriptor describes a protocol. It is not type metadata in // and of itself, but is referenced in the structure of existential type // metadata records. ProtocolDescriptorStructTy = createStructType(*this, "swift.protocol", { Int8PtrTy, // objc isa Int8PtrTy, // name Int8PtrTy, // inherited protocols Int8PtrTy, // required objc instance methods Int8PtrTy, // required objc class methods Int8PtrTy, // optional objc instance methods Int8PtrTy, // optional objc class methods Int8PtrTy, // objc properties Int32Ty, // size Int32Ty, // flags Int32Ty, // total requirement count Int32Ty, // requirements array RelativeAddressTy, // superclass RelativeAddressTy // associated type names }); ProtocolDescriptorPtrTy = ProtocolDescriptorStructTy->getPointerTo(); ProtocolRequirementStructTy = createStructType(*this, "swift.protocol_requirement", { Int32Ty, // flags RelativeAddressTy, // default implementation }); // A tuple type metadata record has a couple extra fields. auto tupleElementTy = createStructType(*this, "swift.tuple_element_type", { TypeMetadataPtrTy, // Metadata *Type; SizeTy // size_t Offset; }); TupleTypeMetadataPtrTy = createStructPointerType(*this, "swift.tuple_type", { TypeMetadataStructTy, // (base) SizeTy, // size_t NumElements; Int8PtrTy, // const char *Labels; llvm::ArrayType::get(tupleElementTy, 0) // Element Elements[]; }); // A full type metadata record is basically just an adjustment to the // address point of a type metadata. Resilience may cause // additional data to be laid out prior to this address point. FullTypeMetadataStructTy = createStructType(*this, "swift.full_type", { WitnessTablePtrTy, TypeMetadataStructTy }); FullTypeMetadataPtrTy = FullTypeMetadataStructTy->getPointerTo(DefaultAS); DeallocatingDtorTy = llvm::FunctionType::get(VoidTy, RefCountedPtrTy, false); llvm::Type *dtorPtrTy = DeallocatingDtorTy->getPointerTo(); // A full heap metadata is basically just an additional small prefix // on a full metadata, used for metadata corresponding to heap // allocations. FullHeapMetadataStructTy = createStructType(*this, "swift.full_heapmetadata", { dtorPtrTy, WitnessTablePtrTy, TypeMetadataStructTy }); FullHeapMetadataPtrTy = FullHeapMetadataStructTy->getPointerTo(DefaultAS); // A full box metadata is non-type heap metadata for a heap allocation of a // single value. The box tracks the offset to the value inside the box. FullBoxMetadataStructTy = createStructType(*this, "swift.full_boxmetadata", { dtorPtrTy, WitnessTablePtrTy, TypeMetadataStructTy, Int32Ty, CaptureDescriptorPtrTy, }); FullBoxMetadataPtrTy = FullBoxMetadataStructTy->getPointerTo(DefaultAS); // This must match struct HeapObject in the runtime. llvm::Type *refCountedElts[] = {TypeMetadataPtrTy, IntPtrTy}; RefCountedStructTy->setBody(refCountedElts); RefCountedStructSize = Size(DataLayout.getStructLayout(RefCountedStructTy)->getSizeInBytes()); PtrSize = Size(DataLayout.getPointerSize(DefaultAS)); FunctionPairTy = createStructType(*this, "swift.function", { FunctionPtrTy, RefCountedPtrTy, }); OpaqueTy = llvm::StructType::create(LLVMContext, "swift.opaque"); OpaquePtrTy = OpaqueTy->getPointerTo(DefaultAS); NoEscapeFunctionPairTy = createStructType(*this, "swift.noescape.function", { FunctionPtrTy, OpaquePtrTy, }); ProtocolRecordTy = createStructType(*this, "swift.protocolref", { RelativeAddressTy }); ProtocolRecordPtrTy = ProtocolRecordTy->getPointerTo(); ProtocolConformanceDescriptorTy = createStructType(*this, "swift.protocol_conformance_descriptor", { RelativeAddressTy, RelativeAddressTy, RelativeAddressTy, Int32Ty }); ProtocolConformanceDescriptorPtrTy = ProtocolConformanceDescriptorTy->getPointerTo(DefaultAS); TypeContextDescriptorTy = llvm::StructType::create(LLVMContext, "swift.type_descriptor"); TypeContextDescriptorPtrTy = TypeContextDescriptorTy->getPointerTo(DefaultAS); ClassContextDescriptorTy = llvm::StructType::get(LLVMContext, { Int32Ty, // context flags Int32Ty, // parent Int32Ty, // name Int32Ty, // kind Int32Ty, // accessor function Int32Ty, // num fields Int32Ty, // field offset vector Int32Ty, // is_reflectable flag Int32Ty, // (Generics Descriptor) argument offset Int32Ty, // (Generics Descriptor) num params Int32Ty, // (Generics Descriptor) num requirements Int32Ty, // (Generics Descriptor) num key arguments Int32Ty, // (Generics Descriptor) num extra arguments Int32Ty, // (VTable Descriptor) offset Int32Ty, // (VTable Descriptor) size Int32Ty, // (Methods Descriptor) accessor Int32Ty, // (Methods Descriptor) flags }, /*packed=*/true); MethodDescriptorStructTy = createStructType(*this, "swift.method_descriptor", { Int32Ty, RelativeAddressTy, }); MethodOverrideDescriptorStructTy = createStructType(*this, "swift.method_override_descriptor", { RelativeAddressTy, RelativeAddressTy, RelativeAddressTy }); TypeMetadataRecordTy = createStructType(*this, "swift.type_metadata_record", { RelativeAddressTy }); TypeMetadataRecordPtrTy = TypeMetadataRecordTy->getPointerTo(DefaultAS); FieldDescriptorTy = llvm::StructType::create(LLVMContext, "swift.field_descriptor"); FieldDescriptorPtrTy = FieldDescriptorTy->getPointerTo(DefaultAS); FieldDescriptorPtrPtrTy = FieldDescriptorPtrTy->getPointerTo(DefaultAS); FixedBufferTy = nullptr; for (unsigned i = 0; i != MaxNumValueWitnesses; ++i) ValueWitnessTys[i] = nullptr; ObjCPtrTy = llvm::StructType::create(getLLVMContext(), "objc_object") ->getPointerTo(DefaultAS); BridgeObjectPtrTy = llvm::StructType::create(getLLVMContext(), "swift.bridge") ->getPointerTo(DefaultAS); ObjCClassStructTy = llvm::StructType::create(LLVMContext, "objc_class"); ObjCClassPtrTy = ObjCClassStructTy->getPointerTo(DefaultAS); llvm::Type *objcClassElts[] = { ObjCClassPtrTy, ObjCClassPtrTy, OpaquePtrTy, OpaquePtrTy, IntPtrTy }; ObjCClassStructTy->setBody(objcClassElts); ObjCSuperStructTy = llvm::StructType::create(LLVMContext, "objc_super"); ObjCSuperPtrTy = ObjCSuperStructTy->getPointerTo(DefaultAS); llvm::Type *objcSuperElts[] = { ObjCPtrTy, ObjCClassPtrTy }; ObjCSuperStructTy->setBody(objcSuperElts); ObjCBlockStructTy = llvm::StructType::create(LLVMContext, "objc_block"); ObjCBlockPtrTy = ObjCBlockStructTy->getPointerTo(DefaultAS); llvm::Type *objcBlockElts[] = { ObjCClassPtrTy, // isa Int32Ty, // flags Int32Ty, // reserved FunctionPtrTy, // invoke function pointer Int8PtrTy, // TODO: block descriptor pointer. // We will probably need a struct type for that at some // point too. }; ObjCBlockStructTy->setBody(objcBlockElts); auto ErrorStructTy = llvm::StructType::create(LLVMContext, "swift.error"); // ErrorStruct is currently opaque to the compiler. ErrorPtrTy = ErrorStructTy->getPointerTo(DefaultAS); llvm::Type *openedErrorTriple[] = { OpaquePtrTy, TypeMetadataPtrTy, WitnessTablePtrTy, }; OpenedErrorTripleTy = llvm::StructType::get(getLLVMContext(), openedErrorTriple, /*packed*/ false); OpenedErrorTriplePtrTy = OpenedErrorTripleTy->getPointerTo(DefaultAS); WitnessTablePtrPtrTy = WitnessTablePtrTy->getPointerTo(DefaultAS); InvariantMetadataID = LLVMContext.getMDKindID("invariant.load"); InvariantNode = llvm::MDNode::get(LLVMContext, {}); DereferenceableID = LLVMContext.getMDKindID("dereferenceable"); C_CC = llvm::CallingConv::C; // TODO: use "tinycc" on platforms that support it DefaultCC = SWIFT_DEFAULT_LLVM_CC; SwiftCC = llvm::CallingConv::Swift; if (opts.DebugInfoLevel > IRGenDebugInfoLevel::None) DebugInfo = IRGenDebugInfo::createIRGenDebugInfo(IRGen.Opts, *CI, *this, Module, MainInputFilenameForDebugInfo); initClangTypeConverter(); if (ClangASTContext) { auto atomicBoolTy = ClangASTContext->getAtomicType(ClangASTContext->BoolTy); AtomicBoolSize = Size(ClangASTContext->getTypeSize(atomicBoolTy)); AtomicBoolAlign = Alignment(ClangASTContext->getTypeSize(atomicBoolTy)); } IsSwiftErrorInRegister = clang::CodeGen::swiftcall::isSwiftErrorLoweredInRegister( ClangCodeGen->CGM()); DynamicReplacementsTy = llvm::StructType::get(getLLVMContext(), {Int8PtrPtrTy, Int8PtrTy}); DynamicReplacementsPtrTy = DynamicReplacementsTy->getPointerTo(DefaultAS); DynamicReplacementLinkEntryTy = llvm::StructType::create(getLLVMContext(), "swift.dyn_repl_link_entry"); DynamicReplacementLinkEntryPtrTy = DynamicReplacementLinkEntryTy->getPointerTo(DefaultAS); llvm::Type *linkEntryFields[] = { Int8PtrTy, // function pointer. DynamicReplacementLinkEntryPtrTy // next. }; DynamicReplacementLinkEntryTy->setBody(linkEntryFields); DynamicReplacementKeyTy = createStructType(*this, "swift.dyn_repl_key", {RelativeAddressTy, Int32Ty}); }
/* * Class: org_OpenNI_Samples_Assistant_NativeMethods * Method: initFromContext * Signature: (JZZ)I */ JNIEXPORT jint JNICALL Java_org_OpenNI_Samples_Assistant_NativeMethods_initFromContext (JNIEnv *env, jclass cls, jlong pContext, jboolean _hasUserGen, jboolean _hasDepthGen, jboolean _hasImageGen, jboolean _hasIrGen) { LOGD("init_start"); hasUserGen = _hasUserGen; hasDepthGen = _hasDepthGen; hasImageGen = _hasImageGen; hasIrGen = _hasIrGen; mContext = new Context((XnContext*) pContext); if (!(hasUserGen || hasDepthGen || hasImageGen || hasIrGen)) { LOGD(" All booleans are false"); return XN_STATUS_BAD_PARAM; } int rc; if (hasUserGen) { rc = mContext->FindExistingNode(XN_NODE_TYPE_USER, mUserGen); if (rc != XN_STATUS_OK) { //TODO log&retval LOGD("No user node exists!"); return 1; } mUserGen.GetUserPixels(0, sceneMD); } if (hasDepthGen) { rc = mContext->FindExistingNode(XN_NODE_TYPE_DEPTH, mDepthGen); if (rc != XN_STATUS_OK) { //TODO log&retval LOGD("No depth node exists! Check your XML."); return 1; } mDepthGen.GetMetaData(depthMD); } if(hasImageGen) { rc = mContext->FindExistingNode(XN_NODE_TYPE_IMAGE,mImageGen); if(rc != XN_STATUS_OK) { LOGD("No image node exists! Check your XML."); return 1; } mImageGen.GetMetaData(imageMD); } if(hasIrGen) { rc = mContext->FindExistingNode(XN_NODE_TYPE_IR,mIrGen); if(rc != XN_STATUS_OK) { LOGD("No IR node exists! Check your XML"); return 1; } LOGD("Ir Node created"); mIrGen.GetMetaData(irMD); } initGraphics(); LOGD("init_end"); return XN_STATUS_OK; }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { mxArray *tmpContext; mxArray *tmpIR, *tmpIRMD; mxArray *tmpDepth, *tmpDepthMD; mxArray *context_initialised_array; mxArray *has_ir_node_array; mxArray *has_depth_node_array; Context* context; IRGenerator* ir; IRMetaData* irMD; DepthGenerator* depth; DepthMetaData* depthMD; unsigned short* output_ir = 0; unsigned short* output_depth = 0; mwSize dims2_ir[2]; mwSize dims2_depth[2]; bool context_initialised = false; bool has_ir_node = false; bool has_depth_node = false; //--------------------------------- // Read input variables //--------------------------------- // ni_context_obj tmpContext = mxGetField(prhs[0], 0, "ni_context_obj"); memcpy((void*)&context, mxGetPr(tmpContext), sizeof(Context*)); // ir_obj tmpIR = mxGetField(prhs[0], 0, "ir_obj"); memcpy((void*)&ir, mxGetPr(tmpIR), sizeof(IRGenerator*)); // irMD_obj tmpIRMD = mxGetField(prhs[0], 0, "irMD_obj"); memcpy((void*)&irMD, mxGetPr(tmpIRMD), sizeof(IRMetaData*)); // depth_obj tmpDepth = mxGetField(prhs[0], 0, "depth_obj"); memcpy((void*)&depth, mxGetPr(tmpDepth), sizeof(DepthGenerator*)); // depthMD_obj tmpDepthMD = mxGetField(prhs[0], 0, "depthMD_obj"); memcpy((void*)&depthMD, mxGetPr(tmpDepthMD), sizeof(DepthMetaData*)); // context_initialised context_initialised_array = mxGetField(prhs[0], 0, "context_initialised"); context_initialised = mxGetScalar(context_initialised_array); // has_ir_node has_ir_node_array = mxGetField(prhs[0], 0, "has_ir_node"); has_ir_node = mxGetScalar(has_ir_node_array); // has_depth_node has_depth_node_array = mxGetField(prhs[0], 0, "has_depth_node"); has_depth_node = mxGetScalar(has_depth_node_array); //------------------------------- // Create output variables //------------------------------- bool initialised = context_initialised; int ir_width = 640; int ir_height = 480; int depth_width = 640; int depth_height = 480; if(initialised){ XnStatus rc; if(has_ir_node){ ir->GetMetaData(*irMD); ir_width = irMD->XRes(); ir_height = irMD->YRes(); } if(has_depth_node){ depth->GetMetaData(*depthMD); depth_width = depthMD->XRes(); depth_height = depthMD->YRes(); } } dims2_ir[0] = ir_height; dims2_ir[1] = ir_width; plhs[0] = mxCreateNumericArray(2, dims2_ir, mxUINT16_CLASS, mxREAL); output_ir = (unsigned short*)mxGetPr(plhs[0]); if(nlhs >= 2){ dims2_depth[0] = depth_height; dims2_depth[1] = depth_width; plhs[1] = mxCreateNumericArray(2, dims2_depth, mxUINT16_CLASS, mxREAL); output_depth = (unsigned short*)mxGetPr(plhs[1]); } if(!initialised) return; if(has_ir_node && output_ir != 0){ const XnIRPixel* pIR = irMD->Data(); int ir_image_size = ir_width*ir_height; for(int i=0;i<ir_height;i++){ for(int j = 0;j < ir_width;j++){ output_ir[j*ir_height+i] = pIR[i*ir_width+j]; } } } if(has_depth_node && output_depth != 0){ const XnDepthPixel* pDepth = depthMD->Data(); int depth_image_size = depth_width*depth_height; for(int i=0;i<depth_height;i++){ for(int j = 0;j < depth_width;j++){ output_depth[j*depth_height+i] = pDepth[i*depth_width+j]; } } } }