示例#1
0
文件: u_debug.c 项目: anupamkaul/mesa
void _debug_assert_fail(const char *expr, 
                        const char *file, 
                        unsigned line, 
                        const char *function) 
{
   _debug_printf("%s:%u:%s: Assertion `%s' failed.\n", file, line, function, expr);
   if (debug_get_bool_option("GALLIUM_ABORT_ON_ASSERT", TRUE))
      os_abort();
   else
      _debug_printf("continuing...\n");
}
示例#2
0
void
_nine_debug_printf( unsigned long flag,
                    const char *func,
                    const char *fmt,
                    ... )
{
    static boolean first = TRUE;
    static unsigned long dbg_flags = DBG_ERROR | DBG_WARN;
    unsigned long tid = 0;

    if (first) {
        first = FALSE;
        dbg_flags |= debug_get_flags_option("NINE_DEBUG", nine_debug_flags, 0);
    }

#if defined(HAVE_PTHREAD)
#  if defined(__GNU_LIBRARY__) && defined(__GLIBC__) && defined(__GLIBC_MINOR__) && \
      (__GLIBC__ >= 3 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 12))
    if (dbg_flags & DBG_TID)
        tid = pthread_self();
#  endif
#endif

    if (dbg_flags & flag) {
        const char *f = func ? strrchr(func, '_') : NULL;
        va_list ap;
        /* inside a class this will print nine:tid:classinlowercase:func: while
         * outside a class (rarely used) it will just print nine:tid:func
         * the reason for lower case is simply to match the filenames, as it
         * will also strip off the "Nine" */
        if (f && strncmp(func, "Nine", 4) == 0) {
            char klass[96]; /* no class name is this long */
            char *ptr = klass;
            for (func += 4; func != f; ++func) { *ptr++ = tolower(*func); }
            *ptr = '\0';
            if (tid)
                _debug_printf("nine:0x%08lx:%s:%s: ", tid, klass, ++f);
            else
                _debug_printf("nine:%s:%s: ", klass, ++f);
        } else if (func) {
            if (tid)
                _debug_printf("nine:0x%08lx:%s ", tid, func);
            else
                _debug_printf("nine:%s ", func);
        }

        va_start(ap, fmt);
        _debug_vprintf(fmt, ap);
        va_end(ap);
    }
}
示例#3
0
void _debug_assert_fail(const char *expr, 
                        const char *file, 
                        unsigned line, 
                        const char *function) 
{
   _debug_printf("%s:%u:%s: Assertion `%s' failed.\n", file, line, function, expr);
#if defined(PIPE_OS_WINDOWS) && !defined(PIPE_SUBSYSTEM_WINDOWS_USER)
   if (debug_get_bool_option("GALLIUM_ABORT_ON_ASSERT", FALSE))
#else
   if (debug_get_bool_option("GALLIUM_ABORT_ON_ASSERT", TRUE))
#endif
      os_abort();
   else
      _debug_printf("continuing...\n");
}
示例#4
0
const struct sh_opcode_info *svga_opcode_info( uint op )
{
   struct sh_opcode_info *info;

   if (op >= sizeof( opcode_info ) / sizeof( opcode_info[0] )) {
      /* The opcode is either PHASE, COMMENT, END or out of range.
       */
      assert( 0 );
      return NULL;
   }

   info = &opcode_info[op];

   if (info->svga_opcode == SVGA3DOP_INVALID) {
      /* No valid information. Please provide number of dst/src registers.
       */
      _debug_printf("Missing information for opcode %u, '%s'\n", op,
                    opcode_info[op].mnemonic);
      assert( 0 );
      return NULL;
   }

   /* Sanity check.
    */
   assert( op == info->svga_opcode );

   return info;
}
示例#5
0
static LLVMValueRef
emit_tex(struct lp_build_tgsi_aos_context *bld,
         const struct tgsi_full_instruction *inst,
         enum lp_build_tex_modifier modifier)
{
   unsigned target;
   unsigned unit;
   LLVMValueRef coords;
   struct lp_derivatives derivs = { {NULL}, {NULL} };

   if (!bld->sampler) {
      _debug_printf("warning: found texture instruction but no sampler generator supplied\n");
      return bld->bld_base.base.undef;
   }

   target = inst->Texture.Texture;

   coords = lp_build_emit_fetch( &bld->bld_base, inst, 0 , LP_CHAN_ALL);

