sigrid/tinycc

 int main(int argc, char **argv)
 {
-    char l[1000], l2[1000], *p, *q, *p0;
+    char l[1000], l2[1000], *p, *q, *qe, *p0;
     FILE *fp, *op;
-    int c, e, f, s, cmt, cmt_n;
+    int c, e, f, s, cmt, cmt_n, n;
     const char *r;
     if (argc < 3)
         }
         /* count & skip leading spaces */
-        p = l, q = l2, f = 0;
+        p = l, q = l2, qe = l2+sizeof(l2), f = 0;
         while (*p && isspc(*p))
             ++p, ++f;
                     //e = memcmp(p, "defined ", 8) ? 0 : 8;
                     if (0 == memcmp(p + e, r, c)) {
                         p += e + c;
-                        q = strchr(strcpy(q, platform_macros[f + 1]), 0);
+                        n = qe - q;
+                        if (snprintf(q, n, "%s", platform_macros[f + 1]) >= n) {
+                            fprintf(stderr, "string too big\n");
+                            return 1;
+                        }
+                        q = strchr(q, 0);
                         break;
                     }

 		next();
             }
             if (n)
-                sprintf(sname, "%s%d", get_tok_str(tok1, NULL), n);
+                snprintf(sname, sizeof(sname), "%s%d", get_tok_str(tok1, NULL), n);
             else
-                sprintf(sname, "%s", get_tok_str(tok1, NULL));
+                snprintf(sname, sizeof(sname), "%s", get_tok_str(tok1, NULL));
+            sname[sizeof(sname)-1] = 0;
             use_section(s1, sname);
 	}
 	break;

 ST_FUNC Section *new_section(TCCState *s1, const char *name, int sh_type, int sh_flags)
 {
     Section *sec;
+    int n;
-    sec = tcc_mallocz(sizeof(Section) + strlen(name));
+    n = strlen(name); // Section->name already has 1 extra char
+    sec = tcc_mallocz(sizeof(Section) + n);
+    memcpy(sec->name, name, n + 1);
     sec->s1 = s1;
-    strcpy(sec->name, name);
     sec->sh_type = sh_type;
     sec->sh_flags = sh_flags;
     switch(sh_type) {
         if (len > sizeof plt_name - 5)
             len = sizeof plt_name - 5;
         memcpy(plt_name, name, len);
-        strcpy(plt_name + len, "@plt");
+        pstrcpy(plt_name + len, sizeof(plt_name) - len, "@plt");
         attr->plt_sym = put_elf_sym(s1->symtab, attr->plt_offset, 0,
             ELFW(ST_INFO)(STB_GLOBAL, STT_FUNC), 0, s1->plt->sh_num, plt_name);
     } else {
         cstr_printf (&cstr, "%s/%s.tcov", wd, filename);
     }
     ptr = section_ptr_add(tcov_section, cstr.size + 1);
-    strcpy((char *)ptr, cstr.data);
+    memcpy(ptr, cstr.data, cstr.size + 1);
     unlink((char *)ptr);
 #ifdef _WIN32
     normalize_slashes((char *)ptr);
     note->n_namesz = 8;
     note->n_descsz = 4;
     note->n_type = type;
-    strcpy (ptr + sizeof(ElfW(Nhdr)), value);
+    pstrcpy (ptr + sizeof(ElfW(Nhdr)), 8, value);
     memcpy (ptr + sizeof(ElfW(Nhdr)) + 8, &data, 4);
 }

                 can_add_underscore = 0;
             }
             if (ref->f.func_call == FUNC_STDCALL && can_add_underscore) {
-                sprintf(buf1, "_%s@%d", name, ref->f.func_args * PTR_SIZE);
+                snprintf(buf1, sizeof(buf1), "_%s@%d", name, ref->f.func_args * PTR_SIZE);
+                buf1[sizeof(buf1)-1] = 0;
                 name = buf1;
                 other |= ST_PE_STDCALL;
                 can_add_underscore = 0;
         break;
     }
-    sprintf(buf, "%s_%d", get_tok_str(atok, 0), size);
+    snprintf(buf, sizeof(buf), "%s_%d", get_tok_str(atok, 0), size);
+    buf[sizeof(buf)-1] = 0;
     vpush_helper_func(tok_alloc_const(buf));
     vrott(arg - save + 1);
     gfunc_call(arg - save);
                    the compilation unit only if they are used */
                 if (sym->type.t & VT_INLINE) {
                     struct InlineFunc *fn;
-                    fn = tcc_malloc(sizeof *fn + strlen(file->filename));
+                    int n = strlen(file->filename);
-                    strcpy(fn->filename, file->filename);
+                    fn = tcc_malloc(sizeof *fn + n);
+                    pstrcpy(fn->filename, n+1, file->filename);
                     fn->sym = sym;
                     dynarray_add(&tcc_state->inline_fns,
 				 &tcc_state->nb_inline_fns, fn);

 /* XXX: float tokens */
 ST_FUNC const char *get_tok_str(int v, CValue *cv)
 {
-    char *p;
+    char *p, *e;
     int i, len;
     cstr_reset(&cstr_buf);
     p = cstr_buf.data;
+	e = p + cstr_buf.size_allocated;
     switch(v) {
     case TOK_CINT:
     case TOK_CLLONG:
     case TOK_CULLONG:
         /* XXX: not quite exact, but only useful for testing  */
-        sprintf(p, "%llu", (unsigned long long)cv->i);
+        snprintf(p, e-p, "%llu", (unsigned long long)cv->i);
         break;
     case TOK_LCHAR:
         cstr_ccat(&cstr_buf, 'L');
                 q += 3;
             }
             if (v >= 127 || (v < 32 && !is_space(v) && v != '\n')) {
-                sprintf(p, "<\\x%02x>", v);
+                snprintf(p, e-p, "<\\x%02x>", v);
                 break;
             }
     addv:
             return table_ident[v - TOK_IDENT]->str;
         } else if (v >= SYM_FIRST_ANOM) {
             /* special name for anonymous symbol */
-            sprintf(p, "L.%u", v - SYM_FIRST_ANOM);
+            snprintf(p, e-p, "L.%u", v - SYM_FIRST_ANOM);
         } else {
             /* should never happen */
             return NULL;
         }
         break;
     }
+	e[-1] = '\0';
     return cstr_buf.data;
 }

make OpenBSD happy about strcpy and sprintf