   if (modifier == LP_BLD_TEX_MODIFIER_EXPLICIT_DERIV) {
      /* probably not going to work */
      derivs.ddx[0] = lp_build_emit_fetch( &bld->bld_base, inst, 1 , LP_CHAN_ALL);
      derivs.ddy[0] = lp_build_emit_fetch( &bld->bld_base, inst, 2 , LP_CHAN_ALL);
      unit = inst->Src[3].Register.Index;
   }
   else {
      unit = inst->Src[1].Register.Index;
   }
   return bld->sampler->emit_fetch_texel(bld->sampler,
                                         &bld->bld_base.base,
                                         target, unit,
                                         coords, derivs,
                                         modifier);
}
示例#6
0
void radio_end_listen(void)
{
  /* Stop the radio task */
  radio_shutdown(0);

  _debug_printf("XCVR should shutdown%s", "");
}
示例#7
0
static int
nouveau_codegen(int chipset, int type, struct tgsi_token tokens[],
                unsigned *size, unsigned **code) {
   struct nv50_ir_prog_info info = {0};
   int ret;

   info.type = type;
   info.target = chipset;
   info.bin.sourceRep = NV50_PROGRAM_IR_TGSI;
   info.bin.source = tokens;

   info.io.ucpCBSlot = 15;
   info.io.ucpBase = NV50_CB_AUX_UCP_OFFSET;

   info.io.resInfoCBSlot = 15;
   info.io.suInfoBase = NV50_CB_AUX_TEX_MS_OFFSET;
   info.io.msInfoCBSlot = 15;
   info.io.msInfoBase = NV50_CB_AUX_MS_OFFSET;

   info.assignSlots = dummy_assign_slots;

   info.optLevel = debug_get_num_option("NV50_PROG_OPTIMIZE", 3);
   info.dbgFlags = debug_get_num_option("NV50_PROG_DEBUG", 0);

   ret = nv50_ir_generate_code(&info);
   if (ret) {
      _debug_printf("Error compiling program: %d\n", ret);
      return ret;
   }

   *size = info.bin.codeSize;
   *code = info.bin.code;
   return 0;
}
示例#8
0
static LLVMValueRef
emit_sample(struct lp_build_tgsi_aos_context *bld,
            const struct tgsi_full_instruction *inst,
            enum lp_build_tex_modifier modifier)
{
   unsigned target;
   unsigned unit;
   LLVMValueRef coords;
   struct lp_derivatives derivs = { {NULL}, {NULL} };

   if (!bld->sampler) {
      _debug_printf("warning: found texture instruction but no sampler generator supplied\n");
      return bld->bld_base.base.undef;
   }

   coords = lp_build_emit_fetch( &bld->bld_base, inst, 0 , LP_CHAN_ALL);

   /* ignore modifiers, can't handle different sampler / sampler view, etc... */
   unit = inst->Src[1].Register.Index;
   assert(inst->Src[2].Register.Index == unit);

   target = bld->sv[unit].Resource;

   return bld->sampler->emit_fetch_texel(bld->sampler,
                                         &bld->bld_base.base,
                                         target, unit,
                                         coords, derivs,
                                         modifier);
}
示例#9
0
void _debug_assert_fail(const char *expr, 
                        const char *file, 
                        unsigned line, 
                        const char *function) 
{
   _debug_printf("%s:%u:%s: Assertion `%s' failed.\n", file, line, function, expr);
   os_abort();
}
示例#10
0
static void blitter_unset_running_flag(struct blitter_context_priv *ctx)
{
   if (!ctx->base.running) {
      _debug_printf("u_blitter:%i: Caught recursion. This is a driver bug.\n",
                    __LINE__);
   }
   ctx->base.running = FALSE;
}
static void
format_reg(const char *name,
           const struct sh_reg reg,
           const struct sh_srcreg *indreg)
{
   if (reg.relative) {
      assert(indreg);

      if (sh_srcreg_type(*indreg) == SVGA3DREG_LOOP) {
         _debug_printf("%s[aL+%u]", name, reg.number);
      } else {
         _debug_printf("%s[a%u.x+%u]", name, indreg->number, reg.number);
      }
   } else {
      _debug_printf("%s%u", name, reg.number);
   }
}
示例#12
0
void
_nine_stub( const char *file,
            const char *func,
            unsigned line )
{
    const char *r = strrchr(file, '/');
    if (r == NULL) { r = strrchr(file, '\\'); }
    _debug_printf("nine:%s:%d: %s STUB!\n", r ? ++r : file, line, func);
}
static void
dump_indent(int indent)
{
   int i;

   for (i = 0; i < indent; ++i) {
      _debug_printf("  ");
   }
}
示例#14
0
uint64_t
debug_get_flags_option(const char *name,
                       const struct debug_named_value *flags,
                       uint64_t dfault)
{
   uint64_t result;
   const char *str;
   const struct debug_named_value *orig = flags;
   unsigned namealign = 0;

   str = os_get_option(name);
   if (!str)
      result = dfault;
   else if (!util_strcmp(str, "help")) {
      result = dfault;
      _debug_printf("%s: help for %s:\n", __FUNCTION__, name);
      for (; flags->name; ++flags)
         namealign = MAX2(namealign, strlen(flags->name));
      for (flags = orig; flags->name; ++flags)
         _debug_printf("| %*s [0x%0*"PRIx64"]%s%s\n", namealign, flags->name,
                      (int)sizeof(uint64_t)*CHAR_BIT/4, flags->value,
                      flags->desc ? " " : "", flags->desc ? flags->desc : "");
   }
   else {
      result = 0;
      while (flags->name) {
	 if (str_has_option(str, flags->name))
	    result |= flags->value;
	 ++flags;
      }
   }

   if (debug_get_option_should_print()) {
      if (str) {
         debug_printf("%s: %s = 0x%"PRIx64" (%s)\n",
                      __FUNCTION__, name, result, str);
      } else {
         debug_printf("%s: %s = 0x%"PRIx64"\n", __FUNCTION__, name, result);
      }
   }

   return result;
}
static void
dump_sampleinfo(struct sh_sampleinfo sampleinfo)
{
   assert( sampleinfo.is_reg == 1 );

   switch (sampleinfo.texture_type) {
   case SVGA3DSAMP_2D:
      _debug_printf( "_2d" );
      break;
   case SVGA3DSAMP_CUBE:
      _debug_printf( "_cube" );
      break;
   case SVGA3DSAMP_VOLUME:
      _debug_printf( "_volume" );
      break;
   default:
      assert( 0 );
   }
}
示例#16
0
static int
nv30_codegen(int chipset, int type, struct tgsi_token tokens[],
             unsigned *size, unsigned **code) {
   switch (type) {
      case PIPE_SHADER_FRAGMENT:
         return nv30_fp(chipset, tokens, size, code);
      case PIPE_SHADER_VERTEX:
         return nv30_vp(chipset, tokens, size, code);
   }
   _debug_printf("Unexpected shader type: %d\n", type);
   return 1;
}
示例#17
0
void
raw_debug_ostream::write_impl(const char *Ptr, size_t Size)
{
   if (Size > 0) {
      char *lastPtr = (char *)&Ptr[Size];
      char last = *lastPtr;
      *lastPtr = 0;
      _debug_printf("%*s", Size, Ptr);
      *lastPtr = last;
      pos += Size;
   }
}
示例#18
0
LLVMValueRef
lp_build_intrinsic(LLVMBuilderRef builder,
                   const char *name,
                   LLVMTypeRef ret_type,
                   LLVMValueRef *args,
                   unsigned num_args,
                   unsigned attr_mask)
{
   LLVMModuleRef module = LLVMGetGlobalParent(LLVMGetBasicBlockParent(LLVMGetInsertBlock(builder)));
   LLVMValueRef function, call;
   bool set_callsite_attrs = HAVE_LLVM >= 0x0400 &&
                             !(attr_mask & LP_FUNC_ATTR_LEGACY);

   function = LLVMGetNamedFunction(module, name);
   if(!function) {
      LLVMTypeRef arg_types[LP_MAX_FUNC_ARGS];
      unsigned i;

      assert(num_args <= LP_MAX_FUNC_ARGS);

      for(i = 0; i < num_args; ++i) {
         assert(args[i]);
         arg_types[i] = LLVMTypeOf(args[i]);
      }

      function = lp_declare_intrinsic(module, name, ret_type, arg_types, num_args);

      /*
       * If llvm removes an intrinsic we use, we'll hit this abort (rather
       * than a call to address zero in the jited code).
       */
      if (LLVMGetIntrinsicID(function) == 0) {
         _debug_printf("llvm (version 0x%x) found no intrinsic for %s, going to crash...\n",
                HAVE_LLVM, name);
         abort();
      }

      if (!set_callsite_attrs)
         lp_add_func_attributes(function, attr_mask);

      if (gallivm_debug & GALLIVM_DEBUG_IR) {
         lp_debug_dump_value(function);
      }
   }

   call = LLVMBuildCall(builder, function, args, num_args, "");
   if (set_callsite_attrs)
      lp_add_func_attributes(call, attr_mask);
   return call;
}
示例#19
0
static LLVMAttribute lp_attr_to_llvm_attr(enum lp_func_attr attr)
{
   switch (attr) {
   case LP_FUNC_ATTR_ALWAYSINLINE: return LLVMAlwaysInlineAttribute;
   case LP_FUNC_ATTR_INREG: return LLVMInRegAttribute;
   case LP_FUNC_ATTR_NOALIAS: return LLVMNoAliasAttribute;
   case LP_FUNC_ATTR_NOUNWIND: return LLVMNoUnwindAttribute;
   case LP_FUNC_ATTR_READNONE: return LLVMReadNoneAttribute;
   case LP_FUNC_ATTR_READONLY: return LLVMReadOnlyAttribute;
   default:
      _debug_printf("Unhandled function attribute: %x\n", attr);
      return 0;
   }
}
static void
dump_inst(struct dump_info *di,
          const unsigned **assem,
          struct sh_op op,
          const struct sh_opcode_info *info)
{
   struct dump_op dop;
   boolean not_first_arg = FALSE;
   uint i;

   assert(info->num_dst <= 1);

   di->indent -= info->pre_dedent;
   dump_indent(di->indent);
   di->indent += info->post_indent;

   dump_op(op, info->mnemonic);

   parse_op(di, assem, &dop, info->num_dst, info->num_src);
   if (info->num_dst > 0) {
      dump_dstreg(dop.dst, &dop.dstind, di);
      not_first_arg = TRUE;
   }

   for (i = 0; i < info->num_src; i++) {
      if (not_first_arg) {
         _debug_printf(", ");
      } else {
         _debug_printf(" ");
      }
      dump_srcreg(dop.src[i], &dop.srcind[i], di);
      not_first_arg = TRUE;
   }

   _debug_printf("\n");
}
示例#21
0
static const char *attr_to_str(enum lp_func_attr attr)
{
   switch (attr) {
   case LP_FUNC_ATTR_ALWAYSINLINE: return "alwaysinline";
   case LP_FUNC_ATTR_INREG: return "inreg";
   case LP_FUNC_ATTR_NOALIAS: return "noalias";
   case LP_FUNC_ATTR_NOUNWIND: return "nounwind";
   case LP_FUNC_ATTR_READNONE: return "readnone";
   case LP_FUNC_ATTR_READONLY: return "readonly";
   case LP_FUNC_ATTR_WRITEONLY: return "writeonly";
   case LP_FUNC_ATTR_INACCESSIBLE_MEM_ONLY: return "inaccessiblememonly";
   case LP_FUNC_ATTR_CONVERGENT: return "convergent";
   default:
      _debug_printf("Unhandled function attribute: %x\n", attr);
      return 0;
   }
}
static LLVMValueRef
emit_tex(struct lp_build_tgsi_aos_context *bld,
         const struct tgsi_full_instruction *inst,
         enum lp_build_tex_modifier modifier)
{
   unsigned target;
   unsigned unit;
   LLVMValueRef coords;
   LLVMValueRef ddx;
   LLVMValueRef ddy;

   if (!bld->sampler) {
      _debug_printf("warning: found texture instruction but no sampler generator supplied\n");
      return bld->base.undef;
   }

   target = inst->Texture.Texture;

   coords = emit_fetch( bld, inst, 0 );

   if (modifier == LP_BLD_TEX_MODIFIER_EXPLICIT_DERIV) {
      ddx = emit_fetch( bld, inst, 1 );
      ddy = emit_fetch( bld, inst, 2 );
      unit = inst->Src[3].Register.Index;
   }  else {
#if 0
      ddx = lp_build_ddx( &bld->base, coords );
      ddy = lp_build_ddy( &bld->base, coords );
#else
      /* TODO */
      ddx = bld->base.one;
      ddy = bld->base.one;
#endif
      unit = inst->Src[1].Register.Index;
   }

   return bld->sampler->emit_fetch_texel(bld->sampler,
                                         &bld->base,
                                         target, unit,
                                         coords, ddx, ddy,
                                         modifier);
}
示例#23
0
/**
*	Convert the TGSI assembly to a runnable shader.
*
* We need not care about geometry shaders. All we have is screen quads.
*/
void *
pp_tgsi_to_state(struct pipe_context *pipe, const char *text, bool isvs,
                 const char *name)
{
   struct pipe_shader_state state;
   struct tgsi_token *tokens = NULL;
   void *ret_state = NULL;
 
   /*
    * Allocate temporary token storage. State creation will duplicate
    * tokens so we must free them on exit.
    */ 
   tokens = tgsi_alloc_tokens(PP_MAX_TOKENS);

   if (!tokens) {
      pp_debug("Failed to allocate temporary token storage.\n");
      return NULL;
   }

   if (tgsi_text_translate(text, tokens, PP_MAX_TOKENS) == FALSE) {
      _debug_printf("pp: Failed to translate a shader for %s\n", name);
      return NULL;
   }

   state.tokens = tokens;
   memset(&state.stream_output, 0, sizeof(state.stream_output));

   if (isvs) {
      ret_state = pipe->create_vs_state(pipe, &state);
      FREE(tokens);
   } else {
      ret_state = pipe->create_fs_state(pipe, &state);
      FREE(tokens);
   }

   return ret_state;
}
示例#24
0
uint16_t radio_middle_listen(volatile radio_packet_t * data, uint16_t us_listen_duration)
{
  if (!data || !us_listen_duration)
  {
    return 0;
  }

  /* Clear packet RX'd */
  RadioPtr->EVENTS_END = 0U;   /* clr END (packet received) flag */

  /* Break listen time into LISTEN_QUANTA quanta */
  uint32_t wait_time = us_listen_duration / LISTEN_QUANTA;

  /* Start Listening */
  RadioPtr->TASKS_START = 1U;
  while (wait_time-- && (RadioPtr->EVENTS_END == 0U))
  {
    nrf_delay_us(LISTEN_QUANTA);
  }

  /* If no packet was received the whole duration */
  if (RadioPtr->EVENTS_END == 0U)
  {
    _debug_printf("No packet received.%s", "");
    return 0;
  }

  /*
   * By here, we know we got a packet
   */
  data->pipe = RadioPtr->RXMATCH;
  data->rssi = RadioPtr->RSSISAMPLE * -1;

  /* Return the amount of time left to listen */
  return wait_time * LISTEN_QUANTA;
}
示例#25
0
/**
 * Allocate gallivm LLVM objects.
 * \return  TRUE for success, FALSE for failure
 */
static boolean
init_gallivm_state(struct gallivm_state *gallivm)
{
   assert(!gallivm->context);
   assert(!gallivm->module);
   assert(!gallivm->provider);

   lp_build_init();

   gallivm->context = LLVMContextCreate();
   if (!gallivm->context)
      goto fail;

   gallivm->module = LLVMModuleCreateWithNameInContext("gallivm",
                                                       gallivm->context);
   if (!gallivm->module)
      goto fail;

   gallivm->provider =
      LLVMCreateModuleProviderForExistingModule(gallivm->module);
   if (!gallivm->provider)
      goto fail;

   if (!GlobalEngine) {
      /* We can only create one LLVMExecutionEngine (w/ LLVM 2.6 anyway) */
      enum LLVM_CodeGenOpt_Level optlevel;
      char *error = NULL;

      if (gallivm_debug & GALLIVM_DEBUG_NO_OPT) {
         optlevel = None;
      }
      else {
         optlevel = Default;
      }

      if (LLVMCreateJITCompiler(&GlobalEngine, gallivm->provider,
                                (unsigned) optlevel, &error)) {
         _debug_printf("%s\n", error);
         LLVMDisposeMessage(error);
         goto fail;
      }

#if defined(DEBUG) || defined(PROFILE)
      lp_register_oprofile_jit_event_listener(GlobalEngine);
#endif
   }

   gallivm->engine = GlobalEngine;

   LLVMAddModuleProvider(gallivm->engine, gallivm->provider);//new

   gallivm->target = LLVMGetExecutionEngineTargetData(gallivm->engine);
   if (!gallivm->target)
      goto fail;

   if (!create_pass_manager(gallivm))
      goto fail;

   gallivm->builder = LLVMCreateBuilderInContext(gallivm->context);
   if (!gallivm->builder)
      goto fail;

   return TRUE;

fail:
   free_gallivm_state(gallivm);
   return FALSE;
}
void
lp_build_tgsi_aos(struct gallivm_state *gallivm,
                  const struct tgsi_token *tokens,
                  struct lp_type type,
                  const unsigned char swizzles[4],
                  LLVMValueRef consts_ptr,
                  const LLVMValueRef *inputs,
                  LLVMValueRef *outputs,
                  struct lp_build_sampler_aos *sampler,
                  const struct tgsi_shader_info *info)
{
   struct lp_build_tgsi_aos_context bld;
   struct tgsi_parse_context parse;
   uint num_immediates = 0;
   unsigned chan;
   int pc = 0;

   /* Setup build context */
   memset(&bld, 0, sizeof bld);
   lp_build_context_init(&bld.bld_base.base, gallivm, type);
   lp_build_context_init(&bld.bld_base.uint_bld, gallivm, lp_uint_type(type));
   lp_build_context_init(&bld.bld_base.int_bld, gallivm, lp_int_type(type));
   lp_build_context_init(&bld.int_bld, gallivm, lp_int_type(type));

   for (chan = 0; chan < 4; ++chan) {
      bld.swizzles[chan] = swizzles[chan];
      bld.inv_swizzles[swizzles[chan]] = chan;
   }

   bld.inputs = inputs;
   bld.outputs = outputs;
   bld.consts_ptr = consts_ptr;
   bld.sampler = sampler;
   bld.indirect_files = info->indirect_files;
   bld.bld_base.emit_swizzle = swizzle_aos;
   bld.bld_base.info = info;

   bld.bld_base.emit_fetch_funcs[TGSI_FILE_CONSTANT] = emit_fetch_constant;
   bld.bld_base.emit_fetch_funcs[TGSI_FILE_IMMEDIATE] = emit_fetch_immediate;
   bld.bld_base.emit_fetch_funcs[TGSI_FILE_INPUT] = emit_fetch_input;
   bld.bld_base.emit_fetch_funcs[TGSI_FILE_TEMPORARY] = emit_fetch_temporary;

   /* Set opcode actions */
   lp_set_default_actions_cpu(&bld.bld_base);

   if (!lp_bld_tgsi_list_init(&bld.bld_base)) {
      return;
   }

   tgsi_parse_init(&parse, tokens);

   while (!tgsi_parse_end_of_tokens(&parse)) {
      tgsi_parse_token(&parse);

      switch(parse.FullToken.Token.Type) {
      case TGSI_TOKEN_TYPE_DECLARATION:
         /* Inputs already interpolated */
         lp_emit_declaration_aos(&bld, &parse.FullToken.FullDeclaration);
         break;

      case TGSI_TOKEN_TYPE_INSTRUCTION:
         /* save expanded instruction */
         lp_bld_tgsi_add_instruction(&bld.bld_base,
                                     &parse.FullToken.FullInstruction);
         break;

      case TGSI_TOKEN_TYPE_IMMEDIATE:
         /* simply copy the immediate values into the next immediates[] slot */
         {
            const uint size = parse.FullToken.FullImmediate.Immediate.NrTokens - 1;
            float imm[4];
            assert(size <= 4);
            assert(num_immediates < LP_MAX_TGSI_IMMEDIATES);
            for (chan = 0; chan < 4; ++chan) {
               imm[chan] = 0.0f;
            }
            for (chan = 0; chan < size; ++chan) {
               unsigned swizzle = bld.swizzles[chan];
               imm[swizzle] = parse.FullToken.FullImmediate.u[chan].Float;
            }
            bld.immediates[num_immediates] =
                     lp_build_const_aos(gallivm, type,
                                        imm[0], imm[1], imm[2], imm[3],
                                        NULL);
            num_immediates++;
         }
         break;

      case TGSI_TOKEN_TYPE_PROPERTY:
         break;

      default:
         assert(0);
      }
   }

   while (pc != -1) {
      struct tgsi_full_instruction *instr = bld.bld_base.instructions + pc;
      const struct tgsi_opcode_info *opcode_info =
         tgsi_get_opcode_info(instr->Instruction.Opcode);
      if (!lp_emit_instruction_aos(&bld, instr, opcode_info, &pc))
         _debug_printf("warning: failed to translate tgsi opcode %s to LLVM\n",
                       opcode_info->mnemonic);
   }

   if (0) {
      LLVMBasicBlockRef block = LLVMGetInsertBlock(gallivm->builder);
      LLVMValueRef function = LLVMGetBasicBlockParent(block);
      debug_printf("11111111111111111111111111111 \n");
      tgsi_dump(tokens, 0);
      lp_debug_dump_value(function);
      debug_printf("2222222222222222222222222222 \n");
   }
   tgsi_parse_free(&parse);
   FREE(bld.bld_base.instructions);

   if (0) {
      LLVMModuleRef module = LLVMGetGlobalParent(
         LLVMGetBasicBlockParent(LLVMGetInsertBlock(gallivm->builder)));
      LLVMDumpModule(module);
   }

}
示例#27
0
void radio_start_listen(volatile radio_packet_t * data, uint8_t is_manufacturing_mode)
{

  if (!data)
  {
    _debug_printf("NULL data pointer%s", "");
    return;
  }

  /* Set up the radio */
  radio_init();

  /* Set the pipe to some value that could never happen */
  data->pipe = RADIO_PIPE_NONE;

  /* Turn off the RADIO Task */
  radio_shutdown(0);

  /* Set the packet source pointer */
  RadioPtr->PACKETPTR = (uint32_t)data->payload;

  /* Set up the RADIO parameters */
  RadioPtr->PCNF1 =
            /* Disable data whitening agent */
            (RADIO_PCNF1_WHITEEN_Disabled << RADIO_PCNF1_WHITEEN_Pos) |
            /* Set endianness to BIG */
            (RADIO_PCNF1_ENDIAN_Big << RADIO_PCNF1_ENDIAN_Pos) |
            /* Set 'base' address length */
            ((ADDRESS_LENGTH - 1) << RADIO_PCNF1_BALEN_Pos) |

            /* Set expected packet length  */
            (data->payloadLength << RADIO_PCNF1_STATLEN_Pos) |

            /* Set the maximum length to the actual max packet size */
            (MAX_PACKET_SIZE << RADIO_PCNF1_MAXLEN_Pos);

  /* Set the listen addresses */
  if (is_manufacturing_mode)
  {
    RadioPtr->PREFIX0 = radio_convert_byte('S') << 24 |  /* 4. Manufacture secrets */
                        radio_convert_byte('M') << 16;   /* 3. Manufacture uuid? */
    RadioPtr->RXADDRESSES = 0x0C;
  }
  else
  {
    RadioPtr->PREFIX0 = radio_convert_byte('R') << 8 |
                        radio_convert_byte('K');
    RadioPtr->RXADDRESSES = 0x03;
  }

  /* Set address bases */
  RadioPtr->BASE0 = radio_convert_bytes("KIWI");  /* Beacon pipe */
  RadioPtr->BASE1 = radio_convert_bytes("RNKI");  /* Random pipe */

  /* Clear the event ready task flag */
  RadioPtr->EVENTS_READY = 0U;

  /* Tell the radio that the task is now receiving */
  RadioPtr->TASKS_RXEN = 1U;

  /* Wait for radio to ramp up */
  wait_for_val_ne(&RadioPtr->EVENTS_READY);

  _debug_printf("XCVR Turned on in RX mode%s", "");
}
示例#28
0
/*
 * Transmit a packet
 * * to the specified address
 * * the specified number of times
 * * and wait a certain amount of microseconds between each packet.
 */
void radio_send_packet(volatile radio_packet_t * data, char * address, uint8_t count, uint8_t us_wait_after)
{

  if (!count || !data || !address)
  {
    return;
  }

  /* Turn off the RADIO Task */
  RadioPtr->TASKS_DISABLE = 1U;

  /* Block until the radio is off */
  wait_for_val_ne(&RadioPtr->EVENTS_DISABLED);

  /* Set the packet source pointer */
  RadioPtr->PACKETPTR = (uint32_t)data->payload;
  /* Set up the RADIO parameters */
  RadioPtr->PCNF1 =
            /* Disable data whitening agent */
            (RADIO_PCNF1_WHITEEN_Disabled << RADIO_PCNF1_WHITEEN_Pos) |
            /* Set endianness to BIG */
            (RADIO_PCNF1_ENDIAN_Big << RADIO_PCNF1_ENDIAN_Pos) |
            /* Set 'base' address length */
            ((ADDRESS_LENGTH - 1) << RADIO_PCNF1_BALEN_Pos) |
            /* Set packet length */
            ((data->payloadLength) << RADIO_PCNF1_STATLEN_Pos) |
            /* Set the maximum length to zero (ignore) */
            (MAX_PACKET_SIZE << RADIO_PCNF1_MAXLEN_Pos);

  /* Clear the SHORTS register */
  RadioPtr->SHORTS = 0b00000000;

  /* Calculate the proper addresses */
  RadioPtr->PREFIX0 = (uint32_t)radio_convert_byte(address[0]);
  RadioPtr->BASE0 = radio_convert_bytes(address);

  _debug_printf("Sending packet to address %s 0x%02x%08x",
      address,
      RadioPtr->PREFIX0,
      RadioPtr->BASE0);

  /* Tell the RADIO to use the above address */
  RadioPtr->TXADDRESS = 0;

  /* Clear event ready */
  RadioPtr->EVENTS_READY = 0U;

  /* Enable the TX Task */
  RadioPtr->TASKS_TXEN = 1U;

  /* Block until Radio is powered up */
  wait_for_val_ne(&RadioPtr->EVENTS_READY);

  while (count--)
  {
    /* Clear event flag */
    RadioPtr->EVENTS_END = 0U;

    /* Start the task */
    RadioPtr->TASKS_START = 1U;

    /* Reset the hold-down timer */
    uint8_t hold_down_timer = 255;

    /* Block until sent */
    while (!RadioPtr->EVENTS_END && hold_down_timer--);

    /* Wait the packet spacing */
    nrf_delay_us(us_wait_after);
  }

  /* Stop Radio Task */
  radio_shutdown(0);
}
/**
 * Similar to sp_get_cached_tile() but for textures.
 * Tiles are read-only and indexed with more params.
 */
const struct softpipe_tex_cached_tile *
sp_find_cached_tile_tex(struct softpipe_tex_tile_cache *tc, 
                        union tex_tile_address addr )
{
   struct softpipe_tex_cached_tile *tile;
   
   tile = tc->entries + tex_cache_pos( addr );

   if (addr.value != tile->addr.value) {

      /* cache miss.  Most misses are because we've invaldiated the
       * texture cache previously -- most commonly on binding a new
       * texture.  Currently we effectively flush the cache on texture
       * bind.
       */
#if 0
      _debug_printf("miss at %u:  x=%d y=%d z=%d face=%d level=%d\n"
                    "   tile %u:  x=%d y=%d z=%d face=%d level=%d\n",
                    pos, x/TILE_SIZE, y/TILE_SIZE, z, face, level,
                    pos, tile->addr.bits.x, tile->addr.bits.y, tile->z, tile->face, tile->level);
#endif

      /* check if we need to get a new transfer */
      if (!tc->tex_trans ||
          tc->tex_face != addr.bits.face ||
          tc->tex_level != addr.bits.level ||
          tc->tex_z != addr.bits.z) {
         /* get new transfer (view into texture) */

         if (tc->tex_trans) {
            if (tc->tex_trans_map) {
               tc->pipe->transfer_unmap(tc->pipe, tc->tex_trans);
               tc->tex_trans_map = NULL;
            }

            tc->pipe->transfer_destroy(tc->pipe, tc->tex_trans);
            tc->tex_trans = NULL;
         }

         tc->tex_trans = 
            pipe_get_transfer(tc->pipe, tc->texture,
                              addr.bits.level,
                              addr.bits.face + addr.bits.z,
                              PIPE_TRANSFER_READ | PIPE_TRANSFER_UNSYNCHRONIZED,
                              0, 0,
                              u_minify(tc->texture->width0, addr.bits.level),
                              u_minify(tc->texture->height0, addr.bits.level));

         tc->tex_trans_map = tc->pipe->transfer_map(tc->pipe, tc->tex_trans);

         tc->tex_face = addr.bits.face;
         tc->tex_level = addr.bits.level;
         tc->tex_z = addr.bits.z;
      }

      /* get tile from the transfer (view into texture) */
      pipe_get_tile_swizzle(tc->pipe,
			    tc->tex_trans,
                            addr.bits.x * TILE_SIZE, 
                            addr.bits.y * TILE_SIZE,
                            TILE_SIZE,
                            TILE_SIZE,
                            tc->swizzle_r,
                            tc->swizzle_g,
                            tc->swizzle_b,
                            tc->swizzle_a,
                            tc->format,
                            (float *) tile->data.color);
      tile->addr = addr;
   }

   tc->last_tile = tile;
   return tile;
}
static boolean
init_gallivm_engine(struct gallivm_state *gallivm)
{
   if (1) {
      /* We can only create one LLVMExecutionEngine (w/ LLVM 2.6 anyway) */
      enum LLVM_CodeGenOpt_Level optlevel;
      char *error = NULL;
      int ret;

      if (gallivm_debug & GALLIVM_DEBUG_NO_OPT) {
         optlevel = None;
      }
      else {
         optlevel = Default;
      }

#if USE_MCJIT
      ret = lp_build_create_mcjit_compiler_for_module(&gallivm->engine,
                                                      gallivm->module,
                                                      (unsigned) optlevel,
                                                      &error);
#else
      ret = LLVMCreateJITCompiler(&gallivm->engine, gallivm->provider,
                                  (unsigned) optlevel, &error);
#endif
      if (ret) {
         _debug_printf("%s\n", error);
         LLVMDisposeMessage(error);
         goto fail;
      }

#if defined(DEBUG) || defined(PROFILE)
      lp_register_oprofile_jit_event_listener(gallivm->engine);
#endif
   }

   LLVMAddModuleProvider(gallivm->engine, gallivm->provider);//new

#if !USE_MCJIT
   gallivm->target = LLVMGetExecutionEngineTargetData(gallivm->engine);
   if (!gallivm->target)
      goto fail;
#else
   if (0) {
       /*
        * Dump the data layout strings.
        */

       LLVMTargetDataRef target = LLVMGetExecutionEngineTargetData(gallivm->engine);
       char *data_layout;
       char *engine_data_layout;

       data_layout = LLVMCopyStringRepOfTargetData(gallivm->target);
       engine_data_layout = LLVMCopyStringRepOfTargetData(target);

       if (1) {
          debug_printf("module target data = %s\n", data_layout);
          debug_printf("engine target data = %s\n", engine_data_layout);
       }

       free(data_layout);
       free(engine_data_layout);
   }
#endif

   return TRUE;

fail:
   return FALSE;
}